fix: link faable app

Author: boyander

src/api/FaableApi.ts

@@ -74,12 +74,14 @@ type FaableApiConfig<T> = {} & FaableClientConfig<T>;
 
 export class FaableApi<T = any> {
   client: AxiosInstance;
+  strategy?: AuthStrategy;
 
   constructor(config: FaableApiConfig<T>) {
     const {authStrategy,auth} = config
     this.client = create_base_client()
-    const strategy: AuthStrategy | undefined = authStrategy && authStrategy(auth);
+    this.strategy = authStrategy && authStrategy(auth);
 
+    const strategy = this.strategy;
     this.client.interceptors.request.use(
     async function (config) {
       // Do something before request is sent
@@ -110,6 +112,11 @@ export class FaableApi<T = any> {
     return data(this.client.get<FaableApp>(`/app/slug/${slug}`));
   }
 
+  @handleError()
+  async getApp(app_id: string) {
+    return data(this.client.get<FaableApp>(`/app/${app_id}`));
+  }
+
   @handleError()
   async getRegistry(app_id: string) {
     return data(this.client.get<FaableAppRegistry>(`/app/${app_id}/registry`));
@@ -127,4 +134,9 @@ export class FaableApi<T = any> {
   async getAppSecrets(app_id: string) {
     return firstPage(data(this.client.get<Page<Secret>>(`/secret/${app_id}`)));
   }
+
+  @handleError()
+  async updateApp(app_id: string, params: Partial<FaableApp> & { github_repo?: string }) {
+    return data(this.client.patch<FaableApp>(`/app/${app_id}`, params));
+  }
 }

src/api/context.ts

@@ -27,7 +27,10 @@ export const context = async () => {
   }
 
 
+  const appId = await api?.strategy?.app_id?.();
+
   return {
     api,
+    appId
   };
 };

src/api/strategies/oidc.strategy.ts

@@ -2,15 +2,15 @@ import { create_base_client } from "../base_client";
 import { AuthStrategyBuilder } from "./types";
 
 
+type TokenExchange = {token:string, app_id:string}
+
 const exchangeGithubOidcToken = async(gh_token:string)=>{
   const client = create_base_client()
-  const res = await client.post("/auth/github-oidc",{
+  const res = await client.post<TokenExchange>("/auth/github-oidc",{
     token:gh_token
   })
-  const {token} =res.data
-  console.log("Obtained github token exchange")
-  console.log(token)
-  return token
+  const {token, app_id} =res.data
+  return {token, app_id}
 }
 
 export const oidc_strategy: AuthStrategyBuilder<{idToken:string}> = (
@@ -21,16 +21,24 @@ export const oidc_strategy: AuthStrategyBuilder<{idToken:string}> = (
     throw new Error("Missing idToken.");
   }
 
-  let token:string="";
+  let token_ex:TokenExchange;
 
   return {
     headers: async () => {
-      if(!token){
-        token =  await exchangeGithubOidcToken(idToken)
+      if(!token_ex){
+        const ex =  await exchangeGithubOidcToken(idToken)
+        token_ex = ex
       }
       return {
-        Authorization: `Bearer ${token}`,
+        Authorization: `Bearer ${token_ex.token}`,
       };
     },
+    app_id: async () => {
+      if(!token_ex){
+        const ex = await exchangeGithubOidcToken(idToken)
+        token_ex = ex
+      }
+      return token_ex.app_id;
+    }
   };
 };

src/api/strategies/types.ts

@@ -1,4 +1,5 @@
 export type AuthStrategy = {
   headers: () => Promise<Record<string, string>>;
+  app_id?: () => Promise<string | undefined>;
 };
 export type AuthStrategyBuilder<T> = (...params: T[]) => AuthStrategy;

src/commands/deploy/deploy_command.ts

@@ -15,18 +15,26 @@ export interface DeployCommandArgs {
 export const deploy_command = async (args: DeployCommandArgs) => {
   const workdir = args.workdir || process.cwd();
 
-  const { api } = await context();
+  const { api, appId } = await context();
 
   // Resolve runtime
   const { app_name, runtime } = await runtime_detection(workdir);
 
-  const name = args.app_slug || app_name;
-  if (!name) {
-    throw new Error("Missing <app_name>");
+  let app;
+  if (args.app_slug) {
+    app = await api.getBySlug(args.app_slug);
+  } else {
+    const oidc_app_id = appId;
+    if (oidc_app_id) {
+      app = await api.getApp(oidc_app_id);
+    } else if (app_name) {
+      app = await api.getBySlug(app_name);
+    }
   }
 
-  // Get app from Faable API
-  const app = await api.getBySlug(name);
+  if (!app) {
+    throw new Error("Missing <app_name>");
+  }
 
   // Check if we can build docker images
   await check_environment();

src/commands/link/index.ts

@@ -0,0 +1,76 @@
+import { CommandModule } from "yargs";
+import { context } from "../../api/context";
+import prompts from "prompts";
+import { log } from "../../log";
+import { cmd } from "../../lib/cmd";
+import { Configuration } from "../../lib/Configuration";
+
+type Options = { workdir: string };
+
+const getGitRemoteUrl = async (workdir: string): Promise<string | undefined> => {
+  try {
+    const { stdout } = await cmd("git remote get-url origin", { cwd: workdir });
+    return stdout?.toString().trim();
+  } catch (error) {
+    log.warn("Could not detect git remote origin URL.");
+    return undefined;
+  }
+};
+
+export const link: CommandModule<object, Options> = {
+  command: "link",
+  describe: "Link the local repository with a Faable app",
+  builder: (yargs) => {
+    return yargs
+      .option("workdir", {
+        alias: "w",
+        type: "string",
+        description: "Working directory",
+      })
+      .showHelpOnFail(false) as any;
+  },
+  handler: async (args) => {
+    const workdir = args.workdir || process.cwd();
+    const { api } = await context();
+
+    log.info("Checking local git repository...");
+    const gitUrl = await getGitRemoteUrl(workdir);
+
+    log.info("Fetching your Faable apps...");
+    const apps = await api.list();
+
+    if (apps.length === 0) {
+      log.error("No apps found in your account. Create one first at https://faable.cloud");
+      return;
+    }
+
+    const { selectedApp } = await prompts({
+      type: "select",
+      name: "selectedApp",
+      message: "Select the Faable app to link with this repository:",
+      choices: apps.map((app) => ({
+        title: `${app.name} (${app.url})`,
+        value: app,
+      })),
+    });
+
+    if (!selectedApp) {
+      log.info("Link cancelled.");
+      return;
+    }
+
+    log.info(`Linking to ${selectedApp.name}...`);
+
+    // Update the app in the API
+    if (gitUrl) {
+      await api.updateApp(selectedApp.id, { github_repo: gitUrl });
+      log.info(`Updated app ${selectedApp.name} with github_repo: ${gitUrl}`);
+    } else {
+      log.warn("No git remote URL detected. Skipping API update for github_repo.");
+    }
+
+    // Save locally for CLI convenience
+    Configuration.instance().saveConfig({ app_slug: selectedApp.name });
+    log.info(`Successfully linked local repository to ${selectedApp.name}.`);
+  },
+};

src/index.ts

@@ -4,14 +4,15 @@ import { apps } from "./commands/apps";
 import { configure } from "./commands/configure";
 import { deploy } from "./commands/deploy";
 import { log } from "./log";
+import { link } from "./commands/link";
 import { init } from "./commands/init";
 import { version } from "./config";
 import { Configuration } from "./lib/Configuration";
 
 const yg = yargs();
 yg.scriptName("faable")
-  .middleware(function (argv) {
-    console.log(`Faable CLI ${version}`);
+  .middleware(function (_argv) {
+    log.info(`Faable CLI ${version}`);
   }, true)
   .option("c", {
     alias: "config",
@@ -31,6 +32,7 @@ yg.scriptName("faable")
   .command(apps)
   .command(configure)
   .command(init)
+  .command(link)
   .demandCommand(1)
   .help()
   .fail(function (msg, err) {

src/lib/Configuration.ts

@@ -4,21 +4,24 @@ import { log } from "../log";
 interface ProjectConfig {
   startCommand?: string;
   buildCommand?: string;
+  app_slug?: string;
 }
 
 export class Configuration {
   private static _instance: Configuration;
   private config: ProjectConfig = {};
+  private config_file: string = "faable.json";
 
   private constructor() {
     // Try to read default config file
     this.setConfigFile("faable.json", { ignoreWarnings: true });
   }
 
   setConfigFile(file: string, options: { ignoreWarnings: boolean }) {
-    const config_file = path.join(process.cwd(), file);
-    if (fs.existsSync(config_file)) {
-      this.config = fs.readJSONSync(config_file);
+    this.config_file = file;
+    const config_path = path.join(process.cwd(), file);
+    if (fs.existsSync(config_path)) {
+      this.config = fs.readJSONSync(config_path);
       log.info(`Loaded configuration from: ${file}`);
     } else {
       if (!options.ignoreWarnings) {
@@ -27,6 +30,13 @@ export class Configuration {
     }
   }
 
+  saveConfig(updates: Partial<ProjectConfig>) {
+    this.config = { ...this.config, ...updates };
+    const config_path = path.join(process.cwd(), this.config_file);
+    fs.writeJSONSync(config_path, this.config, { spaces: 2 });
+    log.info(`Configuration saved to: ${this.config_file}`);
+  }
+
   public static instance() {
     if (!Configuration._instance) {
       Configuration._instance = new Configuration();
@@ -41,4 +51,8 @@ export class Configuration {
   get buildCommand() {
     return this.config.buildCommand;
   }
+
+  get app_slug() {
+    return this.config.app_slug;
+  }
 }