@faable/faable 1.16.0 → 1.18.0

package/dist/api/FaableApi.js

@@ -76,9 +76,24 @@ class FaableApi {
     // `image`/`type` are optional to support the failure path: a failed build
     // is recorded as a deployment without an image (and without `type`, which
     // would otherwise rewrite the app's runtime_strategy server-side).
+    // `source` is the remote-build path (v2): content-addressed manifest +
+    // serialized BuildPlan; the platform builds and completes the image.
     async createDeployment(params) {
         return data(this.client.post(`/deployment`, params));
     }
+    // Remote builds: diff the source manifest against the CAS. Returns
+    // presigned PUTs (sha-pinned by signature) for the missing blobs only.
+    async uploadMissing(app_id, files) {
+        return data(this.client.post(`/upload/missing`, {
+            app_id,
+            files: files.map(({ path, sha, size }) => ({ path, sha, size })),
+        }, { timeout: 60_000 }));
+    }
+    // Remote builds: read the build output the builder attaches to the
+    // deployment (same endpoint the CLI writes to in local builds).
+    async getDeploymentLogs(deployment_id) {
+        return data(this.client.get(`/deployment/${deployment_id}/logs`));
+    }
     // Phase transitions the CLI owns (BUILDING when the build starts,
     // BUILD_ERROR on a failed build). Runtime phases stay controller-territory.
     async updateDeploymentStatus(deployment_id, status) {

package/dist/commands/deploy/index.js

@@ -2,10 +2,11 @@ import { requireApi } from '../../api/context.js';
 import { Configuration } from '../../lib/Configuration.js';
 import { log } from '../../log.js';
 import { link } from '../link/index.js';
-import { plan_summary } from './buildpacks/Buildpack.js';
-import { detect_buildpack, get_buildpack, buildpack_names } from './buildpacks/registry.js';
+import { configure_buildpacks, detect_buildpack, plan_summary, get_buildpack, buildpack_names } from '@faabletools/buildpacks';
+import { cmd } from '../../lib/cmd.js';
 import { check_environment } from './check_environment.js';
 import { git_context } from './git_context.js';
+import { deploy_remote } from './remote/index.js';
 import { resolve_app_id } from './resolve_app_id.js';
 import { secrets } from './secrets/index.js';
 import { mark_build_failure, start_log_sync, upload_logs } from './upload_logs.js';
@@ -35,10 +36,23 @@ const deploy = {
             choices: buildpack_names(),
             description: 'Force a specific buildpack (overrides auto-detection and faable.json)'
         })
+            .option('remote', {
+            type: 'boolean',
+            description: 'Build server-side (remote build), regardless of the app build_mode'
+        })
+            .option('local', {
+            type: 'boolean',
+            description: 'Build locally with Docker, even if the app is set to remote builds'
+        })
+            .conflicts('remote', 'local')
             .showHelpOnFail(false);
     },
     handler: async (args) => {
         const workdir = args.workdir || process.cwd();
+        // Wire the shared buildpacks package to the CLI's sinks: pino (which tees
+        // into the build-log buffer) and cmd() (which captures subprocess output
+        // into the same buffer). Must happen before any detect/build call.
+        configure_buildpacks({ log, exec: cmd });
         const ctx = await requireApi();
         const { api } = ctx;
         const config = Configuration.instance().deployConfig();
@@ -73,62 +87,87 @@ const deploy = {
             }
             throw error;
         }
-        // Create-first: register the deployment BEFORE building. Gate rejections
-        // (free-plan quota 429, disabled app 409) surface here, at second 0 —
-        // before any build minutes are spent. The row is born QUEUED; the CLI
-        // owns it until the built image lands (or the build fails). `type` rides
-        // on the create — the buildpack plan is already resolved.
-        const deployment = await api.createDeployment({
-            app_id: app.id,
-            type: plan.type,
-            ...git
-        });
-        try {
-            // Check if we can build docker images
-            await check_environment();
-            const runtime_label = plan.runtime.version
-                ? `${plan.runtime.name}-${plan.runtime.version}`
-                : plan.runtime.name;
-            log.info(`🚀 Deploying "${app.name}" (${app.id}) runtime=${runtime_label}`);
-            log.info(`🧩 Build plan ${plan_summary(plan)}`);
-            // get environment variables
-            const env_vars = await api.getAppSecrets(app.id);
-            const buildpack = get_buildpack(plan.buildpack);
-            if (!buildpack) {
-                throw new Error(`No buildpack registered for plan=${plan.buildpack}`);
+        // Remote build path (v2, arch/deploy/deploy-v2-remote-build.md): the
+        // server decides via the app's build_mode; --remote/--local override for
+        // testing. Pre-build failures with a server-decided mode fall back to the
+        // local build below (deploy_remote returns null); with --remote they
+        // fail hard.
+        let deployment;
+        const want_remote = !args.local && (Boolean(args.remote) || app.build_mode === 'remote');
+        const remote_deployment = want_remote
+            ? await deploy_remote({
+                api,
+                app,
+                plan,
+                git,
+                workdir,
+                explicit: Boolean(args.remote)
+            })
+            : null;
+        if (remote_deployment) {
+            deployment = remote_deployment;
+        }
+        else {
+            if (want_remote) {
+                log.warn('↩️ Falling back to a local build');
             }
-            // The build starts now: declare it (QUEUED → BUILDING) and stream the
-            // captured output to the deployment while it runs (best-effort).
-            await api
-                .updateDeploymentStatus(deployment.id, { phase: 'BUILDING' })
-                .catch((error) => log.warn(`Could not mark deployment BUILDING: ${error.message}`));
-            const stop_log_sync = start_log_sync(api, deployment.id);
+            // Create-first: register the deployment BEFORE building. Gate rejections
+            // (free-plan quota 429, disabled app 409) surface here, at second 0 —
+            // before any build minutes are spent. The row is born QUEUED; the CLI
+            // owns it until the built image lands (or the build fails). `type` rides
+            // on the create — the buildpack plan is already resolved.
+            deployment = await api.createDeployment({
+                app_id: app.id,
+                type: plan.type,
+                ...git
+            });
             try {
-                await buildpack.build({ workdir, config, app, env_vars, deployment }, plan);
-                // Upload to Faable registry, tagged by version and pinned to digest
-                const { image_ref } = await upload_tag({
-                    app,
-                    api,
-                    deployment_id: deployment.id
-                });
-                // Complete the deployment with the built image — this is the handoff:
-                // the controller claims it and materializes the workload.
-                await api.completeDeployment(deployment.id, image_ref);
+                // Check if we can build docker images
+                await check_environment();
+                const runtime_label = plan.runtime.version
+                    ? `${plan.runtime.name}-${plan.runtime.version}`
+                    : plan.runtime.name;
+                log.info(`🚀 Deploying "${app.name}" (${app.id}) runtime=${runtime_label}`);
+                log.info(`🧩 Build plan ${plan_summary(plan)}`);
+                // get environment variables
+                const env_vars = await api.getAppSecrets(app.id);
+                const buildpack = get_buildpack(plan.buildpack);
+                if (!buildpack) {
+                    throw new Error(`No buildpack registered for plan=${plan.buildpack}`);
+                }
+                // The build starts now: declare it (QUEUED → BUILDING) and stream the
+                // captured output to the deployment while it runs (best-effort).
+                await api
+                    .updateDeploymentStatus(deployment.id, { phase: 'BUILDING' })
+                    .catch((error) => log.warn(`Could not mark deployment BUILDING: ${error.message}`));
+                const stop_log_sync = start_log_sync(api, deployment.id);
+                try {
+                    await buildpack.build({ workdir, config, app, env_vars, deployment }, plan);
+                    // Upload to Faable registry, tagged by version and pinned to digest
+                    const { image_ref } = await upload_tag({
+                        app,
+                        api,
+                        deployment_id: deployment.id
+                    });
+                    // Complete the deployment with the built image — this is the handoff:
+                    // the controller claims it and materializes the workload.
+                    await api.completeDeployment(deployment.id, image_ref);
+                }
+                finally {
+                    stop_log_sync();
+                }
             }
-            finally {
-                stop_log_sync();
+            catch (error) {
+                // The deployment already exists (created pre-build), so a failed build
+                // marks THAT row BUILD_ERROR with the captured logs — no extra row, no
+                // second quota hit. Gate rejections can't reach here anymore: the
+                // create happens before any building.
+                await mark_build_failure(api, { deployment_id: deployment.id, app });
+                throw error;
             }
-        }
-        catch (error) {
-            // The deployment already exists (created pre-build), so a failed build
-            // marks THAT row BUILD_ERROR with the captured logs — no extra row, no
-            // second quota hit. Gate rejections can't reach here anymore: the
-            // create happens before any building.
-            await mark_build_failure(api, { deployment_id: deployment.id, app });
-            throw error;
-        }
-        // Attach the final build output to the deployment (best-effort).
-        await upload_logs(api, deployment.id);
+            // Attach the final build output to the deployment (best-effort).
+            await upload_logs(api, deployment.id);
+        } // end local build path (remote builds upload their own logs server-side)
         const dashboard_url = `https://dashboard.faable.com/deploy/${app.team}/app/${app.id}`;
         log.info(`Preparing to deploy in faable cloud · ${deployment.id}`);
         log.info(`📊 View it in the dashboard -> ${dashboard_url}`);

package/dist/commands/deploy/remote/follow.js

@@ -0,0 +1,61 @@
+import { log } from '../../../log.js';
+
+const POLL_INTERVAL_MS = 4000;
+// Queue wait + build must fit here; the server's own stops (Job deadline
+// 30min, abandoned janitor 60min) resolve the deployment first in practice.
+const FOLLOW_TIMEOUT_MS = 45 * 60 * 1000;
+const wait = (ms) => new Promise((r) => setTimeout(r, ms));
+/**
+ * Follow a remote build until the image handoff: poll the phase and tail the
+ * build logs the builder uploads every ~10s (replace semantics → print the
+ * suffix beyond what we already showed). Returns on INITIALIZING/READY
+ * (image landed — the regular promotion poll takes over); throws on
+ * BUILD_ERROR/ERROR with the server-provided reason.
+ */
+const follow_remote_build = async (api, deployment_id) => {
+    let printed = 0;
+    let last_phase = "";
+    const started = Date.now();
+    const tail_logs = async () => {
+        try {
+            const logs = await api.getDeploymentLogs(deployment_id);
+            const content = logs?.content ?? "";
+            if (content.length > printed) {
+                process.stdout.write(content.slice(printed));
+                printed = content.length;
+            }
+            else if (content.length < printed) {
+                // Keep-tail truncation rotated the buffer — resync silently.
+                printed = content.length;
+            }
+        }
+        catch {
+            // No logs yet (404) or transient failure — next poll.
+        }
+    };
+    while (Date.now() - started < FOLLOW_TIMEOUT_MS) {
+        const deployment = await api
+            .getDeployment(deployment_id)
+            .catch(() => null);
+        const phase = deployment?.status?.phase ?? "";
+        if (phase !== last_phase && phase) {
+            log.info(`☁️ Remote build: ${phase}`);
+            last_phase = phase;
+        }
+        await tail_logs();
+        if (phase === "BUILD_ERROR" || phase === "ERROR") {
+            const reason = deployment?.status?.reason;
+            throw new Error(`Remote build failed${reason ? `: ${reason}` : ""}`.trim());
+        }
+        // Image handoff done: the controller claimed it (INITIALIZING) or it is
+        // already live (READY) — the promotion poll takes over from here.
+        if (phase === "INITIALIZING" || phase === "READY") {
+            await tail_logs();
+            return;
+        }
+        await wait(POLL_INTERVAL_MS);
+    }
+    throw new Error("Timed out waiting for the remote build. Check the dashboard for its status.");
+};
+
+export { follow_remote_build };

package/dist/commands/deploy/remote/index.js

@@ -0,0 +1,48 @@
+import { log } from '../../../log.js';
+import { follow_remote_build } from './follow.js';
+import { collect_manifest } from './manifest.js';
+import { upload_missing_blobs } from './upload.js';
+
+/**
+ * Remote build path (v2, arch/deploy/deploy-v2-remote-build.md): upload the
+ * source delta to the CAS, create the deployment with `source` (manifest +
+ * serialized BuildPlan) and follow the server-side build until the image
+ * handoff. No Docker daemon needed.
+ *
+ * Fallback contract:
+ *  - PRE-build failures (collection, upload, create — including the server
+ *    gate `remote_build_disabled`) return null when the mode came from the
+ *    server, so the caller falls back to a local build. With --remote they
+ *    fail hard (testing wants to see the errors).
+ *  - Failures AFTER the deployment exists never fall back: a BUILD_ERROR
+ *    would fail locally too (it's the user's build), and a timeout may still
+ *    be building — a local fallback would double-deploy.
+ */
+const deploy_remote = async (props) => {
+    const { api, app, plan, git, workdir, explicit } = props;
+    log.info(`☁️ Remote build (${explicit ? "--remote" : `app build_mode=remote`})`);
+    let deployment;
+    try {
+        const manifest = await collect_manifest(workdir);
+        log.info(`🗂️ ${manifest.length} files in the source manifest`);
+        await upload_missing_blobs(api, app.id, workdir, manifest);
+        deployment = await api.createDeployment({
+            app_id: app.id,
+            type: plan.type,
+            source: { manifest, plan },
+            ...git,
+        });
+    }
+    catch (error) {
+        if (explicit)
+            throw error;
+        const code = error?.response?.data?.code;
+        log.warn(`☁️ Remote build unavailable${code ? ` (${code})` : `: ${error.message}`}`);
+        return null;
+    }
+    log.info(`Preparing to build in faable cloud · ${deployment.id}`);
+    await follow_remote_build(api, deployment.id);
+    return deployment;
+};
+
+export { deploy_remote };

package/dist/commands/deploy/remote/manifest.js

@@ -0,0 +1,77 @@
+import { createHash } from 'crypto';
+import { lstatSync, readFileSync } from 'fs';
+import * as path from 'path';
+import { cmd } from '../../../lib/cmd.js';
+
+// Server-side admission caps (mirror DeploymentSource on the API); checking
+// here fails fast with a clearer message than a 400.
+const MAX_FILES = 20_000;
+const MAX_FILE_BYTES = 100 * 1024 * 1024;
+/**
+ * Collect the source tree for a remote build: exactly what git tracks (plus
+ * untracked-but-not-ignored files), hashed for the CAS. Using git as the
+ * collector means the upload is "the source" — build artifacts, node_modules
+ * and local junk stay out via .gitignore, and the remote build re-derives
+ * them like a fresh clone would.
+ *
+ * Symlinks are rejected (no representation in the manifest by design — see
+ * deploy-v2-remote-build.md) and a non-git directory is unsupported in the
+ * MVP (deploy with --local instead).
+ */
+const collect_manifest = async (workdir) => {
+    const inside = await cmd(`git rev-parse --is-inside-work-tree`, {
+        cwd: workdir,
+    }).catch(() => null);
+    if (!inside || String(inside.stdout).trim() !== "true") {
+        throw new Error("Remote builds need a git repository (the source tree is collected via git). Deploy with --local instead.");
+    }
+    // -c/-o: tracked + untracked; --exclude-standard: .gitignore/.git/info.
+    // -z: NUL-separated (paths with spaces/UTF-8 survive).
+    const out = await cmd(`git ls-files -co --exclude-standard -z`, {
+        cwd: workdir,
+    });
+    const rel_paths = String(out.stdout)
+        .split("\0")
+        .filter((p) => p.length > 0);
+    if (rel_paths.length === 0) {
+        throw new Error("No files to upload (empty git tree?)");
+    }
+    if (rel_paths.length > MAX_FILES) {
+        throw new Error(`Too many files for a remote build (${rel_paths.length} > ${MAX_FILES}).`);
+    }
+    const manifest = [];
+    for (const rel of rel_paths) {
+        const abs = path.join(workdir, rel);
+        // lstat: a symlink must be detected as such, not followed.
+        const stat = (() => {
+            try {
+                return lstatSync(abs, { throwIfNoEntry: false });
+            }
+            catch {
+                return undefined;
+            }
+        })();
+        // Listed but unreadable/deleted (e.g. staged deletion) → skip.
+        if (!stat)
+            continue;
+        if (stat.isDirectory())
+            continue;
+        if (stat.isSymbolicLink()) {
+            throw new Error(`Symlinks are not supported in remote builds: ${rel}. Deploy with --local instead.`);
+        }
+        if (stat.size > MAX_FILE_BYTES) {
+            throw new Error(`${rel} is too large for a remote build (${stat.size} bytes > ${MAX_FILE_BYTES}).`);
+        }
+        const body = readFileSync(abs);
+        manifest.push({
+            // Manifest paths are forward-slash relative (API admission contract).
+            path: rel.split(path.sep).join("/"),
+            sha: createHash("sha256").update(body).digest("hex"),
+            size: stat.size,
+            mode: stat.mode & 0o777,
+        });
+    }
+    return manifest;
+};
+
+export { collect_manifest };

package/dist/commands/deploy/remote/upload.js

@@ -0,0 +1,61 @@
+import axios from 'axios';
+import { readFileSync } from 'fs';
+import * as path from 'path';
+import { log } from '../../../log.js';
+
+const PUT_CONCURRENCY = 8;
+const PUT_RETRIES = 2;
+/**
+ * Delta upload to the CAS: ask the API which blobs are missing and PUT only
+ * those (presigned URLs, sha256-pinned by the signature — S3 rejects content
+ * that doesn't match). Redeploys upload just what changed.
+ */
+const upload_missing_blobs = async (api, app_id, workdir, manifest) => {
+    const { uploads } = await api.uploadMissing(app_id, manifest);
+    if (uploads.length === 0) {
+        log.info(`📦 Source already in the build store (0 files to upload)`);
+        return { uploaded: 0, bytes: 0 };
+    }
+    // First path wins per sha — content is identical by definition.
+    const by_sha = new Map();
+    for (const file of manifest) {
+        if (!by_sha.has(file.sha))
+            by_sha.set(file.sha, file);
+    }
+    let bytes = 0;
+    let queue = 0;
+    const worker = async () => {
+        while (queue < uploads.length) {
+            const upload = uploads[queue++];
+            const file = by_sha.get(upload.sha);
+            if (!file)
+                continue; // server echoed a sha we didn't send — ignore
+            const body = readFileSync(path.join(workdir, file.path));
+            let attempt = 0;
+            for (;;) {
+                try {
+                    await axios.put(upload.url, body, {
+                        headers: {
+                            ...upload.headers,
+                            "content-type": "application/octet-stream",
+                        },
+                        maxBodyLength: Infinity,
+                        timeout: 120_000,
+                    });
+                    bytes += body.length;
+                    break;
+                }
+                catch (error) {
+                    if (attempt++ >= PUT_RETRIES) {
+                        throw new Error(`Upload failed for ${file.path}: ${error?.message}`, { cause: error });
+                    }
+                }
+            }
+        }
+    };
+    await Promise.all(Array.from({ length: Math.min(PUT_CONCURRENCY, uploads.length) }, worker));
+    log.info(`📤 Uploaded ${uploads.length} changed files (${(bytes / 1024).toFixed(0)} KB) — delta only`);
+    return { uploaded: uploads.length, bytes };
+};
+
+export { upload_missing_blobs };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@faable/faable",
-  "version": "1.16.0",
+  "version": "1.18.0",
   "main": "dist/index.js",
   "license": "MIT",
   "author": "Marc Pomar <marc@faable.com>",
@@ -27,6 +27,7 @@
   ],
   "dependencies": {
     "@actions/core": "^3.0.0",
+    "@faabletools/buildpacks": "^1.0.0",
     "axios": "^1.13.2",
     "fs-extra": "^11.3.2",
     "handlebars": "^4.7.8",

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

@@ -1,11 +0,0 @@
-/** One-line summary logged before build so the decision is reconstructible. */
-const plan_summary = (plan) => JSON.stringify({
-    buildpack: plan.buildpack,
-    type: plan.type,
-    runtime: `${plan.runtime.name}${plan.runtime.version ? `-${plan.runtime.version}` : ""}`,
-    start: plan.start_command,
-    ...(plan.install_command ? { install: plan.install_command } : {}),
-    ...(plan.build_script ? { build_script: plan.build_script } : {}),
-});
-
-export { plan_summary };

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

@@ -1,78 +0,0 @@
-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/docker/index.js

@@ -1,42 +0,0 @@
-import path__default from 'path';
-import { cmd } from '../../../../lib/cmd.js';
-import { log } from '../../../../log.js';
-import { has_any_of_files } from '../shared/has_any_of_files.js';
-import { read_json_file } from '../shared/read_text_file.js';
-
-// A package.json with a next dependency beside the Dockerfile means this is a
-// Next.js app shipped with a custom image: emit type "next" so the backend
-// provisions the build-cache PVC (runtime_strategy). Reachable via the
-// --buildpack override, since the node buildpack claims package.json first.
-const detect_next = (workdir) => {
-    try {
-        const pkg = read_json_file(path__default.join(workdir, "package.json"));
-        return Boolean(pkg?.dependencies?.next || pkg?.devDependencies?.next);
-    }
-    catch {
-        return false;
-    }
-};
-const docker_buildpack = {
-    name: "docker",
-    detect_files: ["Dockerfile"],
-    async detect(ctx) {
-        if (!has_any_of_files(this.detect_files, ctx.workdir))
-            return null;
-        const type = detect_next(ctx.workdir) ? "next" : "node";
-        return {
-            buildpack: "docker",
-            runtime: { name: "docker" },
-            type,
-            // The user's image defines its own CMD/ENTRYPOINT.
-            start_command: null,
-        };
-    },
-    async build(ctx) {
-        log.info(`📦 Building with the project's own Dockerfile`);
-        const timeout = 10 * 60 * 1000; // 10 minute timeout
-        await cmd(`docker build --platform linux/amd64 -t ${ctx.app.id} ${ctx.workdir} -f ${path__default.join(ctx.workdir, "Dockerfile")}`, { timeout, enableOutput: true });
-    },
-};
-
-export { docker_buildpack };

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

@@ -1,21 +0,0 @@
-/**
- * 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 };