@faable/faable 1.5.28 → 1.5.30

package/README.md

@@ -21,6 +21,54 @@ To install the latest version of Faable CLI:
 npm i -g @faable/faable
 ```
 
+## Runtimes
+
+`faable deploy` auto-detects the runtime from the files in your project (no
+config needed in the common case):
+
+| Detected by | Runtime |
+| --- | --- |
+| `package.json` | Node.js (Next.js, Vite, Astro, Gatsby, CRA, Vue, Angular, …) |
+| `requirements.txt` / `pyproject.toml` / `Pipfile` | Python |
+| `Dockerfile` | Your own image (any language) |
+
+> A project with a `package.json` is always treated as Node. To deploy a Python
+> backend that also has a `package.json`, ship a `Dockerfile` instead.
+
+### Node.js / static frameworks
+
+SPA frameworks are built and served automatically. If the project has **no
+`start` script**, the built output is served statically (e.g. Vite → `npx vite
+preview`, CRA/Vue/Angular → `serve`). If it defines a `start` script (custom SSR,
+Next.js, Nuxt, Remix, …), that command is used.
+
+### Python
+
+The start command is detected from your framework:
+
+| Framework | Detected from | Start command |
+| --- | --- | --- |
+| Django | `manage.py` + the package with `wsgi.py` | `gunicorn <pkg>.wsgi:application` |
+| FastAPI / ASGI | `fastapi`/`uvicorn`/`starlette` dep | `uvicorn <module>:app` |
+| Flask | `flask` dep | `gunicorn <module>:app` |
+
+Dependencies are installed inside the image from `requirements.txt`,
+`pyproject.toml` or `Pipfile`. `gunicorn`/`uvicorn` are installed automatically
+if missing.
+
+Pin the Python version with a `runtime.txt` (`python-3.11.3`), a
+`.python-version`, or `requires-python` in `pyproject.toml`.
+
+### Overriding detection
+
+When auto-detection doesn't fit, set the commands explicitly:
+
+- `faable.json` — `{ "buildCommand": "...", "startCommand": "..." }`
+- `Procfile` — a `web:` line, e.g. `web: gunicorn app:app --bind 0.0.0.0:$PORT`
+
+Precedence: `faable.json` → `Procfile` → auto-detection. The container listens on
+`$PORT` (80).
+
 ## Documentation
 
 For details on how to use Faable CLI, check out our

package/dist/api/context.js

@@ -7,12 +7,8 @@ import { CredentialsStore } from '../lib/CredentialsStore.js';
 
 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 } });
-    }
-    else if (process.env.FAABLE_TOKEN) {
+    // Auth resolution: FAABLE_TOKEN → OIDC (CI) → local `faable login` credentials.
+    if (process.env.FAABLE_TOKEN) {
         // Token in environment
         const token = process.env.FAABLE_TOKEN;
         api = FaableApi.create({ authStrategy: bearer_strategy, auth: { token } });

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

@@ -1,12 +1,34 @@
+import axios from 'axios';
 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 { access_token, app_id } = res.data;
-    return { access_token, app_id };
+    try {
+        const res = await client.post("/auth/github-oidc", {
+            token: gh_token
+        });
+        const { access_token, app_id } = res.data;
+        return { access_token, app_id };
+    }
+    catch (err) {
+        if (axios.isAxiosError(err)) {
+            const status = err.response?.status;
+            const serverMessage = err.response?.data?.message;
+            // No app is linked to this repository — turn the cryptic 404 into an
+            // actionable next step.
+            if (status === 404) {
+                throw new Error('No app linked to this repository. Run "faable link" locally to link it, ' +
+                    "or link it from the dashboard (https://dashboard.faable.com).");
+            }
+            // Monorepo: several apps are linked to the same repository.
+            if (status === 400) {
+                throw new Error(serverMessage ||
+                    "This repository has multiple linked apps. Specify which one with `faable deploy <app_id>`.");
+            }
+            throw new Error(`Faable OIDC token exchange failed (${status ?? "network error"})${serverMessage ? `: ${serverMessage}` : ""}`);
+        }
+        throw err;
+    }
 };
 const oidc_strategy = (config) => {
     const { idToken } = config;

package/dist/commands/deploy/git_context.js

@@ -14,7 +14,9 @@ const gitRunner = (workdir) => command => new Promise(resolve => {
 // Resolve the commit / ref / actor for the current deploy. In GitHub Actions
 // these come from the standard env vars; locally we fall back to git so manual
 // deploys still record a commit. `github_actor` is CI-only (a GitHub login),
-// left undefined locally where no reliable login is available.
+// left undefined locally where no reliable login is available. The commit
+// message has no standard CI env var, so it is always read from git (for the
+// resolved commit, falling back to HEAD) — the dashboard shows its first line.
 const git_context = async (opts) => {
     const env = opts?.env ?? process.env;
     const run = opts?.run ?? gitRunner(opts?.workdir);
@@ -26,6 +28,12 @@ const git_context = async (opts) => {
             github_ref = `refs/heads/${branch}`;
     }
     const github_actor = env.GITHUB_ACTOR || undefined;
+    // Full commit message (subject + body) for the resolved commit; the dashboard
+    // renders only the subject line. Fall back to HEAD when the SHA isn't
+    // resolvable in the local checkout (e.g. shallow clones).
+    const github_commit_message = (github_commit &&
+        (await run(`git show -s --format=%B ${github_commit}`))) ||
+        (await run("git log -1 --pretty=%B"));
     const ctx = {};
     if (github_commit)
         ctx.github_commit = github_commit;
@@ -33,6 +41,8 @@ const git_context = async (opts) => {
         ctx.github_ref = github_ref;
     if (github_actor)
         ctx.github_actor = github_actor;
+    if (github_commit_message)
+        ctx.github_commit_message = github_commit_message;
     return ctx;
 };
 

package/dist/commands/deploy/index.js

@@ -1,9 +1,11 @@
 import { context } from '../../api/context.js';
 import { cmd } from '../../lib/cmd.js';
+import { Configuration } from '../../lib/Configuration.js';
 import { log } from '../../log.js';
 import { check_environment } from './check_environment.js';
 import { git_context } from './git_context.js';
 import { build_node } from './node-pipeline/index.js';
+import { build_python } from './python-pipeline/index.js';
 import { runtime_detection } from './runtime-detect/runtime_detection.js';
 import { upload_tag } from './upload_tag.js';
 
@@ -29,9 +31,13 @@ const deploy = {
         const { api } = ctx;
         // Resolve runtime
         const { runtime } = await runtime_detection(workdir);
-        const app_id = args.app_id || ctx.appId;
+        // app_id resolution (the user never has to look one up):
+        //  1. explicit positional (monorepo escape hatch)
+        //  2. OIDC in CI — the backend resolves the app from the linked repository
+        //  3. locally — the app saved by `faable link` in faable.json
+        const app_id = args.app_id || ctx.appId || Configuration.instance().app_id;
         if (!app_id) {
-            throw new Error('Missing <app_id>, run inside github action or pass <app_id> after deploy command');
+            throw new Error('No app linked to this repository. Run "faable link" to link it (or link it from the dashboard).');
         }
         const app = await api.getApp(app_id);
         // Check if we can build docker images
@@ -48,6 +54,12 @@ const deploy = {
             });
             type = node_result.type;
         }
+        else if (runtime.name == 'python') {
+            const python_result = await build_python(app, {
+                workdir,
+                runtime});
+            type = python_result.type;
+        }
         else if (runtime.name == 'docker') {
             type = 'node';
             await cmd(`docker build -t ${app.id} .`, {

package/dist/commands/deploy/python-pipeline/analyze_python.js

@@ -0,0 +1,158 @@
+import fs from 'fs-extra';
+import path__default from 'path';
+import { log } from '../../../log.js';
+import { Configuration } from '../../../lib/Configuration.js';
+import { parse_procfile } from './parse_procfile.js';
+
+/** Combine all dependency manifests into one lowercased blob for cheap lookups. */
+const read_dependencies_text = (workdir) => {
+    const files = ["requirements.txt", "pyproject.toml", "Pipfile"];
+    return files
+        .map((f) => path__default.join(workdir, f))
+        .filter((p) => fs.existsSync(p))
+        .map((p) => fs.readFileSync(p).toString())
+        .join("\n")
+        .toLowerCase();
+};
+const has_token = (deps, token) => new RegExp(`\\b${token}\\b`).test(deps);
+/** Identify which server binary a start command relies on, to ensure it's installed. */
+const server_from_command = (command) => {
+    const bin = command.trim().split(/\s+/)[0];
+    if (bin === "gunicorn")
+        return "gunicorn";
+    if (bin === "uvicorn")
+        return "uvicorn";
+    return null;
+};
+/** Django project package = the directory that contains wsgi.py. */
+const find_django_package = (workdir) => {
+    const entries = fs.readdirSync(workdir, { withFileTypes: true });
+    for (const entry of entries) {
+        if (entry.isDirectory() &&
+            fs.existsSync(path__default.join(workdir, entry.name, "wsgi.py"))) {
+            return entry.name;
+        }
+    }
+    return null;
+};
+/**
+ * Find the module that defines the app object, returning its dotted module path
+ * (e.g. `main`, `app.main`). Prefers a file matching `pattern`, else the first
+ * existing candidate.
+ */
+const find_app_module = (workdir, pattern) => {
+    const candidates = [
+        "main.py",
+        "app.py",
+        "asgi.py",
+        "wsgi.py",
+        "application.py",
+        "server.py",
+        path__default.join("app", "main.py"),
+        path__default.join("app", "app.py"),
+        path__default.join("src", "main.py"),
+    ];
+    let first_existing = null;
+    for (const rel of candidates) {
+        const abs = path__default.join(workdir, rel);
+        if (!fs.existsSync(abs))
+            continue;
+        const module = rel.replace(/\.py$/, "").split(path__default.sep).join(".");
+        if (!first_existing)
+            first_existing = module;
+        if (pattern.test(fs.readFileSync(abs).toString()))
+            return module;
+    }
+    return first_existing;
+};
+/** Resolve the container start command and which server it needs installed. */
+const resolve_start = (workdir, deps) => {
+    // 1. Explicit override in faable.json
+    const configured = Configuration.instance().configuredStartCommand;
+    if (configured) {
+        log.info(`Using start command from faable.json`);
+        return { start_command: configured, server: server_from_command(configured) };
+    }
+    // 2. Procfile `web:` line
+    const procfile = parse_procfile(workdir);
+    if (procfile) {
+        log.info(`Using start command from Procfile`);
+        return { start_command: procfile, server: server_from_command(procfile) };
+    }
+    // 3. Framework detection
+    // Django: manage.py + the package holding wsgi.py
+    if (fs.existsSync(path__default.join(workdir, "manage.py"))) {
+        const pkg = find_django_package(workdir);
+        if (!pkg) {
+            throw new Error("Detected Django (manage.py) but couldn't find the wsgi.py package. Set `startCommand` in faable.json or add a Procfile.");
+        }
+        return {
+            start_command: `gunicorn ${pkg}.wsgi:application --bind 0.0.0.0:$PORT`,
+            server: "gunicorn",
+        };
+    }
+    // FastAPI / ASGI
+    if (has_token(deps, "fastapi") ||
+        has_token(deps, "starlette") ||
+        has_token(deps, "uvicorn")) {
+        const module = find_app_module(workdir, /app\s*=\s*(FastAPI|Starlette)\(/i);
+        if (module) {
+            return {
+                start_command: `uvicorn ${module}:app --host 0.0.0.0 --port $PORT`,
+                server: "uvicorn",
+            };
+        }
+    }
+    // Flask
+    if (has_token(deps, "flask")) {
+        const module = find_app_module(workdir, /app\s*=\s*Flask\(/i);
+        if (module) {
+            return {
+                start_command: `gunicorn ${module}:app --bind 0.0.0.0:$PORT`,
+                server: "gunicorn",
+            };
+        }
+    }
+    throw new Error("Could not detect how to start this Python app. Set `startCommand` in faable.json or add a Procfile with a `web:` line.");
+};
+/** Build the dependency-install command run during the Docker build. */
+const build_install_command = (workdir, server, deps) => {
+    const steps = [];
+    const configured_build = Configuration.instance().buildCommand;
+    if (configured_build) {
+        steps.push(configured_build);
+    }
+    else if (fs.existsSync(path__default.join(workdir, "requirements.txt"))) {
+        steps.push("pip install --no-cache-dir -r requirements.txt");
+    }
+    else if (fs.existsSync(path__default.join(workdir, "pyproject.toml"))) {
+        steps.push("pip install --no-cache-dir .");
+    }
+    else if (fs.existsSync(path__default.join(workdir, "Pipfile"))) {
+        steps.push("pip install --no-cache-dir pipenv && pipenv install --system --deploy");
+    }
+    // Ensure the WSGI/ASGI server is available when not already declared.
+    if (server === "gunicorn" && !has_token(deps, "gunicorn")) {
+        steps.push("pip install --no-cache-dir gunicorn");
+    }
+    if (server === "uvicorn" && !has_token(deps, "uvicorn")) {
+        steps.push("pip install --no-cache-dir uvicorn[standard]");
+    }
+    if (steps.length === 0) {
+        // No manifest found — nothing to install, but warn the user.
+        log.warn("No requirements.txt/pyproject.toml/Pipfile found");
+        return "true";
+    }
+    return steps.join(" && ");
+};
+const analyze_python = async (params) => {
+    const { workdir } = params;
+    const deps = read_dependencies_text(workdir);
+    const { start_command, server } = resolve_start(workdir, deps);
+    const install_command = build_install_command(workdir, server, deps);
+    log.info(`📦 Install command: ${install_command}`);
+    log.info(`⚙️ Start command: ${start_command}`);
+    return { install_command, start_command };
+};
+
+export { analyze_python };

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

@@ -0,0 +1,42 @@
+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';
+
+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_lines = variable
+        .replace(/(['`\\])/g, "\\$1")
+        .replace(/([$])/g, "\\$1");
+    return escaped_lines.split("\n").join("\\n");
+});
+const docker_template = Handlebars.compile(dockerfile);
+const entrypoint_template = Handlebars.compile(entrypoint);
+const build_docker = async (props) => {
+    const { app, workdir, install_command, start_command, template_context } = props;
+    const entrypoint_custom = entrypoint_template({});
+    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}`);
+    const dockerfile = docker_template({
+        from,
+        entry_script: entrypoint_custom,
+        install_command,
+        start_command,
+    });
+    log.info(`📦 Packaging inside a docker image`);
+    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/python-pipeline/index.js

@@ -0,0 +1,25 @@
+import { analyze_python } from './analyze_python.js';
+import { build_docker } from './build_docker.js';
+
+const build_python = async (app, options) => {
+    const { workdir, runtime } = options;
+    if (!runtime.version) {
+        throw new Error("Runtime version not specified for python");
+    }
+    // Resolve how to install deps and start the app. Unlike node, there is no
+    // separate local build step: dependency install happens inside the Docker
+    // build (where network is available), so we go straight to packaging.
+    const { install_command, start_command } = await analyze_python({ workdir });
+    await build_docker({
+        app,
+        workdir,
+        install_command,
+        start_command,
+        template_context: {
+            from: `python:${runtime.version}`,
+        },
+    });
+    return { type: "python" };
+};
+
+export { build_python };

package/dist/commands/deploy/python-pipeline/parse_procfile.js

@@ -0,0 +1,22 @@
+import fs from 'fs-extra';
+import path__default from 'path';
+
+/**
+ * Read the `web:` process command from a Procfile, if present. Returns null when
+ * there's no Procfile or no `web` entry. Used as a manual start-command override
+ * (Heroku-style) before falling back to framework detection.
+ */
+const parse_procfile = (workdir) => {
+    const procfile = path__default.join(workdir, "Procfile");
+    if (!fs.existsSync(procfile))
+        return null;
+    const content = fs.readFileSync(procfile).toString();
+    for (const line of content.split("\n")) {
+        const match = line.match(/^\s*web\s*:\s*(.+?)\s*$/);
+        if (match?.[1])
+            return match[1];
+    }
+    return null;
+};
+
+export { parse_procfile };

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

@@ -0,0 +1,24 @@
+FROM {{from}}
+LABEL com.faable.cloud="FaableCloud"
+LABEL description="Faablecloud automatic deployment"
+
+WORKDIR /faable/app
+
+# Environment variables for runtime
+ENV PORT=80
+ENV PYTHONUNBUFFERED=1
+# `escape` keeps `$PORT` literal so the build heredoc (unquoted bash) doesn't
+# eat it; Docker then expands $PORT (=80) when building the ENV value.
+ENV START_COMMAND="{{{escape start_command}}}"
+
+# Copy Usercode
+COPY . .
+
+# Install dependencies (Python needs them built into the image, unlike node_modules).
+# Triple-stache + escape: keep `&&` intact and any `$` heredoc-safe.
+RUN {{{escape install_command}}}
+
+# Entrypoint stript
+RUN echo '{{{escape entry_script}}}' >> entrypoint.sh
+
+CMD ["/bin/sh", "./entrypoint.sh"]

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

@@ -0,0 +1,7 @@
+#!/bin/sh
+
+PYTHON_VERSION=$(python --version 2>&1)
+PIP_VERSION=$(pip --version 2>&1)
+
+echo "Faable Cloud · [$PYTHON_VERSION] [$PIP_VERSION]"
+eval $START_COMMAND

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

@@ -2,12 +2,18 @@ import * as R from 'ramda';
 import { has_any_of_files } from './helpers/has_any_of_files.js';
 import { strategy_docker } from './strategies/docker.js';
 import { strategy_nodejs } from './strategies/nodejs.js';
+import { strategy_python } from './strategies/python.js';
 
 const runtime_detection = async (workdir) => {
     const has = R.curry(has_any_of_files);
+    // Order matters: node wins for full-stack apps that ship both a package.json
+    // and Python deps; Dockerfile is the explicit escape hatch evaluated last.
     const strategy = R.cond([
         [has(['package.json']), R.always(strategy_nodejs)],
-        // [has(["requirements.txt"]), R.always(strategy_python)],
+        [
+            has(['requirements.txt', 'pyproject.toml', 'Pipfile']),
+            R.always(strategy_python)
+        ],
         [has(['Dockerfile']), R.always(strategy_docker)]
     ])(workdir);
     if (!strategy) {

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

@@ -0,0 +1,48 @@
+import fs from 'fs-extra';
+import path__default from 'path';
+import { log } from '../../../../log.js';
+
+const DEFAULT_VERSION = "3.11.3";
+/**
+ * Resolve the Python version from (in order):
+ *  1. runtime.txt          → `python-3.11.3`
+ *  2. .python-version      → `3.11.3` (pyenv)
+ *  3. pyproject.toml       → `requires-python = ">=3.11"` (first concrete X.Y[.Z])
+ * Falls back to DEFAULT_VERSION.
+ */
+const resolve_python_version = (workdir) => {
+    const runtime_config = path__default.join(workdir, "runtime.txt");
+    if (fs.existsSync(runtime_config)) {
+        const runtime_data = fs.readFileSync(runtime_config).toString().trim();
+        if (!runtime_data.startsWith("python-")) {
+            throw new Error("runtime.txt must have runtime format with python-<version>");
+        }
+        return runtime_data.split("-")[1];
+    }
+    const python_version_file = path__default.join(workdir, ".python-version");
+    if (fs.existsSync(python_version_file)) {
+        const version = fs.readFileSync(python_version_file).toString().trim();
+        if (version)
+            return version;
+    }
+    const pyproject = path__default.join(workdir, "pyproject.toml");
+    if (fs.existsSync(pyproject)) {
+        const toml = fs.readFileSync(pyproject).toString();
+        const match = toml.match(/requires-python\s*=\s*["'][^0-9]*([0-9]+\.[0-9]+(?:\.[0-9]+)?)/);
+        if (match?.[1])
+            return match[1];
+    }
+    return DEFAULT_VERSION;
+};
+const strategy_python = async (workdir) => {
+    const runtime_version = resolve_python_version(workdir);
+    log.info(`Using python@${runtime_version}`);
+    return {
+        runtime: {
+            name: "python",
+            version: runtime_version,
+        },
+    };
+};
+
+export { strategy_python };

package/dist/commands/link/index.js

@@ -24,14 +24,10 @@ const getGitRemoteUrl = async (workdir) => {
     }
 };
 const link = {
-    command: "link [app_id]",
+    command: "link",
     describe: "Link the local repository with a Faable app",
     builder: (yargs) => {
         return yargs
-            .positional("app_id", {
-            type: "string",
-            description: "app_id to link this repository",
-        })
             .option("workdir", {
             alias: "w",
             type: "string",
@@ -41,7 +37,14 @@ const link = {
     },
     handler: async (args) => {
         const workdir = args.workdir || process.cwd();
-        const { app_id } = args;
+        // `faable link <app_id>` is deprecated. Linking is now fully interactive and
+        // the repository is auto-detected from the current folder — users never need
+        // to look up an app_id. Warn if an extra positional was passed and ignore it.
+        const stray = (args._ ?? []).slice(1);
+        if (stray.length > 0) {
+            log.warn('Passing an app_id to "faable link" is deprecated and ignored. ' +
+                'Just run "faable link" and select the app from the list.');
+        }
         const config = Configuration.instance();
         if (config.app_id) {
             log.info(`This repository is already linked to app: "${config.app_slug}" (${config.app_id})`);
@@ -60,26 +63,20 @@ const link = {
         const { api } = await context();
         log.info("Checking local git repository...");
         const gitUrl = await getGitRemoteUrl(workdir);
-        let selectedApp;
-        if (!app_id) {
-            const apps = await api.list();
-            if (apps.length === 0) {
-                log.error("No apps found in your account. Create one first at https://faable.com");
-                return;
-            }
-            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,
-                })),
-            });
-        }
-        else {
-            selectedApp = await api.getApp(app_id);
+        const apps = await api.list();
+        if (apps.length === 0) {
+            log.error("No apps found in your account. Create one first at https://faable.com");
+            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;

package/dist/lib/Configuration.js

@@ -49,7 +49,7 @@ class Configuration {
         return this.config.app_slug;
     }
     get app_id() {
-        return this.config.app_slug;
+        return this.config.app_id;
     }
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@faable/faable",
-  "version": "1.5.28",
+  "version": "1.5.30",
   "main": "dist/index.js",
   "license": "MIT",
   "author": "Marc Pomar <marc@faable.com>",