@faable/faable 1.9.0 → 1.11.0

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

@@ -0,0 +1,78 @@
+import fs from 'fs-extra';
+import path__default from 'path';
+import { FOREIGN_PLATFORMS } from './foreign_platforms.js';
+
+const DOCS_URL = "https://faable.com/docs/deploy/build-requirements";
+const MAX_LISTED_FILES = 20;
+/** Workdir listing for diagnostics: dirs suffixed "/", noise skipped, capped. */
+const list_found_files = (workdir) => {
+    try {
+        return fs
+            .readdirSync(workdir, { withFileTypes: true })
+            .filter((e) => ![".git", "node_modules"].includes(e.name))
+            .map((e) => (e.isDirectory() ? `${e.name}/` : e.name))
+            .sort()
+            .slice(0, MAX_LISTED_FILES);
+    }
+    catch {
+        return [];
+    }
+};
+const render_message = (props) => {
+    const pad = Math.max(...props.diagnostics.map((d) => d.buildpack.length + 11));
+    const looked = props.diagnostics
+        .flatMap((d) => {
+        const lines = [
+            `  ${d.buildpack.padEnd(pad)} → ${d.looked_for.join(", ")}`,
+        ];
+        if (d.fallback?.length) {
+            lines.push(`  ${`${d.buildpack} (fallback)`.padEnd(pad)} → ${d.fallback.join(", ")}`);
+        }
+        return lines;
+    })
+        .join("\n");
+    const found = props.found_files.length > 0
+        ? `\n\nFiles found in ${props.workdir}:\n  ${props.found_files.join(", ")}`
+        : `\n\nNo files found in ${props.workdir}.`;
+    const foreign = props.foreign.length > 0
+        ? `\n\nFound config for another platform:\n${props.foreign
+            .map((f) => `  ${f.file} → ${f.platform} — Faable can't use it directly.`)
+            .join("\n")}`
+        : "";
+    return (`Cannot detect how to build this project.\n\n` +
+        `Faable looked for (in order):\n${looked}` +
+        found +
+        foreign +
+        `\n\nFix: add one of the files above, or force a buildpack with "buildpack" in faable.json or --buildpack.\n` +
+        `Docs: ${DOCS_URL}`);
+};
+/**
+ * Thrown by the registry when no buildpack claims the project. The full
+ * multi-line diagnostic lives in `message`, so the CLI's standard error path
+ * (yargs .fail → log.error → exit 1) prints it without special handling.
+ */
+class DetectError extends Error {
+    workdir;
+    diagnostics;
+    found_files;
+    foreign;
+    constructor(workdir, buildpacks) {
+        const diagnostics = buildpacks.map((b) => ({
+            buildpack: b.name,
+            looked_for: b.detect_files,
+            ...(b.fallback_files ? { fallback: b.fallback_files } : {}),
+        }));
+        const found_files = list_found_files(workdir);
+        const foreign = Object.entries(FOREIGN_PLATFORMS)
+            .filter(([file]) => fs.existsSync(path__default.join(workdir, file)))
+            .map(([file, platform]) => ({ file, platform }));
+        super(render_message({ workdir, diagnostics, found_files, foreign }));
+        this.name = "DetectError";
+        this.workdir = workdir;
+        this.diagnostics = diagnostics;
+        this.found_files = found_files;
+        this.foreign = foreign;
+    }
+}
+
+export { DetectError };

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

@@ -0,0 +1,21 @@
+/**
+ * Config files from other deployment platforms. Recognizing them turns the
+ * detection-failure error from "nothing found" into "this repo is set up for
+ * X — Faable can't use that file directly". cerebrium.toml is deliberately
+ * absent (it has a real provider); Procfile too (it's a Faable input).
+ */
+const FOREIGN_PLATFORMS = {
+    "cog.yaml": "Replicate",
+    "fly.toml": "Fly.io",
+    "render.yaml": "Render",
+    "vercel.json": "Vercel",
+    "now.json": "Vercel",
+    "netlify.toml": "Netlify",
+    "app.yaml": "Google App Engine",
+    "railway.json": "Railway",
+    "railway.toml": "Railway",
+    "heroku.yml": "Heroku",
+    "captain-definition": "CapRover",
+};
+
+export { FOREIGN_PLATFORMS };

package/dist/commands/deploy/buildpacks/node/ensure_dependencies.js

@@ -46,8 +46,10 @@ const has_node_modules = (workdir, exists) => {
  */
 const ensure_dependencies = async (workdir, deps = {}) => {
     const { run = defaultRun, hasTool = defaultHasTool, exists = existsSync } = deps;
-    if (has_node_modules(workdir, exists))
+    if (has_node_modules(workdir, exists)) {
+        log.info(`📦 Dependencies already installed — skipping install (fresh dependencies)`);
         return;
+    }
     const has = (file) => exists(join(workdir, file));
     let install = "npm install --no-audit --no-fund";
     if (has("package-lock.json") || has("npm-shrinkwrap.json")) {

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

@@ -1,22 +1,29 @@
+import fs from 'fs-extra';
+import path__default from 'path';
 import { log } from '../../../../log.js';
 import { render_dockerfile, build_image } from '../shared/docker_image.js';
 import { has_any_of_files } from '../shared/has_any_of_files.js';
+import { cerebrium_provider } from './providers/cerebrium.js';
 import { pipfile_provider } from './providers/pipfile.js';
 import { pyproject_provider } from './providers/pyproject.js';
 import { requirements_provider } from './providers/requirements.js';
 import { resolve_python_version } from './python_version.js';
-import { read_dependencies_text, resolve_start, with_server_injection } from './resolve_start.js';
+import { resolve_start, with_server_injection, read_dependencies_text } from './resolve_start.js';
 
 const BANNER = `PYTHON_VERSION=$(python --version 2>&1)
 PIP_VERSION=$(pip --version 2>&1)
 
 echo "Faable Cloud · [$PYTHON_VERSION] [$PIP_VERSION]"`;
+const DOCS_URL = "https://faable.com/docs/deploy/build-requirements";
 // Evaluated in order: the first provider whose manifest exists supplies the
-// install command. Classic manifests come before platform-specific ones.
+// install command. Classic manifests come before platform-specific ones, so
+// a repo shipping both requirements.txt and cerebrium.toml builds from the
+// standard manifest.
 const PROVIDERS = [
     requirements_provider,
     pyproject_provider,
     pipfile_provider,
+    cerebrium_provider,
 ];
 const detect_with_provider = (ctx, provider) => {
     const resolved = provider.resolve(ctx.workdir);
@@ -25,7 +32,19 @@ const detect_with_provider = (ctx, provider) => {
     const deps = [read_dependencies_text(ctx.workdir), resolved.deps_text ?? ""]
         .join("\n")
         .toLowerCase();
-    const { start_command, server } = resolve_start(ctx.workdir, deps, ctx.config, resolved.start_hint);
+    let start_command;
+    let server;
+    try {
+        ({ start_command, server } = resolve_start(ctx.workdir, deps, ctx.config, resolved.start_hint));
+    }
+    catch (error) {
+        if (provider.name === "cerebrium") {
+            throw new Error("Detected a Cerebrium project (cerebrium.toml) but couldn't find a web " +
+                "entrypoint. Faable runs web services — expose a FastAPI/Flask app or " +
+                `set \`startCommand\` in faable.json. Docs: ${DOCS_URL}`, { cause: error });
+        }
+        throw error;
+    }
     // faable.json buildCommand overrides the provider's install. The cacheable
     // manifest layer only applies to the provider's own command — an arbitrary
     // buildCommand may need the full source.
@@ -51,12 +70,43 @@ const detect_with_provider = (ctx, provider) => {
 const python_buildpack = {
     name: "python",
     detect_files: PROVIDERS.flatMap((p) => p.files),
+    fallback_files: ["main.py", "app.py", "wsgi.py"],
     async detect(ctx) {
         const provider = PROVIDERS.find((p) => has_any_of_files(p.files, ctx.workdir));
         if (!provider)
             return null;
         return detect_with_provider(ctx, provider);
     },
+    // Weak-signal pass: a Python entrypoint with no dependency manifest at all.
+    // Registered as fallback so it loses against any strong trigger (Dockerfile).
+    async detect_fallback(ctx) {
+        const entries = this.fallback_files.filter((f) => fs.existsSync(path__default.join(ctx.workdir, f)));
+        if (entries.length === 0)
+            return null;
+        log.warn(`⚠️ No dependency manifest (requirements.txt/pyproject.toml/Pipfile) found — ` +
+            `building from ${entries.join(", ")} without installing dependencies. ` +
+            `Your app will likely need a requirements.txt; see ${DOCS_URL}`);
+        // Framework detection blob = the entry files themselves: an
+        // `from fastapi import FastAPI` line carries the token detection needs.
+        const deps = entries
+            .map((f) => fs.readFileSync(path__default.join(ctx.workdir, f)).toString())
+            .join("\n")
+            .toLowerCase();
+        const { start_command, server } = resolve_start(ctx.workdir, deps, ctx.config);
+        const install_command = with_server_injection(ctx.config.buildCommand, server, deps);
+        const version = resolve_python_version(ctx.workdir);
+        log.info(`Using python@${version}`);
+        log.info(`📦 Install command: ${install_command}`);
+        log.info(`⚙️ Start command: ${start_command}`);
+        return {
+            buildpack: "python",
+            runtime: { name: "python", version },
+            type: "python",
+            start_command,
+            install_command,
+            from: `python:${version}`,
+        };
+    },
     async build(ctx, plan) {
         // Dependencies install inside the image (unlike node); nothing runs on
         // the host here.

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

@@ -0,0 +1,43 @@
+import fs from 'fs-extra';
+import path__default from 'path';
+import { parse_cerebrium_toml } from './parse_cerebrium_toml.js';
+
+/**
+ * Cerebrium projects (cerebrium.toml + a Python entrypoint) declare their pip
+ * dependencies and python version in the toml instead of a requirements.txt.
+ * This provider translates that manifest so the standard python buildpack can
+ * build them — the masyosh/cere onboarding case.
+ */
+const cerebrium_provider = {
+    name: "cerebrium",
+    files: ["cerebrium.toml"],
+    resolve(workdir) {
+        const manifest = parse_cerebrium_toml(fs.readFileSync(path__default.join(workdir, "cerebrium.toml")).toString());
+        let install_command;
+        let install_files;
+        if (manifest.pip_requirements_file) {
+            install_command = `pip install --no-cache-dir -r ${manifest.pip_requirements_file}`;
+            // Copying the referenced file AND the toml ties the cached layer to both.
+            install_files = [manifest.pip_requirements_file, "cerebrium.toml"];
+        }
+        else if (manifest.pip_packages.length > 0) {
+            install_command = `pip install --no-cache-dir ${manifest.pip_packages
+                .map((spec) => `"${spec}"`)
+                .join(" ")}`;
+            // The command inlines the packages; copying the toml keeps the layer
+            // cache keyed to the manifest content.
+            install_files = ["cerebrium.toml"];
+        }
+        return {
+            install_command,
+            install_files,
+            python_version: manifest.python_version,
+            // Feed the pip package names into the framework-detection blob so e.g.
+            // `fastapi` in the toml triggers the existing uvicorn start resolution.
+            deps_text: manifest.pip_names.join("\n"),
+            start_hint: manifest.entrypoint,
+        };
+    },
+};
+
+export { cerebrium_provider };

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

@@ -0,0 +1,56 @@
+import { parse } from 'smol-toml';
+import { log } from '../../../../../log.js';
+
+const table = (value) => value && typeof value === "object" && !Array.isArray(value)
+    ? value
+    : {};
+/**
+ * Turn the pip table into installable requirement specs. Cerebrium uses
+ * `"latest"` / `""` for unpinned packages; anything else is a version spec —
+ * exact pins (`"2.0.0"`) become `==`, ranges (`">=2.0"`) pass through.
+ */
+const to_spec = (name, version) => {
+    const v = String(version ?? "").trim();
+    if (!v || v.toLowerCase() === "latest")
+        return name;
+    if (/^[0-9]/.test(v))
+        return `${name}==${v}`;
+    return `${name}${v}`;
+};
+const parse_cerebrium_toml = (content) => {
+    const root = table(table(parse(content)).cerebrium);
+    const deployment = table(root.deployment);
+    const dependencies = table(root.dependencies);
+    const pip = table(dependencies.pip);
+    const paths = table(dependencies.paths);
+    const custom = table(table(root.runtime).custom);
+    for (const skipped of ["apt", "conda"]) {
+        if (Object.keys(table(dependencies[skipped])).length > 0) {
+            log.warn(`cerebrium.toml declares ${skipped} dependencies — Faable only installs the pip table, ${skipped} packages are ignored`);
+        }
+    }
+    const pip_names = Object.keys(pip);
+    const pip_packages = pip_names.map((name) => to_spec(name, pip[name]));
+    const entrypoint_raw = custom.entrypoint;
+    const entrypoint = Array.isArray(entrypoint_raw)
+        ? entrypoint_raw.map(String).join(" ")
+        : typeof entrypoint_raw === "string" && entrypoint_raw.trim()
+            ? entrypoint_raw.trim()
+            : undefined;
+    const python_version = typeof deployment.python_version === "string" &&
+        deployment.python_version.trim()
+        ? deployment.python_version.trim()
+        : undefined;
+    const pip_requirements_file = typeof paths.pip === "string" && paths.pip.trim()
+        ? paths.pip.trim()
+        : undefined;
+    return {
+        python_version,
+        pip_packages,
+        pip_names,
+        pip_requirements_file,
+        entrypoint,
+    };
+};
+
+export { parse_cerebrium_toml };

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

@@ -1,3 +1,4 @@
+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';
@@ -54,7 +55,7 @@ const detect_buildpack = async (ctx, override) => {
         if (plan)
             return plan;
     }
-    throw new Error("Cannot detect project type");
+    throw new DetectError(ctx.workdir, BUILDPACKS);
 };
 
 export { BUILDPACKS, buildpack_names, detect_buildpack, get_buildpack };

package/dist/commands/deploy/index.js

@@ -74,7 +74,7 @@ const deploy = {
             ...git
         });
         const dashboard_url = `https://dashboard.faable.com/deploy/${app.team}/app/${app.id}`;
-        log.info(`🌍 Deployment created (${deployment.id}) -> https://${app.url}`);
+        log.info(`Preparing to deploy in faable cloud · ${deployment.id}`);
         log.info(`📊 View it in the dashboard -> ${dashboard_url}`);
         // Wait (up to 5 minutes) for the deployment to be promoted (live)
         const wait = (ms) => new Promise(resolve => setTimeout(resolve, ms));
@@ -98,7 +98,7 @@ const deploy = {
             }
         }
         if (promoted) {
-            log.info(`✅ Deployment promoted and live -> https://${app.url}`);
+            log.info(`🌍 Deployment promoted and live, visit: https://${app.url}`);
         }
         else {
             log.warn(`⌛ Timed out after 5min waiting for promotion. The deployment is still rolling out, check the dashboard -> ${dashboard_url}`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@faable/faable",
-  "version": "1.9.0",
+  "version": "1.11.0",
   "main": "dist/index.js",
   "license": "MIT",
   "author": "Marc Pomar <marc@faable.com>",
@@ -37,6 +37,7 @@
     "promisify-child-process": "^4.1.2",
     "prompts": "^2.4.2",
     "ramda": "^0.32.0",
+    "smol-toml": "^1.7.0",
     "tslib": "^2.8.1",
     "yaml": "^2.8.2",
     "yargs": "^18.0.0"