@faable/faable 1.13.2 → 1.14.1

package/dist/api/FaableApi.js

@@ -73,9 +73,22 @@ class FaableApi {
     async getRegistry(app_id) {
         return data(this.client.get(`/app/${app_id}/registry`));
     }
+    // `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).
     async createDeployment(params) {
         return data(this.client.post(`/deployment`, params));
     }
+    // Phase transitions the CLI owns (e.g. BUILD_ERROR on a failed build).
+    // Runtime phases stay controller-territory.
+    async updateDeploymentStatus(deployment_id, status) {
+        return data(this.client.post(`/status/${deployment_id}`, status));
+    }
+    // Attach the captured build/deploy output to a deployment. The base client
+    // timeout (10s) is too short for a multi-MB body on a slow uplink.
+    async uploadDeploymentLogs(deployment_id, body) {
+        return data(this.client.post(`/deployment/${deployment_id}/logs`, body, { timeout: 60_000, maxBodyLength: Infinity, maxContentLength: Infinity }));
+    }
     async getAppSecrets(app_id) {
         return firstPage(data(this.client.get(`/secret/${app_id}`)));
     }

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

@@ -10,7 +10,7 @@ import { resolve_node_version } from './node_version.js';
 
 const BANNER = `NODE_VERSION=$(node --version)
 NPM_VERSION=$(npm --version)
-YARN_VERSION=$(yarn --version)
+YARN_VERSION=$(yarn --version 2>/dev/null || echo "n/a")
 
 echo "Faable Cloud · [node $NODE_VERSION] [npm $NPM_VERSION] [yarn $YARN_VERSION]"`;
 const node_buildpack = {

package/dist/commands/deploy/index.js

@@ -8,6 +8,7 @@ import { check_environment } from './check_environment.js';
 import { git_context } from './git_context.js';
 import { resolve_app_id } from './resolve_app_id.js';
 import { secrets } from './secrets/index.js';
+import { report_build_failure, upload_logs } from './upload_logs.js';
 import { upload_tag } from './upload_tag.js';
 
 const deploy = {
@@ -46,33 +47,53 @@ const deploy = {
         const plan = await detect_buildpack({ workdir, config }, args.buildpack || config.buildpack);
         const app_id = await resolve_app_id(args.app_id, ctx.appId, api, workdir);
         const app = await api.getApp(app_id);
-        // 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}`);
+        // From here on there is an app to attach logs to: any build/push failure
+        // is recorded as a BUILD_ERROR deployment with the captured output.
+        let deployment;
+        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}`);
+            }
+            await buildpack.build({ workdir, config, app, env_vars }, plan);
+            const type = plan.type;
+            // Upload to Faable registry
+            const { upload_tagname } = await upload_tag({ app, api });
+            // Capture the commit/ref/actor so the deployment records which commit
+            // it came from and who pushed it (env in CI, git fallback locally).
+            const git = await git_context({ workdir });
+            // Create a deployment for this image
+            deployment = await api.createDeployment({
+                app_id: app.id,
+                image: upload_tagname,
+                type,
+                ...git
+            });
+        }
+        catch (error) {
+            // A free-plan quota rejection (429 deployment_quota_exceeded) is not a
+            // build failure — the build itself succeeded. Skip the failure report
+            // so the app doesn't show a red build; the API's message (with the
+            // upgrade hint) still reaches the user via the error printer.
+            const isQuotaRejection = error?.isFaableApiError &&
+                error?.response?.status === 429 &&
+                error?.response?.data?.code === 'deployment_quota_exceeded';
+            if (!isQuotaRejection) {
+                await report_build_failure(api, { app, workdir });
+            }
+            throw error;
         }
-        await buildpack.build({ workdir, config, app, env_vars }, plan);
-        const type = plan.type;
-        // Upload to Faable registry
-        const { upload_tagname } = await upload_tag({ app, api });
-        // Capture the commit/ref/actor so the deployment records which commit it
-        // came from and who pushed it (env in CI, git fallback locally).
-        const git = await git_context({ workdir });
-        // Create a deployment for this image
-        const deployment = await api.createDeployment({
-            app_id: app.id,
-            image: upload_tagname,
-            type,
-            ...git
-        });
+        // Attach the build output to the deployment (best-effort).
+        await upload_logs(api, deployment.id);
         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/upload_logs.js

@@ -0,0 +1,40 @@
+import { buildLog } from '../../lib/log_buffer.js';
+import { log } from '../../log.js';
+import { git_context } from './git_context.js';
+
+// Best-effort by design: attaching logs (or recording a failed build) must
+// never break or fail a deploy — an older API without these endpoints just
+// produces a warn.
+const upload_logs = async (api, deployment_id) => {
+    try {
+        const { content, truncated } = buildLog.contents();
+        if (!content)
+            return;
+        await api.uploadDeploymentLogs(deployment_id, { content, truncated });
+        log.info(`📝 Build logs attached to deployment ${deployment_id}`);
+    }
+    catch (error) {
+        log.warn(`Could not upload build logs (non-fatal): ${error.message}`);
+    }
+};
+// Record a failed build as a BUILD_ERROR deployment (no image — the
+// controller skips materialization) with the captured logs attached, so
+// private-repo CI failures are debuggable from the platform.
+const report_build_failure = async (api, { app, workdir }) => {
+    try {
+        const git = await git_context({ workdir }).catch(() => ({}));
+        // No `image` and no `type`: a failed build must not materialize anything
+        // nor rewrite the app's runtime_strategy.
+        const failed = await api.createDeployment({ app_id: app.id, ...git });
+        await api
+            .updateDeploymentStatus(failed.id, { phase: "BUILD_ERROR" })
+            .catch((error) => log.warn(`Could not mark deployment BUILD_ERROR: ${error.message}`));
+        await upload_logs(api, failed.id);
+        log.error(`❌ Build failed — logs attached to deployment ${failed.id} · https://dashboard.faable.com/deploy/${app.team}/app/${app.id}`);
+    }
+    catch (error) {
+        log.warn(`Could not report the failed build (non-fatal): ${error.message}`);
+    }
+};
+
+export { report_build_failure, upload_logs };

package/dist/lib/cmd.js

@@ -1,14 +1,23 @@
 import { spawn } from 'promisify-child-process';
 import { log } from '../log.js';
+import { buildLog } from './log_buffer.js';
 
 const cmd = async (cmd, config) => {
     // Defaults
     const enableOutput = config?.enableOutput || false;
     const timeout = config?.timeout;
     const cwd = config?.cwd;
+    // Always pipe (never inherit) so the output can be captured into the
+    // build-log buffer; enableOutput now means "also mirror to the terminal".
+    // Subprocesses see a non-TTY and fall back to plain (uncolored) output —
+    // the intended trade for being able to attach logs to the deployment.
     const child = spawn("/bin/bash", ["-c", cmd], {
         encoding: "utf8",
-        stdio: enableOutput ? "inherit" : "pipe",
+        stdio: ["inherit", "pipe", "pipe"],
+        // promisify-child-process kills the child with "maxBuffer size exceeded"
+        // at 200KB once stdio is piped + encoding set. A docker build easily
+        // exceeds that — never kill on output volume (buildLog caps separately).
+        maxBuffer: Infinity,
         timeout,
         cwd,
         env: {
@@ -19,9 +28,15 @@ const cmd = async (cmd, config) => {
     const out_data = [];
     child.stderr?.on("data", (data) => {
         out_data.push(data);
+        buildLog.append(data);
+        if (enableOutput)
+            process.stderr.write(data);
     });
     child.stdout?.on("data", (data) => {
         out_data.push(data);
+        buildLog.append(data);
+        if (enableOutput)
+            process.stdout.write(data);
     });
     try {
         const result = await child;

package/dist/lib/log_buffer.js

@@ -0,0 +1,50 @@
+// In-memory capture of everything the deploy prints (subprocess output via
+// cmd(), CLI messages via the pino tee in log.ts) so it can be attached to
+// the deployment at the end. Keep-tail: when the cap is hit, head chunks are
+// dropped — a failing build's useful signal is at the end of the output.
+// Keep in lockstep with DEPLOYMENT_LOG_MAX_BYTES on the API side.
+const LOG_CAP_BYTES = 2 * 1024 * 1024;
+// CSI (colors, cursor) + OSC (titles, hyperlinks) escape sequences.
+const ANSI_RE = 
+// eslint-disable-next-line no-control-regex
+/\x1B(?:\[[0-9;?]*[ -/]*[@-~]|\][^\x07\x1B]*(?:\x07|\x1B\\))/g;
+class LogBuffer {
+    cap;
+    chunks = [];
+    bytes = 0;
+    dropped = false;
+    constructor(cap = LOG_CAP_BYTES) {
+        this.cap = cap;
+    }
+    append(chunk) {
+        const buf = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk, "utf8");
+        if (buf.length === 0)
+            return;
+        this.chunks.push(buf);
+        this.bytes += buf.length;
+        while (this.bytes > this.cap && this.chunks.length > 1) {
+            const head = this.chunks.shift();
+            this.bytes -= head.length;
+            this.dropped = true;
+        }
+    }
+    contents() {
+        const content = Buffer.concat(this.chunks)
+            .toString("utf8")
+            .replace(ANSI_RE, "");
+        return {
+            content,
+            truncated: this.dropped,
+            size: Buffer.byteLength(content, "utf8"),
+        };
+    }
+    reset() {
+        this.chunks = [];
+        this.bytes = 0;
+        this.dropped = false;
+    }
+}
+// Process-wide buffer for the current deploy session.
+const buildLog = new LogBuffer();
+
+export { LOG_CAP_BYTES, LogBuffer, buildLog };

package/dist/log.js

@@ -1,12 +1,25 @@
 import pino from 'pino';
-import pretty from 'pino-pretty';
+import pretty, { prettyFactory } from 'pino-pretty';
+import { buildLog } from './lib/log_buffer.js';
 
-// Run pino-pretty as an in-process sync stream instead of a worker-thread
+// Run pino-pretty as in-process sync streams instead of a worker-thread
 // transport: the worker's MessagePort can stay referenced after the last log
 // (thread-stream race) and intermittently keep the CLI from exiting.
-const log = pino(pretty({
-    colorize: true,
-    sync: true,
-}));
+//
+// Tee: terminal stream (colorized) + a plain-text copy into the build-log
+// buffer so CLI messages land in the logs attached to the deployment.
+const toPlainText = prettyFactory({ colorize: false, sync: true });
+// NB: the two-arg form matters — pino(multistream) alone would treat the
+// multistream object as the options bag and log raw JSON to stdout.
+const log = pino({}, pino.multistream([
+    { stream: pretty({ colorize: true, sync: true }) },
+    {
+        stream: {
+            write(line) {
+                buildLog.append(toPlainText(line));
+            },
+        },
+    },
+]));
 
 export { log };

package/package.json

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