@faable/faable 1.14.1 → 1.15.0

package/dist/api/FaableApi.js

@@ -79,11 +79,19 @@ class FaableApi {
     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.
+    // 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) {
         return data(this.client.post(`/status/${deployment_id}`, status));
     }
+    // Complete a create-first deployment with the built image (write-once
+    // server-side). Setting the image is what makes the controller claim the
+    // deployment and materialize it.
+    async completeDeployment(deployment_id, image) {
+        return data(this.client.post(`/deployment/${deployment_id}`, {
+            image,
+        }));
+    }
     // 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) {

package/dist/commands/deploy/index.js

@@ -8,7 +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 { start_log_sync, mark_build_failure, upload_logs } from './upload_logs.js';
 import { upload_tag } from './upload_tag.js';
 
 const deploy = {
@@ -47,9 +47,19 @@ 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);
-        // 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;
+        // 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-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 as before — 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();
@@ -64,35 +74,33 @@ const deploy = {
             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
-            });
+            // 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 }, plan);
+                // Upload to Faable registry
+                const { upload_tagname } = await upload_tag({ app, api });
+                // Complete the deployment with the built image — this is the handoff:
+                // the controller claims it and materializes the workload.
+                await api.completeDeployment(deployment.id, upload_tagname);
+            }
+            finally {
+                stop_log_sync();
+            }
         }
         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 });
-            }
+            // 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 build output to the deployment (best-effort).
+        // Attach the final 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}`);

package/dist/commands/deploy/upload_logs.js

@@ -1,6 +1,5 @@
 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
@@ -17,24 +16,52 @@ const upload_logs = async (api, deployment_id) => {
         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 }) => {
+// Live log sync during the build: re-upload the whole buffer every interval
+// while it grows. The API endpoint is an idempotent replace (one log row per
+// deployment), so partial uploads are simply superseded — the dashboard sees
+// the build progressing instead of only the final dump. Rate-limit friendly:
+// 10s interval = 6 req/min against the endpoint's 30/min cap.
+const start_log_sync = (api, deployment_id, intervalMs = 10_000) => {
+    let lastSize = 0;
+    let inFlight = false;
+    const timer = setInterval(async () => {
+        if (inFlight)
+            return;
+        const { content, truncated, size } = buildLog.contents();
+        if (!content || size === lastSize)
+            return;
+        inFlight = true;
+        try {
+            await api.uploadDeploymentLogs(deployment_id, { content, truncated });
+            lastSize = size;
+        }
+        catch (error) {
+            // Quiet: the final upload_logs still runs at the end of the deploy.
+            log.debug(`Log sync failed (non-fatal): ${error.message}`);
+        }
+        finally {
+            inFlight = false;
+        }
+    }, intervalMs);
+    // Never keep the process alive just for log syncing.
+    timer.unref?.();
+    return () => clearInterval(timer);
+};
+// Mark the create-first deployment as a failed build (phase BUILD_ERROR) and
+// attach the captured logs. The deployment row already exists — created
+// before the build started — so unlike the old flow no extra row is created
+// (and no quota is consumed) to record the failure.
+const mark_build_failure = async (api, { deployment_id, app, }) => {
     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" })
+            .updateDeploymentStatus(deployment_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}`);
+        await upload_logs(api, deployment_id);
+        log.error(`❌ Build failed — logs attached to deployment ${deployment_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 };
+export { mark_build_failure, start_log_sync, upload_logs };

package/package.json

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