@faable/faable 4.18.3 → 4.18.5

package/dist/api/FaableApi.js

@@ -117,7 +117,17 @@ class FaableApi {
                         throw expired;
                     }
                     const serverMessage = res.data?.message || res.statusText || 'Unknown Error';
-                    const wrapped = new Error(`FaableApi ${url} ${res.status}: ${serverMessage}`, { cause: error });
+                    // A 4xx with the api's own sentence is written for the user — say
+                    // just that ("New accounts can have up to 2 apps…"), the way the
+                    // dashboard does (`friendlyErrorMessage`). The "FaableApi <url>
+                    // <status>:" prefix is for us: it stays on 5xx and on bodies with
+                    // no sentence, and url/status ride on the error for --json and
+                    // for whoever catches it (backlog §390).
+                    const userFacing = res.status >= 400 && res.status < 500 && !!res.data?.message;
+                    const wrapped = new Error(userFacing
+                        ? serverMessage
+                        : `FaableApi ${url} ${res.status}: ${serverMessage}`, { cause: error });
+                    wrapped.url = url;
                     wrapped.status = res.status;
                     // The api's own code wins; a bare 403/404 still gets a stable one.
                     if (res.data?.code)

package/dist/commands/deploy/git_context.js

@@ -11,6 +11,19 @@ const gitRunner = (workdir) => command => new Promise(resolve => {
         resolve(out || undefined);
     });
 });
+// Ref from GitLab CI / Bitbucket Pipelines env, as a full `refs/...` name.
+// Tags first: on a tag pipeline GitLab's CI_COMMIT_REF_NAME is the tag name.
+// CI_COMMIT_REF_NAME (not CI_COMMIT_BRANCH) so merge request pipelines still
+// record their source branch.
+const ci_ref = (env) => {
+    const tag = env.CI_COMMIT_TAG || env.BITBUCKET_TAG;
+    if (tag)
+        return `refs/tags/${tag}`;
+    const branch = env.CI_COMMIT_REF_NAME || env.BITBUCKET_BRANCH;
+    if (branch)
+        return `refs/heads/${branch}`;
+    return undefined;
+};
 // Resolve the commit / ref / actor for the current deploy. In GitHub Actions
 // these come from the standard env vars; locally we fall back to git so manual
 // deploys still record a commit. `github_actor` is CI-only (a GitHub login),
@@ -20,8 +33,16 @@ const gitRunner = (workdir) => command => new Promise(resolve => {
 const git_context = async (opts) => {
     const env = opts?.env ?? process.env;
     const run = opts?.run ?? gitRunner(opts?.workdir);
-    const github_commit = env.GITHUB_SHA || (await run("git rev-parse HEAD"));
-    let github_ref = env.GITHUB_REF || undefined;
+    const github_commit = env.GITHUB_SHA ||
+        env.CI_COMMIT_SHA ||
+        env.BITBUCKET_COMMIT ||
+        (await run("git rev-parse HEAD"));
+    // GitLab CI and Bitbucket Pipelines check out a detached HEAD, so the branch
+    // only survives in their env vars. Their actor vars are NOT mapped to
+    // `github_actor`: the dashboard renders it as a GitHub login (avatar and
+    // profile link), and a GitLab username would show whoever owns that name on
+    // GitHub.
+    let github_ref = env.GITHUB_REF || ci_ref(env);
     if (!github_ref) {
         const branch = await run("git rev-parse --abbrev-ref HEAD");
         if (branch && branch !== "HEAD")

package/dist/commands/deploy/inspect/open.js

@@ -1,5 +1,6 @@
 import openBrowser from 'open';
 import { requireApi } from '../../../api/context.js';
+import { dashboardAppUrl } from '../../../lib/dashboard_url.js';
 import { log } from '../../../log.js';
 import { resolve_app_id } from '../resolve_app_id.js';
 
@@ -25,7 +26,7 @@ const open_app = {
         const app_id = await resolve_app_id(args.app, ctx.appId, ctx.api);
         const app = await ctx.api.getApp(app_id);
         const url = args.dashboard
-            ? `https://dashboard.faable.com/deploy/${app.team}/app/${app.id}`
+            ? dashboardAppUrl(String(app.team), app.id)
             : `https://${app.url}`;
         log.info(`🌍 Opening ${url}`);
         await openBrowser(url).catch(() => {

package/dist/commands/deploy/inspect/trigger.js

@@ -1,4 +1,5 @@
 import { requireApi } from '../../../api/context.js';
+import { dashboardAppUrl } from '../../../lib/dashboard_url.js';
 import { print_json, json_option } from '../../../lib/listing.js';
 import { log } from '../../../log.js';
 import { resolve_app_id } from '../resolve_app_id.js';
@@ -55,7 +56,7 @@ const trigger = {
         if (result.deployment_id) {
             log.info(`Follow the build: faable deploy logs --build -d ${result.deployment_id} -a ${app.id} --follow`);
         }
-        log.info(`Track it with: faable deploy status -a ${app.id}  ·  or in the dashboard: https://dashboard.faable.com/deploy/${app.team}/app/${app.id}`);
+        log.info(`Track it with: faable deploy status -a ${app.id}  ·  or in the dashboard: ${dashboardAppUrl(String(app.team), app.id)}`);
     }
 };
 

package/dist/commands/deploy/launch.js

@@ -1,15 +1,16 @@
 import { requireApi } from '../../api/context.js';
+import { requireProject } from '../../api/project.js';
 import { Configuration } from '../../lib/Configuration.js';
+import { dashboardAppUrl } from '../../lib/dashboard_url.js';
 import { CliError } from '../../lib/errors.js';
 import { is_non_interactive, confirm } from '../../lib/interactive.js';
 import { print_json } from '../../lib/listing.js';
 import { log } from '../../log.js';
-import { requireProject } from '../../api/project.js';
+import { assert_name_free } from './apps/name_free.js';
 import { git_context } from './git_context.js';
 import { show_deploy_help } from './help.js';
 import { reachable_timeout_ms, wait_reachable } from './reachable.js';
 import { propose_release } from './release_version.js';
-import { assert_name_free } from './apps/name_free.js';
 import { deploy_remote } from './remote/index.js';
 import { collect_manifest } from './remote/manifest.js';
 import { find_app_id } from './resolve_app_id.js';
@@ -142,7 +143,10 @@ const launch = {
             // Propose the release version (--release > FAABLE_RELEASE > git tag).
             // Optional: when absent the platform injects no FAABLE_RELEASE and the
             // app falls back to its own version source.
-            const proposed = await propose_release({ workdir, explicit: args.release });
+            const proposed = await propose_release({
+                workdir,
+                explicit: args.release
+            });
             if (proposed) {
                 log.info(`🏷️ Release: ${proposed.release} (from ${proposed.source})`);
             }
@@ -165,7 +169,7 @@ const launch = {
                     deployment_started = true;
                 }
             });
-            const dashboard_url = `https://dashboard.faable.com/deploy/${app.team}/app/${app.id}`;
+            const dashboard_url = dashboardAppUrl(String(app.team), app.id);
             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)
@@ -253,7 +257,10 @@ const launch = {
                             phase: failure.phase,
                             reason: failure.reason,
                             ...(fault
-                                ? { fault_owner: fault.fault_owner, error_code: fault.error_code }
+                                ? {
+                                    fault_owner: fault.fault_owner,
+                                    error_code: fault.error_code
+                                }
                                 : {})
                         }
                         : {}),

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

@@ -4,14 +4,14 @@ 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));
+const wait = (ms) => new Promise(r => setTimeout(r, ms));
 /** The clone the platform created to retry this failed build, if any. */
 const retry_of = (deployment) => {
     const retry = deployment?.runtime_fallback_retry;
     if (!retry?.deployment_id)
         return null;
     // The api stores the clone as bare hex (a `.lean()` ObjectId).
-    const id = retry.deployment_id.startsWith("deployment_")
+    const id = retry.deployment_id.startsWith('deployment_')
         ? retry.deployment_id
         : `deployment_${retry.deployment_id}`;
     return { id, to: retry.to };
@@ -30,6 +30,32 @@ const retry_of = (deployment) => {
  * that will go live. Until 2026-10-18 the CLI exited red for a deploy that
  * was about to succeed (backlog §379).
  */
+const TAIL_CHARS = 200;
+/**
+ * The part of `content` not shown yet, given how much was `printed` and the
+ * last characters of it (`seen_tail`).
+ *
+ * Three cases. The same buffer, grown: print from the offset. A buffer that
+ * rotated (keep-tail truncation dropped its head) but still holds the tail we
+ * showed: print what comes after that tail. A DIFFERENT buffer — the build
+ * Job's log replacing the detect Job's — that does not hold it: print it
+ * whole. The old rule only knew the first case and "shrank → resync to its
+ * length", so the build log started being printed at the detect log's
+ * offset, and its head ("📦 installing dependencies…", most of "added 68
+ * packages") never reached the terminal (backlog §390, 2026-10-19).
+ */
+const unseen = (content, printed, seen_tail) => {
+    if (!seen_tail)
+        return { text: content.slice(printed) };
+    const at = printed - seen_tail.length;
+    if (at >= 0 && content.slice(at, printed) === seen_tail) {
+        return { text: content.slice(printed) };
+    }
+    const found = content.lastIndexOf(seen_tail);
+    if (found >= 0)
+        return { text: content.slice(found + seen_tail.length) };
+    return { text: content };
+};
 const follow_remote_build = async (api, 
 // `let`: a platform retry switches the follow to its clone.
 initial_deployment_id, 
@@ -39,59 +65,57 @@ initial_deployment_id,
 // live deploy as failed that way (arch/deploy/cli-mcp-fallos-2026-10-16-plan.md, F1).
 out = process.stdout) => {
     let printed = 0;
-    let last_phase = "";
+    let last_phase = '';
     let followed_retry = false;
     let deployment_id = initial_deployment_id;
     const started = Date.now();
+    // What we already showed, as its last characters: enough to recognise the
+    // same buffer, a rotated one, or a different one.
+    let seen_tail = '';
     const tail_logs = async () => {
         try {
             const logs = await api.getDeploymentLogs(deployment_id);
-            const content = logs?.content ?? "";
-            if (content.length > printed) {
-                out.write(content.slice(printed));
-                printed = content.length;
-            }
-            else if (content.length < printed) {
-                // Keep-tail truncation rotated the buffer — resync silently.
-                printed = content.length;
-            }
+            const content = logs?.content ?? '';
+            const fresh = unseen(content, printed, seen_tail);
+            if (fresh.text)
+                out.write(fresh.text);
+            printed = content.length;
+            seen_tail = content.slice(-TAIL_CHARS);
         }
         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 ?? "";
+        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") {
+        if (phase === 'BUILD_ERROR' || phase === 'ERROR') {
             const retry = retry_of(deployment);
             if (retry && !followed_retry) {
                 followed_retry = true;
                 log.info(`↩️ The default Python failed with your dependencies — the platform is retrying on Python ${retry.to} · ${retry.id}`);
                 deployment_id = retry.id;
                 printed = 0;
-                last_phase = "";
+                last_phase = '';
                 continue;
             }
             const reason = deployment?.status?.reason;
-            throw new Error(`Remote build failed${reason ? `: ${reason}` : ""}`.trim());
+            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") {
+        if (phase === 'INITIALIZING' || phase === 'READY') {
             await tail_logs();
             return { id: deployment_id };
         }
         await wait(POLL_INTERVAL_MS);
     }
-    throw new Error("Timed out waiting for the remote build. Check the dashboard for its status.");
+    throw new Error('Timed out waiting for the remote build. Check the dashboard for its status.');
 };
 
-export { follow_remote_build };
+export { follow_remote_build, unseen };

package/dist/lib/dashboard_url.js

@@ -0,0 +1,11 @@
+// Dashboard links to an app, in the canonical `project_` form.
+//
+// The api returns `app.team` as `team_<hex>`. The dashboard accepts it, but a
+// session that lands on a `team_` URL keeps navigating with it and pays a 400
+// on `/project-favorites/recents` each time — so links leave as `project_`
+// (same rule as the api's emails, arch backlog §387).
+const DASHBOARD = 'https://dashboard.faable.com';
+const toProjectId = (team) => team.replace(/^team_/, 'project_');
+const dashboardAppUrl = (team, app_id) => `${DASHBOARD}/deploy/${toProjectId(team)}/app/${app_id}`;
+
+export { dashboardAppUrl, toProjectId };

package/package.json

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