@faable/faable 0.0.0-dev

package/README.md

@@ -0,0 +1,24 @@
+<p align="center">
+  <a href="https://faable.com">
+    <img src="https://www.faable.com/assets/logo/Emblem.png" height="96">
+    <h3 align="center">Faable</h3>
+  </a>
+</p>
+
+<p align="center">
+  Your React, Node.js or Python apps, up to the cloud in seconds.
+</p>
+
+## Faable
+
+Faable is the best platform to build modern architectures that scale precisely to meet demand. We handle the hard stuff so you can focus on building cloud ready apps. Make your business cloud driven and join those awesome companies.
+
+To install the latest version of Faable CLI:
+
+```bash
+npm i -g @faable/faable
+```
+
+## Documentation
+
+For details on how to use Faable CLI, check out our [documentation](https://docs.faable.com/).

package/bin/faable.js

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+
+import "../dist/index.js";

package/dist/api/FaableApi.js

@@ -0,0 +1,88 @@
+import { __decorate } from 'tslib';
+import { create_base_client } from './base_client.js';
+
+function handleError() {
+    return function (target, propertyKey, descriptor) {
+        const method = descriptor.value;
+        descriptor.value = async function (...args) {
+            try {
+                return await method.bind(this).apply(target, args);
+            }
+            catch (error) {
+                const e = error;
+                if (e.isAxiosError) {
+                    const res = e.response;
+                    if (res) {
+                        throw new Error(`FaableApi ${e.config.url} ${res.status}: ${res?.data.message}`, { cause: error });
+                    }
+                    else {
+                        throw new Error(`FaableApi ${e.message}`, { cause: error });
+                    }
+                }
+                throw error;
+            }
+        };
+    };
+}
+const firstPage = async (res) => {
+    const items = (await res).results;
+    return items;
+};
+const data = async (res) => {
+    const items = (await res).data;
+    return items;
+};
+class FaableApi {
+    client;
+    constructor(config) {
+        const { authStrategy, auth } = config;
+        this.client = create_base_client();
+        const strategy = authStrategy && authStrategy(auth);
+        this.client.interceptors.request.use(async function (config) {
+            // Do something before request is sent
+            const headers = strategy ? await strategy.headers() : {};
+            config.headers.set(headers);
+            // console.log("all headers");
+            // console.log(headers);
+            return config;
+        }, function (error) {
+            // Do something with request error
+            return Promise.reject(error);
+        });
+    }
+    static create(config = {}) {
+        return new FaableApi(config);
+    }
+    async list() {
+        return firstPage(data(this.client.get(`/app`)));
+    }
+    async getBySlug(slug) {
+        return data(this.client.get(`/app/slug/${slug}`));
+    }
+    async getRegistry(app_id) {
+        return data(this.client.get(`/app/${app_id}/registry`));
+    }
+    async createDeployment(params) {
+        return data(this.client.post(`/deployment`, params));
+    }
+    async getAppSecrets(app_id) {
+        return firstPage(data(this.client.get(`/secret/${app_id}`)));
+    }
+}
+__decorate([
+    handleError()
+], FaableApi.prototype, "list", null);
+__decorate([
+    handleError()
+], FaableApi.prototype, "getBySlug", null);
+__decorate([
+    handleError()
+], FaableApi.prototype, "getRegistry", null);
+__decorate([
+    handleError()
+], FaableApi.prototype, "createDeployment", null);
+__decorate([
+    handleError()
+], FaableApi.prototype, "getAppSecrets", null);
+
+export { FaableApi };

package/dist/api/base_client.js

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

package/dist/api/context.js

@@ -0,0 +1,30 @@
+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 { CredentialsStore } from "../lib/CredentialsStore";
+const context = async () => {
+    let api;
+    if (process.env.FAABLE_APIKEY) {
+        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') {
+        try {
+            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'");
+        }
+    }
+    return {
+        api,
+    };
+};
+
+export { context };

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

@@ -0,0 +1,15 @@
+const apikey_strategy = (config) => {
+    const { apikey } = config;
+    if (!apikey) {
+        throw new Error("Missing apikey.");
+    }
+    return {
+        headers: async () => {
+            return {
+                Authorization: `Basic ${Buffer.from(`${apikey}:`).toString("base64")}`,
+            };
+        },
+    };
+};
+
+export { apikey_strategy };

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

@@ -0,0 +1,31 @@
+import { create_base_client } from '../base_client.js';
+
+const exchangeGithubOidcToken = async (gh_token) => {
+    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 oidc_strategy = (config) => {
+    const { idToken } = config;
+    if (!idToken) {
+        throw new Error("Missing idToken.");
+    }
+    let token = "";
+    return {
+        headers: async () => {
+            if (!token) {
+                token = await exchangeGithubOidcToken(idToken);
+            }
+            return {
+                Authorization: `Bearer ${token}`,
+            };
+        },
+    };
+};
+
+export { oidc_strategy };

package/dist/commands/apps/index.js

@@ -0,0 +1,17 @@
+import { context } from '../../api/context.js';
+
+const apps = {
+    command: "apps",
+    describe: "Manage Faable Cloud Apps",
+    builder: (yargs) => {
+        return yargs.showHelpOnFail(false);
+    },
+    handler: async (args) => {
+        const { api } = await context();
+        const apps = await api.list();
+        console.log("Apps...");
+        console.log(apps.map((app) => app.name));
+    },
+};
+
+export { apps };

package/dist/commands/configure/index.js

@@ -0,0 +1,34 @@
+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 };

package/dist/commands/deploy/check_environment.js

@@ -0,0 +1,13 @@
+import { cmd } from '../../lib/cmd.js';
+
+const check_environment = async () => {
+    try {
+        await cmd("docker ps");
+    }
+    catch (error) {
+        console.log(error);
+        throw new Error(`Docker is not running`);
+    }
+};
+
+export { check_environment };

package/dist/commands/deploy/deploy_command.js

@@ -0,0 +1,50 @@
+import { log } from '../../log.js';
+import { upload_tag } from './upload_tag.js';
+import { check_environment } from './check_environment.js';
+import { context } from '../../api/context.js';
+import { build_node } from './node-pipeline/index.js';
+import { runtime_detection } from './runtime-detect/runtime_detection.js';
+import { cmd } from '../../lib/cmd.js';
+
+const deploy_command = async (args) => {
+    const workdir = args.workdir || process.cwd();
+    const { api } = 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>");
+    }
+    // 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}`);
+    // get environment variables
+    const env_vars = await api.getAppSecrets(app.id);
+    let type;
+    if (runtime.name == "node") {
+        const node_result = await build_node(app, {
+            workdir,
+            runtime,
+            env_vars,
+        });
+        type = node_result.type;
+    }
+    else if (runtime.name == "docker") {
+        type = "node";
+        await cmd(`docker build -t ${app.id} .`, {
+            enableOutput: true,
+        });
+    }
+    else {
+        throw new Error(`No build pipeline for runtime=${runtime.name}`);
+    }
+    // Upload to Faable registry
+    const { upload_tagname } = await upload_tag({ app, api });
+    // Create a deployment for this image
+    await api.createDeployment({ app_id: app.id, image: upload_tagname, type });
+    log.info(`🌍 Deployment created -> https://${app.url}`);
+};
+
+export { deploy_command };

package/dist/commands/deploy/index.js

@@ -0,0 +1,22 @@
+import { deploy_command } from './deploy_command.js';
+
+const deploy = {
+    command: "deploy [app_slug]",
+    describe: "Deploy a faable app",
+    builder: (yargs) => {
+        return yargs
+            .positional("app_slug", {
+            type: "string",
+            description: "App slug",
+        })
+            .option("workdir", {
+            alias: "w",
+            type: "string",
+            description: "Working directory",
+        })
+            .showHelpOnFail(false);
+    },
+    handler: deploy_command,
+};
+
+export { deploy };

package/dist/commands/deploy/node-pipeline/analyze_package.js

@@ -0,0 +1,34 @@
+import fs from 'fs-extra';
+import path__default from 'path';
+import { log } from '../../../log.js';
+import * as R from 'ramda';
+
+const analyze_package = async (params) => {
+    const workdir = params.workdir;
+    const package_file = path__default.join(path__default.resolve(workdir), "package.json");
+    log.info(`Loading config from package.json`);
+    const pkg = await fs.readJSON(package_file);
+    // Check if build is required to run
+    const build_script = process.env.FAABLE_NPM_BUILD_SCRIPT
+        ? process.env.FAABLE_NPM_BUILD_SCRIPT
+        : pkg?.scripts["build"]
+            ? "build"
+            : null;
+    if (!build_script) {
+        log.info(`No build script on package.json`);
+    }
+    let type = "node";
+    // Detect nextjs deployment type
+    const next_dep = R.lensPath(["dependencies", "next"]);
+    const next_devdep = R.lensPath(["devDependencies", "next"]);
+    if (R.view(next_dep, pkg) || R.view(next_devdep, pkg)) {
+        type = "next";
+    }
+    log.info(`⚡️ Detected deployment type=${type}`);
+    return {
+        build_script,
+        type,
+    };
+};
+
+export { analyze_package };

package/dist/commands/deploy/node-pipeline/build_docker.js

@@ -0,0 +1,48 @@
+import { log } from '../../../log.js';
+import { cmd } from '../../../lib/cmd.js';
+import fs from 'fs-extra';
+import Handlebars from 'handlebars';
+import * as path from 'path';
+import { fileURLToPath } from 'url';
+import { Configuration } from '../../../lib/Configuration.js';
+
+const __filename$1 = fileURLToPath(import.meta.url);
+const __dirname$1 = path.dirname(__filename$1);
+const templates_dir = path.join(__dirname$1, "templates");
+const dockerfile = fs.readFileSync(`${templates_dir}/Dockerfile`).toString();
+const entrypoint = fs
+    .readFileSync(`${templates_dir}/entrypoint.sh`)
+    .toString("utf-8");
+Handlebars.registerHelper("escape", function (variable) {
+    //const escaped_quotes = variable.replace(/(['"])/g, "\\$1");
+    const escaped_lines = variable
+        .replace(/(['`\\])/g, "\\$1")
+        .replace(/([$])/g, "\\$1");
+    return escaped_lines.split("\n").join("\\n");
+    //return escaped_lines.split("\n").join("\\n");
+});
+// Docker template file
+const docker_template = Handlebars.compile(dockerfile);
+const entrypoint_template = Handlebars.compile(entrypoint);
+const build_docker = async (props) => {
+    const { app, workdir, template_context } = props;
+    const entrypoint_custom = entrypoint_template(template_context);
+    const start_command = Configuration.instance().startCommand;
+    log.info(`⚙️ Start command: ${start_command}`);
+    // NOTE: use slim to build projects
+    const linux_distro = "slim";
+    const from = [template_context.from, linux_distro].filter((e) => e).join("-");
+    log.info(`Using docker image ${from}`);
+    // run template
+    const dockerfile = docker_template({
+        from,
+        entry_script: entrypoint_custom,
+        start_command,
+    });
+    log.info(`📦 Packaging inside a docker image`);
+    // Build options
+    const timeout = 10 * 60 * 1000; // 10 minute timeout
+    await cmd(`docker build --platform linux/amd64 -t ${app.id} ${workdir} -f -<<EOF\n${dockerfile}\nEOF`, { timeout, enableOutput: true });
+};
+
+export { build_docker };

package/dist/commands/deploy/node-pipeline/build_project.js

@@ -0,0 +1,26 @@
+import { log } from '../../../log.js';
+import { cmd } from '../../../lib/cmd.js';
+import { Configuration } from '../../../lib/Configuration.js';
+
+const build_project = async (args) => {
+    const build_script = args.build_script;
+    const build_command = build_script
+        ? `npm run ${build_script}`
+        : Configuration.instance().buildCommand;
+    if (build_command) {
+        const cwd = args.cwd || process.cwd();
+        log.info(`⚙️ Building project [${build_command}]...`);
+        const timeout = 1000 * 60 * 30; // 30 minute timeout
+        await cmd(build_command, {
+            timeout,
+            cwd,
+            enableOutput: true,
+            ...(args?.env ? { env: args?.env } : {}),
+        });
+    }
+    else {
+        log.info(`⚡️ No build step`);
+    }
+};
+
+export { build_project };

package/dist/commands/deploy/node-pipeline/index.js

@@ -0,0 +1,31 @@
+import { build_docker } from './build_docker.js';
+import { analyze_package } from './analyze_package.js';
+import { build_project } from './build_project.js';
+import * as R from 'ramda';
+import { log } from '../../../log.js';
+
+const build_node = async (app, options) => {
+    // log.info(`🚀 Build Toolchain ${app.name} [${app.id}]`);
+    const { workdir, runtime, env_vars = [] } = options;
+    if (!runtime.version) {
+        throw new Error("Runtime version not specified for node");
+    }
+    // Analyze package.json to check if build is needed
+    const { build_script, type } = await analyze_package({ workdir });
+    // Environment variables
+    const env = R.fromPairs(env_vars.map((e) => [e.name, e.value]));
+    log.info(`Building with env variables ${Object.keys(env).join(",")}`);
+    // Do build
+    await build_project({ build_script, env });
+    // Bundle project inside a docker image
+    await build_docker({
+        app,
+        workdir,
+        template_context: {
+            from: `node:${runtime.version}`,
+        },
+    });
+    return { type };
+};
+
+export { build_node };

package/dist/commands/deploy/node-pipeline/templates/Dockerfile

@@ -0,0 +1,18 @@
+FROM {{from}}
+LABEL com.faable.cloud="FaableCloud"
+LABEL description="Faablecloud automatic deployment"
+
+WORKDIR /faable/app
+
+# Environment variables for runtime
+ENV PORT=80
+ENV NODE_ENV=production
+ENV START_COMMAND="{{start_command}}"
+
+# Copy Usercode
+COPY . .
+
+# Entrypoint stript
+RUN echo '{{{escape entry_script}}}' >> entrypoint.sh
+
+CMD ["/bin/sh", "./entrypoint.sh"]  

package/dist/commands/deploy/node-pipeline/templates/entrypoint.sh

@@ -0,0 +1,8 @@
+#!/bin/sh
+
+NODE_VERSION=$(node --version)
+NPM_VERSION=$(npm --version)
+YARN_VERSION=$(yarn --version)
+
+echo "Faable Cloud · [node $NODE_VERSION] [npm $NPM_VERSION] [yarn $YARN_VERSION]"
+eval $START_COMMAND

package/dist/commands/deploy/runtime-detect/helpers/has_any_of_files.js

@@ -0,0 +1,14 @@
+import fs from 'fs-extra';
+import path__default from 'path';
+
+const has_any_of_files = (files, workdir) => {
+    for (let name of files) {
+        const filename = path__default.join(workdir, name);
+        if (fs.existsSync(filename)) {
+            return true;
+        }
+    }
+    return false;
+};
+
+export { has_any_of_files };

package/dist/commands/deploy/runtime-detect/runtime_detection.js

@@ -0,0 +1,19 @@
+import { strategy_nodejs } from './strategies/nodejs.js';
+import * as R from 'ramda';
+import { has_any_of_files } from './helpers/has_any_of_files.js';
+import { strategy_docker } from './strategies/docker.js';
+
+const runtime_detection = async (workdir) => {
+    const has = R.curry(has_any_of_files);
+    const strategy = R.cond([
+        [has(["package.json"]), R.always(strategy_nodejs)],
+        // [has(["requirements.txt"]), R.always(strategy_python)],
+        [has(["Dockerfile"]), R.always(strategy_docker)],
+    ])(workdir);
+    if (!strategy) {
+        throw new Error("Cannot detect project type");
+    }
+    return strategy(workdir);
+};
+
+export { runtime_detection };

package/dist/commands/deploy/runtime-detect/strategies/docker.js

@@ -0,0 +1,9 @@
+const strategy_docker = async (workdir) => {
+    return {
+        runtime: {
+            name: "docker",
+        },
+    };
+};
+
+export { strategy_docker };

package/dist/commands/deploy/runtime-detect/strategies/nodejs.js

@@ -0,0 +1,49 @@
+import fs from 'fs-extra';
+import path__default from 'path';
+import { cmd } from '../../../../lib/cmd.js';
+import { log } from '../../../../log.js';
+
+const getCurrentNodeVersion = async () => {
+    const out = await cmd(`node --version`);
+    const [_, version] = out.stdout.toString().trim().split("v");
+    return version;
+};
+/**
+ * Strategy to detect app name from package.json
+ * @param api
+ * @param workdir
+ * @returns
+ */
+const strategy_nodejs = async (workdir) => {
+    const packageJSONFile = path__default.join(workdir, "package.json");
+    // Check we have a valid name
+    const { name, engines } = fs.readJSONSync(packageJSONFile);
+    if (!name) {
+        throw new Error("Missing name in package.json");
+    }
+    // Use engines.node if found
+    let runtime_version = await getCurrentNodeVersion();
+    if (engines?.node) {
+        try {
+            const check_cmd = `npm view node@"${engines.node}" version | tail -n 1 | cut -d "'" -f2`;
+            const out = await cmd(check_cmd);
+            runtime_version = out.stdout.toString().trim();
+            log.info(`Using node@${runtime_version} from engines in package.json (${engines.node})`);
+        }
+        catch (e) {
+            log.info(`Node version defined in engines in package.json is not valid (${engines.node}), using current version ${runtime_version}`);
+        }
+    }
+    else {
+        log.info(`Node version ${runtime_version}`);
+    }
+    return {
+        app_name: name,
+        runtime: {
+            name: "node",
+            version: runtime_version,
+        },
+    };
+};
+
+export { strategy_nodejs };

package/dist/commands/deploy/upload_tag.js

@@ -0,0 +1,22 @@
+import { log } from '../../log.js';
+import { cmd } from '../../lib/cmd.js';
+
+const upload_tag = async (args) => {
+    const { api, app } = args;
+    log.info(`🔁 Uploading...`);
+    const registry = await api.getRegistry(app.id);
+    // Registry login
+    const { user, password, hostname, image } = registry;
+    await cmd(`echo "${password}" | docker login --username "${user}" --password-stdin ${hostname}`);
+    // Tag image for production
+    const upload_tagname = `${hostname}/${image}`;
+    await cmd(`docker tag ${app.id} ${upload_tagname}`);
+    // Upload the image to faable registry
+    await cmd(`docker push ${upload_tagname}`);
+    log.info(`✅ Upload completed.`);
+    return {
+        upload_tagname,
+    };
+};
+
+export { upload_tag };

package/dist/commands/init/index.js

@@ -0,0 +1,22 @@
+import { writeGithubAction } from './writeGithubAction.js';
+
+const init = {
+    command: ["initialize", "$0"],
+    describe: "Initialize Faable",
+    builder: (yargs) => {
+        return yargs
+            .option("overwrite", {
+            alias: "o",
+            type: "boolean",
+            description: "Overwrite generated file",
+            default: false,
+        })
+            .showHelpOnFail(false);
+    },
+    handler: async (args) => {
+        const { overwrite } = args;
+        await writeGithubAction({ overwrite });
+    },
+};
+
+export { init };

package/dist/commands/init/writeGithubAction.js

@@ -0,0 +1,108 @@
+import path__default from 'path';
+import fs from 'fs-extra';
+import { log } from '../../log.js';
+import prompts from 'prompts';
+import { CredentialsStore } from '../../lib/CredentialsStore.js';
+import yaml from 'yaml';
+
+const store = new CredentialsStore();
+const get_workflows_dir = () => {
+    return path__default.join(process.cwd(), ".github", "workflows");
+};
+const get_default_action = () => {
+    return path__default.join(get_workflows_dir(), "deploy.yml");
+};
+const demandConfig = async (force = false) => {
+    const creds = await store.loadCredentials();
+    if (creds?.apikey) {
+        return;
+    }
+    const { apikey } = await prompts([
+        {
+            type: "text",
+            name: "apikey",
+            message: "What is your Faable ApiKey?",
+        },
+    ]);
+    await store.saveApiKey({ apikey });
+};
+const tentativeName = async () => {
+    try {
+        const pkg = path__default.join(process.cwd(), "package.json");
+        const { name } = await fs.readJSON(pkg);
+        return name;
+    }
+    catch (error) {
+        return;
+    }
+};
+const checkPackageManager = async () => {
+    if (fs.existsSync(path__default.join(process.cwd(), "package-lock.json"))) {
+        return "npm";
+    }
+    if (fs.existsSync(path__default.join(process.cwd(), "yarn.lock"))) {
+        return "yarn";
+    }
+    throw new Error("No package-lock.json or yarn.lock file found");
+};
+const writeGithubAction = async (params = {}) => {
+    const { overwrite } = params;
+    await demandConfig();
+    const gh_action_file = get_default_action();
+    // Already configured
+    if (!overwrite && fs.pathExistsSync(gh_action_file)) {
+        log.info(`Github action is already configured.`);
+        return;
+    }
+    const onCancel = (prompt) => {
+        log.info("Cancel");
+        process.exit(0);
+    };
+    const { app_name } = await prompts([
+        {
+            type: "text",
+            name: "app_name",
+            initial: await tentativeName(),
+            message: "Which app are you deploying",
+        },
+    ], { onCancel });
+    const manager = await checkPackageManager();
+    const action = {
+        name: "Deploy to Faable",
+        on: {
+            push: {
+                branches: ["main"],
+            },
+        },
+        permissions: {
+            "id-token": "write",
+            "contents": "read"
+        },
+        jobs: {
+            deploy: {
+                "runs-on": "ubuntu-latest",
+                steps: [
+                    { uses: "actions/checkout@v2" },
+                    {
+                        uses: "actions/setup-node@v4",
+                        with: {
+                            "node-version": "lts/*",
+                        },
+                    },
+                    ...(manager == "npm" ? [{ run: "npm ci" }] : []),
+                    ...(manager == "yarn"
+                        ? [{ run: "yarn install --frozen-lockfile" }]
+                        : []),
+                    {
+                        name: "Deploy to Faable",
+                        run: `npx @faable/faable deploy ${app_name}`,
+                    },
+                ],
+            },
+        },
+    };
+    await fs.writeFile(gh_action_file, yaml.stringify(action));
+    log.info(`Written ${gh_action_file}`);
+};
+
+export { writeGithubAction };

package/dist/config.js

@@ -0,0 +1,10 @@
+import fs from 'fs-extra';
+import path__default from 'path';
+import { fileURLToPath } from 'url';
+
+const __filename$1 = fileURLToPath(import.meta.url);
+const __dirname$1 = path__default.dirname(__filename$1);
+const pkg = fs.readJSONSync(path__default.join(__dirname$1, "..", "package.json"));
+const version = pkg.version;
+
+export { version };

package/dist/index.js

@@ -0,0 +1,48 @@
+import yargs from 'yargs';
+import { hideBin } from 'yargs/helpers';
+import { apps } from './commands/apps/index.js';
+import { configure } from './commands/configure/index.js';
+import { deploy } from './commands/deploy/index.js';
+import { log } from './log.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}`);
+}, true)
+    .option("c", {
+    alias: "config",
+    description: "Path to the local `faable.json` file",
+    string: true,
+})
+    .middleware(function (argv) {
+    if (argv.config) {
+        Configuration.instance().setConfigFile(argv.config, {
+            ignoreWarnings: false,
+        });
+    }
+    else {
+        Configuration.instance();
+    }
+}, true)
+    .command(deploy)
+    .command(apps)
+    .command(configure)
+    .command(init)
+    .demandCommand(1)
+    .help()
+    .fail(function (msg, err) {
+    if (err) {
+        log.error(`❌ ${err.message}`);
+        process.exit(1);
+        return;
+    }
+    if (msg) {
+        yg.showHelp();
+        log.info(msg);
+    }
+})
+    .parse(hideBin(process.argv), {});

package/dist/lib/Configuration.js

@@ -0,0 +1,38 @@
+import path__default from 'path';
+import fs from 'fs-extra';
+import { log } from '../log.js';
+
+class Configuration {
+    static _instance;
+    config = {};
+    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);
+            log.info(`Loaded configuration from: ${file}`);
+        }
+        else {
+            if (!options.ignoreWarnings) {
+                log.warn(`Cannot read Faable config file ${file}`);
+            }
+        }
+    }
+    static instance() {
+        if (!Configuration._instance) {
+            Configuration._instance = new Configuration();
+        }
+        return Configuration._instance;
+    }
+    get startCommand() {
+        return this.config.startCommand || "npm run start";
+    }
+    get buildCommand() {
+        return this.config.buildCommand;
+    }
+}
+
+export { Configuration };

package/dist/lib/CredentialsStore.js

@@ -0,0 +1,36 @@
+import path__default from 'path';
+import os from 'os';
+import fs from 'fs-extra';
+import { log } from '../log.js';
+
+class CredentialsStore {
+    log;
+    faable_home;
+    constructor(log$1 = log) {
+        this.log = log$1;
+        this.faable_home = path__default.join(os.homedir(), ".faable");
+    }
+    async deleteCredentials() {
+        await fs.remove(this.faable_home);
+        this.log.info(`Deleted credentials`);
+    }
+    get credentials_path() {
+        return path__default.join(this.faable_home, "credentials");
+    }
+    async saveApiKey(config) {
+        await fs.ensureDir(this.faable_home);
+        await fs.writeJSON(this.credentials_path, config);
+        this.log.info(`Stored apikey`);
+    }
+    async loadCredentials() {
+        if (!fs.existsSync(this.credentials_path)) {
+            // No credentials found
+            return;
+        }
+        // Return credentials
+        const config = await fs.readJSON(this.credentials_path);
+        return config || {};
+    }
+}
+
+export { CredentialsStore };

package/dist/lib/cmd.js

@@ -0,0 +1,40 @@
+import { spawn } from 'promisify-child-process';
+import { log } from '../log.js';
+
+const cmd = async (cmd, config) => {
+    // Defaults
+    const enableOutput = config?.enableOutput || false;
+    const timeout = config?.timeout;
+    const cwd = config?.cwd;
+    const child = spawn("/bin/bash", ["-c", cmd], {
+        encoding: "utf8",
+        stdio: enableOutput ? "inherit" : "pipe",
+        timeout,
+        cwd,
+        env: {
+            ...process.env,
+            ...config?.env,
+        },
+    });
+    const out_data = [];
+    child.stderr?.on("data", (data) => {
+        out_data.push(data);
+    });
+    child.stdout?.on("data", (data) => {
+        out_data.push(data);
+    });
+    try {
+        const result = await child;
+        return result;
+    }
+    catch (error) {
+        const output = out_data.map((b) => b.toString()).join("\n");
+        log.error(error?.message);
+        if (output) {
+            log.error(output);
+        }
+        throw new Error(`Command error: ${cmd}`);
+    }
+};
+
+export { cmd };

package/dist/log.js

@@ -0,0 +1,13 @@
+import pino from 'pino';
+import 'pino-pretty';
+
+const log = pino({
+    transport: {
+        target: "pino-pretty",
+        options: {
+            colorize: true,
+        },
+    },
+});
+
+export { log };

package/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "@faable/faable",
+  "main": "dist/index.js",
+  "dependencies": {
+    "@actions/core": "^3.0.0",
+    "axios": "^1.13.2",
+    "fs-extra": "^11.3.2",
+    "handlebars": "^4.7.8",
+    "pino": "^10.1.0",
+    "pino-pretty": "^13.1.3",
+    "promisify-child-process": "^4.1.2",
+    "prompts": "^2.4.2",
+    "ramda": "^0.32.0",
+    "tslib": "^2.8.1",
+    "yaml": "^2.8.2",
+    "yargs": "^18.0.0"
+  },
+  "version": "0.0.0-dev",
+  "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"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/faablecloud/faable.git"
+  },
+  "homepage": "https://github.com/faablecloud/faable#readme"
+}