@faable/faable 4.2.0 → 4.3.0

package/dist/commands/deploy/apps/create.js

@@ -0,0 +1,132 @@
+import { requireApi } from '../../../api/context.js';
+import { requireProject } from '../../../api/project.js';
+import { CliError } from '../../../lib/errors.js';
+import { print_json, json_option } from '../../../lib/listing.js';
+import { log } from '../../../log.js';
+
+// "owner/repo" from any of the ways people paste a GitHub repository.
+const parse_repo = (input) => {
+    const cleaned = input
+        .trim()
+        .replace(/^git@github\.com:/, '')
+        .replace(/^(https?:\/\/)?(www\.)?github\.com\//, '')
+        .replace(/\.git$/, '')
+        .replace(/\/+$/, '');
+    if (!/^[\w.-]+\/[\w.-]+$/.test(cleaned)) {
+        throw new CliError('usage', `"${input}" is not a GitHub repository — use owner/repo.`);
+    }
+    return cleaned;
+};
+// `faable deploy apps create` — the dashboard's "Create & connect", same
+// sequence (components/apps/deploy/app/app-create/AppCreateForm.tsx):
+// create the app in the project, link the repository, and start the first
+// deploy, because linking alone deploys nothing (deploy v4) and a new app
+// that waits for a push is one that never deploys.
+//
+// One difference, on purpose: when the link fails, the app THIS call just
+// created is deleted again. The dashboard can leave it — its app page offers
+// to retry the link — but here the retry is running this command again, and
+// every failed attempt would leave an empty app behind. Nothing that existed
+// before the command is ever touched.
+const apps_create = {
+    command: 'create',
+    describe: 'Create an app from a GitHub repository and start its first deploy',
+    builder: yargs => json_option(yargs)
+        .option('repo', {
+        alias: 'r',
+        type: 'string',
+        description: 'GitHub repository (owner/repo or its URL)'
+    })
+        .option('name', {
+        alias: 'n',
+        type: 'string',
+        description: 'App name (defaults to the repository name)'
+    })
+        .option('description', {
+        type: 'string',
+        description: 'App description'
+    })
+        .option('branch', {
+        alias: 'b',
+        type: 'string',
+        description: 'Branch to deploy (defaults to the repository default)'
+    })
+        .option('deploy', {
+        type: 'boolean',
+        default: true,
+        description: 'Start the first deploy (--no-deploy to only link)'
+    })
+        .check(({ repo, name }) => {
+        if (!repo && !name) {
+            throw new Error('Give the repository (--repo owner/repo), or --name for an app without one.');
+        }
+        return true;
+    })
+        .example('$0 deploy apps create --repo acme/web', 'Create "web" from acme/web and deploy its default branch')
+        .example('$0 deploy apps create --repo acme/mono --name api --branch release', 'Another app from a monorepo, deploying another branch')
+        .showHelpOnFail(false),
+    handler: async (args) => {
+        const repository = args.repo ? parse_repo(args.repo) : undefined;
+        const name = args.name || repository.split('/')[1];
+        const { api } = await requireApi();
+        const { id: project } = await requireProject(api);
+        const app = await api.createApp(project, {
+            name,
+            ...(args.description ? { description: args.description } : {})
+        });
+        log.info(`📦 Created ${app.name} (${app.id})`);
+        let linked = app;
+        if (repository) {
+            try {
+                linked = await api.linkRepository(app.id, {
+                    repository,
+                    ...(args.branch ? { github_branch: args.branch } : {})
+                });
+            }
+            catch (err) {
+                await api.deleteApp(app.id, app.team).catch(() => {
+                    log.warn(`Could not remove ${app.id} after the failed link — delete it from the dashboard.`);
+                });
+                const e = err;
+                const failed = new CliError('usage', `Could not link ${repository}, so ${app.name} was not kept: ${e.message}`, { status: e.status, action: e.action, cause: err });
+                // The api's reason (github_installation_missing, repository_already_linked…)
+                // is the useful code; ours would only say "something failed".
+                if (e.code)
+                    failed.code = e.code;
+                throw failed;
+            }
+            log.info(`🔗 Linked ${repository} (${linked.github_branch ?? 'default branch'})`);
+        }
+        // Only push-to-deploy apps: a repository that brings its own Faable
+        // workflow deploys from the user's CI, and deploy_now would refuse.
+        let first_deploy = null;
+        if (repository && args.deploy && linked.deploy_trigger === 'webhook') {
+            try {
+                const started = await api.deployNow(app.id);
+                first_deploy = {
+                    commit: started.commit,
+                    branch: started.branch,
+                    ...(started.deployment_id
+                        ? { deployment_id: started.deployment_id }
+                        : {})
+                };
+                log.info(`🚀 First deploy: building ${started.commit.slice(0, 7)} from ${started.branch}`);
+            }
+            catch (err) {
+                // Not a failure of the create: an empty repository or a missing
+                // branch is something to tell, and the app is there either way.
+                const e = err;
+                first_deploy = {
+                    refused: e.code ?? 'deploy_refused',
+                    message: e.message
+                };
+                log.warn(`⚠️ The app is ready but the first deploy did not start: ${e.message}`);
+            }
+        }
+        if (args.json)
+            return print_json({ app: linked, first_deploy });
+        log.info(`🌍 https://${linked.url}  ·  follow it with: faable deploy status -a ${app.id}`);
+    }
+};
+
+export { apps_create, parse_repo };

package/dist/commands/deploy/apps/index.js

@@ -1,16 +1,32 @@
 import { apps_list } from '../inspect/list.js';
+import { apps_create } from './create.js';
+import { apps_set } from './set.js';
+import { status } from '../inspect/status.js';
 
 // `faable deploy apps list` — same shape as `secrets list`, `domains list` and
 // `waf list`: the resource, then the verb.
 const apps = {
     command: 'apps <command>',
     describe: 'Apps of the active project',
-    builder: yargs => yargs.command(apps_list).demandCommand(1, 'Specify an apps command: list'),
+    builder: yargs => yargs
+        .command(apps_list)
+        .command(apps_get)
+        .command(apps_create)
+        .command(apps_set)
+        .demandCommand(1, 'Specify an apps command: list, get, create or set'),
     handler: () => {
         // Unreachable: demandCommand(1) either routes to a subcommand or fails
         // through the global .fail() in src/index.ts.
     }
 };
+// `faable deploy apps get` — one app: what is live, the newest deployment and
+// the stack. The same record `faable deploy status` shows, named like the
+// rest of the resource verbs; with --json, the app plus `latest_deployment`.
+const apps_get = {
+    ...status,
+    command: 'get',
+    describe: 'Show one app: what is live, the latest deployment, the stack'
+};
 // The older `faable deploy list`, kept working but out of the help: one
 // documented way to list apps.
 const apps_list_legacy = {
@@ -18,4 +34,4 @@ const apps_list_legacy = {
     describe: false
 };
 
-export { apps, apps_list_legacy };
+export { apps, apps_get, apps_list_legacy };

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

@@ -0,0 +1,70 @@
+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 MODES = ['push', 'ci', 'workflow'];
+// `faable deploy apps set` — how an app deploys from its repository: the
+// branch, the monorepo Root Directory and the trigger. The same three
+// settings as the dashboard's repository card; nothing redeploys by itself,
+// the next push (or `faable deploy trigger`) uses them.
+const apps_set = {
+    command: 'set',
+    describe: 'Change how the app deploys: branch, root directory, trigger',
+    builder: yargs => json_option(yargs)
+        .option('app', {
+        alias: 'a',
+        type: 'string',
+        description: 'App id, name or slug (defaults to the linked app)'
+    })
+        .option('branch', {
+        alias: 'b',
+        type: 'string',
+        description: 'Branch to deploy from'
+    })
+        .option('root-dir', {
+        type: 'string',
+        description: 'Monorepo Root Directory, inside the repository ("" clears it: faable.json rootDir applies again)'
+    })
+        .option('mode', {
+        type: 'string',
+        choices: MODES,
+        description: 'push: every push deploys · ci: once CI tags a release · workflow: your own GitHub workflow runs faable deploy'
+    })
+        .check(({ branch, rootDir, mode }) => {
+        if (branch === undefined &&
+            rootDir === undefined &&
+            mode === undefined) {
+            throw new Error('Nothing to change: pass --branch, --root-dir or --mode.');
+        }
+        return true;
+    })
+        .example('$0 deploy apps set --branch release', 'Deploy from "release"')
+        .example('$0 deploy apps set --root-dir apps/web', 'A monorepo app')
+        .showHelpOnFail(false),
+    handler: async (args) => {
+        const ctx = await requireApi();
+        const app_id = await resolve_app_id(args.app, ctx.appId, ctx.api);
+        // One setting at a time, each its own endpoint (and its own guards).
+        if (args.branch !== undefined) {
+            await ctx.api.setDeployBranch(app_id, args.branch);
+            log.info(`🌿 Deploy branch: ${args.branch}`);
+        }
+        if (args.rootDir !== undefined) {
+            await ctx.api.setRootDir(app_id, args.rootDir || null);
+            log.info(args.rootDir
+                ? `📁 Root directory: ${args.rootDir}`
+                : '📁 Root directory cleared (faable.json rootDir applies again)');
+        }
+        if (args.mode !== undefined) {
+            await ctx.api.setDeployMode(app_id, args.mode);
+            log.info(`⚙️ Deploy mode: ${args.mode}`);
+        }
+        const app = await ctx.api.getApp(app_id);
+        if (args.json)
+            return print_json(app);
+        log.info(`Applies to the next deploy of ${app.name}. Start one now with: faable deploy trigger -a ${app.id}`);
+    }
+};
+
+export { apps_set };

package/dist/commands/deploy/domains/add.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 { cname_target } from './format.js';
@@ -6,7 +7,7 @@ import { cname_target } from './format.js';
 const domains_add = {
     command: 'add <fqdn>',
     describe: 'Add a custom domain to the app',
-    builder: yargs => yargs
+    builder: yargs => json_option(yargs)
         .positional('fqdn', {
         type: 'string',
         demandOption: true,
@@ -15,7 +16,7 @@ const domains_add = {
         .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('tls', {
         type: 'boolean',
@@ -33,6 +34,11 @@ const domains_add = {
             app_id,
             tls: args.tls
         });
+        // Same shape as `domains check --json`: the record plus the CNAME to
+        // create, which is the whole next step.
+        if (args.json) {
+            return print_json({ ...domain, expected_cname: cname_target(domain) });
+        }
         log.info(`🌐 Domain ${domain.fqdn} added to ${app.name} (${app_id}).`);
         log.info(``);
         log.info(`Now create a CNAME record at your DNS provider:`);

package/dist/commands/deploy/domains/check.js

@@ -1,12 +1,13 @@
 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 { find_by_fqdn, dns_badge, cname_target } from './format.js';
+import { find_by_fqdn, cname_target, dns_badge } from './format.js';
 
 const domains_check = {
     command: 'check <fqdn>',
     describe: 'Show the DNS verification status of a domain',
-    builder: yargs => yargs
+    builder: yargs => json_option(yargs)
         .positional('fqdn', {
         type: 'string',
         demandOption: true,
@@ -15,7 +16,7 @@ const domains_check = {
         .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) => {
@@ -27,6 +28,10 @@ const domains_check = {
         if (!domain) {
             throw new Error(`Domain ${args.fqdn} is not attached to ${app_id}. List them with "faable deploy domains list".`);
         }
+        // The record plus the one thing it does not carry: the CNAME to create.
+        if (args.json) {
+            return print_json({ ...domain, expected_cname: cname_target(domain) });
+        }
         const status = domain.status;
         log.info(`🌐 ${domain.fqdn} — ${dns_badge(domain)}`);
         log.info(`  Expected CNAME: ${domain.fqdn} → ${cname_target(domain)}`);

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

@@ -11,7 +11,7 @@ const domains_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)'
     })
         .example('$0 deploy domains list', 'Domains of the linked app')
         .showHelpOnFail(false),

package/dist/commands/deploy/domains/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 { find_by_fqdn } from './format.js';
+import { confirm } from '../../../lib/interactive.js';
 
 const domains_rm = {
     command: 'rm <fqdn>',
     describe: 'Remove a custom domain from the app',
-    builder: yargs => yargs
+    builder: yargs => json_option(yargs)
         .positional('fqdn', {
         type: 'string',
         demandOption: true,
@@ -16,7 +17,7 @@ const domains_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 domains_rm = {
         if (!domain) {
             throw new Error(`Domain ${args.fqdn} is not attached to ${app_id}. List them with "faable deploy domains list".`);
         }
-        if (!args.yes) {
-            // In a non-TTY run without --yes, prompts resolves undefined → cancel.
-            const { confirm } = await prompts({
-                type: 'toggle',
-                name: 'confirm',
-                message: `Remove domain "${domain.fqdn}" from ${app.name} (${app_id})? Traffic to it will stop being served.`,
-                initial: false,
-                active: 'yes',
-                inactive: 'no'
-            });
-            if (!confirm) {
-                log.info('Cancelled.');
-                return;
-            }
+        const go = await confirm({
+            message: `Remove domain "${domain.fqdn}" from ${app.name} (${app_id})? Traffic to it will stop being served.`,
+            yes: args.yes
+        });
+        if (!go) {
+            log.info('Cancelled.');
+            return;
         }
         await ctx.api.deleteDomain(domain.id, app.team);
+        if (args.json) {
+            return print_json({ deleted: true, id: domain.id, fqdn: domain.fqdn });
+        }
         log.info(`🗑️ Removed domain ${domain.fqdn} from ${app_id}.`);
         log.info(`The app stays live at https://${app.url}. Remember to delete the CNAME at your DNS provider.`);
     }

package/dist/commands/deploy/index.js

@@ -9,8 +9,10 @@ import { logs } from './inspect/logs.js';
 import { open_app } from './inspect/open.js';
 import { redeploy } from './inspect/redeploy.js';
 import { status } from './inspect/status.js';
+import { traffic } from './inspect/traffic.js';
 import { trigger } from './inspect/trigger.js';
 import { launch } from './launch.js';
+import { usage, quota } from './project_usage.js';
 import { secrets } from './secrets/index.js';
 import { waf } from './waf/index.js';
 
@@ -39,6 +41,9 @@ const deploy = {
         .command(waf)
         .command(logs)
         .command(status)
+        .command(traffic)
+        .command(usage)
+        .command(quota)
         .command(apps_list_legacy)
         .command(deployments)
         .command(inspect)

package/dist/commands/deploy/inspect/cancel.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';
 
@@ -9,7 +10,7 @@ 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
+    builder: yargs => json_option(yargs)
         .positional('deployment', {
         type: 'string',
         description: 'Deployment id to cancel (defaults to the one currently in flight)'
@@ -17,7 +18,7 @@ const cancel = {
         .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 cancel', 'Stop the build that is running right now')
         .showHelpOnFail(false),
@@ -30,6 +31,9 @@ const cancel = {
             const rows = await ctx.api.listDeployments(app_id, app.team);
             const inFlight = rows.find(d => IN_FLIGHT_PHASES.has(d.status?.phase ?? ''));
             if (!inFlight) {
+                if (args.json) {
+                    return print_noop(`nothing is building for ${app.name}`);
+                }
                 log.info(`✅ Nothing building for ${app.name} — nothing to cancel.`);
                 return;
             }
@@ -39,8 +43,10 @@ const cancel = {
         // 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);
+        if (args.json)
+            return print_json(canceled);
         log.info(`🛑 Canceled ${canceled.id} (${app.name}).`);
-        log.info(`Production keeps serving the last promoted deployment. Deploy again with: faable deploy`);
+        log.info(`Production keeps serving the last promoted deployment. Deploy again with: faable deploy trigger -a ${app.id}`);
     }
 };
 

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

@@ -11,7 +11,7 @@ const deployments = {
         .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) => {

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

@@ -35,7 +35,41 @@ const format_log_lines = (lines) => [...lines]
     const iso = new Date(Number(ts) / 1e6).toISOString().replace(/\.\d+Z$/, 'Z');
     return `${iso}  ${text.replace(/\n+$/, '')}`;
 });
+// The same lines as data, for --json: oldest first, ISO time, the stream
+// when the api says which.
+const log_entries = (lines) => [...lines]
+    .sort((a, b) => Number(a[0]) - Number(b[0]))
+    .map(([ts, text, stream]) => ({
+    time: new Date(Number(ts) / 1e6).toISOString(),
+    message: text.replace(/\n+$/, ''),
+    ...(stream ? { stream } : {})
+}));
+// The last `n` lines of a build output. A failed build's cause is at the end,
+// and the head of a long `npm install` is context nobody — least of all an
+// agent with a context window — needs to read.
+const tail_lines = (content, n) => {
+    if (!n || n < 1)
+        return { content, omitted_lines: 0 };
+    const lines = content.replace(/\n$/, '').split('\n');
+    if (lines.length <= n)
+        return { content, omitted_lines: 0 };
+    return {
+        content: lines.slice(-n).join('\n') + '\n',
+        omitted_lines: lines.length - n
+    };
+};
 const short_commit = (sha) => sha ? sha.slice(0, 7) : '-';
+// The future counterpart of `when`: "in 3h 20m".
+const until = (iso) => {
+    if (!iso)
+        return '-';
+    const minutes = Math.round((new Date(iso).getTime() - Date.now()) / 60_000);
+    if (minutes <= 0)
+        return 'now';
+    if (minutes < 60)
+        return `in ${minutes}m`;
+    return `in ${Math.floor(minutes / 60)}h ${minutes % 60}m`;
+};
 const when = (iso) => {
     if (!iso)
         return '-';
@@ -57,4 +91,4 @@ const deployment_row = (d) => {
     return `${phase_badge(d.status?.phase)}  ${d.id}  ${short_commit(d.github_commit)}${release}  (${trigger}, ${when(d.createdAt)})`;
 };
 
-export { deployment_row, detected_summary, format_log_lines, phase_badge, short_commit, when };
+export { deployment_row, detected_summary, format_log_lines, log_entries, phase_badge, short_commit, tail_lines, until, when };

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

@@ -14,7 +14,7 @@ const inspect = {
         .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('json', {
         type: 'boolean',

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

@@ -1,8 +1,10 @@
 import { requireApi } from '../../../api/context.js';
+import { CliError } from '../../../lib/errors.js';
+import { print_json, as_list, json_option } from '../../../lib/listing.js';
 import { log } from '../../../log.js';
 import { follow_remote_build } from '../remote/follow.js';
 import { resolve_app_id } from '../resolve_app_id.js';
-import { format_log_lines } from './format.js';
+import { tail_lines, log_entries, format_log_lines } from './format.js';
 
 // Phases where the build is still producing output; anything else is a frozen
 // record and following would just wait on nothing.
@@ -10,11 +12,11 @@ const FOLLOWABLE_PHASES = new Set(['UNKNOWN', 'QUEUED', 'BUILDING']);
 const logs = {
     command: 'logs',
     describe: 'Show runtime logs of the app (or build logs with --build)',
-    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)'
     })
         .option('build', {
         type: 'boolean',
@@ -31,10 +33,16 @@ const logs = {
         type: 'boolean',
         default: false,
         description: 'With --build: keep tailing the output while the build runs'
+    })
+        .option('tail', {
+        alias: 'n',
+        type: 'number',
+        description: 'Only the last N lines'
     })
         .example('$0 deploy logs', 'Runtime logs of the linked app (last 24h)')
         .example('$0 deploy logs -d deployment_a1b2c3', 'Runtime logs of ONE deployment (last 24h)')
         .example('$0 deploy logs --build', 'Build output of the latest deployment')
+        .example('$0 deploy logs --build -n 100', 'The last 100 lines of the build — where a failure says why')
         .example('$0 deploy logs --build --follow', 'Tail the build that is running right now')
         .showHelpOnFail(false),
     handler: async (args) => {
@@ -43,6 +51,12 @@ const logs = {
             // stream) — only the build output can be tailed.
             throw new Error('--follow only works with --build');
         }
+        if (args.follow && args.json) {
+            throw new CliError('usage', '--follow streams text; it has no --json');
+        }
+        if (args.tail !== undefined && !(Number.isInteger(args.tail) && args.tail > 0)) {
+            throw new CliError('usage', '--tail must be a positive integer');
+        }
         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);
@@ -54,6 +68,14 @@ const logs = {
                 const deployments = await ctx.api.listDeployments(app_id, app.team);
                 deployment_id = deployments[0]?.id;
                 if (!deployment_id) {
+                    if (args.json) {
+                        return print_json({
+                            deployment_id: null,
+                            content: null,
+                            truncated: false,
+                            omitted_lines: 0
+                        });
+                    }
                     log.info(`📭 ${app.name} has no deployments yet.`);
                     return;
                 }
@@ -73,21 +95,40 @@ const logs = {
                 log.info(`Build of ${deployment_id} already finished (${phase}) — showing the recorded output.`);
             }
             const build = await ctx.api.getDeploymentLogs(deployment_id);
+            const { content, omitted_lines } = tail_lines(build.content ?? '', args.tail);
+            // `truncated`: the server cut the stored log; `omitted_lines`: --tail
+            // left the head out. Different things, both worth knowing.
+            if (args.json) {
+                return print_json({
+                    deployment_id,
+                    content: build.content ? content : null,
+                    truncated: !!build.truncated,
+                    omitted_lines
+                });
+            }
             if (!build.content) {
                 log.info(`📭 No build output recorded for ${deployment_id}.`);
                 return;
             }
             log.info(`🏗️ Build output of ${deployment_id}:`);
-            process.stdout.write(build.content);
-            if (!build.content.endsWith('\n'))
+            if (omitted_lines)
+                log.info(`(… ${omitted_lines} earlier lines)`);
+            process.stdout.write(content);
+            if (!content.endsWith('\n'))
                 process.stdout.write('\n');
             if (build.truncated)
                 log.warn(`(output truncated)`);
             return;
         }
-        const lines = await ctx.api.getAppLogs(app_id, {
+        const all = await ctx.api.getAppLogs(app_id, {
             deployment_id: args.deployment
         });
+        // getAppLogs order is the api's; the tail is taken on time order.
+        const sorted = [...all].sort((a, b) => Number(a[0]) - Number(b[0]));
+        const lines = args.tail ? sorted.slice(-args.tail) : sorted;
+        // The api serves one window (24h, 200 lines): a list that never pages.
+        if (args.json)
+            return print_json(as_list(log_entries(lines)));
         // Say WHICH scope came back empty: with -d the 24h window is usually the
         // reason (a retired deployment stopped writing when it stopped serving).
         const scope = args.deployment

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

@@ -10,7 +10,7 @@ const open_app = {
         .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('dashboard', {
         type: 'boolean',