@aicopycoders/exodus 2026.6.2400

package/dist/commands/template.js

@@ -0,0 +1,225 @@
+import { apiGet, apiPost, apiPostDashboard, getDashboardUrl } from "../lib/client.js";
+import { formatError } from "../lib/format.js";
+import { AD_TYPES, AD_TYPE_NAMES, REPTILE_TRIGGERS, } from "../lib/template-constants.js";
+export const helpText = `
+exodus template — Fernando's Template pipeline (33 AD_TYPES, resume)
+
+Usage:
+  exodus template run --input "<ad brief or numbered ads>" [options]
+  exodus template resume --id <runId>
+  exodus template ad-types
+  exodus template reptile-triggers
+
+Run options:
+  --input "<text>"               Input ads block. One brief, or numbered list
+                                  ("1. ad copy ... 2. ad copy ..."). Required.
+  --mode auto|manual              Generation mode (default: auto)
+  --render-mode images|prompts    Skip render and return prompts only (default: images)
+  --aspect 1:1|9:16               Image aspect ratio (default: 1:1)
+  --model gpt-image-2|nano-banana-pro   Kie.ai model (default: gpt-image-2)
+  --realism off|realistic         Realism enforcement (default: off)
+  --quantities <slug:N,slug:N>    Manual-mode per-type counts (e.g. "testimonial:3,hero:2")
+  --requested-count N             Auto-mode total render target (optional)
+  --no-wait                       (default — no CLI-side polling endpoint yet)
+
+Resume options:
+  --id <runId>                    Template run id to resume (#56 orphan finalization)
+
+Status polling:
+  The Convex HTTP route is POST-only. View live progress at the dashboard URL
+  printed at kickoff (or the dashboard's /creative-suite/template/sessions list).
+
+Examples:
+  exodus template run --input "silver-threaded grounding sheets for inflammation"
+  exodus template run --input "..." --aspect 9:16 --model nano-banana-pro --realism realistic
+  exodus template run --input "..." --mode manual --quantities "testimonial:3,hero:2,ugc:4"
+  exodus template resume --id <runId>
+  exodus template ad-types
+`.trim();
+function dashboardUrlForRun(runId) {
+    return `${getDashboardUrl()}/creative-suite/template/sessions/${runId}`;
+}
+function runAdTypes() {
+    console.log(`AD_TYPES (${AD_TYPES.length} total):`);
+    console.log("");
+    for (const slug of AD_TYPES) {
+        const name = AD_TYPE_NAMES[slug];
+        console.log(`  ${slug.padEnd(28)} ${name}`);
+    }
+}
+function runReptileTriggers() {
+    console.log(`REPTILE_TRIGGERS (${REPTILE_TRIGGERS.length} total):`);
+    console.log("");
+    for (const trigger of REPTILE_TRIGGERS) {
+        console.log(`  ${trigger}`);
+    }
+}
+function parseQuantities(raw) {
+    const out = {};
+    for (const pair of raw.split(",")) {
+        const [slug, nRaw] = pair.split(":").map((s) => s.trim());
+        if (!slug || !nRaw) {
+            throw new Error(`Malformed --quantities entry "${pair}". Use slug:N format.`);
+        }
+        if (!AD_TYPES.includes(slug)) {
+            throw new Error(`Unknown ad type "${slug}" in --quantities. Run \`exodus template ad-types\` for the full list.`);
+        }
+        const n = parseInt(nRaw, 10);
+        if (!Number.isFinite(n) || n <= 0) {
+            throw new Error(`--quantities count for "${slug}" must be a positive integer (got "${nRaw}").`);
+        }
+        out[slug] = n;
+    }
+    return out;
+}
+async function runTemplate(flags) {
+    const input = typeof flags["input"] === "string" ? flags["input"] : undefined;
+    if (!input || input.trim().length < 3) {
+        console.error("Error: template run requires --input \"<text>\" (min 3 chars).");
+        process.exit(1);
+        return;
+    }
+    const mode = typeof flags["mode"] === "string" ? flags["mode"] : "auto";
+    if (mode !== "auto" && mode !== "manual") {
+        console.error(`Error: --mode must be auto | manual (got "${mode}").`);
+        process.exit(1);
+        return;
+    }
+    const renderMode = typeof flags["render-mode"] === "string" ? flags["render-mode"] : "images";
+    if (renderMode !== "images" && renderMode !== "prompts") {
+        console.error(`Error: --render-mode must be images | prompts (got "${renderMode}").`);
+        process.exit(1);
+        return;
+    }
+    const aspect = typeof flags["aspect"] === "string" ? flags["aspect"] : "1:1";
+    if (aspect !== "1:1" && aspect !== "9:16") {
+        console.error(`Error: --aspect must be 1:1 | 9:16 (got "${aspect}").`);
+        process.exit(1);
+        return;
+    }
+    const model = typeof flags["model"] === "string" ? flags["model"] : "gpt-image-2";
+    if (model !== "gpt-image-2" && model !== "nano-banana-pro") {
+        console.error(`Error: --model must be gpt-image-2 | nano-banana-pro (got "${model}").`);
+        process.exit(1);
+        return;
+    }
+    const realism = typeof flags["realism"] === "string" ? flags["realism"] : "off";
+    if (realism !== "off" && realism !== "realistic") {
+        console.error(`Error: --realism must be off | realistic (got "${realism}").`);
+        process.exit(1);
+        return;
+    }
+    let manualQuantities;
+    if (typeof flags["quantities"] === "string") {
+        try {
+            manualQuantities = parseQuantities(flags["quantities"]);
+        }
+        catch (e) {
+            console.error(`Error: ${e instanceof Error ? e.message : String(e)}`);
+            process.exit(1);
+            return;
+        }
+    }
+    if (mode === "manual" && !manualQuantities) {
+        console.error("Error: --mode manual requires --quantities \"slug:N,slug:N\".");
+        process.exit(1);
+        return;
+    }
+    const requestedRaw = flags["requested-count"];
+    const requestedImageCount = typeof requestedRaw === "string" ? parseInt(requestedRaw, 10) : undefined;
+    if (requestedImageCount !== undefined && (!Number.isFinite(requestedImageCount) || requestedImageCount <= 0)) {
+        console.error(`Error: --requested-count must be a positive integer.`);
+        process.exit(1);
+        return;
+    }
+    const who = await apiGet("/api/v2/whoami");
+    if (!who.ok || !who.data.userId || !who.data.workspaceId) {
+        console.error("Error: whoami failed. Check EXODUS_API_KEY and EXODUS_API_URL/CONVEX_SITE_URL.");
+        console.error(formatError(who));
+        process.exit(1);
+        return;
+    }
+    const body = {
+        workspaceId: who.data.workspaceId,
+        submittedBy: who.data.userId,
+        mode,
+        renderMode,
+        inputAds: input,
+        aspectRatio: aspect,
+        model,
+        realismMode: realism,
+        ...(requestedImageCount !== undefined ? { requestedImageCount } : {}),
+        ...(manualQuantities ? { manualQuantities } : {}),
+    };
+    console.log(`Template run: brand=${who.data.workspaceSlug ?? who.data.workspaceId}, mode=${mode}, ` +
+        `aspect=${aspect}, model=${model}, realism=${realism}, render=${renderMode}`);
+    const res = await apiPost("/api/creative-suite-template/run", body);
+    if (!res.ok) {
+        console.error(formatError(res));
+        process.exit(1);
+        return;
+    }
+    const { runId, triggerRunId } = res.data;
+    console.log("");
+    console.log(`✓ Template run started`);
+    console.log(`  runId:        ${runId}`);
+    if (triggerRunId)
+        console.log(`  triggerRunId: ${triggerRunId}`);
+    console.log(`  dashboard:    ${dashboardUrlForRun(runId)}`);
+    console.log("");
+    console.log("Status updates render live in the dashboard (no CLI status endpoint yet).");
+}
+async function runResume(flags) {
+    const runId = typeof flags["id"] === "string" ? flags["id"] : undefined;
+    if (!runId) {
+        console.error("Error: template resume requires --id <runId>.");
+        process.exit(1);
+        return;
+    }
+    const res = await apiPostDashboard(`/api/creative-suite-template/runs/${encodeURIComponent(runId)}/resume`, {});
+    if (!res.ok) {
+        console.error(formatError(res));
+        process.exit(1);
+        return;
+    }
+    const { resumeCandidateCount, triggerRunId } = res.data;
+    console.log("");
+    console.log(`✓ Resume enqueued`);
+    console.log(`  runId:                ${runId}`);
+    if (resumeCandidateCount !== undefined) {
+        console.log(`  resumeCandidateCount: ${resumeCandidateCount}`);
+    }
+    if (triggerRunId)
+        console.log(`  triggerRunId:         ${triggerRunId}`);
+    console.log(`  dashboard:            ${dashboardUrlForRun(runId)}`);
+}
+export async function run(flags) {
+    const sub = process.argv[3] ?? "";
+    if (sub === "ad-types") {
+        runAdTypes();
+        return;
+    }
+    if (sub === "reptile-triggers") {
+        runReptileTriggers();
+        return;
+    }
+    if (sub === "resume") {
+        await runResume(flags);
+        return;
+    }
+    if (sub === "run") {
+        await runTemplate(flags);
+        return;
+    }
+    if (!sub || sub.startsWith("--")) {
+        console.error("Error: template requires a subcommand (run | resume | ad-types | reptile-triggers).");
+        console.error("");
+        console.error(helpText);
+        process.exit(1);
+        return;
+    }
+    console.error(`Error: unknown template subcommand "${sub}".`);
+    console.error("");
+    console.error(helpText);
+    process.exit(1);
+}

package/dist/commands/whoami.d.ts

@@ -0,0 +1,2 @@
+export declare const helpText: string;
+export declare function run(): Promise<void>;

package/dist/commands/whoami.js

@@ -0,0 +1,51 @@
+import { apiGet, getApiUrl } from "../lib/client.js";
+import { resolveActiveBrand } from "../lib/layout.js";
+import { auth401Hint } from "../lib/backend-hint.js";
+export const helpText = `
+exodus whoami — show identity and brand context for the current API key
+
+Usage:
+  exodus whoami
+
+Reads EXODUS_API_KEY from your .env (or env var) and asks the dashboard which
+workspace this key is bound to. Prints:
+  • Brand (workspace slug + name)
+  • User email + role
+  • Whether the brand has full Genesis foundation knowledge filled in
+
+Run this BEFORE any pipeline command to confirm you're pointed at the right
+brand. If "foundation: NOT READY" appears, ask an admin to complete the
+brand's foundation at /settings?tab=brands&brand=<slug>.
+`.trim();
+export async function run() {
+    const res = await apiGet("/api/v2/whoami");
+    if (!res.ok) {
+        if (res.status === 401 || res.status === 403) {
+            console.error(auth401Hint(getApiUrl()));
+        }
+        else {
+            const message = res.data?.error ??
+                `whoami failed (HTTP ${res.status})`;
+            console.error(message);
+        }
+        process.exit(1);
+    }
+    const d = res.data;
+    const ready = d.foundationReady ? "READY" : "NOT READY";
+    const missing = d.foundationMissing.length
+        ? `\n  missing:    ${d.foundationMissing.join(", ")}`
+        : "";
+    const resolved = resolveActiveBrand();
+    const sourceNote = resolved.source === "folder" ? " (brand folder)" : "";
+    const activeLine = resolved.slug
+        ? `\nactive:     ${resolved.slug}${sourceNote}${resolved.slug !== d.workspaceSlug ? "  ← X-Active-Brand override" : ""}`
+        : d.userRole === "admin"
+            ? `\nactive:     (key default)`
+            : "";
+    console.log(`
+brand:      ${d.workspaceName ?? "—"} (${d.workspaceSlug ?? "—"})
+user:       ${d.userEmail ?? "—"} (${d.userRole ?? "—"})
+key:        ${d.keyPrefix ?? "—"}${activeLine}
+foundation: ${ready}${missing}
+`.trim());
+}

package/dist/lib/ad-library-write.d.ts

@@ -0,0 +1,15 @@
+export interface SwipeWriteResult {
+    dispatched: Array<{
+        url: string;
+        key: string;
+        runId: string;
+    }>;
+    bankedFailed: string[];
+}
+export declare function captureSwipeAndWrite(urls: string[], opts: {
+    awarenessLevel: string;
+    variantCount?: number;
+    steering?: string;
+}, rt?: {
+    cc?: string;
+}): Promise<SwipeWriteResult>;

package/dist/lib/ad-library-write.js

@@ -0,0 +1,67 @@
+import { apiGet, apiPost } from "./client.js";
+import { formatError } from "./format.js";
+function normalizeUrl(u) {
+    return u.trim().replace(/\/+$/, "").toLowerCase();
+}
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+async function listAdLibrary() {
+    const res = await apiGet("/api/v2/idea-bank?source=ad-library&limit=200");
+    if (!res.ok)
+        return [];
+    return Array.isArray(res.data.ideas) ? res.data.ideas : [];
+}
+export async function captureSwipeAndWrite(urls, opts, rt = {}) {
+    const wanted = urls.map((u) => u.trim()).filter(Boolean);
+    if (wanted.length === 0)
+        return { dispatched: [], bankedFailed: [] };
+    const wantedNorm = new Map(wanted.map((u) => [normalizeUrl(u), u]));
+    const before = new Set((await listAdLibrary()).map((r) => r.key).filter(Boolean));
+    const ideate = await apiPost("/api/v2/idea-bank/ideate", { source: "ad-library", urls: wanted }, { ccCommand: rt.cc });
+    if (!ideate.ok) {
+        console.log(formatError(ideate));
+        process.exit(1);
+    }
+    const TIMEOUT_MS = 5 * 60 * 1000;
+    const INTERVAL_MS = 4_000;
+    const start = Date.now();
+    const found = new Map();
+    process.stdout.write(`  scraping ${wanted.length} ad${wanted.length === 1 ? "" : "s"} into ideas`);
+    while (found.size < wantedNorm.size && Date.now() - start < TIMEOUT_MS) {
+        await sleep(INTERVAL_MS);
+        process.stdout.write(".");
+        for (const row of await listAdLibrary()) {
+            if (!row.key || before.has(row.key) || found.has(normalizeUrl(row.sourceRef ?? "")))
+                continue;
+            const ref = row.sourceRef ? normalizeUrl(row.sourceRef) : "";
+            if (ref && wantedNorm.has(ref))
+                found.set(ref, row.key);
+        }
+    }
+    process.stdout.write("\n");
+    const bankedFailed = [...wantedNorm.entries()]
+        .filter(([norm]) => !found.has(norm))
+        .map(([, original]) => original);
+    if (found.size === 0)
+        return { dispatched: [], bankedFailed };
+    const keys = [...found.values()];
+    const steering = opts.steering?.trim();
+    if (steering) {
+        for (const key of keys) {
+            const noted = await apiPost("/api/v2/idea-bank/notes", { key, notes: steering }, { ccCommand: rt.cc });
+            if (!noted.ok)
+                console.error(`  (couldn't attach steering to ${key}: ${formatError(noted)})`);
+        }
+    }
+    const dispatch = await apiPost("/api/v2/idea-bank/dispatch", { keys, awarenessLevel: opts.awarenessLevel, variantCount: opts.variantCount }, { ccCommand: rt.cc });
+    if (!dispatch.ok) {
+        console.log(formatError(dispatch));
+        process.exit(1);
+    }
+    const keyToUrl = new Map([...found.entries()].map(([norm, key]) => [key, wantedNorm.get(norm)]));
+    const dispatched = (dispatch.data.dispatched ?? []).map((d) => ({
+        url: keyToUrl.get(d.key) ?? "",
+        key: d.key,
+        runId: d.runId,
+    }));
+    return { dispatched, bankedFailed };
+}

package/dist/lib/assets.d.ts

@@ -0,0 +1,3 @@
+export declare function assetsRoot(override?: string): string;
+export declare function skillsDir(override?: string): string;
+export declare function referencesDir(override?: string): string;

package/dist/lib/assets.js

@@ -0,0 +1,23 @@
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+export function assetsRoot(override) {
+    let dir = override ?? path.dirname(fileURLToPath(import.meta.url));
+    const { root } = path.parse(dir);
+    for (;;) {
+        const candidate = path.join(dir, "assets");
+        if (fs.existsSync(candidate))
+            return candidate;
+        if (dir === root) {
+            throw new Error(`bundled assets not found (searched up from ${override ?? "module dir"}). ` +
+                `Run \`npm run bundle-assets\` in dev, or reinstall the package.`);
+        }
+        dir = path.dirname(dir);
+    }
+}
+export function skillsDir(override) {
+    return path.join(assetsRoot(override), "skills");
+}
+export function referencesDir(override) {
+    return path.join(assetsRoot(override), "references");
+}

package/dist/lib/backend-hint.d.ts

@@ -0,0 +1,2 @@
+export declare function isPlaceholderApiUrl(apiUrl: string): boolean;
+export declare function auth401Hint(apiUrl: string): string;

package/dist/lib/backend-hint.js

@@ -0,0 +1,22 @@
+const PROD_BACKEND = "accomplished-tapir-106";
+const DEV_BACKEND = "good-cod-360";
+const PLACEHOLDER_MARK = "YOUR-EXODUS-BACKEND";
+export function isPlaceholderApiUrl(apiUrl) {
+    return !apiUrl || apiUrl.includes(PLACEHOLDER_MARK);
+}
+export function auth401Hint(apiUrl) {
+    let host = apiUrl || "(no EXODUS_API_URL set)";
+    try {
+        host = new URL(apiUrl).host;
+    }
+    catch {
+    }
+    return [
+        `This API key was rejected by ${host} (HTTP 401).`,
+        `Keys are environment-bound — this key may belong to the other environment.`,
+        `Set EXODUS_API_URL in your .env to match the dashboard you signed up on:`,
+        `  • xo.copycoders.ai      → EXODUS_API_URL=https://${PROD_BACKEND}.convex.site`,
+        `  • dev.xo.copycoders.ai  → EXODUS_API_URL=https://${DEV_BACKEND}.convex.site`,
+        `Then re-run \`node exodus/dist/bin/exodus.js whoami\`.`,
+    ].join("\n");
+}

package/dist/lib/cc-command.d.ts

@@ -0,0 +1 @@
+export declare function formatCcCommand(argv: string[]): string;

package/dist/lib/cc-command.js

@@ -0,0 +1,13 @@
+export function formatCcCommand(argv) {
+    const [cmd, ...rest] = argv;
+    if (!cmd)
+        return "";
+    const parts = rest.map((arg) => {
+        if (arg.startsWith("--"))
+            return arg;
+        if (/\s/.test(arg))
+            return `"${arg.replace(/"/g, '\\"')}"`;
+        return arg;
+    });
+    return `/${cmd}${parts.length ? " " + parts.join(" ") : ""}`;
+}

package/dist/lib/client.d.ts

@@ -0,0 +1,23 @@
+export interface ApiResponse<T> {
+    ok: boolean;
+    status: number;
+    data: T;
+}
+export declare function getApiUrl(): string;
+export declare function apiGet<T>(path: string, opts?: {
+    skipActiveBrand?: boolean;
+    activeBrandOverride?: string;
+}): Promise<ApiResponse<T>>;
+export declare function apiPost<T>(path: string, body: unknown, opts?: {
+    ccCommand?: string;
+}): Promise<ApiResponse<T>>;
+export declare function resolveDashboardUrl(opts: {
+    override?: string;
+    apiUrl?: string;
+}): string;
+export declare function getDashboardUrl(): string;
+export declare function apiGetDashboard<T>(path: string, opts?: {
+    timeoutMs?: number;
+    activeBrandOverride?: string;
+}): Promise<ApiResponse<T>>;
+export declare function apiPostDashboard<T>(path: string, body: unknown): Promise<ApiResponse<T>>;

package/dist/lib/client.js

@@ -0,0 +1,213 @@
+import fs from "node:fs";
+import path from "node:path";
+import { resolveActiveBrand } from "./layout.js";
+let cachedConfig = null;
+function parseEnvFile(content) {
+    const result = {};
+    for (const line of content.split("\n")) {
+        const trimmed = line.trim();
+        if (!trimmed || trimmed.startsWith("#"))
+            continue;
+        const eqIdx = trimmed.indexOf("=");
+        if (eqIdx === -1)
+            continue;
+        const key = trimmed.slice(0, eqIdx).trim();
+        let value = trimmed.slice(eqIdx + 1).trim();
+        if ((value.startsWith('"') && value.endsWith('"')) ||
+            (value.startsWith("'") && value.endsWith("'"))) {
+            value = value.slice(1, -1);
+        }
+        result[key] = value;
+    }
+    return result;
+}
+function loadConfig() {
+    let dir = process.cwd();
+    for (let i = 0; i < 8; i++) {
+        const envPath = path.join(dir, ".env");
+        if (fs.existsSync(envPath)) {
+            const content = fs.readFileSync(envPath, "utf-8");
+            const vars = parseEnvFile(content);
+            const apiUrl = vars["EXODUS_API_URL"] ??
+                vars["CONVEX_SITE_URL"] ??
+                process.env["EXODUS_API_URL"] ??
+                process.env["CONVEX_SITE_URL"] ??
+                "";
+            const apiKey = vars["EXODUS_API_KEY"] ??
+                vars["VAD_API_KEY"] ??
+                process.env["EXODUS_API_KEY"] ??
+                process.env["VAD_API_KEY"] ??
+                "";
+            if (apiUrl) {
+                return { apiUrl: apiUrl.replace(/\/$/, ""), apiKey };
+            }
+        }
+        const parent = path.dirname(dir);
+        if (parent === dir)
+            break;
+        dir = parent;
+    }
+    const apiUrl = process.env["EXODUS_API_URL"] ??
+        process.env["CONVEX_SITE_URL"] ??
+        "";
+    const apiKey = process.env["EXODUS_API_KEY"] ??
+        process.env["VAD_API_KEY"] ??
+        "";
+    return { apiUrl: apiUrl.replace(/\/$/, ""), apiKey };
+}
+function getConfig() {
+    if (!cachedConfig) {
+        cachedConfig = loadConfig();
+    }
+    return cachedConfig;
+}
+export function getApiUrl() {
+    return getConfig().apiUrl;
+}
+function buildHeaders(apiKey, ccCommand, opts) {
+    const headers = {
+        "Content-Type": "application/json",
+    };
+    if (apiKey) {
+        headers["Authorization"] = `Bearer ${apiKey}`;
+    }
+    if (!opts?.skipActiveBrand) {
+        const activeBrand = opts?.activeBrandOverride ?? resolveActiveBrand().slug;
+        if (activeBrand) {
+            headers["X-Active-Brand"] = activeBrand;
+        }
+    }
+    if (ccCommand) {
+        const sanitized = ccCommand
+            .replace(/[\r\n\t]+/g, " ")
+            .replace(/[^\x20-\x7e]/g, "")
+            .slice(0, 500);
+        if (sanitized)
+            headers["X-CC-Command"] = sanitized;
+    }
+    return headers;
+}
+export async function apiGet(path, opts) {
+    const { apiUrl, apiKey } = getConfig();
+    const url = `${apiUrl}${path}`;
+    const res = await fetch(url, {
+        method: "GET",
+        headers: buildHeaders(apiKey, undefined, opts),
+    });
+    const text = await res.text();
+    let data;
+    try {
+        data = JSON.parse(text);
+    }
+    catch {
+        const snippet = text.replace(/\s+/g, " ").trim().slice(0, 300);
+        data = {
+            error: `Non-JSON ${res.status} from ${path}: ${snippet}`,
+            httpStatus: res.status,
+        };
+    }
+    return { ok: res.ok, status: res.status, data: data };
+}
+export async function apiPost(path, body, opts) {
+    const { apiUrl, apiKey } = getConfig();
+    const url = `${apiUrl}${path}`;
+    const res = await fetch(url, {
+        method: "POST",
+        headers: buildHeaders(apiKey, opts?.ccCommand),
+        body: JSON.stringify(body),
+    });
+    const text = await res.text();
+    let data;
+    try {
+        data = JSON.parse(text);
+    }
+    catch {
+        const snippet = text.replace(/\s+/g, " ").trim().slice(0, 300);
+        data = {
+            error: `Non-JSON ${res.status} from ${path}: ${snippet}`,
+            httpStatus: res.status,
+        };
+    }
+    return { ok: res.ok, status: res.status, data: data };
+}
+const DEV_BACKEND_DASHBOARDS = [
+    { match: "good-cod-360", dashboard: "https://dev.xo.copycoders.ai" },
+];
+const PROD_DASHBOARD = "https://xo.copycoders.ai";
+export function resolveDashboardUrl(opts) {
+    if (opts.override)
+        return opts.override.replace(/\/$/, "");
+    const api = opts.apiUrl ?? "";
+    for (const { match, dashboard } of DEV_BACKEND_DASHBOARDS) {
+        if (api.includes(match))
+            return dashboard;
+    }
+    return PROD_DASHBOARD;
+}
+export function getDashboardUrl() {
+    return resolveDashboardUrl({
+        override: process.env["EXODUS_DASHBOARD_URL"],
+        apiUrl: getConfig().apiUrl,
+    });
+}
+export async function apiGetDashboard(path, opts) {
+    const { apiKey } = getConfig();
+    const url = `${getDashboardUrl()}${path}`;
+    const headers = buildHeaders(apiKey, undefined, {
+        activeBrandOverride: opts?.activeBrandOverride,
+    });
+    const controller = opts?.timeoutMs ? new AbortController() : undefined;
+    const timer = controller
+        ? setTimeout(() => controller.abort(), opts.timeoutMs)
+        : undefined;
+    let res;
+    try {
+        res = await fetch(url, {
+            method: "GET",
+            headers,
+            signal: controller?.signal,
+        });
+    }
+    finally {
+        if (timer)
+            clearTimeout(timer);
+    }
+    const text = await res.text();
+    let data;
+    try {
+        data = JSON.parse(text);
+    }
+    catch {
+        const snippet = text.replace(/\s+/g, " ").trim().slice(0, 300);
+        data = {
+            error: `Non-JSON ${res.status} from ${path}: ${snippet}`,
+            httpStatus: res.status,
+            contentType: res.headers.get("content-type") ?? undefined,
+        };
+    }
+    return { ok: res.ok, status: res.status, data: data };
+}
+export async function apiPostDashboard(path, body) {
+    const { apiKey } = getConfig();
+    const url = `${getDashboardUrl()}${path}`;
+    const headers = buildHeaders(apiKey);
+    const res = await fetch(url, {
+        method: "POST",
+        headers,
+        body: JSON.stringify(body),
+    });
+    const text = await res.text();
+    let data;
+    try {
+        data = JSON.parse(text);
+    }
+    catch {
+        const snippet = text.replace(/\s+/g, " ").trim().slice(0, 300);
+        data = {
+            error: `Non-JSON ${res.status} from ${path}: ${snippet}`,
+            httpStatus: res.status,
+            contentType: res.headers.get("content-type") ?? undefined,
+        };
+    }
+    return { ok: res.ok, status: res.status, data: data };
+}

package/dist/lib/format.d.ts

@@ -0,0 +1,8 @@
+export declare function formatGeneration(data: Record<string, unknown>): string;
+export declare function formatGenesisRun(data: Record<string, unknown>): string;
+export declare function formatBrowse(generations: unknown[]): string;
+export declare function formatError(res: {
+    ok: boolean;
+    status: number;
+    data: unknown;
+}): string;