@faable/faable 4.21.0 → 4.22.0

package/dist/api/FaableApi.js

@@ -272,13 +272,21 @@ class FaableApi {
         })));
     }
     // Replace the app's whole secret set (the endpoint deletes and recreates).
-    // This is the only mutation path that triggers an immediate restart of the
-    // app; the per-secret upsert/delete endpoints are not used by the CLI.
+    // The per-secret upsert/delete endpoints are not used by the CLI.
     // The endpoint stamps the created secrets with the team from the request
     // context, which a CLI user token does not carry — pass the app's team
     // (from getApp) so it travels as the `x-faable-project` header.
+    //
+    // `with_redeploy=true` (api §403): a running app restarts to apply the new
+    // values, but an app with nothing running whose last deployment failed at
+    // runtime has nothing to restart — the api relaunches that deployment and
+    // says so in `redeploy`. An api that predates it ignores the parameter and
+    // answers the bare array: read that as "no redeploy to report".
     async createSecretsBatch(context_id, team, secrets) {
-        return data(this.client.post(`/secret/createbatch`, { context_id, secrets }, { headers: projectHeader(team) }));
+        const body = await data(this.client.post(`/secret/createbatch`, { context_id, secrets }, { headers: projectHeader(team), params: { with_redeploy: true } }));
+        if (Array.isArray(body))
+            return { secrets: body, redeploy: null };
+        return { secrets: body?.secrets ?? [], redeploy: body?.redeploy ?? null };
     }
     async updateApp(app_id, params) {
         return data(this.client.post(`/app/${app_id}`, params));

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

@@ -31,6 +31,19 @@ const retry_of = (deployment) => {
  * was about to succeed (backlog §379).
  */
 const TAIL_CHARS = 200;
+/**
+ * The build's warnings, after its log (api `deployment.build_warnings`). The
+ * same lines are in the log above, but scrolled away among hundreds of npm
+ * lines; a deploy that ends READY is exactly the one nobody scrolls back on.
+ */
+const format_build_warnings = (warnings) => {
+    if (!warnings?.length)
+        return '';
+    const n = warnings.length;
+    return (`\n⚠️  ${n} build warning${n === 1 ? '' : 's'} — the build worked around ${n === 1 ? 'this' : 'these'}; fix ${n === 1 ? 'it' : 'them'} so it does not have to:\n` +
+        warnings.map(w => `   • ${w.message}\n`).join('') +
+        '\n');
+};
 /**
  * The part of `content` not shown yet, given how much was `printed` and the
  * last characters of it (`seen_tail`).
@@ -111,11 +124,18 @@ out = process.stdout) => {
         // already live (READY) — the promotion poll takes over from here.
         if (phase === 'INITIALIZING' || phase === 'READY') {
             await tail_logs();
-            return { id: deployment_id };
+            const build_warnings = deployment?.build_warnings;
+            const summary = format_build_warnings(build_warnings);
+            if (summary)
+                out.write(summary);
+            return {
+                id: deployment_id,
+                ...(build_warnings?.length ? { build_warnings } : {})
+            };
         }
         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, unseen };
+export { follow_remote_build, format_build_warnings, unseen };

package/dist/commands/deploy/secrets/after_save.js

@@ -0,0 +1,67 @@
+// What happens to the app after a secrets save, in the words the user reads.
+//
+// A running app restarts to apply the new values. An app with NOTHING running
+// whose last deployment failed at runtime (a crashloop over a missing
+// variable, the usual reason to come and set one) has nothing to restart: the
+// api relaunches that deployment itself and reports it (api §403). Promising
+// a restart there was wrong — nothing was coming, or a whole new deployment
+// was.
+//
+// Every command carries `-a <app id>`: these lines get copied, and outside
+// the app's checkout a bare command resolves no app.
+const after_save_lines = (args) => {
+    const { app, redeploy, changed } = args;
+    const what = args.what ?? 'the new variables';
+    const a = `-a ${app.id}`;
+    if (!redeploy) {
+        return [
+            {
+                level: 'info',
+                text: changed
+                    ? `ℹ️ The app is restarting to apply the changes.`
+                    : `ℹ️ Already up to date — the app was not restarted.`
+            }
+        ];
+    }
+    const failed = redeploy.failed_deployment_id;
+    if (redeploy.status === 'started') {
+        const id = redeploy.deployment_id;
+        return [
+            {
+                level: 'info',
+                text: `🔁 Redeploying ${app.name} with ${what} (deployment ${id}): its last deployment ${failed} had failed and nothing was running.`
+            },
+            {
+                level: 'info',
+                text: `Follow it with: faable deploy logs --build -d ${id} ${a} --follow  ·  status: faable deploy status ${a}`
+            }
+        ];
+    }
+    if (redeploy.status === 'needs_rebuild') {
+        return [
+            {
+                level: 'warn',
+                text: `⚠️ Nothing is running: the last deployment ${failed} failed to build, so ${what} are saved but not deployed.`
+            },
+            {
+                level: 'warn',
+                text: `Rebuild it with: faable deploy redeploy ${failed} ${a}  ·  why it failed: faable deploy logs --build -d ${failed} ${a}`
+            }
+        ];
+    }
+    return [
+        {
+            level: 'warn',
+            text: `⚠️ Nothing is running and Faable could not relaunch the failed deployment ${failed}, so ${what} are saved but not deployed.`
+        },
+        {
+            level: 'warn',
+            text: `Relaunch it by hand (it tells you why if it is refused): faable deploy redeploy ${failed} ${a}`
+        }
+    ];
+};
+// The `restarting` of the --json output: only a running app restarts. When
+// the api reports a redeploy (started or not), nothing restarts.
+const is_restarting = (redeploy, changed) => changed && !redeploy;
+
+export { after_save_lines, is_restarting };

package/dist/commands/deploy/secrets/rm.js

@@ -2,6 +2,7 @@ import { requireApi } from '../../../api/context.js';
 import { print_json, json_option } from '../../../lib/listing.js';
 import { log } from '../../../log.js';
 import { resolve_app_id } from '../resolve_app_id.js';
+import { is_restarting, after_save_lines } from './after_save.js';
 import { remove_app_secret } from './merge.js';
 import { confirm } from '../../../lib/interactive.js';
 
@@ -44,12 +45,24 @@ const secrets_rm = {
             log.info('Cancelled.');
             return;
         }
-        await ctx.api.createSecretsBatch(app.id, app.team, remaining);
+        const { redeploy } = await ctx.api.createSecretsBatch(app.id, app.team, remaining);
         if (args.json) {
-            return print_json({ deleted: true, name: args.name, restarting: true });
+            return print_json({
+                deleted: true,
+                name: args.name,
+                restarting: is_restarting(redeploy, true),
+                redeploy
+            });
         }
         log.info(`🗑️ Removed secret ${args.name} from ${app_id}.`);
-        log.info(`ℹ️ The app is restarting to apply the changes.`);
+        const lines = after_save_lines({
+            app,
+            redeploy,
+            changed: true,
+            what: 'the updated variables'
+        });
+        for (const { level, text } of lines)
+            log[level](text);
     }
 };
 

package/dist/commands/deploy/secrets/set.js

@@ -5,6 +5,7 @@ import { print_json, json_option } from '../../../lib/listing.js';
 import { read_stdin } from '../../../lib/stdin.js';
 import { log } from '../../../log.js';
 import { resolve_app_id } from '../resolve_app_id.js';
+import { is_restarting, after_save_lines } from './after_save.js';
 import { managed_warning } from './managed_names.js';
 import { merge_app_secrets } from './merge.js';
 import { parse_env } from './parse_env.js';
@@ -113,12 +114,12 @@ const secrets_set = {
         const app = await ctx.api.getApp(app_id);
         const existing = await ctx.api.getAppSecrets(app_id, app.team);
         const merged = merge_app_secrets(existing, parsed);
-        await ctx.api.createSecretsBatch(app.id, app.team, merged);
+        const { redeploy } = await ctx.api.createSecretsBatch(app.id, app.team, merged);
         const current = new Map(existing
             .filter(s => s.related_model === 'app')
             .map(s => [s.name, s.value]));
         const updated = parsed.filter(({ name }) => current.has(name)).length;
-        // Only claim the restart when something actually changed. Setting a name
+        // Only claim a restart when something actually changed. Setting a name
         // to the value it already has is a no-op end to end — the API compares
         // before writing and never emits the event, so the pod keeps running —
         // and this line used to promise a restart that was not coming.
@@ -134,7 +135,10 @@ const secrets_set = {
                 unchanged: parsed
                     .filter(p => current.get(p.name) === p.value)
                     .map(p => p.name),
-                restarting: changed
+                restarting: is_restarting(redeploy, changed),
+                // api §403: what the api did for an app with nothing running whose
+                // last deployment failed — null when there was nothing to relaunch.
+                redeploy
             });
         }
         if (parsed.length <= MAX_DETAILED) {
@@ -148,9 +152,13 @@ const secrets_set = {
             log.info(`🔑 ${parsed.length - updated} added, ${updated} updated`);
         }
         log.info(`✅ ${parsed.length} secret(s) saved to ${app_id}.`);
-        log.info(changed
-            ? `ℹ️ The app is restarting to apply the changes.`
-            : `ℹ️ Already up to date — the app was not restarted.`);
+        for (const { level, text } of after_save_lines({
+            app,
+            redeploy,
+            changed
+        })) {
+            log[level](text);
+        }
     }
 };
 

package/dist/mcp/tools.js

@@ -760,7 +760,7 @@ const TOOLS = [
     {
         name: 'set_secrets',
         title: 'Set environment variables',
-        description: 'Add or update environment variables of an app. The app restarts to apply them when a value changed. Returns the names added, updated and unchanged — never the values.',
+        description: 'Add or update environment variables of an app. When the app is running, it restarts to apply them (only if a value changed); if its last deployment failed at runtime and nothing is running, Faable redeploys it with the new variables. Returns the names added, updated and unchanged — never the values — and `redeploy`: null when there was nothing to relaunch; otherwise `status` is `started` (follow `deployment_id` with get_deployment), `needs_rebuild` (the last deployment failed to build: retry `failed_deployment_id` with redeploy) or `not_started` (the platform refused the relaunch: retry it with redeploy to see why).',
         input: {
             app,
             project,

package/package.json

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