@faable/faable 1.16.0 → 1.18.0

package/dist/commands/deploy/buildpacks/python/providers/requirements.js

@@ -1,14 +0,0 @@
-const requirements_provider = {
-    name: "requirements",
-    files: ["requirements.txt"],
-    resolve() {
-        return {
-            install_command: "pip install --no-cache-dir -r requirements.txt",
-            // Copying only the manifest keeps the install layer cached until
-            // requirements.txt itself changes.
-            install_files: ["requirements.txt"],
-        };
-    },
-};
-
-export { requirements_provider };

package/dist/commands/deploy/buildpacks/python/python_version.js

@@ -1,41 +0,0 @@
-import fs from 'fs-extra';
-import path__default from 'path';
-import { read_text_file } from '../shared/read_text_file.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. provider hint        → e.g. cerebrium.toml `python_version`
- *  4. pyproject.toml       → `requires-python = ">=3.11"` (first concrete X.Y[.Z])
- * Falls back to DEFAULT_VERSION.
- */
-const resolve_python_version = (workdir, provider_hint) => {
-    const runtime_config = path__default.join(workdir, "runtime.txt");
-    if (fs.existsSync(runtime_config)) {
-        const runtime_data = read_text_file(runtime_config).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 = read_text_file(python_version_file).trim();
-        if (version)
-            return version;
-    }
-    if (provider_hint)
-        return provider_hint;
-    const pyproject = path__default.join(workdir, "pyproject.toml");
-    if (fs.existsSync(pyproject)) {
-        const toml = read_text_file(pyproject);
-        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;
-};
-
-export { resolve_python_version };

package/dist/commands/deploy/buildpacks/python/resolve_start.js

@@ -1,149 +0,0 @@
-import fs from 'fs-extra';
-import path__default from 'path';
-import { log } from '../../../../log.js';
-import { read_text_file } from '../shared/read_text_file.js';
-import { parse_procfile } from './parse_procfile.js';
-
-/** Combine all classic dependency manifests into one lowercased blob. */
-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) => read_text_file(p))
-        .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(read_text_file(abs)))
-            return module;
-    }
-    return first_existing;
-};
-/**
- * Resolve the container start command and which server it needs installed.
- * Precedence: faable.json startCommand → Procfile `web:` → provider start
- * hint (e.g. cerebrium entrypoint) → framework detection (Django → FastAPI/
- * ASGI → Flask).
- */
-const resolve_start = (workdir, deps, config, start_hint) => {
-    // 1. Explicit override in faable.json
-    if (config.startCommand) {
-        log.info(`Using start command from faable.json`);
-        return {
-            start_command: config.startCommand,
-            server: server_from_command(config.startCommand),
-        };
-    }
-    // 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. Provider hint (e.g. cerebrium.toml runtime entrypoint)
-    if (start_hint) {
-        log.info(`Using start command from the project manifest`);
-        return { start_command: start_hint, server: server_from_command(start_hint) };
-    }
-    // 4. 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.");
-};
-/**
- * Append the WSGI/ASGI server install when the start command needs one that
- * isn't already declared in the dependencies. Returns "true" (no-op) when
- * there is nothing to install at all.
- */
-const with_server_injection = (base, server, deps) => {
-    const steps = base ? [base] : [];
-    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) {
-        return "true";
-    }
-    return steps.join(" && ");
-};
-
-export { find_app_module, has_token, read_dependencies_text, resolve_start, with_server_injection };

package/dist/commands/deploy/buildpacks/registry.js

@@ -1,61 +0,0 @@
-import { DetectError } from './DetectError.js';
-import { docker_buildpack } from './docker/index.js';
-import { node_buildpack } from './node/index.js';
-import { python_buildpack } from './python/index.js';
-
-/**
- * Ordered registry, first claim wins. Order is load-bearing:
- *  1. node before python — full-stack repos shipping both a package.json and
- *     Python manifests build as node (historical rule).
- *  2. python (all its manifest providers) before docker — a dependency
- *     manifest beats a Dockerfile; the Dockerfile is the explicit escape
- *     hatch evaluated last among strong triggers.
- * Weak signals (python's entrypoint fallback) run in a second pass so they
- * lose against ANY strong trigger without buildpacks knowing about each other.
- */
-const BUILDPACKS = [
-    node_buildpack,
-    python_buildpack,
-    docker_buildpack,
-];
-const buildpack_names = () => BUILDPACKS.map((b) => b.name);
-const get_buildpack = (name) => BUILDPACKS.find((b) => b.name === name);
-/**
- * Resolve the buildpack plan for a workdir. `override` (from --buildpack or
- * faable.json) skips detection order and forces one buildpack; it still runs
- * that buildpack's detect so the plan is computed from real project files.
- */
-const detect_buildpack = async (ctx, override) => {
-    if (override) {
-        const buildpack = get_buildpack(override);
-        if (!buildpack) {
-            throw new Error(`Unknown buildpack "${override}". Valid buildpacks: ${buildpack_names().join(", ")}.`);
-        }
-        const plan = (await buildpack.detect(ctx)) ??
-            (await buildpack.detect_fallback?.(ctx)) ??
-            null;
-        if (!plan) {
-            throw new Error(`Buildpack "${override}" was forced but none of its trigger files ` +
-                `(${[...buildpack.detect_files, ...(buildpack.fallback_files ?? [])].join(", ")}) ` +
-                `exist in ${ctx.workdir}.`);
-        }
-        return plan;
-    }
-    // Strong pass: manifests and Dockerfiles.
-    for (const buildpack of BUILDPACKS) {
-        const plan = await buildpack.detect(ctx);
-        if (plan)
-            return plan;
-    }
-    // Fallback pass: weak signals, only when nothing claimed the project.
-    for (const buildpack of BUILDPACKS) {
-        if (!buildpack.detect_fallback)
-            continue;
-        const plan = await buildpack.detect_fallback(ctx);
-        if (plan)
-            return plan;
-    }
-    throw new DetectError(ctx.workdir, BUILDPACKS);
-};
-
-export { BUILDPACKS, buildpack_names, detect_buildpack, get_buildpack };

package/dist/commands/deploy/buildpacks/shared/docker_image.js

@@ -1,49 +0,0 @@
-import fs from 'fs-extra';
-import Handlebars from 'handlebars';
-import * as path from 'path';
-import { fileURLToPath } from 'url';
-import { cmd } from '../../../../lib/cmd.js';
-import { log } from '../../../../log.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_source = fs
-    .readFileSync(path.join(templates_dir, "Dockerfile"))
-    .toString();
-const entrypoint_source = fs
-    .readFileSync(path.join(templates_dir, "entrypoint.sh"))
-    .toString("utf-8");
-// Backslash-escape content so it survives BOTH the unquoted bash heredoc the
-// Dockerfile is piped through (docker build -f -<<EOF) and, for the entry
-// script, the single-quoted `RUN echo '...'`.
-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_source);
-const entrypoint_template = Handlebars.compile(entrypoint_source);
-/** Pure render of the final Dockerfile contents — snapshot-tested. */
-const render_dockerfile = (params) => {
-    // NOTE: use slim to build projects
-    const from = [params.from, "slim"].filter((e) => e).join("-");
-    const entry_script = entrypoint_template({ banner: params.banner });
-    return docker_template({
-        from,
-        env: params.env,
-        entry_script,
-        start_command: params.start_command,
-        install_command: params.install_command,
-        install_files: params.install_files,
-    });
-};
-const build_image = async (props) => {
-    const { app, workdir, dockerfile } = props;
-    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_image, render_dockerfile };

package/dist/commands/deploy/buildpacks/shared/has_any_of_files.js

@@ -1,14 +0,0 @@
-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/buildpacks/shared/read_text_file.js

@@ -1,31 +0,0 @@
-import fs from 'fs-extra';
-
-/**
- * Decode a manifest/source buffer to a string, honoring a leading BOM.
- *
- * Editors and shells on Windows (PowerShell `>` redirection, Notepad "Save As")
- * frequently write files as UTF‑16 with a BOM. Reading those as UTF‑8 yields
- * mojibake with interleaved NUL bytes (`f\x00a\x00s\x00t…`), which silently
- * breaks token detection — e.g. `\bfastapi\b` never matches a UTF‑16
- * `requirements.txt`, so the Python buildpack skips framework detection and
- * fails with "Could not detect how to start this Python app". Detect the BOM and
- * decode accordingly, stripping the BOM from the result.
- */
-const decode_buffer = (buf) => {
-    if (buf.length >= 2 && buf[0] === 0xff && buf[1] === 0xfe) {
-        return new TextDecoder("utf-16le").decode(buf.subarray(2));
-    }
-    if (buf.length >= 2 && buf[0] === 0xfe && buf[1] === 0xff) {
-        return new TextDecoder("utf-16be").decode(buf.subarray(2));
-    }
-    if (buf.length >= 3 && buf[0] === 0xef && buf[1] === 0xbb && buf[2] === 0xbf) {
-        return buf.subarray(3).toString("utf8");
-    }
-    return buf.toString("utf8");
-};
-/** Read a file to a string, decoding UTF‑16/UTF‑8 BOMs (see {@link decode_buffer}). */
-const read_text_file = (file) => decode_buffer(fs.readFileSync(file));
-/** Read and parse a JSON file, tolerating a UTF‑16/UTF‑8 BOM. */
-const read_json_file = (file) => JSON.parse(read_text_file(file));
-
-export { decode_buffer, read_json_file, read_text_file };

package/dist/commands/deploy/buildpacks/shared/templates/Dockerfile

@@ -1,38 +0,0 @@
-FROM {{from}}
-LABEL com.faable.cloud="FaableCloud"
-LABEL description="Faablecloud automatic deployment"
-
-WORKDIR /faable/app
-
-# Environment variables for runtime
-ENV PORT=80
-{{#each env}}
-ENV {{@key}}={{this}}
-{{/each}}
-# `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}}}"
-
-{{#if install_files}}
-# Copy dependency manifests first so the install layer stays cached until
-# they change (any source change no longer reinstalls dependencies).
-{{#each install_files}}
-COPY {{this}} ./
-{{/each}}
-RUN {{{escape install_command}}}
-{{/if}}
-
-# Copy Usercode
-COPY . .
-
-{{#unless install_files}}
-{{#if install_command}}
-# Install needs the full source (e.g. `pip install .`), so it runs after COPY.
-RUN {{{escape install_command}}}
-{{/if}}
-{{/unless}}
-
-# Entrypoint stript
-RUN echo '{{{escape entry_script}}}' >> entrypoint.sh
-
-CMD ["/bin/sh", "./entrypoint.sh"]

package/dist/commands/deploy/buildpacks/shared/templates/entrypoint.sh

@@ -1,4 +0,0 @@
-#!/bin/sh
-
-{{{banner}}}
-eval $START_COMMAND