@faable/faable 4.2.0 → 4.4.0

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

@@ -1,4 +1,5 @@
 import { requireApi } from '../../../api/context.js';
+import { print_noop, print_json, json_option } from '../../../lib/listing.js';
 import { log } from '../../../log.js';
 import { resolve_app_id } from '../resolve_app_id.js';
 
@@ -6,7 +7,7 @@ const FAILED_PHASES = new Set(['ERROR', 'BUILD_ERROR']);
 const redeploy = {
     command: 'redeploy [deployment]',
     describe: 'Rebuild a failed deployment from its recorded source',
-    builder: yargs => yargs
+    builder: yargs => json_option(yargs)
         .positional('deployment', {
         type: 'string',
         description: 'Deployment id to rebuild (defaults to the latest failed one)'
@@ -14,7 +15,7 @@ const redeploy = {
         .option('app', {
         alias: 'a',
         type: 'string',
-        description: 'App Identifier (defaults to the linked app)'
+        description: 'App id, name or slug (defaults to the linked app)'
     })
         .example('$0 deploy redeploy', 'Retry the latest failed deployment')
         .showHelpOnFail(false),
@@ -27,6 +28,9 @@ const redeploy = {
             const rows = await ctx.api.listDeployments(app_id, app.team);
             const failed = rows.find(d => FAILED_PHASES.has(d.status?.phase ?? ''));
             if (!failed) {
+                if (args.json) {
+                    return print_noop(`${app.name} has no failed deployment to retry`);
+                }
                 log.info(`✅ No failed deployments to retry for ${app.name}. To rebuild the repo HEAD use: faable deploy trigger`);
                 return;
             }
@@ -35,8 +39,12 @@ const redeploy = {
         // The API enforces the guards (failed phase only, never older than what
         // production serves) and answers with an actionable refusal otherwise.
         const clone = await ctx.api.redeployDeployment(deployment_id, app.team);
+        if (args.json)
+            return print_json(clone);
         log.info(`🔁 Rebuilding ${deployment_id} as ${clone.id}.`);
-        log.info(`Track it with: faable deploy status  ·  build output: faable deploy logs --build`);
+        // With -a: these lines get copied, and outside the app's checkout a
+        // bare command resolves no app (see next_steps in detail.ts).
+        log.info(`Track it with: faable deploy status -a ${app.id}  ·  build output: faable deploy logs --build -d ${clone.id} -a ${app.id}`);
     }
 };
 

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

@@ -1,4 +1,5 @@
 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 { phase_badge, detected_summary, short_commit, when } from './format.js';
@@ -6,11 +7,11 @@ import { phase_badge, detected_summary, short_commit, when } from './format.js';
 const status = {
     command: 'status',
     describe: 'Show what is live for the app',
-    builder: yargs => yargs
+    builder: yargs => json_option(yargs)
         .option('app', {
         alias: 'a',
         type: 'string',
-        description: 'App Identifier (defaults to the linked app)'
+        description: 'App id, name or slug (defaults to the linked app)'
     })
         .showHelpOnFail(false),
     handler: async (args) => {
@@ -19,6 +20,11 @@ const status = {
         const app = await ctx.api.getApp(app_id);
         const deployments = await ctx.api.listDeployments(app_id, app.team);
         const latest = deployments[0];
+        // The app record plus its newest deployment — which may not be the live
+        // one (status.deployment): a failed build leaves production as it was.
+        if (args.json) {
+            return print_json({ ...app, latest_deployment: latest ?? null });
+        }
         log.info(`${phase_badge(app.status?.phase)}  ${app.name} (${app.id})`);
         log.info(`  URL:        https://${app.url}`);
         const stack = detected_summary(app.detected);
@@ -34,7 +40,7 @@ const status = {
             log.info(`  Latest:     ${latest.id} — ${phase_badge(latest.status?.phase)} (${short_commit(latest.github_commit)}, ${when(latest.createdAt)})`);
             if (latest.status?.reason) {
                 log.info(`  Reason:     ${latest.status.reason.split('\n')[0]}`);
-                log.info(`  Full error: faable deploy logs --build`);
+                log.info(`  Full error: faable deploy logs --build -d ${latest.id} -a ${app.id}`);
             }
         }
         if (deployments.length === 0) {

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

@@ -0,0 +1,84 @@
+import { requireApi } from '../../../api/context.js';
+import { CliError } from '../../../lib/errors.js';
+import { print_json, print, table_lines, json_option } from '../../../lib/listing.js';
+import { log } from '../../../log.js';
+import { resolve_app_id } from '../resolve_app_id.js';
+
+const UNITS = { m: 60, h: 3600, d: 86400 };
+// "24h", "7d", "30m" → seconds. The api keeps about a month of edge logs.
+const parse_since = (since) => {
+    const m = /^(\d+)([mhd])$/.exec(since.trim());
+    if (!m || Number(m[1]) < 1) {
+        throw new CliError('usage', `--since takes a duration like 30m, 24h or 7d (got "${since}")`);
+    }
+    return Number(m[1]) * UNITS[m[2]];
+};
+// `faable deploy traffic` — what the edge saw for the app: busiest paths,
+// failing paths and status codes. Trails reality by up to 15 minutes.
+const traffic = {
+    command: 'traffic',
+    describe: 'Requests the app served: top paths, errors and status codes',
+    builder: yargs => json_option(yargs)
+        .option('app', {
+        alias: 'a',
+        type: 'string',
+        description: 'App id, name or slug (defaults to the linked app)'
+    })
+        .option('since', {
+        type: 'string',
+        default: '24h',
+        description: 'How far back: 30m, 24h, 7d…'
+    })
+        .option('deployment', {
+        alias: 'd',
+        type: 'string',
+        description: 'Only the traffic one deployment served'
+    })
+        .example('$0 deploy traffic', 'The last 24h of the linked app')
+        .example('$0 deploy traffic --since 7d -a my-app', 'A week of another app')
+        .showHelpOnFail(false),
+    handler: async (args) => {
+        const seconds = parse_since(args.since ?? '24h');
+        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);
+        const to = Math.floor(Date.now() / 1000);
+        const data = (await ctx.api.getAppTraffic(app_id, app.team, {
+            from: to - seconds,
+            to,
+            ...(args.deployment ? { deployment_id: args.deployment } : {})
+        }));
+        if (args.json)
+            return print_json({ app_id, ...data });
+        const total = (data.status_codes ?? []).reduce((n, s) => n + s.requests, 0);
+        log.info(`📈 ${app.name} — last ${args.since}: ${total} request(s)`);
+        if (data.degraded?.length) {
+            log.warn(`⚠️ Partial: ${data.degraded.join(', ')} could not be read — those are missing, not zero.`);
+        }
+        if (total === 0)
+            return;
+        print('');
+        print('Status codes');
+        for (const line of table_lines(['  STATUS', 'REQUESTS'], (data.status_codes ?? []).map(s => [`  ${s.status}`, String(s.requests)]))) {
+            print(line);
+        }
+        if (data.top_endpoints?.length) {
+            print('');
+            print('Top paths');
+            for (const line of table_lines(['  REQUESTS', 'PATH'], data.top_endpoints.slice(0, 10).map(e => [`  ${e.requests}`, e.path]))) {
+                print(line);
+            }
+        }
+        if (data.error_endpoints?.length) {
+            print('');
+            print('Failing paths');
+            for (const line of table_lines(['  ERRORS', 'STATUS', 'PATH'], data.error_endpoints
+                .slice(0, 10)
+                .map(e => [`  ${e.errors}`, String(e.status), e.path]))) {
+                print(line);
+            }
+        }
+    }
+};
+
+export { parse_since, traffic };

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

@@ -1,15 +1,16 @@
 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';
 
 const trigger = {
     command: 'trigger',
     describe: 'Build and deploy the latest commit of the deploy branch, server-side',
-    builder: yargs => yargs
+    builder: yargs => json_option(yargs)
         .option('app', {
         alias: 'a',
         type: 'string',
-        description: 'App Identifier (defaults to the linked app)'
+        description: 'App id, name or slug (defaults to the linked app)'
     })
         .example('$0 deploy trigger', 'Deploy the repo HEAD without uploading anything from this machine')
         .showHelpOnFail(false),
@@ -20,8 +21,13 @@ const trigger = {
         // Takes the exact same path a git push would (same-commit dedupe
         // included) — the API answers with an actionable refusal otherwise.
         const result = await ctx.api.deployNow(app_id);
-        log.info(`🚀 Building ${result.commit.slice(0, 7)} (${result.branch}) of ${app.name} server-side.`);
-        log.info(`Track it with: faable deploy status  ·  or in the dashboard: https://dashboard.faable.com/deploy/${app.team}/app/${app.id}`);
+        if (args.json)
+            return print_json({ app_id, ...result });
+        log.info(`🚀 Building ${result.commit.slice(0, 7)} (${result.branch}) of ${app.name} server-side${result.deployment_id ? ` as ${result.deployment_id}` : ''}.`);
+        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}`);
     }
 };
 

package/dist/commands/deploy/launch.js

@@ -1,6 +1,7 @@
-import prompts from 'prompts';
 import { requireApi } from '../../api/context.js';
 import { Configuration } from '../../lib/Configuration.js';
+import { CliError } from '../../lib/errors.js';
+import { is_non_interactive, confirm } from '../../lib/interactive.js';
 import { log } from '../../log.js';
 import { git_context } from './git_context.js';
 import { show_deploy_help } from './help.js';
@@ -21,7 +22,7 @@ const launch = {
         .option('app', {
         alias: 'a',
         type: 'string',
-        description: 'App Identifier (defaults to the app linked to this repository)'
+        description: 'App id, name or slug (defaults to the app linked to this repository)'
     })
         .option('workdir', {
         alias: 'w',
@@ -42,10 +43,25 @@ const launch = {
         .example('$0 deploy --app app_a1b2c3', 'Deploy another app (monorepo: several apps, one repo)')
         .showHelpOnFail(false),
     handler: async (args) => {
+        // Driven by a program: nothing about the target is left to the process'
+        // working directory, and the go-ahead is explicit (see lib/interactive).
+        if (is_non_interactive()) {
+            const missing = [
+                !args.app && '--app',
+                !args.workdir && '--workdir',
+                !args.yes && '--yes'
+            ].filter(Boolean);
+            if (missing.length) {
+                throw new CliError(missing.includes('--yes') && missing.length === 1
+                    ? 'confirmation_required'
+                    : 'usage', `In non-interactive mode a deploy needs ${missing.join(', ')}: the app, the directory to upload and the go-ahead are never inferred.`);
+            }
+        }
         const workdir = args.workdir || process.cwd();
         // Pass the explicit app target to the OIDC exchange so a monorepo (several
         // apps, one repo) can be disambiguated in CI.
-        const ctx = await requireApi(args.app);
+        // Only an id: the OIDC exchange in CI takes an app id, not a name.
+        const ctx = await requireApi(args.app?.startsWith('app_') ? args.app : undefined);
         const { api } = ctx;
         const config = Configuration.instance().deployConfig();
         const app_id = await find_app_id(args.app, ctx.appId, api, workdir);
@@ -55,25 +71,18 @@ const launch = {
         // answering a bare `faable deploy` with an error and nothing else.
         if (!app_id) {
             show_deploy_help();
-            log.error(`❌ No app linked to ${workdir}. Connect a repository from the dashboard (or run "faable deploy link"), or target one with --app <app_id>.`);
-            process.exit(1);
+            throw new CliError('app_required', `No app linked to ${workdir}. Connect a repository from the dashboard (or run "faable deploy link"), or target one with --app <app_id>.`);
         }
         const app = await api.getApp(app_id);
         // Confirm which app/dir is about to go out. Only in a real terminal — CI
         // (non-TTY) deploys unattended, so pipelines need no changes.
-        if (!args.yes && process.stdout.isTTY) {
-            const { confirm } = await prompts({
-                type: 'toggle',
-                name: 'confirm',
+        if (process.stdout.isTTY &&
+            !(await confirm({
                 message: `Deploy "${app.name}" (${app.id}) from ${workdir}?`,
-                initial: false,
-                active: 'yes',
-                inactive: 'no'
-            });
-            if (!confirm) {
-                log.info('Cancelled.');
-                return;
-            }
+                yes: args.yes
+            }))) {
+            log.info('Cancelled.');
+            return;
         }
         // Monorepo Root Directory — single precedence rule everywhere
         // (arch/deploy/root-dir-faable-json.md): App.root_dir (platform

package/dist/commands/deploy/project_usage.js

@@ -0,0 +1,83 @@
+import { requireApi } from '../../api/context.js';
+import { requireProject } from '../../api/project.js';
+import { print_json, print, json_option } from '../../lib/listing.js';
+import { log } from '../../log.js';
+import { until } from './inspect/format.js';
+
+// `faable deploy quota` — why a deploy did not start today. A held build is
+// waiting for the daily allowance, not failing.
+const quota = {
+    command: 'quota',
+    describe: "Today's deploy allowance of the project, and builds held by it",
+    builder: yargs => json_option(yargs).showHelpOnFail(false),
+    handler: async (args) => {
+        const { api } = await requireApi();
+        const { id: project } = await requireProject(api);
+        const quota = await api.getDeployQuota(project);
+        if (args.json)
+            return print_json({ project, ...quota });
+        const limit = quota.limit === null ? 'unlimited' : String(quota.limit);
+        print(`Deploys today: ${quota.used} of ${limit}`);
+        print(`Resets:        ${until(quota.resets_at)} (${quota.resets_at})`);
+        if (quota.held > 0) {
+            print(`Held:          ${quota.held} build(s) waiting for the allowance`);
+        }
+        if (quota.over) {
+            log.warn('⚠️ The daily allowance is spent: new builds wait until it resets, or upgrade the plan.');
+        }
+    }
+};
+// `faable deploy usage` — this billing period, for the active project. The
+// api answers for every project of the caller; the active one is picked out
+// (by its id in either form: project_… / team_…).
+const usage = {
+    command: 'usage',
+    describe: "This billing period's usage of the project (apps, deploys, traffic)",
+    builder: yargs => json_option(yargs)
+        .option('traffic', {
+        type: 'boolean',
+        default: true,
+        description: 'Include egress (the slow part; --no-traffic skips it)'
+    })
+        .showHelpOnFail(false),
+    handler: async (args) => {
+        const { api } = await requireApi();
+        const { id: project } = await requireProject(api);
+        const summary = (await api.getUsageSummary(project, {
+            traffic: args.traffic
+        }));
+        const hex = project.replace(/^project_/, '');
+        const mine = summary.teams?.find(t => t.id.endsWith(hex)) ?? null;
+        if (args.json) {
+            return print_json({
+                project,
+                usage: mine,
+                billing_available: summary.billing_available ?? null
+            });
+        }
+        if (!mine) {
+            log.info(`📭 No usage recorded for ${project} this period.`);
+            return;
+        }
+        print(`${mine.name} (${project})`);
+        if (mine.period) {
+            print(`Period:      ${mine.period.start.slice(0, 10)} → ${mine.period.end.slice(0, 10)}`);
+        }
+        if (mine.subscription) {
+            print(`Plan:        ${mine.subscription.plan ?? 'free'} (${mine.subscription.status})`);
+        }
+        else if (summary.billing_available === false) {
+            // null then means "unknown", not "free".
+            print(`Plan:        unknown (billing did not answer)`);
+        }
+        if (mine.resources) {
+            const r = mine.resources;
+            print(`Resources:   ${r.apps} app(s), ${r.domains} domain(s), ${r.deployments} deployment(s)`);
+        }
+        if (mine.traffic) {
+            print(`Egress:      ${mine.traffic.used_gb.toFixed(2)} GB`);
+        }
+    }
+};
+
+export { quota, usage };

package/dist/commands/deploy/resolve_app_id.js

@@ -1,9 +1,37 @@
+import { requireProject } from '../../api/project.js';
 import { Configuration } from '../../lib/Configuration.js';
+import { CliError } from '../../lib/errors.js';
+import { is_non_interactive } from '../../lib/interactive.js';
+import { fetch_page } from '../../lib/listing.js';
 import { getGitRemoteUrl } from '../../lib/git_remote.js';
 import { log } from '../../log.js';
 
+// --app takes an id, a name or a slug. An id (`app_…`) is used as-is — the
+// api checks access on use. A name or slug is looked up among the apps of ONE
+// project (--project, FAABLE_PROJECT, `faable project use`, or your only
+// one) and must match exactly one: never across projects, where a staff
+// session would see every customer's "dashboard" too.
+const resolve_app_ref = async (api, ref, 
+// The project to search; by default the configured one (see above).
+in_project) => {
+    if (ref.startsWith('app_'))
+        return ref;
+    const project = (await requireProject(api)).id;
+    const apps = await fetch_page(p => api.listApps(p, project), {
+        limit: 200,
+        all: true
+    });
+    const wanted = ref.toLowerCase();
+    const matches = apps.data.filter(a => a.name.toLowerCase() === wanted || a.slug?.toLowerCase() === wanted);
+    if (matches.length === 1)
+        return matches[0].id;
+    if (matches.length === 0) {
+        throw new CliError('not_found', `No app named "${ref}" in ${project}. See them with: faable deploy apps list`);
+    }
+    throw new CliError('usage', `Several apps are named "${ref}": ${matches.map(a => a.id).join(', ')}. Use its id.`);
+};
 // app_id resolution (the user never has to look one up):
-//  1. explicit (--app, on `deploy` and on every subcommand)
+//  1. explicit (--app, on `deploy` and on every subcommand; id, name or slug)
 //  2. OIDC in CI — the backend resolves the app from the linked repository
 //  3. locally — a legacy app_id in faable.json (older CLIs wrote it on
 //     `faable deploy link`; the current link only persists in the API)
@@ -11,12 +39,20 @@ import { log } from '../../log.js';
 //     of the working directory (repos are connected in the dashboard when the
 //     app is created, or via `faable deploy link`)
 //
+// Non-interactive mode stops at 2: the working directory of a process a
+// program spawned (the MCP server) says nothing about which app the user
+// meant, and guessing from it is how a deploy lands on the wrong app.
+//
 // "No app here" is an answer, not an error — a bare `faable deploy` in an
 // unlinked directory lists the subcommands instead of failing, and only the
 // caller knows which of the two it wants. An AMBIGUOUS repository does throw:
 // several apps is a question only the user can answer.
 const find_app_id = async (explicit, ctxAppId, api, workdir = process.cwd()) => {
-    const app_id = explicit || ctxAppId || Configuration.instance().app_id;
+    if (explicit)
+        return resolve_app_ref(api, explicit);
+    if (is_non_interactive())
+        return ctxAppId || null;
+    const app_id = ctxAppId || Configuration.instance().app_id;
     if (app_id)
         return app_id;
     const repository = await getGitRemoteUrl(workdir);
@@ -40,7 +76,9 @@ const resolve_app_id = async (explicit, ctxAppId, api, workdir = process.cwd())
     const app_id = await find_app_id(explicit, ctxAppId, api, workdir);
     if (app_id)
         return app_id;
-    throw new Error('No app linked to this repository. Link it from the dashboard (or run "faable deploy link"), or pass one with --app <app_id>.');
+    throw new CliError('app_required', is_non_interactive()
+        ? 'Pass the app with --app <app_id> (non-interactive mode never infers it from the working directory).'
+        : 'No app linked to this repository. Link it from the dashboard (or run "faable deploy link"), or pass one with --app <app_id>.');
 };
 
-export { find_app_id, resolve_app_id };
+export { find_app_id, resolve_app_id, resolve_app_ref };

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

@@ -12,7 +12,7 @@ const secrets_list = {
         .option('app', {
         alias: 'a',
         type: 'string',
-        description: 'App Identifier (defaults to the linked app)'
+        description: 'App id, name or slug (defaults to the linked app)'
     })
         .option('show', {
         type: 'boolean',

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

@@ -1,3 +1,5 @@
+import { CliError } from '../../../lib/errors.js';
+
 // The mutation endpoint (`/secret/createbatch`) replaces the app's whole
 // secret set, so every change is a read-merge-replace over the CURRENT
 // app-scoped secrets. GET /secret/:app_id also returns secrets inherited
@@ -23,10 +25,10 @@ const remove_app_secret = (existing, name) => {
     const app_secrets = app_scoped(existing);
     if (!app_secrets.some(p => p.name === name)) {
         if (existing.some(s => s.related_model === 'profile' && s.name === name)) {
-            throw new Error(`"${name}" is inherited from the team profile and cannot be removed from the app. Manage team secrets from the dashboard.`);
+            throw new CliError('usage', `"${name}" is inherited from the team profile and cannot be removed from the app. Manage team secrets from the dashboard.`);
         }
         const names = app_secrets.map(p => p.name).sort().join(', ') || '(none)';
-        throw new Error(`Secret "${name}" not found. Existing secrets: ${names}`);
+        throw new CliError('not_found', `Secret "${name}" not found. Existing secrets: ${names}`);
     }
     return app_secrets.filter(p => p.name !== name);
 };

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

@@ -1,13 +1,14 @@
-import prompts from 'prompts';
 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 { remove_app_secret } from './merge.js';
+import { confirm } from '../../../lib/interactive.js';
 
 const secrets_rm = {
     command: 'rm <name>',
     describe: 'Remove a secret by name',
-    builder: yargs => yargs
+    builder: yargs => json_option(yargs)
         .positional('name', {
         type: 'string',
         demandOption: true,
@@ -16,7 +17,7 @@ const secrets_rm = {
         .option('app', {
         alias: 'a',
         type: 'string',
-        description: 'App Identifier (defaults to the linked app)'
+        description: 'App id, name or slug (defaults to the linked app)'
     })
         .option('yes', {
         alias: 'y',
@@ -35,22 +36,18 @@ const secrets_rm = {
         const app = await ctx.api.getApp(app_id);
         const secrets = await ctx.api.getAppSecrets(app_id);
         const remaining = remove_app_secret(secrets, args.name);
-        if (!args.yes) {
-            // In a non-TTY run without --yes, prompts resolves undefined → cancel.
-            const { confirm } = await prompts({
-                type: 'toggle',
-                name: 'confirm',
-                message: `Remove secret "${args.name}" from ${app_id}?`,
-                initial: false,
-                active: 'yes',
-                inactive: 'no'
-            });
-            if (!confirm) {
-                log.info('Cancelled.');
-                return;
-            }
+        const go = await confirm({
+            message: `Remove secret "${args.name}" from ${app_id}?`,
+            yes: args.yes
+        });
+        if (!go) {
+            log.info('Cancelled.');
+            return;
         }
         await ctx.api.createSecretsBatch(app.id, app.team, remaining);
+        if (args.json) {
+            return print_json({ deleted: true, name: args.name, restarting: true });
+        }
         log.info(`🗑️ Removed secret ${args.name} from ${app_id}.`);
         log.info(`ℹ️ The app is restarting to apply the changes.`);
     }

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

@@ -1,6 +1,7 @@
 import { readFileSync } from 'node:fs';
 import { resolve } from 'node:path';
 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 { managed_warning } from './managed_names.js';
@@ -11,7 +12,17 @@ import { parse_pairs } from './parse_pairs.js';
 // `--env-file` with no value means "the .env in this directory", the case
 // people actually have.
 const DEFAULT_ENV_FILE = '.env';
+// `-` reads the .env from stdin: the way to pass values without putting them
+// in argv, where `ps` and any process log can read them (the MCP server
+// always sets secrets this way).
+//
+// Spell it `-f -`. Node ≥ 22 scans the WHOLE argv for its own `--env-file`,
+// even after the script, and dies with "node: -: not found" before the CLI
+// runs; the short alias is invisible to it.
+const STDIN = '-';
 const read_env_file = (raw_path) => {
+    if (raw_path === STDIN)
+        return parse_env(readFileSync(0, 'utf8'), 'stdin');
     const path = raw_path || DEFAULT_ENV_FILE;
     let content;
     try {
@@ -45,7 +56,7 @@ const MAX_DETAILED = 10;
 const secrets_set = {
     command: 'set [pairs...]',
     describe: 'Set secrets as KEY=VALUE pairs or from a .env file',
-    builder: yargs => yargs
+    builder: yargs => json_option(yargs)
         .positional('pairs', {
         type: 'string',
         array: true,
@@ -54,17 +65,18 @@ const secrets_set = {
         .option('app', {
         alias: 'a',
         type: 'string',
-        description: 'App Identifier (defaults to the linked app)'
+        description: 'App id, name or slug (defaults to the linked app)'
     })
         .option('env-file', {
         alias: 'f',
         type: 'string',
-        description: 'Load variables from a .env file (defaults to ./.env)'
+        description: 'Load variables from a .env file (defaults to ./.env; `-f -` reads stdin)'
     })
         .example('$0 deploy secrets set API_KEY=abc123', 'Set a single secret')
         .example('$0 deploy secrets set A=1 DB_URL=postgres://u:p@host/db', 'Set several at once (values may contain "=")')
         .example('$0 deploy secrets set --env-file', 'Upload every variable in ./.env')
         .example('$0 deploy secrets set -f .env.production', 'Upload another env file')
+        .example('op read op://vault/api/env | $0 deploy secrets set -f -', 'Read the variables from stdin, never from the command line')
         .showHelpOnFail(false),
     handler: async (args) => {
         const env_file = args['env-file'];
@@ -77,7 +89,7 @@ const secrets_set = {
         const from_file = env_file === undefined ? [] : read_env_file(env_file);
         const parsed = combine(from_file, parse_pairs(pairs));
         if (env_file !== undefined) {
-            const path = env_file || DEFAULT_ENV_FILE;
+            const path = env_file === STDIN ? 'stdin' : env_file || DEFAULT_ENV_FILE;
             if (from_file.length === 0) {
                 throw new Error(`${path} has no variables to set.`);
             }
@@ -103,6 +115,25 @@ const secrets_set = {
             .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
+        // 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.
+        const changed = parsed.some(({ name, value }) => current.get(name) !== value);
+        // Names only: a value never goes back out.
+        if (args.json) {
+            return print_json({
+                app_id,
+                added: parsed.filter(p => !current.has(p.name)).map(p => p.name),
+                updated: parsed
+                    .filter(p => current.has(p.name) && current.get(p.name) !== p.value)
+                    .map(p => p.name),
+                unchanged: parsed
+                    .filter(p => current.get(p.name) === p.value)
+                    .map(p => p.name),
+                restarting: changed
+            });
+        }
         if (parsed.length <= MAX_DETAILED) {
             for (const { name } of parsed) {
                 log.info(current.has(name)
@@ -114,11 +145,6 @@ const secrets_set = {
             log.info(`🔑 ${parsed.length - updated} added, ${updated} updated`);
         }
         log.info(`✅ ${parsed.length} secret(s) saved to ${app_id}.`);
-        // Only claim the 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.
-        const changed = parsed.some(({ name, value }) => current.get(name) !== value);
         log.info(changed
             ? `ℹ️ The app is restarting to apply the changes.`
             : `ℹ️ Already up to date — the app was not restarted.`);

package/dist/commands/deploy/waf/add_rule.js

@@ -25,7 +25,7 @@ const rule_matches_request = (rule, want, action) => rule.action === action &&
  * verify, explain, tell the user how to check) lives here once.
  */
 const add_rule = async (opts) => {
-    const { api, app_id, app_name, app_url, pattern, user_agent, query, action, description, force } = opts;
+    const { api, app_id, app_name, app_url, pattern, user_agent, query, action, description, force, json } = opts;
     const want = { pattern, user_agent, query };
     const waf = await api.addAppWafRule(app_id, {
         pattern,
@@ -60,6 +60,8 @@ const add_rule = async (opts) => {
         throw new Error(`This Faable server does not support ${query ? 'query-parameter' : 'user-agent'} rules yet, so the rule was not created.\n` +
             `  Update the CLI and try again, or ask support to upgrade the platform.`);
     }
+    if (json)
+        return waf;
     const answer = action === 'deny' ? '403' : '404';
     log.info(`🛡️  ${describe_selector(want)} → ${answer} at the edge`);
     log.info(`   for ${app_name} (${app_id}).`);
@@ -85,6 +87,7 @@ const add_rule = async (opts) => {
         : `  curl -s -o /dev/null -w '%{http_code}\\n' https://${app_url}<path>`);
     log.info(``);
     log.info(`Undo: faable deploy waf rm ${undo_args(want)} -a ${app_id}`);
+    return waf;
 };
 /** The exact arguments that reverse this rule. */
 const undo_args = (s) => [