@faable/faable 1.27.0 → 1.29.0

package/dist/api/FaableApi.js

@@ -169,6 +169,54 @@ class FaableApi {
     async getMe() {
         return data(this.client.get(`/auth/me`));
     }
+    // Runtime logs of the app (Loki-backed; last 24h, up to 200 lines, newest
+    // first). Optionally scoped to one deployment.
+    async getAppLogs(app_id, params = {}) {
+        return data(this.client.get(`/app/${app_id}/logs`, { params }));
+    }
+    // Deployments of an app, newest first (the API's list index sorts
+    // createdAt desc). Team pinned via header — same reason as domains.
+    async listDeployments(app_id, team) {
+        return firstPage(data(this.client.get(`/deployment`, {
+            params: { app_id },
+            headers: { "x-faable-team": team },
+        })));
+    }
+    // Build and deploy the current head of the deploy branch server-side —
+    // the same path a push webhook takes, same-commit dedupe included.
+    async deployNow(app_id) {
+        return data(this.client.post(`/app/${app_id}/deploy`));
+    }
+    // Rebuild a failed deployment from its recorded source (CAS manifest or
+    // 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 } }));
+    }
+    // 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
+    // createSecretsBatch).
+    async listDomains(app_id, team) {
+        return firstPage(data(this.client.get(`/domain`, {
+            params: { app_id },
+            headers: { "x-faable-team": team },
+        })));
+    }
+    async createDomain(team, params) {
+        return data(this.client.post(`/domain`, params, {
+            headers: { "x-faable-team": team },
+        }));
+    }
+    async getDomain(domain_id, team) {
+        return data(this.client.get(`/domain/${domain_id}`, {
+            headers: { "x-faable-team": team },
+        }));
+    }
+    async deleteDomain(domain_id, team) {
+        return data(this.client.delete(`/domain/${domain_id}`, {
+            headers: { "x-faable-team": team },
+        }));
+    }
 }
 
 export { FaableApi };

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

@@ -0,0 +1,46 @@
+import { requireApi } from '../../../api/context.js';
+import { log } from '../../../log.js';
+import { resolve_app_id } from '../resolve_app_id.js';
+import { cname_target } from './format.js';
+
+const domains_add = {
+    command: 'add <fqdn>',
+    describe: 'Add a custom domain to the app',
+    builder: yargs => yargs
+        .positional('fqdn', {
+        type: 'string',
+        demandOption: true,
+        description: 'Fully qualified domain name (e.g. www.example.com)'
+    })
+        .option('app', {
+        alias: 'a',
+        type: 'string',
+        description: 'App Identifier (defaults to the linked app)'
+    })
+        .option('tls', {
+        type: 'boolean',
+        default: true,
+        description: 'Provision a TLS certificate automatically (default)'
+    })
+        .example('$0 deploy domains add www.example.com', 'Attach www.example.com to the linked app')
+        .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);
+        const domain = await ctx.api.createDomain(app.team, {
+            fqdn: args.fqdn,
+            app_id,
+            tls: args.tls
+        });
+        log.info(`🌐 Domain ${domain.fqdn} added to ${app.name} (${app_id}).`);
+        log.info(``);
+        log.info(`Now create a CNAME record at your DNS provider:`);
+        log.info(`  ${domain.fqdn} → ${cname_target(domain)}`);
+        log.info(``);
+        log.info(`Faable verifies the record automatically once DNS propagates${args.tls ? ' and then provisions the TLS certificate' : ''}.`);
+        log.info(`Track it with: faable deploy domains check ${domain.fqdn}`);
+    }
+};
+
+export { domains_add };

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

@@ -0,0 +1,51 @@
+import { requireApi } from '../../../api/context.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';
+
+const domains_check = {
+    command: 'check <fqdn>',
+    describe: 'Show the DNS verification status of a domain',
+    builder: yargs => yargs
+        .positional('fqdn', {
+        type: 'string',
+        demandOption: true,
+        description: 'Domain to check'
+    })
+        .option('app', {
+        alias: 'a',
+        type: 'string',
+        description: 'App Identifier (defaults to the linked app)'
+    })
+        .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);
+        const domains = await ctx.api.listDomains(app_id, app.team);
+        const domain = find_by_fqdn(domains, args.fqdn);
+        if (!domain) {
+            throw new Error(`Domain ${args.fqdn} is not attached to ${app_id}. List them with "faable deploy domains list".`);
+        }
+        const status = domain.status;
+        log.info(`🌐 ${domain.fqdn} — ${dns_badge(domain)}`);
+        log.info(`  Expected CNAME: ${domain.fqdn} → ${cname_target(domain)}`);
+        if (status?.dns_observed?.length) {
+            log.info(`  Observed:       ${status.dns_observed.join(', ')}`);
+        }
+        else {
+            log.info(`  Observed:       (no CNAME resolved yet)`);
+        }
+        if (status?.dns_message) {
+            log.info(`  Diagnostic:     ${status.dns_message}`);
+        }
+        if (status?.dns_checked_at) {
+            log.info(`  Last checked:   ${status.dns_checked_at}`);
+        }
+        if (!domain.verified) {
+            log.info(`Faable re-checks automatically — no action needed beyond the CNAME record.`);
+        }
+    }
+};
+
+export { domains_check };

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

@@ -0,0 +1,24 @@
+// Human summary of a domain's verification state, derived from the DNS
+// verification worker's status. Kept pure for tests.
+const dns_badge = (domain) => {
+    if (domain.verified)
+        return '✅ verified';
+    switch (domain.status?.dns_state) {
+        case 'ok':
+            return '✅ dns ok';
+        case 'misconfigured':
+            return '❌ misconfigured';
+        case 'error':
+            return '❌ dns error';
+        default:
+            return '⏳ pending verification';
+    }
+};
+// The CNAME target the user must configure. The API publishes it in
+// `status.dns_expected` (the dashboard shows `<domain.id>.faable.link` — same
+// value); fall back to deriving it from the id so `add` can print
+// instructions even before the first DNS check populates the status.
+const cname_target = (domain) => domain.status?.dns_expected?.[0] ?? `${domain.id}.faable.link`;
+const find_by_fqdn = (domains, fqdn) => domains.find(d => d.fqdn.toLowerCase() === fqdn.toLowerCase());
+
+export { cname_target, dns_badge, find_by_fqdn };

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

@@ -0,0 +1,21 @@
+import { domains_add } from './add.js';
+import { domains_check } from './check.js';
+import { domains_list } from './list.js';
+import { domains_rm } from './rm.js';
+
+const domains = {
+    command: 'domains <command>',
+    describe: 'Manage custom domains of an app',
+    builder: yargs => yargs
+        .command(domains_list)
+        .command(domains_add)
+        .command(domains_check)
+        .command(domains_rm)
+        .demandCommand(1, 'Specify a domains command: list, add, check or rm'),
+    handler: () => {
+        // Unreachable: demandCommand(1) either routes to a subcommand or fails
+        // through the global .fail() in src/index.ts.
+    }
+};
+
+export { domains };

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

@@ -0,0 +1,45 @@
+import { requireApi } from '../../../api/context.js';
+import { log } from '../../../log.js';
+import { resolve_app_id } from '../resolve_app_id.js';
+import { dns_badge, cname_target } from './format.js';
+
+const domains_list = {
+    command: 'list',
+    describe: 'List custom domains of the app',
+    builder: yargs => yargs
+        .option('app', {
+        alias: 'a',
+        type: 'string',
+        description: 'App Identifier (defaults to the linked app)'
+    })
+        .example('$0 deploy domains list', 'Domains of the linked app')
+        .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);
+        const domains = await ctx.api.listDomains(app_id, app.team);
+        if (domains.length === 0) {
+            log.info(`🌐 No custom domains for ${app.name} (${app_id}).`);
+            log.info(`Add one with: faable deploy domains add <yourdomain.com>. The app is always live at https://${app.url}.`);
+            return;
+        }
+        log.info(`🌐 ${domains.length} domain(s) for ${app.name} (${app_id}):`);
+        const width = Math.max(...domains.map(d => d.fqdn.length));
+        for (const domain of domains) {
+            const tls = domain.tls ? 'tls' : 'no-tls';
+            log.info(`  ${domain.fqdn.padEnd(width)}  ${dns_badge(domain)}  (${tls})`);
+        }
+        const unverified = domains.filter(d => !d.verified);
+        if (unverified.length > 0) {
+            log.info(``);
+            log.info(`To finish verification, point each domain at Faable with a CNAME:`);
+            for (const domain of unverified) {
+                log.info(`  ${domain.fqdn} → ${cname_target(domain)}`);
+            }
+            log.info(`Run "faable deploy domains check <fqdn>" to see the diagnostic.`);
+        }
+    }
+};
+
+export { domains_list };

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

@@ -0,0 +1,59 @@
+import prompts from 'prompts';
+import { requireApi } from '../../../api/context.js';
+import { log } from '../../../log.js';
+import { resolve_app_id } from '../resolve_app_id.js';
+import { find_by_fqdn } from './format.js';
+
+const domains_rm = {
+    command: 'rm <fqdn>',
+    describe: 'Remove a custom domain from the app',
+    builder: yargs => yargs
+        .positional('fqdn', {
+        type: 'string',
+        demandOption: true,
+        description: 'Domain to remove'
+    })
+        .option('app', {
+        alias: 'a',
+        type: 'string',
+        description: 'App Identifier (defaults to the linked app)'
+    })
+        .option('yes', {
+        alias: 'y',
+        type: 'boolean',
+        default: false,
+        description: 'Skip the confirmation prompt'
+    })
+        .example('$0 deploy domains rm www.example.com', 'Detach after confirmation')
+        .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);
+        const domains = await ctx.api.listDomains(app_id, app.team);
+        const domain = find_by_fqdn(domains, args.fqdn);
+        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;
+            }
+        }
+        await ctx.api.deleteDomain(domain.id, app.team);
+        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.`);
+    }
+};
+
+export { domains_rm };

package/dist/commands/deploy/index.js

@@ -2,7 +2,15 @@ import { requireApi } from '../../api/context.js';
 import { Configuration } from '../../lib/Configuration.js';
 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 { deployments } from './inspect/deployments.js';
+import { apps_list } from './inspect/list.js';
+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 { trigger } from './inspect/trigger.js';
 import { propose_release } from './release_version.js';
 import { deploy_remote } from './remote/index.js';
 import { resolve_app_id } from './resolve_app_id.js';
@@ -17,6 +25,14 @@ const deploy = {
         // app_id positional, so `faable deploy <app_id>` keeps working).
         return yargs
             .command(secrets)
+            .command(domains)
+            .command(logs)
+            .command(status)
+            .command(apps_list)
+            .command(deployments)
+            .command(open_app)
+            .command(trigger)
+            .command(redeploy)
             .command(link)
             .positional('app_id', {
             type: 'string',

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

@@ -0,0 +1,40 @@
+import { requireApi } from '../../../api/context.js';
+import { log } from '../../../log.js';
+import { resolve_app_id } from '../resolve_app_id.js';
+import { deployment_row } from './format.js';
+
+const deployments = {
+    command: 'deployments',
+    describe: 'List recent deployments of the app',
+    builder: yargs => yargs
+        .option('app', {
+        alias: 'a',
+        type: 'string',
+        description: 'App Identifier (defaults to the linked app)'
+    })
+        .option('limit', {
+        alias: 'n',
+        type: 'number',
+        default: 10,
+        description: 'How many to show'
+    })
+        .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);
+        const rows = await ctx.api.listDeployments(app_id, app.team);
+        if (rows.length === 0) {
+            log.info(`📭 ${app.name} has no deployments yet.`);
+            return;
+        }
+        const shown = rows.slice(0, args.limit ?? 10);
+        log.info(`🚀 Last ${shown.length} deployment(s) of ${app.name}:`);
+        for (const d of shown) {
+            const live = d.id === app.status?.deployment ? '  ← live' : '';
+            log.info(`  ${deployment_row(d)}${live}`);
+        }
+    }
+};
+
+export { deployments };

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

@@ -0,0 +1,60 @@
+// Pure formatting helpers for the read commands (logs/status/list/
+// deployments), kept out of the handlers for tests.
+const PHASE_ICONS = {
+    READY: '🟢',
+    INITIALIZING: '🔵',
+    BUILDING: '🔵',
+    QUEUED: '⚪',
+    UNKNOWN: '⚪',
+    QUOTA_HOLD: '🟡',
+    SUPERSEDED: '⚪',
+    CANCELED: '⚪',
+    TERMINATING: '⚪',
+    ERROR: '🔴',
+    BUILD_ERROR: '🔴'
+};
+const phase_badge = (phase) => {
+    const p = phase || 'UNKNOWN';
+    return `${PHASE_ICONS[p] ?? '⚪'} ${p}`;
+};
+// "python 3.11.3 (django)" from the platform-detected metadata; null when
+// nothing was ever detected (no build yet).
+const detected_summary = (detected) => {
+    if (!detected)
+        return null;
+    const runtime = [detected.runtime.name, detected.runtime.version]
+        .filter(Boolean)
+        .join(' ');
+    return detected.framework ? `${runtime} (${detected.framework})` : runtime;
+};
+// Loki serves [ns_timestamp, text, deployment_id] newest first; render
+// oldest first (reading order) with an ISO second-precision prefix.
+const format_log_lines = (lines) => [...lines]
+    .sort((a, b) => Number(a[0]) - Number(b[0]))
+    .map(([ts, text]) => {
+    const iso = new Date(Number(ts) / 1e6).toISOString().replace(/\.\d+Z$/, 'Z');
+    return `${iso}  ${text.replace(/\n+$/, '')}`;
+});
+const short_commit = (sha) => sha ? sha.slice(0, 7) : '-';
+const when = (iso) => {
+    if (!iso)
+        return '-';
+    const ms = Date.now() - new Date(iso).getTime();
+    const minutes = Math.floor(ms / 60_000);
+    if (minutes < 1)
+        return 'just now';
+    if (minutes < 60)
+        return `${minutes}m ago`;
+    const hours = Math.floor(minutes / 60);
+    if (hours < 48)
+        return `${hours}h ago`;
+    return `${Math.floor(hours / 24)}d ago`;
+};
+// One row per deployment for the `deployments` table.
+const deployment_row = (d) => {
+    const release = d.release ? ` ${d.release}` : '';
+    const trigger = d.trigger === 'webhook' ? 'push' : 'cli';
+    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 };

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

@@ -0,0 +1,24 @@
+import { requireApi } from '../../../api/context.js';
+import { log } from '../../../log.js';
+import { phase_badge } from './format.js';
+
+const apps_list = {
+    command: 'list',
+    describe: 'List your apps',
+    builder: yargs => yargs.showHelpOnFail(false),
+    handler: async () => {
+        const ctx = await requireApi();
+        const apps = await ctx.api.list();
+        if (apps.length === 0) {
+            log.info(`📭 No apps yet. Create one in the dashboard (https://dashboard.faable.com) and link your repo.`);
+            return;
+        }
+        log.info(`📦 ${apps.length} app(s):`);
+        const width = Math.max(...apps.map(a => a.name.length));
+        for (const app of apps) {
+            log.info(`  ${app.name.padEnd(width)}  ${phase_badge(app.status?.phase)}  ${app.id}  https://${app.url}`);
+        }
+    }
+};
+
+export { apps_list };

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

@@ -0,0 +1,72 @@
+import { requireApi } from '../../../api/context.js';
+import { log } from '../../../log.js';
+import { resolve_app_id } from '../resolve_app_id.js';
+import { format_log_lines } from './format.js';
+
+const logs = {
+    command: 'logs',
+    describe: 'Show runtime logs of the app (or build logs with --build)',
+    builder: yargs => yargs
+        .option('app', {
+        alias: 'a',
+        type: 'string',
+        description: 'App Identifier (defaults to the linked app)'
+    })
+        .option('build', {
+        type: 'boolean',
+        default: false,
+        description: 'Show the build output of the latest deployment instead'
+    })
+        .option('deployment', {
+        alias: 'd',
+        type: 'string',
+        description: 'Scope to one deployment id'
+    })
+        .example('$0 deploy logs', 'Runtime logs of the linked app (last 24h)')
+        .example('$0 deploy logs --build', 'Build output of the latest deployment')
+        .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);
+        if (args.build) {
+            // Build output lives on the deployment. Default to the newest one —
+            // exactly what you want after a red `faable deploy`.
+            let deployment_id = args.deployment;
+            if (!deployment_id) {
+                const deployments = await ctx.api.listDeployments(app_id, app.team);
+                deployment_id = deployments[0]?.id;
+                if (!deployment_id) {
+                    log.info(`📭 ${app.name} has no deployments yet.`);
+                    return;
+                }
+            }
+            const build = await ctx.api.getDeploymentLogs(deployment_id);
+            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'))
+                process.stdout.write('\n');
+            if (build.truncated)
+                log.warn(`(output truncated)`);
+            return;
+        }
+        const lines = await ctx.api.getAppLogs(app_id, {
+            deployment_id: args.deployment
+        });
+        if (lines.length === 0) {
+            log.info(`📭 No runtime logs in the last 24h for ${app.name} (${app_id}).`);
+            log.info(`For build output, use: faable deploy logs --build`);
+            return;
+        }
+        log.info(`📜 Runtime logs of ${app.name} (last 24h, newest last):`);
+        for (const line of format_log_lines(lines)) {
+            process.stdout.write(line + '\n');
+        }
+    }
+};
+
+export { logs };

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

@@ -0,0 +1,37 @@
+import openBrowser from 'open';
+import { requireApi } from '../../../api/context.js';
+import { log } from '../../../log.js';
+import { resolve_app_id } from '../resolve_app_id.js';
+
+const open_app = {
+    command: 'open',
+    describe: 'Open the app in the browser',
+    builder: yargs => yargs
+        .option('app', {
+        alias: 'a',
+        type: 'string',
+        description: 'App Identifier (defaults to the linked app)'
+    })
+        .option('dashboard', {
+        type: 'boolean',
+        default: false,
+        description: 'Open the Faable dashboard page of the app instead'
+    })
+        .example('$0 deploy open', 'Open the live app URL')
+        .example('$0 deploy open --dashboard', 'Open the app in the dashboard')
+        .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);
+        const url = args.dashboard
+            ? `https://dashboard.faable.com/deploy/${app.team}/app/${app.id}`
+            : `https://${app.url}`;
+        log.info(`🌍 Opening ${url}`);
+        await openBrowser(url).catch(() => {
+            log.warn(`Could not open the browser automatically — visit: ${url}`);
+        });
+    }
+};
+
+export { open_app };

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

@@ -0,0 +1,43 @@
+import { requireApi } from '../../../api/context.js';
+import { log } from '../../../log.js';
+import { resolve_app_id } from '../resolve_app_id.js';
+
+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
+        .positional('deployment', {
+        type: 'string',
+        description: 'Deployment id to rebuild (defaults to the latest failed one)'
+    })
+        .option('app', {
+        alias: 'a',
+        type: 'string',
+        description: 'App Identifier (defaults to the linked app)'
+    })
+        .example('$0 deploy redeploy', 'Retry the latest failed deployment')
+        .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 failed = rows.find(d => FAILED_PHASES.has(d.status?.phase ?? ''));
+            if (!failed) {
+                log.info(`✅ No failed deployments to retry for ${app.name}. To rebuild the repo HEAD use: faable deploy trigger`);
+                return;
+            }
+            deployment_id = failed.id;
+        }
+        // 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);
+        log.info(`🔁 Rebuilding ${deployment_id} as ${clone.id}.`);
+        log.info(`Track it with: faable deploy status  ·  build output: faable deploy logs --build`);
+    }
+};
+
+export { redeploy };

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

@@ -0,0 +1,46 @@
+import { requireApi } from '../../../api/context.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';
+
+const status = {
+    command: 'status',
+    describe: 'Show what is live for the app',
+    builder: yargs => yargs
+        .option('app', {
+        alias: 'a',
+        type: 'string',
+        description: 'App Identifier (defaults to the linked app)'
+    })
+        .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);
+        const deployments = await ctx.api.listDeployments(app_id, app.team);
+        const latest = deployments[0];
+        log.info(`${phase_badge(app.status?.phase)}  ${app.name} (${app.id})`);
+        log.info(`  URL:        https://${app.url}`);
+        const stack = detected_summary(app.detected);
+        if (stack)
+            log.info(`  Stack:      ${stack}`);
+        if (app.repository) {
+            log.info(`  Repository: ${app.repository} (${app.github_branch || 'main'}${app.deploy_trigger === 'webhook' ? ', push-to-deploy' : ''})`);
+        }
+        if (app.status?.deployment) {
+            log.info(`  Live:       ${app.status.deployment}`);
+        }
+        if (latest && latest.id !== app.status?.deployment) {
+            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`);
+            }
+        }
+        if (deployments.length === 0) {
+            log.info(`  No deployments yet — push to deploy, or run: faable deploy`);
+        }
+    }
+};
+
+export { status };

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

@@ -0,0 +1,28 @@
+import { requireApi } from '../../../api/context.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
+        .option('app', {
+        alias: 'a',
+        type: 'string',
+        description: 'App Identifier (defaults to the linked app)'
+    })
+        .example('$0 deploy trigger', 'Deploy the repo HEAD without uploading anything from this machine')
+        .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);
+        // 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}`);
+    }
+};
+
+export { trigger };

package/dist/commands/login/index.js

@@ -2,7 +2,7 @@ import { FaableApi } from '../../api/FaableApi.js';
 import { getDeviceCode, getDeviceToken, getMe } from '../../api/auth.js';
 import { isTokenLive } from '../../api/session.js';
 import { CredentialsStore } from '../../lib/CredentialsStore.js';
-import open from 'open';
+import openBrowser from 'open';
 import ora from 'ora';
 import prompts from 'prompts';
 import { log } from '../../log.js';
@@ -120,7 +120,7 @@ const login = {
         process.stdout.write(renderUserCodeBlock(user_code));
         log.info(`If your browser doesn't open automatically, visit: ${verification_uri}`);
         try {
-            await open(verification_uri_complete);
+            await openBrowser(verification_uri_complete);
         }
         catch {
             log.warn("Could not open browser automatically.");

package/package.json

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