frontpage-host 0.1.0

package/dist/auth/keychain.d.ts

@@ -0,0 +1,5 @@
+export declare function getApiKey(): Promise<string | null>;
+export declare function setApiKey(secret: string): Promise<void>;
+export declare function clearApiKey(): Promise<void>;
+/** Never print the full key — used by doctor / help hygiene. */
+export declare function maskKey(secret: string): string;

package/dist/auth/keychain.js

@@ -0,0 +1,85 @@
+/**
+ * Store / load API keys. Prefers FRONTPAGE_API_KEY, then OS keychain via `security` (macOS)
+ * or a restrictive file under ~/.config/frontpage (other platforms).
+ */
+import { execFile } from "node:child_process";
+import { chmod, mkdir, readFile, unlink, writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { promisify } from "node:util";
+const execFileAsync = promisify(execFile);
+const SERVICE = "frontpage-cli";
+const ACCOUNT = "api-key";
+function filePath() {
+    return join(homedir(), ".config", "frontpage", "api-key");
+}
+export async function getApiKey() {
+    const fromEnv = process.env.FRONTPAGE_API_KEY?.trim();
+    if (fromEnv)
+        return fromEnv;
+    if (process.platform === "darwin") {
+        try {
+            const { stdout } = await execFileAsync("security", [
+                "find-generic-password",
+                "-s",
+                SERVICE,
+                "-a",
+                ACCOUNT,
+                "-w",
+            ]);
+            const key = stdout.trim();
+            return key || null;
+        }
+        catch {
+            // fall through to file
+        }
+    }
+    try {
+        const raw = (await readFile(filePath(), "utf8")).trim();
+        return raw || null;
+    }
+    catch {
+        return null;
+    }
+}
+export async function setApiKey(secret) {
+    const trimmed = secret.trim();
+    if (!trimmed)
+        throw new Error("API key is empty.");
+    if (process.platform === "darwin") {
+        try {
+            await execFileAsync("security", ["delete-generic-password", "-s", SERVICE, "-a", ACCOUNT]).catch(() => { });
+            await execFileAsync("security", [
+                "add-generic-password",
+                "-s",
+                SERVICE,
+                "-a",
+                ACCOUNT,
+                "-w",
+                trimmed,
+                "-U",
+            ]);
+            return;
+        }
+        catch {
+            // fall through to file
+        }
+    }
+    const dir = join(homedir(), ".config", "frontpage");
+    await mkdir(dir, { recursive: true, mode: 0o700 });
+    const path = filePath();
+    await writeFile(path, trimmed, { encoding: "utf8", mode: 0o600 });
+    await chmod(path, 0o600);
+}
+export async function clearApiKey() {
+    if (process.platform === "darwin") {
+        await execFileAsync("security", ["delete-generic-password", "-s", SERVICE, "-a", ACCOUNT]).catch(() => { });
+    }
+    await unlink(filePath()).catch(() => { });
+}
+/** Never print the full key — used by doctor / help hygiene. */
+export function maskKey(secret) {
+    if (secret.length <= 12)
+        return "****";
+    return `${secret.slice(0, 11)}…${secret.slice(-4)}`;
+}

package/dist/bin.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/bin.js

@@ -0,0 +1,124 @@
+#!/usr/bin/env node
+import { runHelp } from "./commands/help.js";
+import { runLogin } from "./commands/login.js";
+import { runLogout } from "./commands/logout.js";
+import { runWhoami } from "./commands/whoami.js";
+import { runSites } from "./commands/sites.js";
+import { runUse } from "./commands/use.js";
+import { runDoctor } from "./commands/doctor.js";
+import { runPull } from "./commands/pull.js";
+import { runPush } from "./commands/push.js";
+import { runDiff } from "./commands/diff.js";
+import { runLs } from "./commands/ls.js";
+import { runCat } from "./commands/cat.js";
+import { runSearch } from "./commands/search.js";
+import { runStatus } from "./commands/status.js";
+import { runOpen } from "./commands/open.js";
+import { runPrompt } from "./commands/prompt.js";
+import { runRuns } from "./commands/runs.js";
+import { runPublish, runUnpublish } from "./commands/publish.js";
+import { runDeploy } from "./commands/deploy.js";
+import { runUsage } from "./commands/usage.js";
+import { runAnalytics } from "./commands/analytics.js";
+import { runPages } from "./commands/pages.js";
+import { runModules } from "./commands/modules.js";
+import { runExtensions } from "./commands/extensions.js";
+import { runMedia } from "./commands/media.js";
+import { runInbox } from "./commands/inbox.js";
+import { runSeo } from "./commands/seo.js";
+import { runArticles } from "./commands/articles.js";
+import { runSettings } from "./commands/settings.js";
+import { runEdit } from "./commands/edit.js";
+import { runHistory } from "./commands/history.js";
+import { runRevert } from "./commands/revert.js";
+import { runCompletion } from "./commands/completion.js";
+import { EXIT_USAGE, EXIT_UNEXPECTED } from "./http/client.js";
+async function main() {
+    const argv = process.argv.slice(2);
+    const cmd = argv[0];
+    const args = argv.slice(1);
+    if (!cmd || cmd === "help" || cmd === "--help" || cmd === "-h") {
+        return runHelp(cmd === "help" ? args : []);
+    }
+    switch (cmd) {
+        case "login":
+            return runLogin(args);
+        case "logout":
+            return runLogout();
+        case "whoami":
+            return runWhoami();
+        case "sites":
+            return runSites();
+        case "use":
+        case "link":
+            return runUse(args);
+        case "doctor":
+            return runDoctor();
+        case "pull":
+            return runPull(args);
+        case "push":
+            return runPush(args);
+        case "diff":
+            return runDiff(args);
+        case "ls":
+            return runLs(args);
+        case "cat":
+            return runCat(args);
+        case "search":
+            return runSearch(args);
+        case "status":
+            return runStatus(args);
+        case "open":
+            return runOpen(args);
+        case "prompt":
+            return runPrompt(args);
+        case "runs":
+            return runRuns(args);
+        case "publish":
+            return runPublish(args);
+        case "unpublish":
+            return runUnpublish(args);
+        case "deploy":
+            return runDeploy(args);
+        case "usage":
+            return runUsage(args);
+        case "analytics":
+            return runAnalytics(args);
+        case "pages":
+            return runPages(args);
+        case "modules":
+            return runModules(args);
+        case "extensions":
+            return runExtensions(args);
+        case "media":
+            return runMedia(args);
+        case "inbox":
+            return runInbox(args);
+        case "seo":
+            return runSeo(args);
+        case "articles":
+            return runArticles(args);
+        case "settings":
+            return runSettings(args);
+        case "edit":
+            return runEdit(args);
+        case "history":
+            return runHistory(args);
+        case "revert":
+            return runRevert(args);
+        case "completion":
+            return runCompletion(args);
+        default:
+            console.error(`Unknown command: ${cmd}`);
+            console.error("Run: frontpage help");
+            return EXIT_USAGE;
+    }
+}
+main()
+    .then((code) => {
+    process.exitCode = code;
+})
+    .catch((err) => {
+    console.error(err instanceof Error ? err.message : String(err));
+    process.exitCode = EXIT_UNEXPECTED;
+});

package/dist/commands/analytics.d.ts

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

package/dist/commands/analytics.js

@@ -0,0 +1,18 @@
+import { resolveSlug } from "../site.js";
+import { EXIT_OK, exitCodeForError, v1Get } from "../http/client.js";
+export async function runAnalytics(args) {
+    try {
+        const { slug, rest } = await resolveSlug(args);
+        let days = "7";
+        const daysIdx = rest.indexOf("--days");
+        if (daysIdx >= 0 && rest[daysIdx + 1])
+            days = rest[daysIdx + 1];
+        const data = await v1Get(`/api/v1/sites/${encodeURIComponent(slug)}/analytics?days=${encodeURIComponent(days)}`);
+        console.log(JSON.stringify(data.dashboard, null, 2));
+        return EXIT_OK;
+    }
+    catch (err) {
+        console.error(err instanceof Error ? err.message : String(err));
+        return exitCodeForError(err);
+    }
+}

package/dist/commands/articles.d.ts

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

package/dist/commands/articles.js

@@ -0,0 +1,111 @@
+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;
+}
+async function postOp(slug, op, extra) {
+    return v1Post(`/api/v1/sites/${encodeURIComponent(slug)}/articles`, {
+        op,
+        ...extra,
+    });
+}
+export async function runArticles(args) {
+    try {
+        const { slug, rest } = await resolveSlug(args);
+        const sub = rest[0] ?? "list";
+        if (sub === "list" || sub === "ls") {
+            const data = await v1Get(`/api/v1/sites/${encodeURIComponent(slug)}/articles`);
+            console.log(JSON.stringify(data, null, 2));
+            return EXIT_OK;
+        }
+        if (sub === "content") {
+            const action = rest[1];
+            const work = rest.slice(2);
+            const section = takeFlag(work, "--section") ?? work[0];
+            const articleSlug = takeFlag(work, "--article") ?? takeFlag(work, "--slug") ?? work[1];
+            if (!section || !articleSlug) {
+                console.error("Usage: frontpage articles content get|set --section <sec> --article <slug> …");
+                return EXIT_USAGE;
+            }
+            if (action === "get") {
+                const data = await v1Get(`/api/v1/sites/${encodeURIComponent(slug)}/articles/content?section=${encodeURIComponent(section)}&articleSlug=${encodeURIComponent(articleSlug)}`);
+                console.log(JSON.stringify(data, null, 2));
+                return EXIT_OK;
+            }
+            if (action === "set") {
+                const body = takeFlag(work, "--body");
+                const baseCommitSha = takeFlag(work, "--base");
+                if (body === undefined || !baseCommitSha) {
+                    console.error("Usage: frontpage articles content set --section … --article … --body … --base <sha>");
+                    return EXIT_USAGE;
+                }
+                const data = await v1Post(`/api/v1/sites/${encodeURIComponent(slug)}/articles/content`, { section, articleSlug, body, baseCommitSha });
+                console.log(JSON.stringify(data, null, 2));
+                return EXIT_OK;
+            }
+            console.error("Usage: frontpage articles content get|set …");
+            return EXIT_USAGE;
+        }
+        const work = rest.slice(1);
+        const opMap = {
+            "create-section": "create-section",
+            "config-section": "config-section",
+            "archive-section": "archive-section",
+            "restore-section": "restore-section",
+            "create-article": "create-article",
+            "delete-article": "delete-article",
+            "set-draft": "set-article-draft",
+            "set-image": "set-article-image",
+            "set-tags": "set-article-tags",
+            "set-seo": "set-article-seo",
+            "set-meta": "set-article-meta",
+        };
+        const op = opMap[sub];
+        if (!op) {
+            console.error("Usage: frontpage articles list|content|create-section|create-article|set-draft|… [--site <slug>]");
+            return EXIT_USAGE;
+        }
+        const body = {};
+        const section = takeFlag(work, "--section") ?? takeFlag(work, "--instance");
+        if (section) {
+            body.section = section;
+            body.instanceId = section;
+        }
+        for (const [flag, key] of [
+            ["--label", "label"],
+            ["--route", "routePrefix"],
+            ["--title", "title"],
+            ["--article", "articleSlug"],
+            ["--description", "description"],
+            ["--featured-image", "featuredImage"],
+            ["--image-alt", "imageAlt"],
+            ["--seo-title", "seoTitle"],
+            ["--seo-description", "seoDescription"],
+            ["--author", "author"],
+        ]) {
+            const v = takeFlag(work, flag);
+            if (v !== undefined)
+                body[key] = v;
+        }
+        const draft = takeFlag(work, "--draft");
+        if (draft !== undefined)
+            body.draft = draft === "true" || draft === "1";
+        const tags = takeFlag(work, "--tags");
+        if (tags !== undefined)
+            body.tags = tags.split(",").map((t) => t.trim()).filter(Boolean);
+        if (work.includes("--clear-image"))
+            body.clearImage = true;
+        const data = await postOp(slug, op, body);
+        console.log(JSON.stringify(data, null, 2));
+        return EXIT_OK;
+    }
+    catch (err) {
+        console.error(err instanceof Error ? err.message : String(err));
+        return exitCodeForError(err);
+    }
+}

package/dist/commands/cat.d.ts

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

package/dist/commands/cat.js

@@ -0,0 +1,27 @@
+import { resolveSlug } from "../site.js";
+import { EXIT_OK, EXIT_USAGE, exitCodeForError, v1Get } from "../http/client.js";
+export async function runCat(args) {
+    try {
+        const { slug, rest } = await resolveSlug(args);
+        const path = rest[0];
+        if (!path) {
+            console.error("Usage: frontpage cat <path> [--site <slug>]");
+            return EXIT_USAGE;
+        }
+        const encPath = path.split("/").map(encodeURIComponent).join("/");
+        const data = await v1Get(`/api/v1/sites/${encodeURIComponent(slug)}/files/${encPath}`);
+        if (data.file.encoding === "base64") {
+            process.stdout.write(Buffer.from(data.file.content, "base64"));
+        }
+        else {
+            process.stdout.write(data.file.content);
+            if (!data.file.content.endsWith("\n"))
+                process.stdout.write("\n");
+        }
+        return EXIT_OK;
+    }
+    catch (err) {
+        console.error(err instanceof Error ? err.message : String(err));
+        return exitCodeForError(err);
+    }
+}

package/dist/commands/completion.d.ts

@@ -0,0 +1 @@
+export declare function runCompletion(args: string[]): number;

package/dist/commands/completion.js

@@ -0,0 +1,19 @@
+import { EXIT_OK, EXIT_USAGE } from "../http/client.js";
+import { generateCompletion } from "../completions/generate.js";
+export function runCompletion(args) {
+    const shell = (args[0] ?? "").trim().toLowerCase();
+    if (!shell || shell === "--help" || shell === "-h") {
+        console.error("Usage: frontpage completion bash|zsh|fish");
+        console.error('  eval "$(frontpage completion bash)"');
+        console.error('  eval "$(frontpage completion zsh)"');
+        console.error("  frontpage completion fish | source");
+        return EXIT_USAGE;
+    }
+    const script = generateCompletion(shell);
+    if (!script) {
+        console.error(`Unknown shell: ${shell}. Use bash, zsh, or fish.`);
+        return EXIT_USAGE;
+    }
+    process.stdout.write(script);
+    return EXIT_OK;
+}

package/dist/commands/deploy.d.ts

@@ -0,0 +1,2 @@
+/** `frontpage deploy wait` — wait until no run is in deploying/queued/running. */
+export declare function runDeploy(args: string[]): Promise<number>;

package/dist/commands/deploy.js

@@ -0,0 +1,32 @@
+import { resolveSlug } from "../site.js";
+import { EXIT_OK, EXIT_USAGE, exitCodeForError, v1Get } from "../http/client.js";
+/** `frontpage deploy wait` — wait until no run is in deploying/queued/running. */
+export async function runDeploy(args) {
+    try {
+        const sub = args[0];
+        if (sub !== "wait") {
+            console.error("Usage: frontpage deploy wait [--site <slug>]");
+            return EXIT_USAGE;
+        }
+        const { slug } = await resolveSlug(args.slice(1));
+        const started = Date.now();
+        const maxMs = 30 * 60 * 1000;
+        while (Date.now() - started < maxMs) {
+            const data = await v1Get(`/api/v1/sites/${encodeURIComponent(slug)}/agent-runs`);
+            const busy = (data.active ?? []).filter((r) => ["queued", "running", "deploying"].includes(r.status));
+            if (busy.length === 0) {
+                console.log(data.run ? `${data.run.id}  ${data.run.status}` : "No active deploy.");
+                return EXIT_OK;
+            }
+            const head = busy.find((r) => r.status === "deploying") ?? busy[0];
+            process.stderr.write(`\r${head.status}  ${head.statusMessage ?? ""}   `);
+            await new Promise((r) => setTimeout(r, 2000));
+        }
+        console.error("Timed out waiting for deploy.");
+        return EXIT_USAGE;
+    }
+    catch (err) {
+        console.error(err instanceof Error ? err.message : String(err));
+        return exitCodeForError(err);
+    }
+}

package/dist/commands/diff.d.ts

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

package/dist/commands/diff.js

@@ -0,0 +1,93 @@
+import { readFile, readdir, stat } from "node:fs/promises";
+import { createHash } from "node:crypto";
+import { join, relative, sep } from "node:path";
+import { resolveSlug } from "../site.js";
+import { EXIT_OK, EXIT_USAGE, exitCodeForError, v1Get } from "../http/client.js";
+const ROOTS = ["src", "public", "content"];
+async function walkLocal(cwd) {
+    const map = new Map();
+    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}/`)))
+                    continue;
+                const buf = await readFile(child);
+                map.set(rel, createHash("sha256").update(buf).digest("hex"));
+            }
+        }
+    }
+    for (const root of ROOTS)
+        await walk(join(cwd, root));
+    return map;
+}
+function remoteHash(file) {
+    const buf = file.encoding === "base64"
+        ? Buffer.from(file.content, "base64")
+        : Buffer.from(file.content, "utf8");
+    return createHash("sha256").update(buf).digest("hex");
+}
+export async function runDiff(args) {
+    try {
+        const { slug } = await resolveSlug(args);
+        const cwd = process.cwd();
+        const local = await walkLocal(cwd);
+        const listing = await v1Get(`/api/v1/sites/${encodeURIComponent(slug)}/files`);
+        const remotePaths = new Set(listing.files.map((f) => f.path));
+        let changed = 0;
+        let onlyLocal = 0;
+        let onlyRemote = 0;
+        for (const path of [...local.keys()].sort()) {
+            if (!remotePaths.has(path)) {
+                console.log(`A  ${path}`);
+                onlyLocal++;
+                continue;
+            }
+            const encPath = path.split("/").map(encodeURIComponent).join("/");
+            const remote = await v1Get(`/api/v1/sites/${encodeURIComponent(slug)}/files/${encPath}`);
+            const rh = remoteHash(remote.file);
+            const lh = local.get(path);
+            if (rh !== lh) {
+                console.log(`M  ${path}`);
+                changed++;
+            }
+        }
+        for (const f of listing.files) {
+            if (!local.has(f.path)) {
+                console.log(`D  ${f.path}`);
+                onlyRemote++;
+            }
+        }
+        const total = changed + onlyLocal + onlyRemote;
+        if (total === 0) {
+            console.log("No differences.");
+        }
+        else {
+            console.error(`# ${total} difference(s) · tip ${(listing.baseCommitSha ?? "").slice(0, 7) || "?"} · A=local-only M=modified D=remote-only`);
+        }
+        // Ensure cwd has the tree (optional UX check)
+        void (await stat(cwd).catch(() => null));
+        return EXIT_OK;
+    }
+    catch (err) {
+        if (err instanceof Error && /No site selected/.test(err.message)) {
+            console.error(err.message);
+            return EXIT_USAGE;
+        }
+        console.error(err instanceof Error ? err.message : String(err));
+        return exitCodeForError(err);
+    }
+}

package/dist/commands/doctor.d.ts

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

package/dist/commands/doctor.js

@@ -0,0 +1,26 @@
+import { getApiKey, maskKey } from "../auth/keychain.js";
+import { apiBase, EXIT_OK, EXIT_AUTH, EXIT_UNEXPECTED, v1Get } from "../http/client.js";
+import { readState } from "../state/frontpage-state.js";
+export async function runDoctor() {
+    console.log(`API base: ${apiBase()}`);
+    const key = await getApiKey();
+    if (!key) {
+        console.error("No API key. Run: frontpage login");
+        return EXIT_AUTH;
+    }
+    console.log(`API key:  ${maskKey(key)} (never prints the full secret)`);
+    const state = await readState();
+    console.log(`Folder site: ${state.slug ?? "(not set — run frontpage use <subdomain>)"}`);
+    try {
+        const me = await v1Get("/api/v1/me");
+        console.log(`whoami:   ok (${me.email ?? me.userId})`);
+        const sites = await v1Get("/api/v1/sites");
+        console.log(`sites:    ok (${sites.sites.length} site(s))`);
+        console.log("doctor:   all checks passed");
+        return EXIT_OK;
+    }
+    catch (err) {
+        console.error(err instanceof Error ? err.message : String(err));
+        return EXIT_UNEXPECTED;
+    }
+}

package/dist/commands/edit.d.ts

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

package/dist/commands/edit.js

@@ -0,0 +1,31 @@
+import { resolveSlug } from "../site.js";
+import { EXIT_OK, EXIT_USAGE, exitCodeForError, 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 runEdit(args) {
+    try {
+        const { slug, rest } = await resolveSlug(args);
+        const work = [...rest];
+        const path = takeFlag(work, "--path") ?? "/";
+        const oldText = takeFlag(work, "--old") ?? takeFlag(work, "--old-text");
+        const newText = takeFlag(work, "--new") ?? takeFlag(work, "--new-text");
+        if (!oldText || !newText) {
+            console.error('Usage: frontpage edit --path / --old "exact text" --new "replacement" [--site <slug>]');
+            return EXIT_USAGE;
+        }
+        const data = await v1Post(`/api/v1/sites/${encodeURIComponent(slug)}/edit`, { path, oldText, newText });
+        console.log(`${data.commitHash.slice(0, 7)}  ${data.sourcePath}`);
+        console.log(data.message);
+        return EXIT_OK;
+    }
+    catch (err) {
+        console.error(err instanceof Error ? err.message : String(err));
+        return exitCodeForError(err);
+    }
+}

package/dist/commands/extensions.d.ts

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