frontpage-host 0.1.0

package/dist/commands/push.js

@@ -0,0 +1,117 @@
+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, exitCodeForError, v1Put } from "../http/client.js";
+import { readState, writeState } from "../state/frontpage-state.js";
+const TEXT_EXTS = new Set([
+    ".astro",
+    ".ts",
+    ".tsx",
+    ".js",
+    ".jsx",
+    ".mjs",
+    ".cjs",
+    ".css",
+    ".scss",
+    ".md",
+    ".mdx",
+    ".json",
+    ".svg",
+    ".html",
+    ".txt",
+    ".yml",
+    ".yaml",
+    ".toml",
+]);
+const ROOTS = ["src", "public", "content"];
+async function walkAllowlisted(cwd) {
+    const out = [];
+    async function walk(abs) {
+        let entries;
+        try {
+            entries = await readdir(abs, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const ent of entries) {
+            const child = join(abs, ent.name);
+            if (ent.isDirectory()) {
+                if (ent.name === "node_modules" || ent.name === ".git" || ent.name === ".frontpage")
+                    continue;
+                await walk(child);
+            }
+            else if (ent.isFile()) {
+                const rel = relative(cwd, child).split(sep).join("/");
+                if (ROOTS.some((r) => rel === r || rel.startsWith(`${r}/`)))
+                    out.push(rel);
+            }
+        }
+    }
+    for (const root of ROOTS)
+        await walk(join(cwd, root));
+    return out.sort();
+}
+function isTextPath(repoPath) {
+    const i = repoPath.lastIndexOf(".");
+    if (i < 0)
+        return true;
+    return TEXT_EXTS.has(repoPath.slice(i).toLowerCase());
+}
+export async function runPush(args) {
+    try {
+        const { slug, rest } = await resolveSlug(args);
+        const messageIdx = rest.indexOf("--message");
+        const message = messageIdx >= 0
+            ? rest[messageIdx + 1]
+            : rest.find((a) => a.startsWith("--message="))?.slice("--message=".length);
+        const cwd = process.cwd();
+        const state = await readState(cwd);
+        if (!state.baseCommitSha) {
+            console.error("No baseCommitSha in .frontpage/state.json. Run: frontpage pull");
+            return EXIT_USAGE;
+        }
+        const paths = await walkAllowlisted(cwd);
+        if (paths.length === 0) {
+            console.error("No allowlisted files (src/, public/, content/) found in this folder.");
+            return EXIT_USAGE;
+        }
+        const files = [];
+        for (const path of paths) {
+            const abs = join(cwd, path);
+            const st = await stat(abs);
+            if (!st.isFile())
+                continue;
+            if (isTextPath(path)) {
+                const content = await readFile(abs, "utf8");
+                files.push({ path, encoding: "utf-8", content });
+            }
+            else {
+                const buf = await readFile(abs);
+                files.push({ path, encoding: "base64", content: buf.toString("base64") });
+            }
+        }
+        const data = await v1Put(`/api/v1/sites/${encodeURIComponent(slug)}/files`, {
+            baseCommitSha: state.baseCommitSha,
+            expectedHeadSha: state.baseCommitSha,
+            message: message || undefined,
+            files,
+        });
+        if (data.commitSha) {
+            await writeState({ ...state, slug, baseCommitSha: data.commitSha }, cwd);
+        }
+        if (!data.changed) {
+            console.log("Nothing to commit (remote already matches).");
+            return EXIT_OK;
+        }
+        console.log(`Pushed ${data.filesChanged.length} file(s) → ${data.commitSha}`);
+        console.log("Updated .frontpage/state.json baseCommitSha");
+        console.log("Note: module markup may auto-activate modules (same as the editor agent).");
+        console.log("tokens.ts may be auto-repaired at commit if it would break the build.");
+        return EXIT_OK;
+    }
+    catch (err) {
+        console.error(err instanceof Error ? err.message : String(err));
+        return exitCodeForError(err);
+    }
+}

package/dist/commands/revert.d.ts

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

package/dist/commands/revert.js

@@ -0,0 +1,27 @@
+import { resolveSlug } from "../site.js";
+import { EXIT_OK, EXIT_USAGE, exitCodeForError, v1Post } from "../http/client.js";
+export async function runRevert(args) {
+    try {
+        const { slug, rest } = await resolveSlug(args);
+        const target = rest.find((a) => !a.startsWith("-"));
+        if (!target || !/^[0-9a-f]{7,40}$/i.test(target)) {
+            console.error("Usage: frontpage revert <commitSha> [--site <slug>]");
+            console.error("Pass a full 40-char SHA from `frontpage history`.");
+            return EXIT_USAGE;
+        }
+        if (target.length !== 40) {
+            console.error("targetCommitSha must be a full 40-char hex SHA (not a short SHA).");
+            return EXIT_USAGE;
+        }
+        const data = await v1Post(`/api/v1/sites/${encodeURIComponent(slug)}/revert`, {
+            targetCommitSha: target.toLowerCase(),
+        });
+        console.log(`${data.commitHash.slice(0, 7)}  ${data.message}`);
+        console.log(`restored ${data.targetCommitSha.slice(0, 7)}  (was ${data.previousTipSha.slice(0, 7)})`);
+        return EXIT_OK;
+    }
+    catch (err) {
+        console.error(err instanceof Error ? err.message : String(err));
+        return exitCodeForError(err);
+    }
+}

package/dist/commands/runs.d.ts

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

package/dist/commands/runs.js

@@ -0,0 +1,134 @@
+import { resolveSlug } from "../site.js";
+import { EXIT_OK, EXIT_USAGE, exitCodeForError, v1Get, v1Post } from "../http/client.js";
+const TERMINAL = new Set(["succeeded", "failed", "canceled"]);
+function printRun(run) {
+    const msg = run.statusMessage || run.summary || run.error || "";
+    console.log(`${run.id}  ${run.status}${msg ? `  ${msg}` : ""}`);
+    if (run.commitSha)
+        console.log(`  commit: ${run.commitSha}`);
+}
+export async function runRuns(args) {
+    try {
+        const sub = args[0];
+        if (!sub || sub === "list" || sub.startsWith("--")) {
+            return await listRuns(args[0] === "list" ? args.slice(1) : args);
+        }
+        if (sub === "current")
+            return await listRuns(args.slice(1));
+        if (sub === "wait")
+            return await waitRun(args.slice(1));
+        if (sub === "cancel")
+            return await cancelRun(args.slice(1));
+        if (sub === "retry")
+            return await retryRunCmd(args.slice(1));
+        if (sub === "get")
+            return await getRun(args.slice(1));
+        // `frontpage runs <runId>` → get
+        if (/^[0-9a-f-]{36}$/i.test(sub))
+            return await getRun(args);
+        console.error("Usage: frontpage runs [current|wait|cancel|retry|get] …");
+        return EXIT_USAGE;
+    }
+    catch (err) {
+        console.error(err instanceof Error ? err.message : String(err));
+        return exitCodeForError(err);
+    }
+}
+async function listRuns(args) {
+    const { slug } = await resolveSlug(args);
+    const data = await v1Get(`/api/v1/sites/${encodeURIComponent(slug)}/agent-runs`);
+    if (data.run) {
+        console.log("latest:");
+        printRun(data.run);
+    }
+    else {
+        console.log("latest: (none)");
+    }
+    if (data.active?.length) {
+        console.log(`active (${data.active.length}):`);
+        for (const r of data.active)
+            printRun(r);
+    }
+    if (data.poll?.reply) {
+        const r = data.poll.reply;
+        const detail = r.summary || r.message || r.kind;
+        console.log(`poll: ${r.kind}${detail && detail !== r.kind ? ` — ${detail}` : ""}`);
+    }
+    return EXIT_OK;
+}
+async function getRun(args) {
+    const { slug, rest } = await resolveSlug(args);
+    const runId = rest[0];
+    if (!runId) {
+        console.error("Usage: frontpage runs get <runId> [--site <slug>]");
+        return EXIT_USAGE;
+    }
+    const data = await v1Get(`/api/v1/sites/${encodeURIComponent(slug)}/agent-runs/${encodeURIComponent(runId)}`);
+    printRun(data.run);
+    return EXIT_OK;
+}
+async function waitRun(args) {
+    const { slug, rest } = await resolveSlug(args);
+    let runId = rest[0];
+    const started = Date.now();
+    const maxMs = 30 * 60 * 1000;
+    while (Date.now() - started < maxMs) {
+        if (runId) {
+            const data = await v1Get(`/api/v1/sites/${encodeURIComponent(slug)}/agent-runs/${encodeURIComponent(runId)}`);
+            process.stderr.write(`\r${data.run.status}  ${data.run.statusMessage ?? ""}   `);
+            if (TERMINAL.has(data.run.status)) {
+                process.stderr.write("\n");
+                printRun(data.run);
+                if (data.run.status === "failed")
+                    return EXIT_USAGE;
+                if (data.run.status === "canceled")
+                    return EXIT_USAGE;
+                return EXIT_OK;
+            }
+        }
+        else {
+            const data = await v1Get(`/api/v1/sites/${encodeURIComponent(slug)}/agent-runs`);
+            const current = data.poll?.activeRunId
+                ? data.active.find((r) => r.id === data.poll?.activeRunId) ?? data.run
+                : data.run;
+            if (current) {
+                runId = current.id;
+                process.stderr.write(`\r${current.status}  ${current.statusMessage ?? ""}   `);
+                if (TERMINAL.has(current.status) && !data.poll?.active) {
+                    process.stderr.write("\n");
+                    printRun(current);
+                    return current.status === "succeeded" ? EXIT_OK : EXIT_USAGE;
+                }
+            }
+            else {
+                console.log("No active run.");
+                return EXIT_OK;
+            }
+        }
+        await new Promise((r) => setTimeout(r, 2000));
+    }
+    console.error("Timed out waiting for run.");
+    return EXIT_USAGE;
+}
+async function cancelRun(args) {
+    const { slug, rest } = await resolveSlug(args);
+    const runId = rest[0];
+    if (!runId) {
+        console.error("Usage: frontpage runs cancel <runId> [--site <slug>]");
+        return EXIT_USAGE;
+    }
+    await v1Post(`/api/v1/sites/${encodeURIComponent(slug)}/agent-runs/${encodeURIComponent(runId)}/cancel`);
+    console.log(`Canceled ${runId}`);
+    return EXIT_OK;
+}
+async function retryRunCmd(args) {
+    const { slug, rest } = await resolveSlug(args);
+    const runId = rest[0];
+    if (!runId) {
+        console.error("Usage: frontpage runs retry <runId> [--site <slug>]");
+        return EXIT_USAGE;
+    }
+    const data = await v1Post(`/api/v1/sites/${encodeURIComponent(slug)}/agent-runs/${encodeURIComponent(runId)}/retry`);
+    console.log(data.runId);
+    return EXIT_OK;
+}

package/dist/commands/search.d.ts

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

package/dist/commands/search.js

@@ -0,0 +1,30 @@
+import { resolveSlug } from "../site.js";
+import { EXIT_OK, EXIT_USAGE, exitCodeForError, v1Get } from "../http/client.js";
+export async function runSearch(args) {
+    try {
+        const { slug, rest } = await resolveSlug(args);
+        const pattern = rest[0];
+        if (!pattern) {
+            console.error("Usage: frontpage search <pattern> [--site <slug>]");
+            return EXIT_USAGE;
+        }
+        const q = new URLSearchParams({ pattern });
+        const pathFilter = rest[1];
+        if (pathFilter)
+            q.set("path", pathFilter);
+        const data = await v1Get(`/api/v1/sites/${encodeURIComponent(slug)}/search?${q.toString()}`);
+        const matches = data.matches ?? [];
+        for (const m of matches) {
+            console.log(`${m.file}:${m.lineNumber}: ${m.line}`);
+        }
+        if (matches.length === 0)
+            console.error("(no matches)");
+        if (data.truncated || data.scanTruncated)
+            console.error("# results truncated");
+        return EXIT_OK;
+    }
+    catch (err) {
+        console.error(err instanceof Error ? err.message : String(err));
+        return exitCodeForError(err);
+    }
+}

package/dist/commands/seo.d.ts

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

package/dist/commands/seo.js

@@ -0,0 +1,57 @@
+import { resolveSlug } from "../site.js";
+import { EXIT_OK, EXIT_USAGE, exitCodeForError, v1Get, v1Post } from "../http/client.js";
+function takeFlag(rest, name) {
+    const i = rest.indexOf(name);
+    if (i === -1)
+        return undefined;
+    const v = rest[i + 1];
+    rest.splice(i, 2);
+    return v;
+}
+export async function runSeo(args) {
+    try {
+        const { slug, rest } = await resolveSlug(args);
+        const sub = rest[0];
+        if (!sub || sub === "get") {
+            const pathArgs = rest[0] === "get" ? rest.slice(1) : rest;
+            const path = pathArgs[0] ?? "/";
+            const data = await v1Get(`/api/v1/sites/${encodeURIComponent(slug)}/seo?path=${encodeURIComponent(path)}`);
+            console.log(JSON.stringify(data, null, 2));
+            return EXIT_OK;
+        }
+        if (sub === "set") {
+            const work = rest.slice(1);
+            const path = takeFlag(work, "--path") ?? work.find((a) => a.startsWith("/")) ?? "/";
+            const body = { path };
+            for (const field of [
+                "title",
+                "description",
+                "ogImage",
+                "ogTitle",
+                "ogDescription",
+                "canonical",
+            ]) {
+                const v = takeFlag(work, `--${field}`);
+                if (v !== undefined)
+                    body[field] = v;
+            }
+            const noindex = takeFlag(work, "--noindex");
+            if (noindex !== undefined) {
+                body.noindex = noindex === "true" || noindex === "1";
+            }
+            if (Object.keys(body).length <= 1) {
+                console.error("Usage: frontpage seo set --path / [--title …] [--description …] [--ogImage …] [--noindex true|false]");
+                return EXIT_USAGE;
+            }
+            const data = await v1Post(`/api/v1/sites/${encodeURIComponent(slug)}/seo`, body);
+            console.log(JSON.stringify(data, null, 2));
+            return EXIT_OK;
+        }
+        console.error("Usage: frontpage seo get|set … [--site <slug>]");
+        return EXIT_USAGE;
+    }
+    catch (err) {
+        console.error(err instanceof Error ? err.message : String(err));
+        return exitCodeForError(err);
+    }
+}

package/dist/commands/settings.d.ts

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

package/dist/commands/settings.js

@@ -0,0 +1,65 @@
+import { resolveSlug } from "../site.js";
+import { EXIT_OK, EXIT_USAGE, exitCodeForError, v1Get, v1Patch } from "../http/client.js";
+function takeFlag(rest, name) {
+    const i = rest.indexOf(name);
+    if (i === -1)
+        return undefined;
+    const v = rest[i + 1];
+    rest.splice(i, 2);
+    return v;
+}
+export async function runSettings(args) {
+    try {
+        const { slug, rest } = await resolveSlug(args);
+        const sub = rest[0] ?? "get";
+        if (sub === "get") {
+            const data = await v1Get(`/api/v1/sites/${encodeURIComponent(slug)}/settings`);
+            console.log(JSON.stringify(data, null, 2));
+            return EXIT_OK;
+        }
+        if (sub === "set") {
+            const work = rest.slice(1);
+            const body = {};
+            const subdomainPublic = takeFlag(work, "--subdomain-public");
+            if (subdomainPublic !== undefined) {
+                body.subdomainPublic = subdomainPublic === "true" || subdomainPublic === "1";
+            }
+            const usageAlerts = takeFlag(work, "--usage-alerts");
+            if (usageAlerts !== undefined) {
+                body.notificationPrefs = {
+                    usageAlerts: usageAlerts === "true" || usageAlerts === "1",
+                };
+            }
+            const buildModel = takeFlag(work, "--build-model");
+            if (buildModel !== undefined)
+                body.buildModel = buildModel;
+            const brandName = takeFlag(work, "--brand-name");
+            const brandLogo = takeFlag(work, "--brand-logo");
+            if (work.includes("--brand-reset")) {
+                body.brand = null;
+                const i = work.indexOf("--brand-reset");
+                if (i !== -1)
+                    work.splice(i, 1);
+            }
+            else if (brandName !== undefined || brandLogo !== undefined) {
+                body.brand = {
+                    ...(brandName !== undefined ? { name: brandName } : {}),
+                    ...(brandLogo !== undefined ? { logo: brandLogo } : {}),
+                };
+            }
+            if (Object.keys(body).length === 0) {
+                console.error("Usage: frontpage settings set [--subdomain-public true|false] [--usage-alerts true|false] [--build-model …] [--brand-name …] [--brand-logo …] [--brand-reset]");
+                return EXIT_USAGE;
+            }
+            const data = await v1Patch(`/api/v1/sites/${encodeURIComponent(slug)}/settings`, body);
+            console.log(JSON.stringify(data, null, 2));
+            return EXIT_OK;
+        }
+        console.error("Usage: frontpage settings get|set … [--site <slug>]");
+        return EXIT_USAGE;
+    }
+    catch (err) {
+        console.error(err instanceof Error ? err.message : String(err));
+        return exitCodeForError(err);
+    }
+}

package/dist/commands/sites.d.ts

@@ -0,0 +1 @@
+export declare function runSites(): Promise<number>;

package/dist/commands/sites.js

@@ -0,0 +1,20 @@
+import { EXIT_OK, exitCodeForError, v1Get } from "../http/client.js";
+export async function runSites() {
+    try {
+        const data = await v1Get("/api/v1/sites");
+        if (data.sites.length === 0) {
+            console.log("No sites. Create a site in Frontpage first.");
+            return EXIT_OK;
+        }
+        console.log("Use the subdomain with `frontpage use <subdomain>` (not a custom domain).\n");
+        for (const s of data.sites) {
+            const label = s.customDomain ? `${s.name} · ${s.customDomain}` : s.name;
+            console.log(`${s.subdomain.padEnd(28)} ${s.role.padEnd(8)} ${label}`);
+        }
+        return EXIT_OK;
+    }
+    catch (err) {
+        console.error(err instanceof Error ? err.message : String(err));
+        return exitCodeForError(err);
+    }
+}

package/dist/commands/status.d.ts

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

package/dist/commands/status.js

@@ -0,0 +1,35 @@
+import { resolveSlug } from "../site.js";
+import { EXIT_OK, exitCodeForError, v1Get, apiBase } from "../http/client.js";
+import { readState } from "../state/frontpage-state.js";
+export async function runStatus(args) {
+    try {
+        const { slug } = await resolveSlug(args);
+        const state = await readState();
+        const [data, runs] = await Promise.all([
+            v1Get(`/api/v1/sites/${encodeURIComponent(slug)}/files`),
+            v1Get(`/api/v1/sites/${encodeURIComponent(slug)}/agent-runs`).catch(() => ({
+                active: [],
+            })),
+        ]);
+        console.log(`API base:       ${apiBase()}`);
+        console.log(`Site:           ${slug}`);
+        console.log(`Local state:    ${state.slug ?? "(none)"}${state.baseCommitSha ? ` @ ${state.baseCommitSha.slice(0, 7)}` : ""}`);
+        console.log(`Remote tip:     ${data.baseCommitSha ?? "(unknown)"}`);
+        console.log(`Remote files:   ${data.files.length}`);
+        if (runs.active?.length) {
+            console.log(`Active runs:    ${runs.active.map((r) => `${r.status}:${r.id.slice(0, 8)}`).join(", ")}`);
+            console.log("Note: do not push while an agent run is active");
+        }
+        else {
+            console.log("Active runs:    none");
+        }
+        if (state.baseCommitSha && data.baseCommitSha && state.baseCommitSha !== data.baseCommitSha) {
+            console.log("Note: remote tip differs from last pull — run frontpage pull");
+        }
+        return EXIT_OK;
+    }
+    catch (err) {
+        console.error(err instanceof Error ? err.message : String(err));
+        return exitCodeForError(err);
+    }
+}

package/dist/commands/usage.d.ts

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

package/dist/commands/usage.js

@@ -0,0 +1,14 @@
+import { resolveSlug } from "../site.js";
+import { EXIT_OK, exitCodeForError, v1Get } from "../http/client.js";
+export async function runUsage(args) {
+    try {
+        const { slug } = await resolveSlug(args);
+        const data = await v1Get(`/api/v1/sites/${encodeURIComponent(slug)}/usage`);
+        console.log(JSON.stringify(data.usage, null, 2));
+        return EXIT_OK;
+    }
+    catch (err) {
+        console.error(err instanceof Error ? err.message : String(err));
+        return exitCodeForError(err);
+    }
+}

package/dist/commands/use.d.ts

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

package/dist/commands/use.js

@@ -0,0 +1,25 @@
+import { assertSubdomainSlug, readState, writeState } from "../state/frontpage-state.js";
+import { EXIT_OK, EXIT_USAGE } from "../http/client.js";
+export async function runUse(args) {
+    const raw = args[0];
+    if (!raw) {
+        console.error("Usage: frontpage use <subdomain>   (alias: frontpage link <subdomain>)");
+        return EXIT_USAGE;
+    }
+    try {
+        const slug = assertSubdomainSlug(raw);
+        const prev = await readState();
+        // Switching sites must drop the previous tip — a stale baseCommitSha would poison status/CAS.
+        const next = prev.slug === slug
+            ? { ...prev, slug }
+            : { slug };
+        await writeState(next);
+        console.log(`Using site subdomain: ${slug}`);
+        console.log("Wrote .frontpage/state.json");
+        return EXIT_OK;
+    }
+    catch (err) {
+        console.error(err instanceof Error ? err.message : String(err));
+        return EXIT_USAGE;
+    }
+}

package/dist/commands/whoami.d.ts

@@ -0,0 +1 @@
+export declare function runWhoami(): Promise<number>;

package/dist/commands/whoami.js

@@ -0,0 +1,14 @@
+import { EXIT_OK, exitCodeForError, v1Get } from "../http/client.js";
+export async function runWhoami() {
+    try {
+        const me = await v1Get("/api/v1/me");
+        console.log(`email:  ${me.email ?? "(none)"}`);
+        console.log(`userId: ${me.userId}`);
+        console.log(`keyId:  ${me.keyId}`);
+        return EXIT_OK;
+    }
+    catch (err) {
+        console.error(err instanceof Error ? err.message : String(err));
+        return exitCodeForError(err);
+    }
+}

package/dist/completions/generate.d.ts

@@ -0,0 +1,4 @@
+export declare function generateBashCompletion(): string;
+export declare function generateZshCompletion(): string;
+export declare function generateFishCompletion(): string;
+export declare function generateCompletion(shell: string): string | null;

package/dist/completions/generate.js

@@ -0,0 +1,82 @@
+/**
+ * Shell completion scripts generated from the command registry.
+ */
+import { COMMANDS } from "../registry.js";
+const NAMES = COMMANDS.map((c) => c.name).join(" ");
+export function generateBashCompletion() {
+    return `# frontpage bash completion — eval "$(frontpage completion bash)"
+_frontpage_completions() {
+  local cur="\${COMP_WORDS[COMP_CWORD]}"
+  local cmds="${NAMES}"
+  if [[ \${COMP_CWORD} -eq 1 ]]; then
+    COMPREPLY=( $(compgen -W "\${cmds}" -- "\${cur}") )
+    return
+  fi
+  local cmd="\${COMP_WORDS[1]}"
+  case "\${cmd}" in
+    help) COMPREPLY=( $(compgen -W "\${cmds} auth sync agent content history exit-codes" -- "\${cur}") ) ;;
+    completion) COMPREPLY=( $(compgen -W "bash zsh fish" -- "\${cur}") ) ;;
+    runs) COMPREPLY=( $(compgen -W "current wait cancel retry get" -- "\${cur}") ) ;;
+    deploy) COMPREPLY=( $(compgen -W "wait" -- "\${cur}") ) ;;
+    media) COMPREPLY=( $(compgen -W "list upload" -- "\${cur}") ) ;;
+    seo|settings) COMPREPLY=( $(compgen -W "get set" -- "\${cur}") ) ;;
+    articles) COMPREPLY=( $(compgen -W "list content create-section create-article set-draft" -- "\${cur}") ) ;;
+    modules|extensions) COMPREPLY=( $(compgen -W "list enable disable config" -- "\${cur}") ) ;;
+    *) COMPREPLY=( $(compgen -W "--site --help" -- "\${cur}") ) ;;
+  esac
+}
+complete -F _frontpage_completions frontpage
+`;
+}
+export function generateZshCompletion() {
+    const describe = COMMANDS.map((c) => `'${c.name}:${c.summary.replace(/'/g, "'\\''")}'`).join(" ");
+    return `# frontpage zsh completion — eval "$(frontpage completion zsh)"
+#compdef frontpage
+_frontpage() {
+  local -a cmds
+  cmds=(${describe})
+  _arguments '1:command:->cmds' '*::arg:->args'
+  case $state in
+    cmds) _describe 'command' cmds ;;
+    args)
+      case $words[1] in
+        completion) _values 'shell' bash zsh fish ;;
+        runs) _values 'subcommand' current wait cancel retry get ;;
+        deploy) _values 'subcommand' wait ;;
+        media) _values 'subcommand' list upload ;;
+        seo|settings) _values 'subcommand' get set ;;
+        modules|extensions) _values 'subcommand' list enable disable config ;;
+      esac
+      ;;
+  esac
+}
+compdef _frontpage frontpage
+`;
+}
+export function generateFishCompletion() {
+    const lines = [
+        `# frontpage fish completion — frontpage completion fish | source`,
+        `complete -c frontpage -f`,
+        ...COMMANDS.map((c) => `complete -c frontpage -n "__fish_use_subcommand" -a "${c.name}" -d "${c.summary.replace(/"/g, '\\"')}"`),
+        `complete -c frontpage -n "__fish_seen_subcommand_from completion" -a "bash zsh fish"`,
+        `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 seo settings" -a "get set"`,
+        `complete -c frontpage -n "__fish_seen_subcommand_from modules extensions" -a "list enable disable config"`,
+        `complete -c frontpage -l site -d "Site subdomain slug"`,
+    ];
+    return `${lines.join("\n")}\n`;
+}
+export function generateCompletion(shell) {
+    switch (shell) {
+        case "bash":
+            return generateBashCompletion();
+        case "zsh":
+            return generateZshCompletion();
+        case "fish":
+            return generateFishCompletion();
+        default:
+            return null;
+    }
+}