@faable/faable 1.38.4 → 1.39.0

package/dist/api/FaableApi.js

@@ -3,11 +3,11 @@ import { create_base_client } from './base_client.js';
 // Socket-level failures where no response ever arrived: the connection died
 // before the server produced anything, so a single retry is safe for any
 // method (a reset mid-flight means the request was not processed).
-const RESET_CODES = new Set(["ECONNRESET", "EPIPE"]);
+const RESET_CODES = new Set(['ECONNRESET', 'EPIPE']);
 const RETRY_DELAY_MS = 300;
 const is_connection_reset = (e) => e.isAxiosError &&
     !e.response &&
-    (RESET_CODES.has(e.code ?? "") || e.message.includes("socket hang up"));
+    (RESET_CODES.has(e.code ?? '') || e.message.includes('socket hang up'));
 const firstPage = async (res) => {
     const items = (await res).results;
     return items;
@@ -58,28 +58,26 @@ class FaableApi {
             const config = e.config;
             if (config && !config._retried && is_connection_reset(e)) {
                 config._retried = true;
-                await new Promise((r) => setTimeout(r, RETRY_DELAY_MS));
+                await new Promise(r => setTimeout(r, RETRY_DELAY_MS));
                 return client.request(config);
             }
             throw error;
         });
-        this.client.interceptors.response.use((response) => response, (error) => {
+        this.client.interceptors.response.use(response => response, error => {
             const e = error;
             if (e.isAxiosError) {
                 const res = e.response;
-                const url = e.config?.url || "";
+                const url = e.config?.url || '';
                 if (res) {
                     // Uniform handling for an expired/invalid session across every
                     // command, regardless of which endpoint returned the 401.
                     if (res.status === 401) {
-                        const expired = new Error("Your Faable session has expired or is invalid. Run `faable login` to sign in again.", { cause: error });
+                        const expired = new Error('Your Faable session has expired or is invalid. Run `faable login` to sign in again.', { cause: error });
                         expired.status = 401;
                         throw expired;
                     }
-                    const serverMessage = res.data?.message || res.statusText || "Unknown Error";
+                    const serverMessage = res.data?.message || res.statusText || 'Unknown Error';
                     const wrapped = new Error(`FaableApi ${url} ${res.status}: ${serverMessage}`, { cause: error });
-                    // Surface the structured error contract (e.g. the repository-link
-                    // flow returns { code, action }) so callers can branch on it.
                     wrapped.status = res.status;
                     if (res.data?.code)
                         wrapped.code = res.data.code;
@@ -98,8 +96,8 @@ class FaableApi {
         return new FaableApi(config);
     }
     async list() {
-        return allPages((next) => data(this.client.get(`/app`, {
-            params: { pageSize: 200, ...(next ? { next } : {}) },
+        return allPages(next => data(this.client.get(`/app`, {
+            params: { pageSize: 200, ...(next ? { next } : {}) }
         })));
     }
     async getBySlug(slug) {
@@ -121,7 +119,7 @@ class FaableApi {
     async uploadMissing(app_id, files) {
         return data(this.client.post(`/upload/missing`, {
             app_id,
-            files: files.map(({ path, sha, size }) => ({ path, sha, size })),
+            files: files.map(({ path, sha, size }) => ({ path, sha, size }))
         }, { timeout: 60_000 }));
     }
     // Remote builds: read the build output the builder attaches to the
@@ -139,7 +137,7 @@ class FaableApi {
     // deployment and materialize it.
     async completeDeployment(deployment_id, image) {
         return data(this.client.post(`/deployment/${deployment_id}`, {
-            image,
+            image
         }));
     }
     // Fetch a deployment with its runtime status, so the deploy command can
@@ -169,7 +167,7 @@ class FaableApi {
     // context, which a CLI user token does not carry — pass the app's team
     // (from getApp) so it travels as the `x-faable-team` header.
     async createSecretsBatch(context_id, team, secrets) {
-        return data(this.client.post(`/secret/createbatch`, { context_id, secrets }, { headers: { "x-faable-team": team } }));
+        return data(this.client.post(`/secret/createbatch`, { context_id, secrets }, { headers: { 'x-faable-team': team } }));
     }
     async updateApp(app_id, params) {
         return data(this.client.post(`/app/${app_id}`, params));
@@ -179,11 +177,11 @@ class FaableApi {
     }
     // Organizations/accounts where the Faable GitHub App is installed.
     async listGithubInstallations() {
-        return data(this.client.get(`/github/installations`)).then((res) => res.installations);
+        return data(this.client.get(`/github/installations`)).then(res => res.installations);
     }
     // Top repositories for a single installation (org), optionally filtered.
     async listGithubRepos(installation_id, params = {}) {
-        return data(this.client.get(`/github/installations/${installation_id}/repositories`, { params })).then((res) => res.repositories);
+        return data(this.client.get(`/github/installations/${installation_id}/repositories`, { params })).then(res => res.repositories);
     }
     async getMe() {
         return data(this.client.get(`/auth/me`));
@@ -198,7 +196,7 @@ class FaableApi {
     async listDeployments(app_id, team) {
         return firstPage(data(this.client.get(`/deployment`, {
             params: { app_id },
-            headers: { "x-faable-team": team },
+            headers: { 'x-faable-team': team }
         })));
     }
     // Build and deploy the current head of the deploy branch server-side —
@@ -210,7 +208,14 @@ class FaableApi {
     // git ref). The API enforces the guards: failed phase only, never older
     // than what production serves.
     async redeployDeployment(deployment_id, team) {
-        return data(this.client.post(`/deployment/${deployment_id}/redeploy`, undefined, { headers: { "x-faable-team": team } }));
+        return data(this.client.post(`/deployment/${deployment_id}/redeploy`, undefined, { headers: { 'x-faable-team': team } }));
+    }
+    // Give up on a build still in the pre-handoff window (QUEUED/BUILDING).
+    // A route of its own rather than a `{phase: 'CANCELED'}` status write:
+    // phase transitions belong to the controller, and the api only lets a user
+    // token touch the phases the CLI owns.
+    async cancelDeployment(deployment_id, team) {
+        return data(this.client.post(`/deployment/${deployment_id}/cancel`, undefined, { headers: { 'x-faable-team': team } }));
     }
     // Domains are team-scoped rows; a CLI user token carries no default team,
     // so every call pins the app's team via `x-faable-team` (same pattern as
@@ -218,22 +223,22 @@ class FaableApi {
     async listDomains(app_id, team) {
         return firstPage(data(this.client.get(`/domain`, {
             params: { app_id },
-            headers: { "x-faable-team": team },
+            headers: { 'x-faable-team': team }
         })));
     }
     async createDomain(team, params) {
         return data(this.client.post(`/domain`, params, {
-            headers: { "x-faable-team": team },
+            headers: { 'x-faable-team': team }
         }));
     }
     async getDomain(domain_id, team) {
         return data(this.client.get(`/domain/${domain_id}`, {
-            headers: { "x-faable-team": team },
+            headers: { 'x-faable-team': team }
         }));
     }
     async deleteDomain(domain_id, team) {
         return data(this.client.delete(`/domain/${domain_id}`, {
-            headers: { "x-faable-team": team },
+            headers: { 'x-faable-team': team }
         }));
     }
 }

package/dist/api/session.js

@@ -44,7 +44,16 @@ const loadLiveCredentials = async (store = new CredentialsStore()) => {
             log.debug?.("Refreshed access token");
             return next;
         }
-        catch {
+        catch (e) {
+            // The auth server marks a suspension with a stable machine code on the
+            // token endpoint's RFC 6749 error body. "Run `faable login` again"
+            // would be a lie here — login is denied too — so say what actually
+            // happened and stop instead of letting a generic 401 mislead.
+            const body = e?.response?.data;
+            if (body?.error_code === "user_suspended") {
+                log.error("❌ Your account has been suspended. Contact support@faable.com.");
+                process.exit(1);
+            }
             // Refresh failed — keep the stale config; the API call's 401 (or
             // requireApi) will tell the user to run `faable login` again.
         }

package/dist/commands/deploy/index.js

@@ -4,6 +4,7 @@ import { log } from '../../log.js';
 import { link } from '../link/index.js';
 import { domains } from './domains/index.js';
 import { git_context } from './git_context.js';
+import { cancel } from './inspect/cancel.js';
 import { deployments } from './inspect/deployments.js';
 import { inspect } from './inspect/inspect.js';
 import { apps_list } from './inspect/list.js';
@@ -37,6 +38,7 @@ const deploy = {
             .command(open_app)
             .command(trigger)
             .command(redeploy)
+            .command(cancel)
             .command(link)
             .positional('app_id', {
             type: 'string',
@@ -138,14 +140,14 @@ const deploy = {
                 // ~1min, long before this 5min promotion timeout.
                 const dep = await api.getDeployment(deployment.id);
                 const phase = dep.status?.phase;
-                if (phase === "ERROR" || phase === "BUILD_ERROR") {
+                if (phase === 'ERROR' || phase === 'BUILD_ERROR') {
                     failure = { phase, reason: dep.status?.reason };
                     break;
                 }
                 // CANCELED: the platform superseded this build before it produced a
                 // runnable (a sibling deployment of the app won the promotion).
-                if (phase === "CANCELED") {
-                    superseded = dep.status?.reason ?? "canceled";
+                if (phase === 'CANCELED') {
+                    superseded = dep.status?.reason ?? 'canceled';
                     break;
                 }
             }

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

@@ -0,0 +1,47 @@
+import { requireApi } from '../../../api/context.js';
+import { log } from '../../../log.js';
+import { resolve_app_id } from '../resolve_app_id.js';
+
+// Mirrors CANCELABLE_PHASES in the api (deployment/api/cancel.ts). Used only
+// to pick a default target; the api is the one that enforces it, so a phase
+// that changed between the list and the call is still refused server-side.
+const IN_FLIGHT_PHASES = new Set(['UNKNOWN', 'QUEUED', 'BUILDING']);
+const cancel = {
+    command: 'cancel [deployment]',
+    describe: 'Stop a deployment that is still queued or building',
+    builder: yargs => yargs
+        .positional('deployment', {
+        type: 'string',
+        description: 'Deployment id to cancel (defaults to the one currently in flight)'
+    })
+        .option('app', {
+        alias: 'a',
+        type: 'string',
+        description: 'App Identifier (defaults to the linked app)'
+    })
+        .example('$0 deploy cancel', 'Stop the build that is running right now')
+        .showHelpOnFail(false),
+    handler: async (args) => {
+        const ctx = await requireApi();
+        const app_id = await resolve_app_id(args.app, ctx.appId, ctx.api);
+        const app = await ctx.api.getApp(app_id);
+        let deployment_id = args.deployment;
+        if (!deployment_id) {
+            const rows = await ctx.api.listDeployments(app_id, app.team);
+            const inFlight = rows.find(d => IN_FLIGHT_PHASES.has(d.status?.phase ?? ''));
+            if (!inFlight) {
+                log.info(`✅ Nothing building for ${app.name} — nothing to cancel.`);
+                return;
+            }
+            deployment_id = inFlight.id;
+        }
+        // The api owns the guards: it refuses once a controller has claimed the
+        // deployment, and answers a repeated cancel with the same 200 so a retry
+        // is never an error the user has to read.
+        const canceled = await ctx.api.cancelDeployment(deployment_id, app.team);
+        log.info(`🛑 Canceled ${canceled.id} (${app.name}).`);
+        log.info(`Production keeps serving the last promoted deployment. Deploy again with: faable deploy`);
+    }
+};
+
+export { cancel };

package/package.json

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