@faable/faable 1.28.0 → 1.30.0

package/dist/api/FaableApi.js

@@ -169,6 +169,30 @@ 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).

package/dist/commands/deploy/index.js

@@ -4,6 +4,13 @@ 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';
@@ -19,6 +26,13 @@ const deploy = {
         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,102 @@
+import { requireApi } from '../../../api/context.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';
+
+// Phases where the build is still producing output; anything else is a frozen
+// record and following would just wait on nothing.
+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
+        .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'
+    })
+        .option('follow', {
+        alias: 'f',
+        type: 'boolean',
+        default: false,
+        description: 'With --build: keep tailing the output while the build runs'
+    })
+        .example('$0 deploy logs', 'Runtime logs of the linked app (last 24h)')
+        .example('$0 deploy logs --build', 'Build output of the latest deployment')
+        .example('$0 deploy logs --build --follow', 'Tail the build that is running right now')
+        .showHelpOnFail(false),
+    handler: async (args) => {
+        if (args.follow && !args.build) {
+            // Runtime logs have no follow mode (the API serves a 24h window, not a
+            // stream) — only the build output can be tailed.
+            throw new Error('--follow only works with --build');
+        }
+        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;
+                }
+            }
+            if (args.follow) {
+                // Live tail (the builder re-uploads the log every ~10s): same loop the
+                // deploy command uses, so it ends at the image handoff and exits red
+                // on BUILD_ERROR. On an already-settled deployment fall through to the
+                // recorded snapshot instead of waiting on nothing.
+                const deployment = await ctx.api.getDeployment(deployment_id);
+                const phase = deployment?.status?.phase ?? '';
+                if (FOLLOWABLE_PHASES.has(phase)) {
+                    log.info(`🏗️ Following the build of ${deployment_id}:`);
+                    await follow_remote_build(ctx.api, deployment_id);
+                    return;
+                }
+                log.info(`Build of ${deployment_id} already finished (${phase}) — showing the recorded output.`);
+            }
+            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.28.0",
+  "version": "1.30.0",
   "main": "dist/index.js",
   "license": "MIT",
   "author": "Marc Pomar <marc@faable.com>",