frontpage-host 0.1.16 → 0.1.18

package/dist/commands/publish.js

@@ -1,19 +1,81 @@
 import { resolveSlug } from "../site.js";
-import { EXIT_OK, EXIT_USAGE, v1Delete, v1Post } from "../http/client.js";
-import { emitErr, emitOk, emitUsage, isJson, requireYesOrTty } from "../runtime.js";
+import { EXIT_OK, EXIT_USAGE, v1Post, v1Delete } from "../http/client.js";
+import { emitErr, emitFail, emitOk, emitUsage, isJson, progress, requireYesOrTty } from "../runtime.js";
+import { describePublishResult, waitForCompileReady } from "../compile.js";
+function takeWaitFlag(rest) {
+    const i = rest.indexOf("--wait");
+    if (i === -1)
+        return false;
+    rest.splice(i, 1);
+    return true;
+}
+function emitPublished(slug, data) {
+    const described = describePublishResult({
+        productionCommit: data.productionCommit ?? null,
+        productionUrl: data.productionUrl ?? null,
+    });
+    if (isJson()) {
+        emitOk("publish", {
+            slug,
+            productionUrl: data.productionUrl ?? null,
+            productionCommit: data.productionCommit ?? null,
+            servingCommit: described.servingCommit,
+            matchesTip: described.matchesTip,
+        });
+    }
+    else {
+        console.log(`Published ${slug}`);
+        for (const line of described.lines)
+            console.log(line);
+        if (data.productionUrl)
+            console.log(data.productionUrl);
+        if (!described.matchesTip) {
+            console.error("Publish promoted a build that is not the current tip. Wait for the site compile, then publish again.");
+        }
+    }
+    return EXIT_OK;
+}
 export async function runPublish(args) {
     try {
-        const { slug } = await resolveSlug(args);
-        const data = await v1Post(`/api/v1/sites/${encodeURIComponent(slug)}/publish`);
-        if (isJson()) {
-            emitOk("publish", { slug, productionUrl: data.productionUrl ?? null });
+        const { slug, rest } = await resolveSlug(args);
+        const work = [...rest];
+        const wait = takeWaitFlag(work);
+        if (work.length > 0) {
+            return emitUsage("publish", "Usage: frontpage publish [--site <slug>] [--wait] [--json]", EXIT_USAGE);
         }
-        else {
-            console.log(`Published ${slug}`);
-            if (data.productionUrl)
-                console.log(data.productionUrl);
+        if (wait) {
+            if (!isJson())
+                progress("Waiting for the site compile…\n");
+            const compile = await waitForCompileReady({ slug });
+            if (compile.exitCode !== EXIT_OK) {
+                const message = compile.apiMissing
+                    ? "Compile status API is missing. Refusing to publish."
+                    : compile.failed
+                        ? "Site compile failed. Refusing to publish a previous build."
+                        : compile.timedOut
+                            ? "Timed out waiting for the site compile. Refusing to publish a previous build."
+                            : "Site compile is not ready. Refusing to publish a previous build.";
+                return emitFail("publish", {
+                    message,
+                    exitCode: compile.exitCode,
+                    data: {
+                        slug,
+                        compile: compile.status,
+                        tip: compile.status?.stagingCommit ?? null,
+                        live: compile.status?.liveCommit ?? null,
+                        status: compile.apiMissing
+                            ? "compile_api_missing"
+                            : compile.failed
+                                ? "compile_failed"
+                                : compile.timedOut
+                                    ? "compile_timeout"
+                                    : "compile_not_ready",
+                    },
+                });
+            }
         }
-        return EXIT_OK;
+        const data = await v1Post(`/api/v1/sites/${encodeURIComponent(slug)}/publish`);
+        return emitPublished(slug, data);
     }
     catch (err) {
         return emitErr("publish", err);

package/dist/commands/push.d.ts

@@ -1 +1,6 @@
+/** Remote allowlisted paths that are gone locally become explicit deletes. */
+export declare function pushDeletesForMissingLocal(localPaths: Iterable<string>, remotePaths: Iterable<string>): Array<{
+    path: string;
+    delete: true;
+}>;
 export declare function runPush(args: string[]): Promise<number>;

package/dist/commands/push.js

@@ -1,10 +1,10 @@
 import { readdir, readFile, stat } from "node:fs/promises";
 import { join, relative, sep } from "node:path";
 import { resolveSlug } from "../site.js";
-import { EXIT_OK, EXIT_USAGE, v1Put } from "../http/client.js";
+import { EXIT_OK, EXIT_USAGE, v1Get, v1Put } from "../http/client.js";
 import { readState, writeState } from "../state/frontpage-state.js";
 import { emitErr, emitOk, emitUsage, isJson } from "../runtime.js";
-import { emitWaitOutcome, waitForAgentIdle } from "./wait-agent-idle.js";
+import { waitForAgentThenCompile } from "./wait-site-compile.js";
 const TEXT_EXTS = new Set([
     ".astro",
     ".ts",
@@ -26,6 +26,14 @@ const TEXT_EXTS = new Set([
     ".toml",
 ]);
 const ROOTS = ["src", "public", "content"];
+/** Remote allowlisted paths that are gone locally become explicit deletes. */
+export function pushDeletesForMissingLocal(localPaths, remotePaths) {
+    const local = new Set(localPaths);
+    return [...remotePaths]
+        .filter((path) => path && !local.has(path))
+        .sort()
+        .map((path) => ({ path, delete: true }));
+}
 async function walkAllowlisted(cwd) {
     const out = [];
     async function walk(abs) {
@@ -85,7 +93,10 @@ export async function runPush(args) {
         if (paths.length === 0) {
             return emitUsage("push", "No allowlisted files (src/, public/, content/) found in this folder.", EXIT_USAGE);
         }
-        const files = [];
+        const listing = await v1Get(`/api/v1/sites/${encodeURIComponent(slug)}/files`);
+        const files = [
+            ...pushDeletesForMissingLocal(paths, listing.files.map((f) => f.path)),
+        ];
         for (const path of paths) {
             const abs = join(cwd, path);
             const st = await stat(abs);
@@ -136,8 +147,7 @@ export async function runPush(args) {
                 console.error(`Warning: ${w}`);
             return EXIT_OK;
         }
-        // --wait: after push, wait for agent-run busy to clear (same statuses as deploy wait).
-        // Does not invent a Vercel deploy oracle; file-only pushes with no active run return promptly.
+        // --wait: agent-run idle (if any), then the new commit's site compile.
         if (!isJson()) {
             if (!data.changed) {
                 console.log("Nothing to commit (remote already matches).");
@@ -148,17 +158,12 @@ export async function runPush(args) {
             }
             for (const w of data.warnings ?? [])
                 console.error(`Warning: ${w}`);
-            console.error("Waiting for agent run / deploy idle…");
         }
-        const result = await waitForAgentIdle({
-            slug,
-            // Do not fail on an ancient canceled run when this push never saw busy work.
-            failClosedOnIdleTerminalFailure: false,
-        });
-        return emitWaitOutcome({
+        return waitForAgentThenCompile({
             command: "push",
             slug,
-            result,
+            expectCommit: data.commitSha ?? null,
+            failClosedOnIdleTerminalFailure: false,
             extra: { ...pushPayload, waited: true },
         });
     }

package/dist/commands/redirects.d.ts

@@ -0,0 +1 @@
+export declare function runRedirects(args: string[]): Promise<number>;

package/dist/commands/redirects.js

@@ -0,0 +1,83 @@
+import { resolveSlug } from "../site.js";
+import { CliHttpError, EXIT_OK, EXIT_USAGE, exitCodeForError, v1Delete, v1Get, v1Put } from "../http/client.js";
+import { assertNoUnknownFlags, takeFlag } from "../argv.js";
+import { emitErr, emitOk, isJson } from "../runtime.js";
+const USAGE = "Usage: frontpage redirects list | set --from /old --to /new [--status 301|308] | rm --from /old [--site <slug>] [--json]";
+function requirePathFlag(work, flag) {
+    const value = takeFlag(work, flag);
+    if (!value) {
+        throw new CliHttpError(`${flag} is required (e.g. ${flag} /old).`, EXIT_USAGE, 0, "bad_request");
+    }
+    if (!value.startsWith("/") || value.startsWith("//")) {
+        throw new CliHttpError(`${flag} must be a pathname starting with /.`, EXIT_USAGE, 0, "bad_request");
+    }
+    return value;
+}
+export async function runRedirects(args) {
+    try {
+        const { slug, rest } = await resolveSlug(args);
+        const sub = rest[0];
+        if (!sub || sub === "list") {
+            const work = sub === "list" ? rest.slice(1) : [...rest];
+            assertNoUnknownFlags(work, "redirects");
+            const data = await v1Get(`/api/v1/sites/${encodeURIComponent(slug)}/redirects`);
+            if (isJson()) {
+                emitOk("redirects", data);
+                return EXIT_OK;
+            }
+            const rows = data.redirects ?? [];
+            if (rows.length === 0) {
+                console.log("No redirects.");
+                return EXIT_OK;
+            }
+            for (const row of rows) {
+                console.log(`${row.from} → ${row.to} (${row.status})`);
+            }
+            return EXIT_OK;
+        }
+        if (sub === "set") {
+            const work = rest.slice(1);
+            const from = requirePathFlag(work, "--from");
+            const to = requirePathFlag(work, "--to");
+            const statusRaw = takeFlag(work, "--status");
+            assertNoUnknownFlags(work, "redirects");
+            const body = { from, to };
+            if (statusRaw !== undefined) {
+                const status = Number(statusRaw);
+                if (status !== 301 && status !== 308) {
+                    console.error("Status must be 301 or 308.");
+                    return EXIT_USAGE;
+                }
+                body.status = status;
+            }
+            const data = await v1Put(`/api/v1/sites/${encodeURIComponent(slug)}/redirects`, body);
+            if (isJson()) {
+                emitOk("redirects", data);
+                return EXIT_OK;
+            }
+            const row = data.redirect;
+            console.log(`${row.from} → ${row.to} (${row.status})`);
+            return EXIT_OK;
+        }
+        if (sub === "rm" || sub === "remove") {
+            const work = rest.slice(1);
+            const from = requirePathFlag(work, "--from");
+            assertNoUnknownFlags(work, "redirects");
+            const data = await v1Delete(`/api/v1/sites/${encodeURIComponent(slug)}/redirects?from=${encodeURIComponent(from)}`);
+            if (isJson()) {
+                emitOk("redirects", data);
+                return EXIT_OK;
+            }
+            console.log(`Removed ${data.removed.from}`);
+            return EXIT_OK;
+        }
+        console.error(USAGE);
+        return EXIT_USAGE;
+    }
+    catch (err) {
+        if (isJson())
+            return emitErr("redirects", err);
+        console.error(err instanceof Error ? err.message : String(err));
+        return exitCodeForError(err);
+    }
+}

package/dist/commands/wait-agent-idle.d.ts

@@ -16,6 +16,18 @@ export type WaitIdleResult = {
 };
 export declare function isBusyStatus(status: string): boolean;
 export declare function isFailTerminal(status: string): boolean;
+/**
+ * A historical succeeded run is unrelated when this wait never saw busy work.
+ * Keep failed/canceled latest so deploy wait stays fail-closed (Phase D).
+ */
+export declare function sanitizeUnrelatedIdleRun(args: {
+    observedBusy: boolean;
+    run: WaitRunSnapshot | null;
+    status: string;
+}): {
+    run: WaitRunSnapshot | null;
+    status: string;
+};
 /**
  * Decide exit after idle. Pure — unit-tested.
  * - If we watched a busy run end: succeeded → 0; failed/canceled → 2.

package/dist/commands/wait-agent-idle.js

@@ -1,6 +1,7 @@
 /**
- * §CLI Phase D — shared wait for agent-run busy states (queued/running/deploying).
- * Used by `deploy wait` and `push --wait`. Not a Vercel deploy oracle.
+ * Shared wait for editor agent-run busy states (queued/running/deploying).
+ * This is the agent-run clock, not the site compile. File-only pushes have
+ * no agent run — success here does not mean the latest commit is built.
  */
 import { EXIT_OK, EXIT_USAGE, v1Get } from "../http/client.js";
 import { emitFail, emitOk, isJson, progress } from "../runtime.js";
@@ -12,6 +13,18 @@ export function isBusyStatus(status) {
 export function isFailTerminal(status) {
     return FAIL_TERMINAL.has(status);
 }
+/**
+ * A historical succeeded run is unrelated when this wait never saw busy work.
+ * Keep failed/canceled latest so deploy wait stays fail-closed (Phase D).
+ */
+export function sanitizeUnrelatedIdleRun(args) {
+    if (args.observedBusy)
+        return { run: args.run, status: args.status };
+    if (args.run && isFailTerminal(args.run.status)) {
+        return { run: args.run, status: args.status };
+    }
+    return { run: null, status: "idle" };
+}
 /**
  * Decide exit after idle. Pure — unit-tested.
  * - If we watched a busy run end: succeeded → 0; failed/canceled → 2.
@@ -111,11 +124,16 @@ export async function waitForAgentIdle(args) {
             observedBusy,
             failClosedOnIdleTerminalFailure: args.failClosedOnIdleTerminalFailure,
         });
+        const sanitized = sanitizeUnrelatedIdleRun({
+            observedBusy,
+            run: decided.run,
+            status: decided.status,
+        });
         return {
             exitCode: decided.exitCode,
-            run: decided.run,
+            run: sanitized.run,
             observedBusy,
-            status: decided.status,
+            status: sanitized.status,
         };
     }
     progress("\n");
@@ -175,7 +193,7 @@ export function emitWaitOutcome(args) {
         console.log(`${result.run.id}  ${result.run.status}${result.run.statusMessage ? `  ${result.run.statusMessage}` : ""}`);
     }
     else {
-        console.log("No active deploy.");
+        console.log("No agent run was in flight. This does not mean the latest commit is compiled.");
     }
     return EXIT_OK;
 }

package/dist/commands/wait-site-compile.d.ts

@@ -0,0 +1,22 @@
+import { type DeployStatus } from "../compile.js";
+import { type WaitIdleResult } from "./wait-agent-idle.js";
+export declare function waitForAgentThenCompile(args: {
+    command: "deploy" | "push";
+    slug: string;
+    expectCommit?: string | null;
+    failClosedOnIdleTerminalFailure: boolean;
+    extra?: Record<string, unknown>;
+}): Promise<number>;
+export declare function emitCompileWaitOutcome(args: {
+    command: "deploy" | "push";
+    slug: string;
+    agent: WaitIdleResult;
+    compile: {
+        exitCode: number;
+        timedOut: boolean;
+        failed?: boolean;
+        apiMissing?: boolean;
+        status: DeployStatus | null;
+    };
+    extra?: Record<string, unknown>;
+}): number;

package/dist/commands/wait-site-compile.js

@@ -0,0 +1,98 @@
+/**
+ * After the agent-run clock is idle, wait for the site compile of the tip.
+ */
+import { EXIT_OK } from "../http/client.js";
+import { emitFail, emitOk, isJson, progress } from "../runtime.js";
+import { waitForCompileReady } from "../compile.js";
+import { emitWaitOutcome, waitForAgentIdle, } from "./wait-agent-idle.js";
+export async function waitForAgentThenCompile(args) {
+    const agent = await waitForAgentIdle({
+        slug: args.slug,
+        failClosedOnIdleTerminalFailure: args.failClosedOnIdleTerminalFailure,
+    });
+    if (agent.exitCode !== EXIT_OK) {
+        return emitWaitOutcome({
+            command: args.command,
+            slug: args.slug,
+            result: agent,
+            extra: args.extra,
+        });
+    }
+    if (!isJson()) {
+        if (agent.observedBusy && agent.run) {
+            console.log(`${agent.run.id}  ${agent.run.status}${agent.run.statusMessage ? `  ${agent.run.statusMessage}` : ""}`);
+        }
+        else {
+            console.log("No agent run was in flight.");
+        }
+        progress("Waiting for the site compile…\n");
+    }
+    const compile = await waitForCompileReady({
+        slug: args.slug,
+        expectCommit: args.expectCommit,
+    });
+    return emitCompileWaitOutcome({
+        command: args.command,
+        slug: args.slug,
+        agent,
+        compile,
+        extra: args.extra,
+    });
+}
+export function emitCompileWaitOutcome(args) {
+    const compileData = {
+        compile: args.compile.status,
+        compileReady: Boolean(args.compile.status?.ready) && !args.compile.timedOut,
+    };
+    if (args.compile.exitCode !== EXIT_OK) {
+        const message = args.compile.apiMissing
+            ? "Compile status API is missing. Cannot confirm the tip is live."
+            : args.compile.failed
+                ? "Site compile failed. The git tip is not live."
+                : args.compile.timedOut
+                    ? "Timed out waiting for the site compile. The git tip is not live yet."
+                    : "Site compile is not ready.";
+        if (isJson()) {
+            return emitFail(args.command, {
+                message,
+                exitCode: args.compile.exitCode,
+                data: {
+                    slug: args.slug,
+                    waited: true,
+                    observedBusy: args.agent.observedBusy,
+                    status: args.compile.apiMissing
+                        ? "compile_api_missing"
+                        : args.compile.failed
+                            ? "compile_failed"
+                            : args.compile.timedOut
+                                ? "compile_timeout"
+                                : "compile_not_ready",
+                    run: args.agent.run,
+                    ...compileData,
+                    ...args.extra,
+                },
+            });
+        }
+        console.error(message);
+        if (args.compile.status) {
+            console.error(`tip ${args.compile.status.stagingCommit ?? "(none)"}  live ${args.compile.status.liveCommit ?? "(none)"}`);
+        }
+        return args.compile.exitCode;
+    }
+    if (isJson()) {
+        emitOk(args.command, {
+            slug: args.slug,
+            waited: true,
+            observedBusy: args.agent.observedBusy,
+            status: "ready",
+            run: args.agent.run,
+            ...compileData,
+            ...args.extra,
+        });
+    }
+    else {
+        const live = args.compile.status?.liveCommit ?? args.compile.status?.stagingCommit;
+        console.log(`Site compile ready  ${live ?? ""}`.trim());
+    }
+    return EXIT_OK;
+}

package/dist/compile.d.ts

@@ -0,0 +1,46 @@
+export type DeployStatus = {
+    slug?: string;
+    stagingCommit: string | null;
+    servingCommit: string | null;
+    liveCommit: string | null;
+    ready: boolean;
+    splitBrain: boolean;
+    compileState?: "ready" | "building" | "failed" | "canceled" | "unknown";
+    stagingUrl: string | null;
+    productionCommit: string | null;
+    productionServingCommit: string | null;
+    productionUrl: string | null;
+};
+export declare function normalizeSha(raw: string | null | undefined): string | null;
+export declare function shortSha(raw: string | null | undefined): string;
+/** SHA encoded in a Blob artifact prefix URL. */
+export declare function commitFromArtifactUrl(url: string | null | undefined): string | null;
+export declare function compileIsReady(status: Pick<DeployStatus, "ready" | "liveCommit">, expectCommit?: string | null): boolean;
+export type CompileWaitResult = {
+    exitCode: number;
+    timedOut: boolean;
+    failed: boolean;
+    apiMissing?: boolean;
+    status: DeployStatus | null;
+};
+/** Compile clock is gone (flag off / old API). A site-not-found 404 is not this. */
+export declare function isMissingDeployApi(err: unknown): boolean;
+/** A deploy payload we can poll. Missing `ready` means the compile clock is not there. */
+export declare function deployStatusLooksComplete(status: DeployStatus | null | undefined): boolean;
+export declare function fetchDeployStatus(slug: string): Promise<DeployStatus>;
+export declare function waitForCompileReady(args: {
+    slug: string;
+    expectCommit?: string | null;
+    maxMs?: number;
+    pollMs?: number;
+    fetchStatus?: (slug: string) => Promise<DeployStatus>;
+}): Promise<CompileWaitResult>;
+export declare function describePublishResult(args: {
+    productionCommit: string | null;
+    productionUrl: string | null;
+}): {
+    tipCommit: string | null;
+    servingCommit: string | null;
+    matchesTip: boolean;
+    lines: string[];
+};

package/dist/compile.js

@@ -0,0 +1,99 @@
+/**
+ * Site compile clock (not the editor agent run).
+ *
+ * GET /api/v1/sites/{slug}/deploy → ready when the live compile SHA equals the tip.
+ */
+import { CliHttpError, EXIT_OK, EXIT_USAGE, v1Get } from "./http/client.js";
+import { progress } from "./runtime.js";
+const SHA_RE = /^[0-9a-f]{40}$/i;
+export function normalizeSha(raw) {
+    const sha = (raw ?? "").trim().toLowerCase();
+    return SHA_RE.test(sha) ? sha : null;
+}
+export function shortSha(raw) {
+    const sha = normalizeSha(raw);
+    return sha ? sha.slice(0, 7) : "(none)";
+}
+/** SHA encoded in a Blob artifact prefix URL. */
+export function commitFromArtifactUrl(url) {
+    if (!url)
+        return null;
+    const m = String(url).match(/\/artifacts\/[^/]+\/([0-9a-f]{40})(?:\/|$)/i);
+    return m ? m[1].toLowerCase() : null;
+}
+export function compileIsReady(status, expectCommit) {
+    if (!status.ready)
+        return false;
+    const live = normalizeSha(status.liveCommit);
+    if (!live)
+        return false;
+    const expect = normalizeSha(expectCommit ?? null);
+    if (!expect)
+        return true;
+    return live === expect;
+}
+/** Compile clock is gone (flag off / old API). A site-not-found 404 is not this. */
+export function isMissingDeployApi(err) {
+    if (!(err instanceof CliHttpError))
+        return false;
+    const message = err.message.toLowerCase();
+    if (message.includes("api not available"))
+        return true;
+    if (err.status === 404 && (message === "not found." || message === "not found"))
+        return true;
+    return false;
+}
+/** A deploy payload we can poll. Missing `ready` means the compile clock is not there. */
+export function deployStatusLooksComplete(status) {
+    return Boolean(status && typeof status.ready === "boolean");
+}
+export async function fetchDeployStatus(slug) {
+    return v1Get(`/api/v1/sites/${encodeURIComponent(slug)}/deploy`);
+}
+export async function waitForCompileReady(args) {
+    const maxMs = args.maxMs ?? 30 * 60 * 1000;
+    const pollMs = args.pollMs ?? 2000;
+    const fetchStatus = args.fetchStatus ?? fetchDeployStatus;
+    const started = Date.now();
+    let last = null;
+    while (Date.now() - started < maxMs) {
+        try {
+            last = await fetchStatus(args.slug);
+        }
+        catch (err) {
+            if (isMissingDeployApi(err)) {
+                progress("\n");
+                return { exitCode: EXIT_USAGE, timedOut: false, failed: true, apiMissing: true, status: null };
+            }
+            throw err;
+        }
+        if (!deployStatusLooksComplete(last)) {
+            progress("\n");
+            return { exitCode: EXIT_USAGE, timedOut: false, failed: true, apiMissing: true, status: last };
+        }
+        if (last.compileState === "failed" || last.compileState === "canceled") {
+            progress("\n");
+            return { exitCode: EXIT_USAGE, timedOut: false, failed: true, status: last };
+        }
+        if (compileIsReady(last, args.expectCommit)) {
+            progress("\n");
+            return { exitCode: EXIT_OK, timedOut: false, failed: false, status: last };
+        }
+        const tip = shortSha(args.expectCommit ?? last.stagingCommit);
+        const live = shortSha(last.liveCommit ?? last.servingCommit);
+        progress(`\rwaiting for site compile  tip ${tip}  live ${live}   `);
+        await new Promise((r) => setTimeout(r, pollMs));
+    }
+    progress("\n");
+    return { exitCode: EXIT_USAGE, timedOut: true, failed: false, status: last };
+}
+export function describePublishResult(args) {
+    const tipCommit = normalizeSha(args.productionCommit);
+    const servingCommit = commitFromArtifactUrl(args.productionUrl) ?? tipCommit;
+    const matchesTip = Boolean(tipCommit && servingCommit && tipCommit === servingCommit);
+    const lines = [
+        `tip      ${tipCommit ?? "(none)"}`,
+        `serving  ${servingCommit ?? "(none)"}${matchesTip ? "" : "  ← not the tip; this is the previous build"}`,
+    ];
+    return { tipCommit, servingCommit, matchesTip, lines };
+}

package/dist/completions/generate.js

@@ -19,15 +19,19 @@ _frontpage_completions() {
     runs) COMPREPLY=( $(compgen -W "list current wait cancel retry get" -- "\${cur}") ) ;;
     deploy) COMPREPLY=( $(compgen -W "wait" -- "\${cur}") ) ;;
     media) COMPREPLY=( $(compgen -W "list upload" -- "\${cur}") ) ;;
+    images) COMPREPLY=( $(compgen -W "generate" -- "\${cur}") ) ;;
     fonts) COMPREPLY=( $(compgen -W "list search" -- "\${cur}") ) ;;
     tokens) COMPREPLY=( $(compgen -W "set" -- "\${cur}") ) ;;
     seo|settings) COMPREPLY=( $(compgen -W "get set" -- "\${cur}") ) ;;
     articles) COMPREPLY=( $(compgen -W "list content create-section create-article set-draft" -- "\${cur}") ) ;;
     analytics) COMPREPLY=( $(compgen -W "dashboard summary query funnel timeseries compare sql" -- "\${cur}") ) ;;
+    people) COMPREPLY=( $(compgen -W "list get add set note rm-note follow-up hide unhide" -- "\${cur}") ) ;;
     modules)
       if [[ \${COMP_CWORD} -ge 3 && \${COMP_WORDS[2]} == google_reviews ]]; then
         COMPREPLY=( $(compgen -W "docs request-setup enable disable archive config connect resolve status list-reviews hide show set-stars set-sort set-weight reset-weights write-review-url refresh disconnect" -- "\${cur}") )
-      elif [[ \${COMP_CWORD} -ge 3 && (\${COMP_WORDS[2]} == callbar || \${COMP_WORDS[2]} == forms || \${COMP_WORDS[2]} == booking || \${COMP_WORDS[2]} == signups) ]]; then
+      elif [[ \${COMP_CWORD} -ge 3 && \${COMP_WORDS[2]} == forms ]]; then
+        COMPREPLY=( $(compgen -W "docs request-setup enable disable archive config get set destinations connect-destination remove-destination disconnect-destination attach-destination detach-destination request-destination-setup" -- "\${cur}") )
+      elif [[ \${COMP_CWORD} -ge 3 && (\${COMP_WORDS[2]} == callbar || \${COMP_WORDS[2]} == booking || \${COMP_WORDS[2]} == signups) ]]; then
         COMPREPLY=( $(compgen -W "docs request-setup enable disable archive config get set" -- "\${cur}") )
       elif [[ \${COMP_CWORD} -ge 3 && (\${COMP_WORDS[2]} == payments || \${COMP_WORDS[2]} == shop) ]]; then
         COMPREPLY=( $(compgen -W "docs request-setup enable disable archive config status connect disconnect" -- "\${cur}") )
@@ -61,14 +65,18 @@ _frontpage() {
         runs) _values 'subcommand' current wait cancel retry get ;;
         deploy) _values 'subcommand' wait ;;
         media) _values 'subcommand' list upload ;;
+        images) _values 'subcommand' generate ;;
         fonts) _values 'subcommand' list search ;;
         tokens) _values 'subcommand' set ;;
         seo|settings) _values 'subcommand' get set ;;
         analytics) _values 'subcommand' dashboard summary query funnel timeseries compare sql ;;
+        people) _values 'subcommand' list get add set note rm-note follow-up hide unhide ;;
         modules)
           if [[ $words[2] == google_reviews ]]; then
             _values 'subcommand' docs request-setup enable disable archive config connect resolve status list-reviews hide show set-stars set-sort set-weight reset-weights write-review-url refresh disconnect
-          elif [[ $words[2] == callbar || $words[2] == forms || $words[2] == booking || $words[2] == signups ]]; then
+          elif [[ $words[2] == forms ]]; then
+            _values 'subcommand' docs request-setup enable disable archive config get set destinations connect-destination remove-destination disconnect-destination attach-destination detach-destination request-destination-setup
+          elif [[ $words[2] == callbar || $words[2] == booking || $words[2] == signups ]]; then
             _values 'subcommand' docs request-setup enable disable archive config get set
           elif [[ $words[2] == payments || $words[2] == shop ]]; then
             _values 'subcommand' docs request-setup enable disable archive config status connect disconnect
@@ -95,13 +103,16 @@ export function generateFishCompletion() {
         `complete -c frontpage -n "__fish_seen_subcommand_from runs" -a "current wait cancel retry get"`,
         `complete -c frontpage -n "__fish_seen_subcommand_from deploy" -a "wait"`,
         `complete -c frontpage -n "__fish_seen_subcommand_from media" -a "list upload"`,
+        `complete -c frontpage -n "__fish_seen_subcommand_from images" -a "generate"`,
         `complete -c frontpage -n "__fish_seen_subcommand_from fonts" -a "list search"`,
         `complete -c frontpage -n "__fish_seen_subcommand_from tokens" -a "set"`,
         `complete -c frontpage -n "__fish_seen_subcommand_from seo settings" -a "get set"`,
         `complete -c frontpage -n "__fish_seen_subcommand_from analytics" -a "dashboard summary query funnel timeseries compare sql"`,
+        `complete -c frontpage -n "__fish_seen_subcommand_from people" -a "list get add set note rm-note follow-up hide unhide"`,
         `complete -c frontpage -n "__fish_seen_subcommand_from modules" -a "list docs request-setup enable disable archive config callbar forms booking signups payments shop ordering articles google_reviews"`,
         `complete -c frontpage -n "__fish_seen_subcommand_from modules; and __fish_seen_subcommand_from google_reviews" -a "connect resolve status list-reviews hide show set-stars set-sort set-weight reset-weights write-review-url refresh disconnect"`,
-        `complete -c frontpage -n "__fish_seen_subcommand_from modules; and __fish_seen_subcommand_from callbar forms booking signups" -a "get set"`,
+        `complete -c frontpage -n "__fish_seen_subcommand_from modules; and __fish_seen_subcommand_from forms" -a "get set destinations connect-destination remove-destination disconnect-destination attach-destination detach-destination request-destination-setup"`,
+        `complete -c frontpage -n "__fish_seen_subcommand_from modules; and __fish_seen_subcommand_from callbar booking signups" -a "get set"`,
         `complete -c frontpage -n "__fish_seen_subcommand_from modules; and __fish_seen_subcommand_from payments shop" -a "status connect disconnect"`,
         `complete -c frontpage -n "__fish_seen_subcommand_from modules; and __fish_seen_subcommand_from ordering" -a "status connect disconnect sync"`,
         `complete -c frontpage -n "__fish_seen_subcommand_from extensions" -a "list docs enable disable config"`,