@synteq/cli 0.1.6 → 1.1.1

package/dist/commands/function/deploy.js

@@ -0,0 +1,608 @@
+import { Args, Flags } from "@oclif/core";
+import { existsSync, statSync } from "node:fs";
+import { resolve, basename } from "node:path";
+import { BaseCommand } from "../../base/command.js";
+import { resolveLinkedFunction, notLinkedFunctionError } from "../../functions-support/link.js";
+import FunctionInit from "./init.js";
+import { slugify } from "../link.js";
+import { RUNTIMES } from "../../functions-support/runtime.js";
+import { ensurePaymentMethod, PaymentMethodRequired } from "../../ui/payment-gate.js";
+import { collectSourceFiles, tarballFromFiles, EDITOR_MAX_FILES, MAX_TOTAL_BYTES, SourceTooLargeError, SourceTooManyFilesError, } from "../../functions-support/source.js";
+import { waitForBuild, waitForRelease, DeployTimeoutError } from "../../functions-support/poll.js";
+import { inferRuntime } from "../../functions-support/runtime.js";
+import { buildProgress, deployedCard, failedCard, deploymentUrl } from "../../ui/deploy-ui.js";
+import { withSpinner } from "../../ui/spinner.js";
+import { importDotenv, offerDotenv } from "../../apps-support/dotenv.js";
+import { ApiError } from "../../api/errors.js";
+import { portalUrl } from "../../ui/portal.js";
+import { dim, ok, statusColor, G } from "../../ui/glyphs.js";
+import { parseEnvAssignment } from "../../functions-support/env.js";
+const ENV_KEY_RE = /^[A-Za-z_][A-Za-z0-9_]*$/;
+import { normalizeSchedule, shortTriggerId } from "../../functions-support/cron.js";
+import { isInteractive, confirmAction, pickFromCatalog, promptString } from "../../ui/wizard.js";
+/** One-line function plan description: resources + the metered prices. */
+function fnPlanLine(p) {
+    const cpu = p.cpuMillicores ? `${(p.cpuMillicores / 1000).toFixed(p.cpuMillicores % 1000 ? 1 : 0)} vCPU` : "";
+    const mem = p.memoryMib ? `${p.memoryMib} MiB` : "";
+    const inv = p.pricePerMillionInvocationsUsd != null ? `$${p.pricePerMillionInvocationsUsd}/M runs` : "";
+    const gbs = p.pricePerGbSecondUsd != null ? `$${p.pricePerGbSecondUsd}/GB·s` : "";
+    return [cpu, mem, inv, gbs].filter(Boolean).join(" · ");
+}
+/** Sentinel picker value for the "create a new function" row. */
+const CREATE = "__create__";
+/** Human wording for each reason collectSourceFiles reports a skip. */
+const SKIP_REASON = {
+    binary: "binary file",
+    "too-large": "larger than the source limit on its own",
+    ignored: "excluded",
+    dotenv: "never packed — set variables with `synteq function env set`, `--env-file`, or the Environment tab",
+    symlink: "symlink (not followed)",
+    "bad-path": "path the backend won't accept",
+};
+/**
+ * `synteq function deploy` — upload this directory's source and roll it out,
+ * or roll out a pre-built image with `--image <ref>`.
+ *
+ * Backend: POST /functions/{id}/deploys/source — the files inline when the
+ * tree fits the editor's 32-file shape (so the portal editor can reopen it),
+ * else a gzipped tarball (`sourceB64`) bounded only by the function's source
+ * caps (`maxSourceBytes` / `maxSourceFiles` on the row). The server decides the build path (Dockerfile / bundle) itself and
+ * returns the build row. The deploy then has two phases the CLI follows: the
+ * BUILD reaches succeeded/failed, then the status cron mints a RELEASE and
+ * flips it current once the function is live. `--image` is the apps
+ * `deploy --image` route, function-owned (POST /functions/{id}/deploys): no
+ * source, a pull Build the same two phases follow.
+ */
+export default class FunctionDeploy extends BaseCommand {
+    static apiKeyScope = "none";
+    static description = [
+        "Deploy a function from a local source directory or a pre-built image.",
+        "",
+        "Uploads the directory's text files (node_modules, .git, build output, .env",
+        "files and anything a .synteqignore excludes are left out), then follows the build",
+        "and the release it produces, printing each status transition. Ctrl-C stops",
+        "watching; the deploy keeps running server-side. `--image <ref>` skips the",
+        "upload: the platform pulls the image and rolls it out the same way.",
+        "",
+        "First run (an unlinked directory on a TTY): pick one of the project's",
+        "functions to link, or create one — name, plan, location, then optional env",
+        "vars and a cron trigger. --env/--secret/--cron do the same from the command",
+        "line, with --create, --name or a linked directory; they are applied before",
+        "the build starts, so the release carries them. If one of those fails, the",
+        "deploy stops before the build; whatever was already set stays set.",
+        "",
+        "On a function that already has a release, --env/--secret reach the server",
+        "before the build, and the server rolls env changes out after 120 s. A build",
+        "that takes longer can first mint an \"Environment change\" release of the",
+        "old image, then the new release: two releases, two restarts. The first",
+        "deploy of a new function is unaffected.",
+    ].join("\n");
+    static examples = [
+        "<%= config.bin %> function deploy                     # first run on a TTY: pick a function, or create one (name → plan → location → env → cron), then deploy",
+        "<%= config.bin %> function deploy --create my-fn --runtime node22 --plan nano --location dfw   # scripted first run, no prompts",
+        '<%= config.bin %> function deploy --create my-fn --env LOG_LEVEL=info --secret API_KEY=sk-abc --cron "*/15 * * * *"',
+        "<%= config.bin %> function deploy                     # bare: this directory's linked function",
+        "<%= config.bin %> function deploy --name my-fn",
+        "<%= config.bin %> function deploy --name my-fn --dir ./api",
+        "<%= config.bin %> function deploy --env-file .env.production   # import that file's variables onto the function first, no prompt",
+        "<%= config.bin %> function deploy --name my-fn --image docker.io/library/nginx:1.27-alpine   # pre-built image, no upload",
+        "<%= config.bin %> function deploy --name my-fn --no-wait   # fire-and-forget; returns the build row",
+        "<%= config.bin %> function deploy --name my-fn -o json",
+    ];
+    static args = {
+        target: Args.string({ required: false, description: "Function slug or id (optional; default: the directory's linked function or --name)." }),
+    };
+    static flags = {
+        name: Flags.string({
+            description: "Function slug (or uuid) to deploy (default: the function this directory is linked to via `synteq function init`).",
+        }),
+        create: Flags.string({
+            description: "Create a function with this name (or reuse one of that name), link this directory to it, and deploy — the scripted first run. Pair with --runtime, --plan and --location.",
+        }),
+        runtime: Flags.string({
+            options: [...RUNTIMES],
+            description: `Runtime for --create: ${RUNTIMES.join(" or ")} (default: what the directory's files imply, else node22).`,
+        }),
+        plan: Flags.string({
+            description: "Plan tier for --create (default: the first tier in the catalog).",
+        }),
+        location: Flags.string({
+            description: "Location code for --create, e.g. dfw (default: the first location).",
+        }),
+        project: Flags.string({
+            description: "Project id for --create, and the project whose functions the first-run picker lists (default: the active project).",
+        }),
+        dir: Flags.string({
+            description: "Directory to upload as the function's source (default: the current directory).",
+        }),
+        image: Flags.string({
+            description: "Pre-built image reference to roll out, registry host included (mutually exclusive with --dir; no source is uploaded).",
+        }),
+        "no-wait": Flags.boolean({
+            description: "Return as soon as the build is triggered; don't follow it to completion.",
+        }),
+        "poll-interval": Flags.integer({
+            default: 3,
+            description: "Seconds between build/release polls (default: 3, min: 2).",
+        }),
+        timeout: Flags.integer({
+            default: 600,
+            description: "Max seconds to wait for the build and release (default: 600).",
+        }),
+        env: Flags.string({
+            multiple: true,
+            description: "Config env var KEY=VALUE to set before the build (repeatable). Works with --create, --name or a linked directory.",
+        }),
+        secret: Flags.string({
+            multiple: true,
+            description: "Secret env var KEY=VALUE to set before the build (repeatable; reveal is masked). Works with --create, --name or a linked directory.",
+        }),
+        cron: Flags.string({
+            description: 'Cron trigger to add before the build: a quoted 5-field expression in UTC, e.g. "*/15 * * * *".',
+        }),
+        yes: Flags.boolean({
+            char: "y",
+            description: "Deploy without confirming when the directory looks like a different runtime than the function is configured for (non-interactive runs never pause).",
+        }),
+        "env-file": Flags.string({
+            description: "Import this .env's KEY=VALUE lines as variables on the function before the build (runtime secrets unless a `# scope=… kind=…` comment above a line says otherwise); no question asked. A .env is never packed, and a plain deploy never asks about it.",
+        }),
+    };
+    /** The argv `function init` runs with on a first deploy: --create's values
+     *  verbatim, else what the user picks. Runtime comes from the directory's
+     *  files when they say (init infers it too; passing it keeps the two in
+     *  step when the user overrides). */
+    async firstRunArgs(dir, flags, interactive) {
+        let name = flags.create ? slugify(flags.create) : "";
+        let plan = flags.plan;
+        let location = flags.location;
+        const runtime = flags.runtime;
+        if (!flags.create) {
+            name = slugify(await promptString("Function name", {
+                default: slugify(basename(dir)),
+                validate: (s) => (slugify(s).length >= 1 ? true : "Give it a name."),
+            }));
+        }
+        if (interactive && !plan) {
+            const plans = await this.clients.api.functions.plans().catch(() => []);
+            if (plans.length > 1) {
+                const items = plans.map((p) => ({
+                    value: p.name,
+                    name: p.displayName ?? p.name,
+                    description: fnPlanLine(p),
+                }));
+                plan = await pickFromCatalog("Plan", items, { defaultValue: plans[0].name });
+            }
+        }
+        if (interactive && !location) {
+            const locations = await this.clients.api.functions.locations().catch(() => []);
+            if (locations.length > 1) {
+                location = await pickFromCatalog("Primary location", locations.map((l) => ({ value: l.code, name: l.city, description: l.code })));
+            }
+            else if (locations.length === 1) {
+                this.log(dim(`Primary location: ${locations[0].city} (${locations[0].code})`));
+            }
+        }
+        const argv = [name, "--dir", dir, "--from-deploy"];
+        if (flags.image)
+            argv.push("--no-scaffold");
+        if (runtime)
+            argv.push("--runtime", runtime);
+        if (plan)
+            argv.push("--plan", plan);
+        if (location)
+            argv.push("--location", location);
+        if (flags.project)
+            argv.push("--project", flags.project);
+        if (this.outputFormat === "json")
+            argv.push("-o", "json");
+        return argv;
+    }
+    /** Step 0 of the first run — the apps `pickOrCreateApp` shape: link one of
+     *  the project's functions, or null for "Create a new function…". No
+     *  functions at all goes straight to create. */
+    async pickExistingFunction(projectId) {
+        const fns = await withSpinner("Loading functions", () => this.clients.api.functions.list(projectId));
+        if (fns.length === 0)
+            return null;
+        const items = [
+            ...fns.map((f) => ({
+                value: f.id,
+                name: f.slug,
+                description: `${f.status} · ${f.runtime} · ${f.region}`,
+            })),
+            {
+                value: CREATE,
+                name: "Create a new function…",
+                description: "Name, plan and location; optional env vars and a cron trigger.",
+            },
+        ];
+        const choice = await pickFromCatalog("Which function should this directory deploy?", items);
+        return choice === CREATE ? null : fns.find((f) => f.id === choice);
+    }
+    /** The two optional steps after location on a created function: env vars
+     *  (the apps walkthrough's shape — confirm, then name → value → secret?
+     *  until a blank name) and a cron trigger (blank for none). Each is
+     *  skipped when its flags already answered it. */
+    async promptFirstRunExtras(dir, have) {
+        const env = [];
+        // A .env in the directory first — this is the one place it is offered.
+        // Scope is runtime (what applySetup saves); kind follows the file.
+        if (!have.env) {
+            const rows = await offerDotenv({ dir, target: "the new function", log: (l) => this.log(l) });
+            env.push(...rows.map((r) => ({ key: r.key, value: r.value, kind: r.kind ?? "secret" })));
+        }
+        if (!have.env && (await confirmAction(env.length ? "Add more variables?" : "Set environment variables now?"))) {
+            this.log(dim("Secrets are masked after saving; config values can be revealed in full."));
+            for (;;) {
+                const key = await promptString("Variable name (blank to finish)", {
+                    allowEmpty: true,
+                    validate: (s) => ENV_KEY_RE.test(s.trim()) ? true : "Letters, digits and underscores; can't start with a digit.",
+                });
+                if (!key.trim())
+                    break;
+                const value = await promptString(`Value for ${key.trim()}`, { allowEmpty: true });
+                const secret = await confirmAction(`Is ${key.trim()} a secret?`, false);
+                env.push({ key: key.trim(), value, kind: secret ? "secret" : "config" });
+            }
+        }
+        let cron;
+        if (!have.cron) {
+            const raw = await promptString("Cron trigger (5-field UTC, blank for none)", {
+                allowEmpty: true,
+                validate: (s) => {
+                    try {
+                        normalizeSchedule(s);
+                        return true;
+                    }
+                    catch (e) {
+                        return e.message;
+                    }
+                },
+            });
+            if (raw.trim())
+                cron = normalizeSchedule(raw);
+        }
+        return { env, cron };
+    }
+    /** Set the env vars (same call `function env set` makes) and add the cron
+     *  trigger (same call `function cron add` makes) — before the build, so
+     *  the release it produces carries them. */
+    async applySetup(fn, env, cron) {
+        const table = this.outputFormat === "table";
+        for (const v of env) {
+            const saved = await withSpinner(`Setting ${v.key}`, () => this.clients.api.functions.setEnv(fn.id, { key: v.key, value: v.value, kind: v.kind, scope: "runtime" }));
+            if (table)
+                this.log(ok(`Set ${saved.key} on ${fn.slug} ${dim(`(${saved.kind} · ${saved.scope})`)}`));
+        }
+        if (cron) {
+            // Idempotent: a scripted deploy re-run on every push (or a linked dir
+            // deployed with --cron again) must not stack a second trigger on the
+            // same schedule — the backend doesn't dedupe, so each copy would fire
+            // (and bill) every tick until the per-function cap 422s the deploy.
+            const existing = await this.clients.api.functions.cronTriggers(fn.id);
+            const same = existing.find((t) => t.schedule.trim().replace(/\s+/g, " ") === cron);
+            if (same) {
+                if (table) {
+                    this.log(dim(`Cron ${cron} (UTC) is already scheduled on ${fn.slug} (trigger ${shortTriggerId(same.id)}).`));
+                }
+                return;
+            }
+            const trigger = await withSpinner("Adding cron trigger", () => this.clients.api.functions.createCronTrigger(fn.id, {
+                schedule: cron,
+                enabled: true,
+                retries: 0,
+                description: null,
+            }));
+            if (table) {
+                this.log(ok(`Added cron trigger ${shortTriggerId(trigger.id)} to ${fn.slug}: ${trigger.schedule} (UTC).`));
+            }
+        }
+    }
+    async run() {
+        await this.initClients();
+        const { args, flags: rawFlags } = await this.parse(FunctionDeploy);
+        const flags = { ...rawFlags, name: args.target ?? rawFlags.name };
+        try {
+            const dir = resolve(flags.dir && flags.dir !== "" ? flags.dir : ".");
+            if (!existsSync(dir) || !statSync(dir).isDirectory()) {
+                this.error(`Not a directory: ${dir}`, { exit: 1 });
+            }
+            if (flags.create && flags.name) {
+                this.error("Pass either --create <name> or --name <slug>, not both.", { exit: 1 });
+            }
+            if (flags.image && flags.dir) {
+                this.error("Pass either --image or --dir, not both.", { exit: 1 });
+            }
+            // --env / --secret / --cron are checked before anything is created, so
+            // a typo never leaves a half-set-up function behind.
+            let env = [];
+            let cron;
+            const parseFlag = (flag, raw, kind) => {
+                try {
+                    return parseEnvAssignment(raw, kind);
+                }
+                catch (e) {
+                    this.error(`--${flag}: ${e.message}`, { exit: 1 });
+                }
+            };
+            env = [
+                ...(flags.env ?? []).map((a) => parseFlag("env", a, "config")),
+                ...(flags.secret ?? []).map((a) => parseFlag("secret", a, "secret")),
+            ];
+            try {
+                cron = flags.cron !== undefined ? normalizeSchedule(flags.cron) : undefined;
+            }
+            catch (e) {
+                this.error(`--cron: ${e.message}`, { exit: 1 });
+            }
+            // First run: nothing linked and no --name. On a TTY, pick one of the
+            // project's functions to link, or set a new one up right here (name →
+            // plan → location → env → cron; runtime from the files) and carry on
+            // into the deploy — one command. --create is the same thing with every
+            // answer on the command line, so scripts never prompt.
+            const interactive = isInteractive() && this.outputFormat === "table";
+            const linked = this.clients.config.linkFor(dir);
+            const firstRun = !flags.create && !flags.name && !linked && interactive;
+            let existing = null;
+            if (firstRun) {
+                this.log(dim("No function is linked to this directory yet — set it up, then the deploy runs."));
+                existing = await this.pickExistingFunction(flags.project ?? this.clients.config.get().default_project_id ?? undefined);
+            }
+            if (existing) {
+                // Link it exactly as `function init <slug>` would (init reuses an
+                // existing function and writes the same link record) — no scaffold:
+                // this directory's files are what gets deployed.
+                const argv = [existing.id, "--dir", dir, "--from-deploy", "--no-scaffold"];
+                if (flags.project)
+                    argv.push("--project", flags.project);
+                await FunctionInit.run(argv, this.config);
+                this.clients.config.reload();
+                this.log("");
+            }
+            else if (flags.create || firstRun) {
+                const argv = await this.firstRunArgs(dir, flags, interactive);
+                if (firstRun) {
+                    const extras = await this.promptFirstRunExtras(dir, {
+                        env: env.length > 0,
+                        cron: cron !== undefined,
+                    });
+                    env = [...env, ...extras.env];
+                    cron = cron ?? extras.cron;
+                }
+                await FunctionInit.run(argv, this.config);
+                // init wrote the link through its own ConfigStore; pick it up here.
+                this.clients.config.reload();
+                if (interactive)
+                    this.log("");
+            }
+            const { fn, clients } = await resolveLinkedFunction(this.clients, flags, dir).catch((e) => {
+                if (e instanceof Error && !("status" in e)) {
+                    this.error(flags.create || interactive ? e.message : notLinkedFunctionError("--name <slug>, or --create <name>"), { exit: 1 });
+                }
+                throw e;
+            });
+            this.clients = clients;
+            // Every deploy needs a payment method on the team, free tier included.
+            // (A just-created function was gated at create; this is the cheap
+            // re-check for a directory linked long ago.)
+            await ensurePaymentMethod({
+                api: this.clients.api,
+                apiBaseUrl: this.clients.config.get().api_base_url,
+                interactive,
+                log: (l) => this.log(l),
+            }).catch((e) => {
+                if (e instanceof PaymentMethodRequired)
+                    this.error(e.message, { exit: 1 });
+                throw e;
+            });
+            // --image: no tree to collect or check; the env/cron setup and the
+            // follow below are the same as for a source deploy.
+            if (flags.image) {
+                await this.applySetup(fn, env, cron);
+                const build = await withSpinner("Triggering deploy", () => this.clients.api.functions.deployImage(fn.id, flags.image));
+                await this.follow(fn, build, [], flags);
+                return;
+            }
+            // 1. Collect the tree against the backend's LIVE caps (the row carries
+            //    them; older backends don't, and the collector's fallbacks are the
+            //    backend's defaults). A too-large tree is a user error with a
+            //    message that already names the offenders.
+            let collected;
+            try {
+                collected = await withSpinner("Collecting source", () => collectSourceFiles(dir, {
+                    maxTotalBytes: fn.maxSourceBytes ?? undefined,
+                    maxFiles: fn.maxSourceFiles ?? undefined,
+                }));
+            }
+            catch (e) {
+                if (e instanceof SourceTooLargeError || e instanceof SourceTooManyFilesError) {
+                    this.error(e.message, { exit: 1 });
+                }
+                throw e;
+            }
+            if (collected.files.length === 0) {
+                this.error(`No deployable files in ${dir}. Add a handler (\`synteq function init ${fn.slug}\` writes one).`, { exit: 1 });
+            }
+            // A skipped file is reported in EVERY output mode. In JSON mode the
+            // lines go to stderr so the JSON body stays parseable, and the body
+            // itself carries `skipped` (below) — a 6 MB data.json silently left out
+            // of a deploy is exactly the surprise -o json callers cannot see
+            // otherwise (2026-09-25).
+            const skipLines = collected.skipped.map((s) => `skipped ${s.path} — ${SKIP_REASON[s.reason] ?? s.reason}`);
+            if (this.outputFormat === "table") {
+                for (const line of skipLines)
+                    this.log(dim(`  ${line}`));
+                this.log(dim(`Uploading ${collected.files.length} file${collected.files.length === 1 ? "" : "s"} (${(collected.totalBytes / 1024).toFixed(0)} KiB) to ${fn.slug}.`));
+            }
+            // 2. A tree that looks like a different runtime than the function is
+            //    configured for is the mismatch that fails LATE (the build uses the
+            //    FUNCTION's runtime and finds no entry), so surface it now. On a
+            //    TTY it is a confirm the user can decline; --yes and non-interactive
+            //    runs get the warning and proceed, since a script cannot answer.
+            const inferred = inferRuntime(collected.files.map((f) => f.path));
+            const hasDockerfile = collected.files.some((f) => f.path === "Dockerfile");
+            if (inferred && !hasDockerfile && inferred !== fn.runtime && this.outputFormat === "table") {
+                this.log("");
+                // Advisory only; route to stderr so -o json stdout stays clean, and
+                // only prompt in table mode (json/non-TTY proceeds — the build uses
+                // fn.runtime either way).
+                this.info(`${G.dot} This directory looks like ${inferred}, but ${fn.slug} is configured for ${fn.runtime}.`);
+                this.info(dim(`  The build will use ${fn.runtime}. Change the runtime in the portal (function → Settings) if that's wrong.`));
+                this.info("");
+                if (!flags.yes && interactive) {
+                    const go = await confirmAction(`Deploy to ${fn.slug} as ${fn.runtime} anyway?`, false);
+                    if (!go)
+                        this.error("Deploy cancelled.", { exit: 1 });
+                }
+            }
+            // 3. The first release carries the env vars and the cron trigger:
+            //    apply them now, after the function exists and before the build.
+            //    --env-file lands the same way (a .env is never packed; a plain
+            //    deploy never asks about it — the first-run create did).
+            await this.applySetup(fn, env, cron);
+            try {
+                await importDotenv({
+                    dir,
+                    envFile: flags["env-file"],
+                    interactive: false,
+                    target: `function ${fn.slug}`,
+                    log: (l) => this.log(l),
+                    save: (r) => this.clients.api.functions
+                        .setEnv(fn.id, {
+                        key: r.key,
+                        value: r.value,
+                        scope: r.scope ?? "runtime",
+                        kind: r.kind ?? "secret",
+                        ...(r.note ? { note: r.note } : {}),
+                        rollout: false,
+                    })
+                        .then(() => undefined),
+                });
+            }
+            catch (e) {
+                if (e instanceof ApiError)
+                    throw e;
+                this.error(e.message, { exit: 1 });
+            }
+            // 4. Trigger. Past the editor's 32 files the tree goes up as a tarball,
+            //    which the API bounds by the compressed size; refuse here rather
+            //    than after the upload in the rare case tar overhead tips it over.
+            let tarball;
+            if (collected.files.length > EDITOR_MAX_FILES) {
+                tarball = tarballFromFiles(collected.files);
+                const limit = fn.maxSourceBytes ?? MAX_TOTAL_BYTES;
+                if (tarball.length > limit) {
+                    this.error(`Source archive is ${(tarball.length / 1024).toFixed(0)} KiB; the limit is ${(limit / 1024).toFixed(0)} KiB. ` +
+                        "Exclude files with a .synteqignore, or add a Dockerfile and deploy as a container.", { exit: 1 });
+                }
+            }
+            const build = await withSpinner("Uploading source", () => tarball
+                ? this.clients.api.functions.deployTarball(fn.id, tarball)
+                : this.clients.api.functions.deployFiles(fn.id, collected.files));
+            await this.follow(fn, build, collected.skipped, flags);
+        }
+        catch (err) {
+            this.fail(err);
+        }
+    }
+    /** Steps 5+: print the build row (--no-wait) or follow the build and the
+     *  release it produces — in JSON mode too, with progress on stderr. Shared
+     *  by the source and image paths. */
+    async follow(fn, build, skipped, flags) {
+        const skipLines = skipped.map((s) => `skipped ${s.path} — ${SKIP_REASON[s.reason] ?? s.reason}`);
+        const json = this.outputFormat === "json";
+        // Every emitted document carries the skip list; in JSON mode the lines go
+        // to stderr too, since a scripted caller never sees them otherwise (the
+        // skip report in run(), 2026-09-25).
+        const withSkipped = (doc) => (skipped.length ? { ...doc, skipped } : doc);
+        if (json)
+            for (const line of skipLines)
+                process.stderr.write(`${line}\n`);
+        if (flags["no-wait"]) {
+            this.emit(withSkipped(build), () => this.log(`${statusColor(build.status)}  build ${build.id.slice(0, 8)}  ${build.frontend}`));
+            return;
+        }
+        // JSON mode follows the build like table mode — a CI job must see exit 1
+        // for a failed build or a release that never goes live (until 1.2.2 JSON
+        // returned the triggered build and exit 0, so the failure was invisible).
+        // The checklist takes an `out` stream and goes to stderr; stdout carries
+        // the final document only.
+        const out = json ? process.stderr : process.stdout;
+        // 5. Follow it. Ctrl-C stops watching, not the deploy.
+        const controller = new AbortController();
+        const onSigint = () => {
+            controller.abort();
+        };
+        process.on("SIGINT", onSigint);
+        const apiBaseUrl = this.clients.config.get().api_base_url;
+        const panelUrl = portalUrl(apiBaseUrl, `/functions/${fn.id}`);
+        const intervalMs = Math.max(2, flags["poll-interval"]) * 1000;
+        const deadline = Date.now() + flags.timeout * 1000;
+        const progress = buildProgress(`Deploying ${fn.slug}`, { out });
+        progress.update(build.status);
+        try {
+            const finalBuild = await waitForBuild(this.clients.api, fn.id, build.id, {
+                intervalMs,
+                timeoutMs: Math.max(0, deadline - Date.now()),
+                signal: controller.signal,
+                onStatus: (status) => progress.update(status),
+            });
+            if (finalBuild.status !== "succeeded") {
+                progress.failed();
+                this.emit(withSkipped(finalBuild), () => this.log(failedCard({ appSlug: fn.slug, buildId: finalBuild.id, panelUrl })));
+                this.exit(1);
+            }
+            const release = await waitForRelease(this.clients.api, fn.id, build.id, {
+                intervalMs,
+                timeoutMs: Math.max(0, deadline - Date.now()),
+                signal: controller.signal,
+            });
+            progress.done("succeeded");
+            const durationMs = finalBuild.startedAt && finalBuild.finishedAt
+                ? new Date(finalBuild.finishedAt).getTime() - new Date(finalBuild.startedAt).getTime()
+                : null;
+            if (release.isCurrent) {
+                this.emit(withSkipped({ build: finalBuild, release }), () => this.log(deployedCard({
+                    appSlug: fn.slug,
+                    url: deploymentUrl(fn.hostname),
+                    release: release.number,
+                    digest: release.imageDigest,
+                    durationMs,
+                    panelUrl,
+                })));
+            }
+            else {
+                // The build produced a release that never went current — the image
+                // is fine, the rollout is not. Say so rather than claiming success.
+                this.emit(withSkipped({ build: finalBuild, release }), () => this.log(failedCard({ appSlug: fn.slug, buildId: finalBuild.id, panelUrl }) +
+                    `\n${dim(`  Release #${release.number} is ${statusColor(release.status)}.`)}`));
+                this.exit(1);
+            }
+        }
+        catch (e) {
+            if (controller.signal.aborted) {
+                progress.failed("Stopped watching");
+                // JSON stdout stays empty on an interrupt (nothing parseable to emit);
+                // the hint is for a human at a terminal only.
+                if (!json) {
+                    this.log("");
+                    this.log(`${G.dot} The deploy continues server-side. Watch it: ${panelUrl}, or run \`synteq function releases --name ${fn.slug}\`.`);
+                }
+                return;
+            }
+            if (e instanceof DeployTimeoutError) {
+                progress.failed(e.message);
+                // A timeout is "unknown", not a failure (exit 0). JSON still owes the
+                // caller a parseable document — the build row plus `timedOut`.
+                this.emit(withSkipped({ ...build, timedOut: true }), () => this.log(`${G.dot} Stopped waiting after ${flags.timeout}s — the deploy may still finish. Watch it: ${panelUrl}`));
+                return;
+            }
+            throw e;
+        }
+        finally {
+            process.removeListener("SIGINT", onSigint);
+        }
+    }
+}
+//# sourceMappingURL=deploy.js.map