@faable/faable 1.5.17-next.1 → 1.5.17-next.21

package/dist/api/FaableApi.js

@@ -1,5 +1,5 @@
 import { __decorate } from 'tslib';
-import { base_client } from './base_client.js';
+import { create_base_client } from './base_client.js';
 
 function handleError() {
     return function (target, propertyKey, descriptor) {
@@ -34,10 +34,12 @@ const data = async (res) => {
 };
 class FaableApi {
     client;
+    strategy;
     constructor(config) {
         const { authStrategy, auth } = config;
-        this.client = base_client;
-        const strategy = authStrategy && authStrategy(auth);
+        this.client = create_base_client();
+        this.strategy = authStrategy && authStrategy(auth);
+        const strategy = this.strategy;
         this.client.interceptors.request.use(async function (config) {
             // Do something before request is sent
             const headers = strategy ? await strategy.headers() : {};
@@ -59,6 +61,9 @@ class FaableApi {
     async getBySlug(slug) {
         return data(this.client.get(`/app/slug/${slug}`));
     }
+    async getApp(app_id) {
+        return data(this.client.get(`/app/${app_id}`));
+    }
     async getRegistry(app_id) {
         return data(this.client.get(`/app/${app_id}/registry`));
     }
@@ -68,6 +73,18 @@ class FaableApi {
     async getAppSecrets(app_id) {
         return firstPage(data(this.client.get(`/secret/${app_id}`)));
     }
+    async updateApp(app_id, params) {
+        return data(this.client.post(`/app/${app_id}`, params));
+    }
+    async getDeviceCode() {
+        return data(this.client.post(`/auth/device/code`));
+    }
+    async getDeviceToken(device_code) {
+        return data(this.client.post(`/auth/device/token`, { device_code }));
+    }
+    async getMe() {
+        return data(this.client.get(`/auth/me`));
+    }
 }
 __decorate([
     handleError()
@@ -75,6 +92,9 @@ __decorate([
 __decorate([
     handleError()
 ], FaableApi.prototype, "getBySlug", null);
+__decorate([
+    handleError()
+], FaableApi.prototype, "getApp", null);
 __decorate([
     handleError()
 ], FaableApi.prototype, "getRegistry", null);
@@ -84,5 +104,17 @@ __decorate([
 __decorate([
     handleError()
 ], FaableApi.prototype, "getAppSecrets", null);
+__decorate([
+    handleError()
+], FaableApi.prototype, "updateApp", null);
+__decorate([
+    handleError()
+], FaableApi.prototype, "getDeviceCode", null);
+__decorate([
+    handleError()
+], FaableApi.prototype, "getDeviceToken", null);
+__decorate([
+    handleError()
+], FaableApi.prototype, "getMe", null);
 
 export { FaableApi };

package/dist/api/base_client.js

@@ -1,9 +1,11 @@
 import axios from 'axios';
 
 const BASE_URL = process.env.BASE_URL || "https://api.faable.com";
-const base_client = axios.create({
-    baseURL: BASE_URL,
-    timeout: 10000
-});
+const create_base_client = () => {
+    return axios.create({
+        baseURL: BASE_URL,
+        timeout: 10000
+    });
+};
 
-export { base_client };
+export { create_base_client };

package/dist/api/context.js

@@ -2,28 +2,53 @@ import { FaableApi } from './FaableApi.js';
 import { apikey_strategy } from './strategies/apikey.strategy.js';
 import { getIDToken } from '@actions/core';
 import { oidc_strategy } from './strategies/oidc.strategy.js';
+import { bearer_strategy } from './strategies/bearer.strategy.js';
+import { CredentialsStore } from '../lib/CredentialsStore.js';
 
-// import { CredentialsStore } from "../lib/CredentialsStore";
 const context = async () => {
     let api;
     if (process.env.FAABLE_APIKEY) {
+        // Apikey in environment
         const apikey = process.env.FAABLE_APIKEY;
         api = FaableApi.create({ authStrategy: apikey_strategy, auth: { apikey } });
     }
-    //const store = new CredentialsStore();
-    //(await store.loadCredentials())?.apikey
-    // Github actions environment
-    if (process.env.GITHUB_ACTIONS === 'true') {
+    else if (process.env.FAABLE_TOKEN) {
+        // Token in environment
+        const token = process.env.FAABLE_TOKEN;
+        api = FaableApi.create({ authStrategy: bearer_strategy, auth: { token } });
+    }
+    else if (process.env.GITHUB_ACTIONS === "true") {
+        // Github actions environment
         try {
-            const idToken = await getIDToken("https://faable.com");
+            const idToken = process.env.FAABLE_ID_TOKEN || (await getIDToken("https://faable.com"));
             api = FaableApi.create({ authStrategy: oidc_strategy, auth: { idToken } });
         }
         catch (_) {
             console.error("Error fetching token, configure 'permissions: id-token: write'");
         }
     }
+    else {
+        const store = new CredentialsStore();
+        const config = await store.loadCredentials();
+        if (config) {
+            if (config.token) {
+                api = FaableApi.create({
+                    authStrategy: bearer_strategy,
+                    auth: { token: config.token },
+                });
+            }
+            else if (config.apikey) {
+                api = FaableApi.create({
+                    authStrategy: apikey_strategy,
+                    auth: { apikey: config.apikey },
+                });
+            }
+        }
+    }
+    const appId = await api?.strategy?.app_id?.();
     return {
         api,
+        appId,
     };
 };
 

package/dist/api/strategies/bearer.strategy.js

@@ -0,0 +1,15 @@
+const bearer_strategy = (config) => {
+    const { token } = config;
+    if (!token) {
+        throw new Error("Missing token.");
+    }
+    return {
+        headers: async () => {
+            return {
+                Authorization: `Bearer ${token}`,
+            };
+        },
+    };
+};
+
+export { bearer_strategy };

package/dist/api/strategies/oidc.strategy.js

@@ -1,29 +1,36 @@
-import { base_client } from '../base_client.js';
+import { create_base_client } from '../base_client.js';
 
 const exchangeGithubOidcToken = async (gh_token) => {
-    const res = await base_client.post("/auth/github-oidc", {
+    const client = create_base_client();
+    const res = await client.post("/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 };
 };
 const oidc_strategy = (config) => {
     const { idToken } = config;
     if (!idToken) {
         throw new Error("Missing idToken.");
     }
-    let token = "";
+    let token_ex;
     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;
+        }
     };
 };
 

package/dist/commands/auth/index.js

@@ -0,0 +1,31 @@
+import { log } from '../../log.js';
+import { context } from '../../api/context.js';
+
+const auth = {
+    command: "auth",
+    describe: "Manage authentication",
+    builder: (yargs) => {
+        return yargs.command({
+            command: "status",
+            describe: "Check authentication status",
+            handler: async () => {
+                const { api } = await context();
+                if (!api) {
+                    log.error("❌ Not authenticated. Run 'faable login' first.");
+                    process.exit(1);
+                }
+                try {
+                    const me = await api.getMe();
+                    log.info(`✅ Authenticated as ${me.email}`);
+                }
+                catch (e) {
+                    log.error("❌ Not authenticated or session expired");
+                    process.exit(1);
+                }
+            },
+        });
+    },
+    handler: () => { },
+};
+
+export { auth };

package/dist/commands/deploy/deploy_command.js

@@ -8,15 +8,25 @@ import { cmd } from '../../lib/cmd.js';
 
 const deploy_command = async (args) => {
     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) {
+    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);
+        }
+    }
+    if (!app) {
         throw new Error("Missing <app_name>");
     }
-    // Get app from Faable API
-    const app = await api.getBySlug(name);
     // Check if we can build docker images
     await check_environment();
     log.info(`🚀 Deploying ${app.name} (${app.id}) runtime=${runtime.name}-${runtime.version}`);

package/dist/commands/init/index.js

@@ -1,7 +1,7 @@
 import { writeGithubAction } from './writeGithubAction.js';
 
 const init = {
-    command: ["initialize", "$0"],
+    command: ["init", "initialize"],
     describe: "Initialize Faable",
     builder: (yargs) => {
         return yargs

package/dist/commands/link/index.js

@@ -0,0 +1,82 @@
+import { context } from '../../api/context.js';
+import prompts from 'prompts';
+import { log } from '../../log.js';
+import { cmd } from '../../lib/cmd.js';
+import { Configuration } from '../../lib/Configuration.js';
+
+const getGitRemoteUrl = async (workdir) => {
+    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;
+    }
+};
+const link = {
+    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);
+    },
+    handler: async (args) => {
+        const workdir = args.workdir || process.cwd();
+        const config = Configuration.instance();
+        if (config.app_slug) {
+            log.info(`This repository is already linked to app: ${config.app_slug}`);
+            const { relink } = await prompts({
+                type: "toggle",
+                name: "relink",
+                message: "Do you want to link it to a different app?",
+                initial: false,
+                active: "yes",
+                inactive: "no",
+            });
+            if (!relink) {
+                return;
+            }
+        }
+        const { api } = await context();
+        log.info("Checking local git repository...");
+        const gitUrl = await getGitRemoteUrl(workdir);
+        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}.`);
+    },
+};
+
+export { link };

package/dist/commands/login/index.js

@@ -0,0 +1,104 @@
+import { FaableApi } from '../../api/FaableApi.js';
+import { CredentialsStore } from '../../lib/CredentialsStore.js';
+import open from 'open';
+import { log } from '../../log.js';
+
+const login = {
+    command: "login",
+    describe: "Login to Faable",
+    builder: (yargs) => {
+        return yargs
+            .option("apikey", {
+            type: "string",
+            description: "Login using an API Key",
+        })
+            .option("token", {
+            type: "string",
+            description: "Login using an OIDC token",
+        })
+            .showHelpOnFail(false);
+    },
+    handler: async (args) => {
+        const { apikey, token } = args;
+        const store = new CredentialsStore();
+        const api = FaableApi.create(); // Base client for device flow
+        if (apikey) {
+            log.info("Logging in with API Key...");
+            const tempApi = FaableApi.create({ auth: { apikey }, authStrategy: (await import('../../api/strategies/apikey.strategy.js')).apikey_strategy });
+            try {
+                const me = await tempApi.getMe();
+                await store.saveCredentials({ apikey, email: me.email });
+                log.info(`✅ Successfully logged in as ${me.email}`);
+            }
+            catch (e) {
+                log.error("❌ Invalid API Key");
+                process.exit(1);
+            }
+            return;
+        }
+        if (token) {
+            log.info("Logging in with OIDC token...");
+            const tempApi = FaableApi.create({ auth: { idToken: token }, authStrategy: (await import('../../api/strategies/oidc.strategy.js')).oidc_strategy });
+            try {
+                const me = await tempApi.getMe();
+                await store.saveCredentials({ token, email: me.email });
+                log.info(`✅ Successfully logged in as ${me.email}`);
+            }
+            catch (e) {
+                log.error("❌ Invalid OIDC token");
+                process.exit(1);
+            }
+            return;
+        }
+        // Interactive Device Flow
+        log.info("Starting browser-based authentication...");
+        try {
+            const { device_code, user_code, verification_uri, interval, expires_in } = await api.getDeviceCode();
+            log.info(`\nVerification code: ${user_code}\n`);
+            log.info(`If your browser doesn't open automatically, please visit:\n${verification_uri}\n`);
+            try {
+                await open(verification_uri);
+            }
+            catch (e) {
+                log.warn("Could not open browser automatically.");
+            }
+            // Polling
+            const start = Date.now();
+            const timeout = expires_in * 1000;
+            while (Date.now() - start < timeout) {
+                try {
+                    const { access_token } = await api.getDeviceToken(device_code);
+                    if (access_token) {
+                        log.info("Token received!");
+                        const tempApi = FaableApi.create({ auth: { token: access_token }, authStrategy: () => ({ headers: async () => ({ Authorization: `Bearer ${access_token}` }) }) });
+                        const me = await tempApi.getMe();
+                        await store.saveCredentials({ token: access_token, email: me.email });
+                        log.info(`✅ Successfully logged in as ${me.email}`);
+                        return;
+                    }
+                }
+                catch (e) {
+                    // Typically returns 400 with "authorization_pending"
+                    if (e.cause?.response?.data?.error === "authorization_pending") {
+                        // Wait and continue
+                    }
+                    else if (e.cause?.response?.data?.error === "slow_down") {
+                        // Should increase interval but for now we just wait
+                    }
+                    else if (e.cause?.response?.headers?.["content-type"]?.includes("application/json")) {
+                        // Other error
+                    }
+                }
+                await new Promise(resolve => setTimeout(resolve, interval * 1000));
+            }
+            log.error("❌ Authentication timed out");
+            process.exit(1);
+        }
+        catch (e) {
+            log.error(`❌ Failed to start authentication: ${e.message}`);
+            process.exit(1);
+        }
+    },
+};
+
+export { login };

package/dist/commands/logout/index.js

@@ -0,0 +1,14 @@
+import { CredentialsStore } from '../../lib/CredentialsStore.js';
+import { log } from '../../log.js';
+
+const logout = {
+    command: "logout",
+    describe: "Logout from Faable",
+    handler: async () => {
+        const store = new CredentialsStore();
+        await store.deleteCredentials();
+        log.info("✅ Successfully logged out");
+    },
+};
+
+export { logout };

package/dist/commands/whoami/index.js

@@ -0,0 +1,24 @@
+import { log } from '../../log.js';
+import { context } from '../../api/context.js';
+
+const whoami = {
+    command: "whoami",
+    describe: "Display the current logged in user",
+    handler: async () => {
+        const { api } = await context();
+        if (!api) {
+            log.error("❌ Not logged in. Run 'faable login' first.");
+            process.exit(1);
+        }
+        try {
+            const me = await api.getMe();
+            log.info(`Logged in as: ${me.email}`);
+        }
+        catch (e) {
+            log.error("❌ Not logged in or session expired");
+            process.exit(1);
+        }
+    },
+};
+
+export { whoami };

package/dist/index.js

@@ -1,17 +1,21 @@
 import yargs from 'yargs';
 import { hideBin } from 'yargs/helpers';
 import { apps } from './commands/apps/index.js';
-import { configure } from './commands/configure/index.js';
+import { login } from './commands/login/index.js';
+import { logout } from './commands/logout/index.js';
+import { whoami } from './commands/whoami/index.js';
+import { auth } from './commands/auth/index.js';
 import { deploy } from './commands/deploy/index.js';
 import { log } from './log.js';
+import { link } from './commands/link/index.js';
 import { init } from './commands/init/index.js';
 import { version } from './config.js';
 import { Configuration } from './lib/Configuration.js';
 
 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",
@@ -30,8 +34,12 @@ yg.scriptName("faable")
 }, true)
     .command(deploy)
     .command(apps)
-    .command(configure)
+    .command(login)
+    .command(logout)
+    .command(whoami)
+    .command(auth)
     .command(init)
+    .command(link)
     .demandCommand(1)
     .help()
     .fail(function (msg, err) {

package/dist/lib/Configuration.js

@@ -5,14 +5,16 @@ import { log } from '../log.js';
 class Configuration {
     static _instance;
     config = {};
+    config_file = "faable.json";
     constructor() {
         // Try to read default config file
         this.setConfigFile("faable.json", { ignoreWarnings: true });
     }
     setConfigFile(file, options) {
-        const config_file = path__default.join(process.cwd(), file);
-        if (fs.existsSync(config_file)) {
-            this.config = fs.readJSONSync(config_file);
+        this.config_file = file;
+        const config_path = path__default.join(process.cwd(), file);
+        if (fs.existsSync(config_path)) {
+            this.config = fs.readJSONSync(config_path);
             log.info(`Loaded configuration from: ${file}`);
         }
         else {
@@ -21,6 +23,12 @@ class Configuration {
             }
         }
     }
+    saveConfig(updates) {
+        this.config = { ...this.config, ...updates };
+        const config_path = path__default.join(process.cwd(), this.config_file);
+        fs.writeJSONSync(config_path, this.config, { spaces: 2 });
+        log.info(`Configuration saved to: ${this.config_file}`);
+    }
     static instance() {
         if (!Configuration._instance) {
             Configuration._instance = new Configuration();
@@ -33,6 +41,9 @@ class Configuration {
     get buildCommand() {
         return this.config.buildCommand;
     }
+    get app_slug() {
+        return this.config.app_slug;
+    }
 }
 
 export { Configuration };

package/dist/lib/CredentialsStore.js

@@ -11,18 +11,35 @@ class CredentialsStore {
         this.faable_home = path__default.join(os.homedir(), ".faable");
     }
     async deleteCredentials() {
-        await fs.remove(this.faable_home);
+        if (fs.existsSync(this.credentials_path)) {
+            await fs.remove(this.credentials_path);
+        }
         this.log.info(`Deleted credentials`);
     }
     get credentials_path() {
-        return path__default.join(this.faable_home, "credentials");
+        return path__default.join(this.faable_home, "auth.json");
     }
-    async saveApiKey(config) {
+    async saveCredentials(config) {
         await fs.ensureDir(this.faable_home);
-        await fs.writeJSON(this.credentials_path, config);
-        this.log.info(`Stored apikey`);
+        await fs.writeJSON(this.credentials_path, config, { spaces: 2 });
+        await fs.chmod(this.credentials_path, 0o600);
+        this.log.info(`Stored credentials`);
+    }
+    /**
+     * @deprecated use saveCredentials
+     */
+    async saveApiKey(config) {
+        return this.saveCredentials(config);
     }
     async loadCredentials() {
+        const old_path = path__default.join(this.faable_home, "credentials");
+        // Migration from old path if it exists
+        if (fs.existsSync(old_path) && !fs.existsSync(this.credentials_path)) {
+            const config = await fs.readJSON(old_path);
+            await this.saveCredentials(config);
+            await fs.remove(old_path);
+            return config;
+        }
         if (!fs.existsSync(this.credentials_path)) {
             // No credentials found
             return;

package/package.json

@@ -1,11 +1,36 @@
 {
   "name": "@faable/faable",
+  "version": "1.5.17-next.21",
   "main": "dist/index.js",
+  "license": "MIT",
+  "author": "Marc Pomar <marc@faable.com>",
+  "type": "module",
+  "types": "./dist/index.d.ts",
+  "bugs": {
+    "url": "https://github.com/faablecloud/faable/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/faablecloud/faable.git"
+  },
+  "bin": {
+    "faable": "bin/faable.js"
+  },
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org/",
+    "access": "public"
+  },
+  "homepage": "https://github.com/faablecloud/faable#readme",
+  "files": [
+    "dist",
+    "bin"
+  ],
   "dependencies": {
     "@actions/core": "^3.0.0",
     "axios": "^1.13.2",
     "fs-extra": "^11.3.2",
     "handlebars": "^4.7.8",
+    "open": "^11.0.0",
     "pino": "^10.1.0",
     "pino-pretty": "^13.1.3",
     "promisify-child-process": "^4.1.2",
@@ -15,24 +40,45 @@
     "yaml": "^2.8.2",
     "yargs": "^18.0.0"
   },
-  "version": "1.5.17-next.1",
-  "bin": {
-    "faable": "bin/faable.js"
-  },
-  "type": "module",
-  "license": "MIT",
-  "author": "Marc Pomar <marc@faable.com>",
-  "types": "./dist/index.d.ts",
-  "bugs": {
-    "url": "https://github.com/faablecloud/faable/issues"
-  },
-  "publishConfig": {
-    "registry": "https://registry.npmjs.org/",
-    "access": "public"
+  "devDependencies": {
+    "@eslint/js": "^10.0.1",
+    "@rollup/plugin-commonjs": "^29.0.0",
+    "@rollup/plugin-json": "^6.1.0",
+    "@rollup/plugin-node-resolve": "^16.0.3",
+    "@rollup/plugin-typescript": "^12.3.0",
+    "@types/bluebird": "^3.5.38",
+    "@types/fs-extra": "^11.0.4",
+    "@types/node": "^24.10.2",
+    "@types/ramda": "^0.31.1",
+    "@types/yargs": "^17.0.35",
+    "@typescript-eslint/eslint-plugin": "^8.57.1",
+    "ava": "^7.0.0",
+    "eslint-config-prettier": "^10.1.8",
+    "globals": "^17.4.0",
+    "husky": "^9.1.7",
+    "rimraf": "^6.1.2",
+    "rollup": "^4.53.3",
+    "rollup-plugin-auto-external": "^2.0.0",
+    "rollup-plugin-copy": "^3.4.0",
+    "rollup-plugin-generate-package-json": "^3.2.0",
+    "semantic-release": "^25.0.3",
+    "ts-node": "^10.9.2",
+    "tsx": "^4.21.0",
+    "type-fest": "^5.3.1",
+    "typescript": "^5.9.3"
   },
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/faablecloud/faable.git"
+  "scripts": {
+    "start": "npm run cli",
+    "cli": "tsx src/index.ts",
+    "gh-action-cli": "GITHUB_ACTIONS=true FAABLE_ID_TOKEN=fake-token tsx src/index.ts",
+    "build": "rimraf dist && rollup --config rollup.config.mjs",
+    "test": "ava",
+    "lint": "npx eslint .",
+    "lint:fix": "npx eslint . --fix",
+    "prepare": "husky",
+    "release": "semantic-release"
   },
-  "homepage": "https://github.com/faablecloud/faable#readme"
+  "engines": {
+    "node": ">=22.8"
+  }
 }

package/dist/commands/configure/index.js

@@ -1,34 +0,0 @@
-import { CredentialsStore } from '../../lib/CredentialsStore.js';
-import prompts from 'prompts';
-
-const configure = {
-    command: "configure",
-    describe: "Configure Faable CLI",
-    builder: (yargs) => {
-        return yargs
-            .option("remove", {
-            alias: "d",
-            type: "boolean",
-            description: "Delete current configuration",
-            default: false,
-        })
-            .showHelpOnFail(false);
-    },
-    handler: async (args) => {
-        const { app_name, workdir, api, remove } = args;
-        const store = new CredentialsStore();
-        if (remove) {
-            await store.deleteCredentials();
-        }
-        const { apikey } = await prompts([
-            {
-                type: "text",
-                name: "apikey",
-                message: "What is your Faable ApiKey?",
-            },
-        ]);
-        await store.saveApiKey({ apikey });
-    },
-};
-
-export { configure };