@aicopycoders/exodus 2026.6.2400

package/dist/commands/keys.js

@@ -0,0 +1,101 @@
+import { PROVIDER_ENV_MAP, fetchRemoteKeys, mapKeysToEnvVars, resolveEnvFilePath, upsertEnvVars, } from "../lib/keys-sync.js";
+export const helpText = `
+exodus keys — sync your provider API keys from the dashboard to local .env
+
+You enter your keys once in the dashboard (Settings → Claude Code): your provider
+LLM key (Anthropic or OpenRouter) plus Kie.ai. This command pulls them down
+(decrypted, scoped to you) and writes them into the workspace .env so the local
+manual-Genesis path (the genesis-bots skill calls bots with your provider key)
+and other local tools have them — you never have to edit .env by hand.
+
+Usage:
+  exodus keys status     Show which keys are set in the dashboard vs locally
+  exodus keys pull       Pull your dashboard keys into the workspace .env
+
+Notes:
+  • Uses your EXODUS_API_KEY (.env) to authenticate — run 'exodus whoami' first
+    if you're unsure which account you're on.
+  • Values are never printed. Only key names and statuses are shown.
+  • 'pull' preserves every other line in your .env and only upserts the keys.
+`.trim();
+const PROVIDER_LABEL = {
+    genesis: "Genesis",
+    anthropic: "Anthropic",
+    openrouter: "OpenRouter",
+    elevenlabs: "ElevenLabs",
+    kie: "Kie.ai",
+};
+async function status() {
+    let remote;
+    try {
+        remote = await fetchRemoteKeys();
+    }
+    catch (e) {
+        console.error(`Could not reach the dashboard: ${e.message}`);
+        process.exit(1);
+        return;
+    }
+    console.log("Pipeline keys\n");
+    const providers = Object.keys(PROVIDER_ENV_MAP);
+    for (const provider of providers) {
+        const inDashboard = provider in remote.keys;
+        const envName = PROVIDER_ENV_MAP[provider];
+        const localSet = !!process.env[envName];
+        const label = (PROVIDER_LABEL[provider] ?? provider).padEnd(11);
+        const dash = inDashboard ? "dashboard ✓" : "dashboard —";
+        const local = localSet ? "local ✓" : "local —";
+        console.log(`  ${label} ${dash}   ${local}   (${envName})`);
+    }
+    if (remote.failed.length) {
+        console.log(`\n⚠ Could not decrypt: ${remote.failed.join(", ")} — re-save in the dashboard.`);
+    }
+    console.log(`\nRun 'exodus keys pull' to write dashboard keys into your .env.`);
+}
+async function pull() {
+    let remote;
+    try {
+        remote = await fetchRemoteKeys();
+    }
+    catch (e) {
+        console.error(`Could not reach the dashboard: ${e.message}`);
+        process.exit(1);
+        return;
+    }
+    const count = Object.keys(remote.keys).length;
+    if (count === 0) {
+        console.log("No keys are set in the dashboard yet. Add them at Settings → Pipeline Keys, then run this again.");
+        if (remote.failed.length) {
+            console.log(`(Could not decrypt: ${remote.failed.join(", ")}.)`);
+        }
+        return;
+    }
+    const { vars, skipped } = mapKeysToEnvVars(remote.keys);
+    const envPath = resolveEnvFilePath();
+    const results = upsertEnvVars(envPath, vars);
+    const added = results.filter((r) => r.action === "added").map((r) => r.name);
+    const updated = results.filter((r) => r.action === "updated").map((r) => r.name);
+    const unchanged = results.filter((r) => r.action === "unchanged").map((r) => r.name);
+    console.log(`Synced ${results.length} key(s) → ${envPath}\n`);
+    if (added.length)
+        console.log(`  added:     ${added.join(", ")}`);
+    if (updated.length)
+        console.log(`  updated:   ${updated.join(", ")}`);
+    if (unchanged.length)
+        console.log(`  unchanged: ${unchanged.join(", ")}`);
+    if (skipped.length) {
+        console.log(`  skipped:   ${skipped.join(", ")} (no known env var mapping)`);
+    }
+    if (remote.failed.length) {
+        console.log(`\n⚠ Could not decrypt: ${remote.failed.join(", ")} — re-save in the dashboard.`);
+    }
+}
+export async function run() {
+    const sub = process.argv.slice(2)[1] ?? "status";
+    if (sub === "pull")
+        return pull();
+    if (sub === "status")
+        return status();
+    console.error(`Unknown 'keys' sub-action: "${sub}"`);
+    console.error("Usage: exodus keys status | exodus keys pull");
+    process.exit(1);
+}

package/dist/commands/meme.d.ts

@@ -0,0 +1,12 @@
+export declare const helpText: string;
+export interface RunFormat {
+    layer: 1 | 2 | 3;
+    name: string;
+    template_id?: string;
+    template_name?: string;
+    box_count?: number;
+    format_id?: string;
+}
+export declare function normalizeFormat(entry: unknown, index: number): RunFormat;
+export declare function normalizeFormats(raw: unknown): RunFormat[];
+export declare function run(flags: Record<string, string | boolean>): Promise<void>;

package/dist/commands/meme.js

@@ -0,0 +1,272 @@
+import { apiPostDashboard, getDashboardUrl } from "../lib/client.js";
+import { formatError } from "../lib/format.js";
+import { readFileSync } from "node:fs";
+export const helpText = `
+exodus meme — Meme generator: brief → recommended formats → one batched run
+
+Usage:
+  exodus meme recommend --brief "<text>" [--avatar "<text>"]
+  exodus meme run --brief "<text>" --formats '<json>' [--avatar "<text>"] [--name "<label>"]
+  exodus meme run --brief "<text>" --formats-file <path> [--avatar "<text>"] [--name "<label>"]
+  exodus meme regenerate --brief "<text>" --layer 1 --template-id <id> --template-name "<name>" --boxes <N> [--id <runId>] [--avatar "<text>"]
+  exodus meme regenerate --brief "<text>" --layer 2|3 --format <formatId> [--hint "<text>"] [--id <runId>] [--avatar "<text>"]
+
+Flow:
+  1. recommend  → { recommendations: [...] } — 15 picks (5 per layer), each with
+                  name, layer, reasoning, ad_angle. Layer 1 = classic Imgflip
+                  templates; layers 2/3 = AI-image formats.
+  2. run        → pass the picked recommendation objects straight into --formats
+                  (a JSON array; both recommendation-shape and run-shape entries
+                  are accepted, 1–50). Returns { runId } — the whole batch renders
+                  server-side via Trigger.dev; closing your session won't kill it.
+  3. poll       → exodus status --id <runId> --type creative
+                  (terminal: complete | partial-error | error)
+  4. regenerate → re-render a single miss using the format fields from the
+                  recommend output. Synchronous; returns the new image URL.
+
+Keys (strict BYOK — checked server-side before anything starts):
+  classic (layer 1) memes need your Imgflip login; AI (layer 2/3) memes need
+  your Kie.ai key; captions always need your LLM key. Run \`npx @aicopycoders/exodus doctor\`.
+
+Examples:
+  exodus meme recommend --brief "grounding sheets reduce inflammation"
+  exodus meme run --brief "grounding sheets reduce inflammation" --formats '[{"layer":2,"name":"Group Chat","format_id":"group-chat"}]'
+  exodus meme regenerate --brief "grounding sheets reduce inflammation" --layer 2 --format group-chat --hint "make the last message land the product" --id <runId>
+`.trim();
+function dashboardUrlForRun(runId) {
+    return `${getDashboardUrl()}/creative-suite/runs/${runId}`;
+}
+function flagString(flags, name) {
+    const v = flags[name];
+    return typeof v === "string" ? v : undefined;
+}
+function flagInt(flags, name) {
+    const v = flags[name];
+    if (typeof v !== "string")
+        return undefined;
+    const n = parseInt(v, 10);
+    return Number.isFinite(n) ? n : undefined;
+}
+function requireString(value, flag) {
+    if (!value) {
+        console.error(`Error: --${flag} is required.`);
+        process.exit(1);
+        throw new Error("unreachable");
+    }
+    return value;
+}
+export function normalizeFormat(entry, index) {
+    if (typeof entry !== "object" || entry === null || Array.isArray(entry)) {
+        throw new Error(`formats[${index}] must be an object.`);
+    }
+    const e = entry;
+    const layer = e["layer"];
+    if (layer !== 1 && layer !== 2 && layer !== 3) {
+        throw new Error(`formats[${index}].layer must be 1, 2, or 3.`);
+    }
+    const name = typeof e["name"] === "string" ? e["name"].trim() : "";
+    if (!name) {
+        throw new Error(`formats[${index}].name is required.`);
+    }
+    if (layer === 1) {
+        const templateId = e["template_id"] ?? e["imgflip_template_id"] ?? e["format_id"];
+        if (templateId === undefined || templateId === null || templateId === "") {
+            throw new Error(`formats[${index}] (layer 1) needs template_id (or imgflip_template_id / format_id from recommend output).`);
+        }
+        const templateName = typeof e["template_name"] === "string" && e["template_name"].trim()
+            ? e["template_name"].trim()
+            : name;
+        const boxRaw = e["box_count"] ?? e["imgflip_box_count"];
+        const boxCount = typeof boxRaw === "number" && Number.isFinite(boxRaw) ? boxRaw : 2;
+        return {
+            layer: 1,
+            name,
+            template_id: String(templateId),
+            template_name: templateName,
+            box_count: boxCount,
+        };
+    }
+    const formatId = typeof e["format_id"] === "string" ? e["format_id"].trim() : "";
+    if (!formatId) {
+        throw new Error(`formats[${index}] (layer ${layer}) needs format_id.`);
+    }
+    return { layer, name, format_id: formatId };
+}
+export function normalizeFormats(raw) {
+    if (!Array.isArray(raw)) {
+        throw new Error("--formats must be a JSON array.");
+    }
+    if (raw.length === 0) {
+        throw new Error("--formats must contain at least one format.");
+    }
+    if (raw.length > 50) {
+        throw new Error(`--formats supports at most 50 formats per run (got ${raw.length}).`);
+    }
+    return raw.map((entry, i) => normalizeFormat(entry, i));
+}
+async function runRecommend(flags) {
+    const brief = requireString(flagString(flags, "brief"), "brief");
+    const avatar = flagString(flags, "avatar");
+    const res = await apiPostDashboard("/api/meme/recommend", {
+        brief,
+        ...(avatar ? { avatar_description: avatar } : {}),
+    });
+    if (!res.ok) {
+        console.error(formatError(res));
+        if (res.status === 400) {
+            console.error("Hint: run `npx @aicopycoders/exodus doctor` to check your keys.");
+        }
+        process.exit(1);
+        return;
+    }
+    console.log(JSON.stringify(res.data, null, 2));
+}
+async function runRun(flags) {
+    const brief = requireString(flagString(flags, "brief"), "brief");
+    const avatar = flagString(flags, "avatar");
+    const name = flagString(flags, "name");
+    const formatsInline = flagString(flags, "formats");
+    const formatsFile = flagString(flags, "formats-file");
+    if (!formatsInline && !formatsFile) {
+        console.error("Error: meme run requires --formats '<json>' or --formats-file <path>.");
+        process.exit(1);
+        return;
+    }
+    let formatsRaw;
+    if (formatsFile) {
+        try {
+            formatsRaw = readFileSync(formatsFile, "utf8");
+        }
+        catch (err) {
+            console.error(`Error: could not read --formats-file "${formatsFile}": ${err instanceof Error ? err.message : err}`);
+            process.exit(1);
+            return;
+        }
+    }
+    else {
+        formatsRaw = formatsInline;
+    }
+    let formats;
+    try {
+        formats = normalizeFormats(JSON.parse(formatsRaw));
+    }
+    catch (err) {
+        if (err instanceof SyntaxError) {
+            console.error("Error: --formats must be valid JSON (an array of format objects).");
+        }
+        else {
+            console.error(`Error: ${err instanceof Error ? err.message : err}`);
+        }
+        process.exit(1);
+        return;
+    }
+    const classics = formats.filter((f) => f.layer === 1).length;
+    console.log(`Meme run: ${formats.length} format${formats.length === 1 ? "" : "s"} (${classics} classic, ${formats.length - classics} AI)`);
+    const res = await apiPostDashboard("/api/meme/run", {
+        brief,
+        ...(avatar ? { avatar_description: avatar } : {}),
+        ...(name ? { name } : {}),
+        formats,
+    });
+    if (!res.ok) {
+        console.error(formatError(res));
+        if (res.status === 400) {
+            console.error("Hint: run `npx @aicopycoders/exodus doctor` to check your keys.");
+        }
+        process.exit(1);
+        return;
+    }
+    console.log("");
+    console.log(`✓ Meme run started`);
+    console.log(`  runId:        ${res.data.runId}`);
+    if (res.data.triggerRunId)
+        console.log(`  triggerRunId: ${res.data.triggerRunId}`);
+    console.log(`  memes:        ${formats.length} queued`);
+    console.log(`  dashboard:    ${dashboardUrlForRun(res.data.runId)}`);
+    console.log("");
+    console.log(`Poll: exodus status --id ${res.data.runId} --type creative`);
+    console.log("(The batch renders server-side — closing this session won't kill it.)");
+}
+async function runRegenerate(flags) {
+    const brief = requireString(flagString(flags, "brief"), "brief");
+    const layer = flagInt(flags, "layer");
+    if (layer !== 1 && layer !== 2 && layer !== 3) {
+        console.error("Error: meme regenerate requires --layer 1|2|3.");
+        process.exit(1);
+        return;
+    }
+    const avatar = flagString(flags, "avatar");
+    const runId = flagString(flags, "id");
+    let body;
+    if (layer === 1) {
+        const templateId = requireString(flagString(flags, "template-id"), "template-id");
+        const templateName = requireString(flagString(flags, "template-name"), "template-name");
+        const boxes = flagInt(flags, "boxes");
+        if (boxes === undefined || boxes < 1 || boxes > 10) {
+            console.error("Error: --boxes <N> is required for layer 1 (1–10).");
+            process.exit(1);
+            return;
+        }
+        body = {
+            layer: 1,
+            brief,
+            template_id: templateId,
+            template_name: templateName,
+            box_count: boxes,
+            ...(avatar ? { avatar_description: avatar } : {}),
+            ...(runId ? { runId } : {}),
+        };
+    }
+    else {
+        const formatId = requireString(flagString(flags, "format"), "format");
+        const hint = flagString(flags, "hint");
+        body = {
+            layer,
+            brief,
+            format_id: formatId,
+            ...(hint ? { userHint: hint } : {}),
+            ...(avatar ? { avatar_description: avatar } : {}),
+            ...(runId ? { runId } : {}),
+        };
+    }
+    const res = await apiPostDashboard("/api/meme/regenerate", body);
+    if (!res.ok) {
+        console.error(formatError(res));
+        if (res.status === 400) {
+            console.error("Hint: run `npx @aicopycoders/exodus doctor` to check your keys.");
+        }
+        process.exit(1);
+        return;
+    }
+    if (res.data.image_url) {
+        console.log(`✓ Meme regenerated`);
+        console.log(`  image: ${res.data.image_url}`);
+        if (runId)
+            console.log(`  dashboard: ${dashboardUrlForRun(runId)}`);
+    }
+    else {
+        console.log(JSON.stringify(res.data, null, 2));
+    }
+}
+const SUBCOMMANDS = {
+    recommend: runRecommend,
+    run: runRun,
+    regenerate: runRegenerate,
+};
+export async function run(flags) {
+    const sub = process.argv[3] ?? "";
+    const handler = SUBCOMMANDS[sub];
+    if (!handler) {
+        if (sub && !sub.startsWith("--")) {
+            console.error(`Error: unknown meme subcommand "${sub}".`);
+        }
+        else {
+            console.error("Error: meme requires a subcommand (recommend | run | regenerate).");
+        }
+        console.error("");
+        console.error(helpText);
+        process.exit(1);
+        return;
+    }
+    await handler(flags);
+}

package/dist/commands/migrate.d.ts

@@ -0,0 +1,3 @@
+export declare const helpText: string;
+export declare function findMergeConflicts(src: string, dest: string): string[];
+export declare function run(flags: Record<string, string | boolean>): Promise<void>;

package/dist/commands/migrate.js

@@ -0,0 +1,158 @@
+import fs from "node:fs";
+import path from "node:path";
+import { execSync } from "node:child_process";
+import { apiGet, apiGetDashboard } from "../lib/client.js";
+import { getActiveBrand, setLayoutVersion, findWorkspaceRoot } from "../lib/state.js";
+import { detectLayout, brandDirFor, ensureBrandDir, BRAND_MARKER_FILE, } from "../lib/layout.js";
+export const helpText = `
+exodus migrate — convert a single-brand install to the multi-brand layout
+
+Usage:
+  exodus migrate
+
+What it does (one-time, opt-in — updates never force this):
+  1. Figures out which brand this install belongs to (your active brand,
+     falling back to the key's bound brand).
+  2. Creates a subfolder for it and MOVES your brand-specific files in:
+     state/  and  output/  →  <brand>/state/  and  <brand>/output/
+  3. Marks the install as multi-brand. From then on, \`npx @aicopycoders/exodus@latest init\`
+     creates a subfolder for every brand you own, and running a command
+     from inside a brand's folder targets that brand automatically.
+
+Shared files (.env, exodus/, .claude/skills/, references/) stay where they
+are. Safe to re-run: an already-migrated install exits immediately. Your
+state/ files are backed up under .backup/ before anything moves.
+
+Already on the multi-brand layout (fresh installs after the redesign)?
+You don't need this command.
+`.trim();
+function fail(msg, code = 1) {
+    console.error(`exodus migrate: ${msg}`);
+    process.exit(code);
+}
+function ts() {
+    const d = new Date();
+    const pad = (n) => String(n).padStart(2, "0");
+    return `${d.getFullYear()}${pad(d.getMonth() + 1)}${pad(d.getDate())}-${pad(d.getHours())}${pad(d.getMinutes())}${pad(d.getSeconds())}`;
+}
+export function findMergeConflicts(src, dest) {
+    if (!fs.existsSync(src) || !fs.existsSync(dest))
+        return [];
+    const conflicts = [];
+    const walk = (rel) => {
+        const srcFull = path.join(src, rel);
+        for (const entry of fs.readdirSync(srcFull, { withFileTypes: true })) {
+            const childRel = path.join(rel, entry.name);
+            const destFull = path.join(dest, childRel);
+            if (entry.isDirectory()) {
+                if (fs.existsSync(destFull))
+                    walk(childRel);
+            }
+            else if (entry.isFile() && fs.existsSync(destFull)) {
+                try {
+                    const a = fs.readFileSync(path.join(src, childRel));
+                    const b = fs.readFileSync(destFull);
+                    if (!a.equals(b))
+                        conflicts.push(childRel);
+                }
+                catch {
+                    conflicts.push(childRel);
+                }
+            }
+        }
+    };
+    walk("");
+    return conflicts;
+}
+function moveDir(src, dest) {
+    if (!fs.existsSync(src))
+        return;
+    if (!fs.existsSync(dest)) {
+        fs.mkdirSync(path.dirname(dest), { recursive: true });
+        try {
+            fs.renameSync(src, dest);
+            return;
+        }
+        catch {
+        }
+        execSync(`cp -R "${src}" "${dest}"`);
+        fs.rmSync(src, { recursive: true, force: true });
+        return;
+    }
+    execSync(`cp -R "${src}/." "${dest}/"`);
+    fs.rmSync(src, { recursive: true, force: true });
+}
+async function resolveBrand() {
+    let slug = getActiveBrand();
+    let name = null;
+    if (!slug) {
+        const res = await apiGet("/api/v2/whoami");
+        if (res.ok && res.data?.workspaceSlug) {
+            slug = res.data.workspaceSlug;
+            name = res.data.workspaceName ?? null;
+        }
+    }
+    if (!slug) {
+        fail("could not determine which brand this install belongs to.\n" +
+            "  Run `npx @aicopycoders/exodus brand use <slug>` first (or check your network/.env), then re-run `npx @aicopycoders/exodus migrate`.");
+    }
+    if (!name) {
+        try {
+            const res = await apiGetDashboard("/api/brands/mine", {
+                timeoutMs: 10_000,
+            });
+            if (res.ok) {
+                name = res.data?.brands?.find((b) => b.slug === slug)?.name ?? null;
+            }
+        }
+        catch {
+        }
+    }
+    return { slug, name: name ?? slug };
+}
+export async function run(flags) {
+    void flags;
+    const root = findWorkspaceRoot();
+    if (detectLayout(root) === "v2") {
+        console.log("✓ Already on the multi-brand layout — nothing to migrate.");
+        console.log("  Run `npx @aicopycoders/exodus@latest init` to sync brand folders.");
+        return;
+    }
+    const brand = await resolveBrand();
+    const brandDir = brandDirFor(root, brand.slug);
+    const brandDirRel = path.relative(root, brandDir) || brandDir;
+    const conflicts = [
+        ...findMergeConflicts(path.join(root, "state"), path.join(brandDir, "state")).map((f) => path.join("state", f)),
+        ...findMergeConflicts(path.join(root, "output"), path.join(brandDir, "output")).map((f) => path.join("output", f)),
+    ];
+    if (conflicts.length > 0) {
+        fail(`"${brandDirRel}/" already contains different versions of:\n` +
+            conflicts.map((f) => `    ${f}`).join("\n") +
+            "\n  Reconcile or remove them, then re-run `npx @aicopycoders/exodus migrate`. Nothing was changed.");
+    }
+    console.log(`Migrating this install to the multi-brand layout...`);
+    console.log(`  brand: ${brand.slug} (${brand.name})`);
+    const stateSrc = path.join(root, "state");
+    if (fs.existsSync(stateSrc)) {
+        const backupRoot = path.join(root, ".backup", `${ts()}-migrate`);
+        fs.mkdirSync(backupRoot, { recursive: true });
+        execSync(`cp -R "${stateSrc}" "${path.join(backupRoot, "state")}"`);
+        console.log(`  backup: ${path.relative(root, backupRoot)}/state/`);
+    }
+    moveDir(path.join(root, "state"), path.join(brandDir, "state"));
+    moveDir(path.join(root, "output"), path.join(brandDir, "output"));
+    ensureBrandDir(root, brand);
+    setLayoutVersion(2);
+    console.log(`
+✓ Migrated. New structure:
+    ${brandDirRel}/${path.basename(BRAND_MARKER_FILE)}   (brand marker)
+    ${brandDirRel}/state/    ${brandDirRel}/output/
+
+  Shared files (.env, exodus/, .claude/skills/, references/) did not move.
+
+Next steps:
+  • Run \`npx @aicopycoders/exodus@latest init\` to pull folders for your other brands.
+  • Run commands from inside ${brandDirRel}/ to target it automatically,
+    or keep using \`npx @aicopycoders/exodus brand use <slug>\` from anywhere.
+`.trimEnd());
+}

package/dist/commands/primer.d.ts

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