@aicopycoders/exodus 2026.6.2400

package/dist/lib/preflight.js

@@ -0,0 +1,56 @@
+import { spawnSync } from "node:child_process";
+import { fetchRemoteKeys, mapKeysToEnvVars, resolveEnvFilePath, upsertEnvVars, } from "./keys-sync.js";
+export function hasBinary(name) {
+    try {
+        const res = spawnSync(name, ["-version"], { stdio: "ignore" });
+        return res.error == null;
+    }
+    catch {
+        return false;
+    }
+}
+export async function syncKeysToEnv() {
+    let remote;
+    try {
+        remote = await fetchRemoteKeys();
+    }
+    catch (e) {
+        return { pulled: [], failed: [], error: e.message };
+    }
+    const { vars } = mapKeysToEnvVars(remote.keys);
+    upsertEnvVars(resolveEnvFilePath(), vars);
+    for (const [name, value] of Object.entries(vars)) {
+        process.env[name] = value;
+    }
+    return { pulled: Object.keys(vars), failed: remote.failed };
+}
+export const PIXAR_REQUIRED_KEYS = [
+    { label: "Genesis", anyOf: ["GENESIS_API_KEY"] },
+    {
+        label: "LLM (Anthropic or OpenRouter)",
+        anyOf: ["ANTHROPIC_API_KEY", "OPENROUTER_API_KEY"],
+    },
+    { label: "ElevenLabs", anyOf: ["ELEVENLABS_API_KEY"] },
+    { label: "Kie.ai", anyOf: ["KIE_API_KEY"] },
+];
+export const PIXAR_MUX_ENV_VARS = ["MUX_TOKEN_ID", "MUX_TOKEN_SECRET"];
+function isSet(env, name) {
+    const v = env[name];
+    return typeof v === "string" && v.trim().length > 0;
+}
+export function missingRequiredKeys(env, required = PIXAR_REQUIRED_KEYS) {
+    return required
+        .filter((r) => !r.anyOf.some((name) => isSet(env, name)))
+        .map((r) => r.label);
+}
+export function missingRequiredEnvVars(env, required = PIXAR_REQUIRED_KEYS) {
+    const out = [];
+    for (const r of required) {
+        if (!r.anyOf.some((name) => isSet(env, name)))
+            out.push(...r.anyOf);
+    }
+    return out;
+}
+export function muxConfigured(env) {
+    return PIXAR_MUX_ENV_VARS.every((name) => isSet(env, name));
+}

package/dist/lib/prompts.d.ts

@@ -0,0 +1,9 @@
+export declare function promptYesNo(question: string, defaultValue?: boolean): Promise<boolean>;
+export interface ChoiceOption {
+    key: string;
+    label: string;
+}
+export declare function promptChoice(question: string, options: ChoiceOption[], defaultKey?: string): Promise<string>;
+export declare function promptMultiline(prompt: string): Promise<string>;
+export declare function openInEditor(initial: string, fileSuffix?: string): string | null;
+export declare function promptText(question: string): Promise<string>;

package/dist/lib/prompts.js

@@ -0,0 +1,99 @@
+import { createInterface } from "node:readline";
+import { spawnSync } from "node:child_process";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+export async function promptYesNo(question, defaultValue = false) {
+    const suffix = defaultValue ? "(Y/n)" : "(y/N)";
+    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    try {
+        const answer = await new Promise((resolve) => {
+            rl.question(`${question} ${suffix} `, resolve);
+        });
+        const trimmed = answer.trim();
+        if (!trimmed)
+            return defaultValue;
+        return /^y(es)?$/i.test(trimmed);
+    }
+    finally {
+        rl.close();
+    }
+}
+export async function promptChoice(question, options, defaultKey) {
+    const keys = options.map((o) => o.key.toLowerCase());
+    const labelLine = options
+        .map((o) => o.key === defaultKey ? `[${o.key.toUpperCase()}] ${o.label}` : `[${o.key}] ${o.label}`)
+        .join("  ");
+    for (;;) {
+        const rl = createInterface({ input: process.stdin, output: process.stdout });
+        const answer = await new Promise((resolve) => {
+            rl.question(`${question}\n${labelLine}\n> `, resolve);
+        });
+        rl.close();
+        const trimmed = answer.trim().toLowerCase();
+        if (!trimmed && defaultKey)
+            return defaultKey;
+        if (keys.includes(trimmed))
+            return trimmed;
+        process.stdout.write(`Please enter one of: ${keys.join(", ")}\n`);
+    }
+}
+export async function promptMultiline(prompt) {
+    process.stdout.write(`${prompt}\n(end with Ctrl-D on its own line)\n`);
+    return await new Promise((resolve, reject) => {
+        let buf = "";
+        process.stdin.setEncoding("utf-8");
+        const onData = (chunk) => {
+            buf += chunk;
+        };
+        const onEnd = () => {
+            cleanup();
+            resolve(buf);
+        };
+        const onError = (err) => {
+            cleanup();
+            reject(err);
+        };
+        const cleanup = () => {
+            process.stdin.off("data", onData);
+            process.stdin.off("end", onEnd);
+            process.stdin.off("error", onError);
+        };
+        process.stdin.on("data", onData);
+        process.stdin.on("end", onEnd);
+        process.stdin.on("error", onError);
+    });
+}
+export function openInEditor(initial, fileSuffix = ".md") {
+    const editor = process.env.EDITOR || process.env.VISUAL || "vi";
+    const dir = fs.mkdtempSync(path.join(os.tmpdir(), "exodus-edit-"));
+    const file = path.join(dir, `edit${fileSuffix}`);
+    try {
+        fs.writeFileSync(file, initial, "utf-8");
+        const result = spawnSync(editor, [file], { stdio: "inherit" });
+        if (result.status !== 0) {
+            return null;
+        }
+        const out = fs.readFileSync(file, "utf-8");
+        return out.replace(/\n+$/, "");
+    }
+    finally {
+        try {
+            fs.rmSync(dir, { recursive: true, force: true });
+        }
+        catch {
+        }
+    }
+}
+export async function promptText(question) {
+    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    try {
+        const answer = await new Promise((resolve) => {
+            rl.question(`${question} `, resolve);
+        });
+        return answer.trim();
+    }
+    finally {
+        rl.close();
+    }
+}

package/dist/lib/reel-write.d.ts

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

package/dist/lib/reel-write.js

@@ -0,0 +1,59 @@
+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 listOrganic() {
+    const res = await apiGet("/api/v2/idea-bank?source=organic&limit=200");
+    if (!res.ok)
+        return [];
+    return Array.isArray(res.data.ideas) ? res.data.ideas : [];
+}
+export async function captureReelAndWrite(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 listOrganic()).map((r) => r.key).filter(Boolean));
+    const ideate = await apiPost("/api/v2/idea-bank/ideate", { source: "organic", 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(`  transcribing ${wanted.length} reel${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 listOrganic()) {
+            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 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/release.d.ts

@@ -0,0 +1,4 @@
+export declare function compareVersions(a: string, b: string): number;
+export declare function readPackageVersion(exodusDir: string): string;
+export declare function readOwnedCommands(exodusDir: string): string[];
+export declare function missingInstalledCommands(exodusDir: string, ownedCommands: string[]): string[];

package/dist/lib/release.js

@@ -0,0 +1,81 @@
+import fs from "node:fs";
+import path from "node:path";
+export function compareVersions(a, b) {
+    const parse = (v) => {
+        const clean = v.replace(/^v/, "");
+        const dash = clean.indexOf("-");
+        const main = dash === -1 ? clean : clean.slice(0, dash);
+        const pre = dash === -1 ? null : clean.slice(dash + 1);
+        return { nums: main.split(".").map((x) => parseInt(x, 10) || 0), pre };
+    };
+    const pa = parse(a);
+    const pb = parse(b);
+    const len = Math.max(pa.nums.length, pb.nums.length);
+    for (let i = 0; i < len; i++) {
+        const av = pa.nums[i] ?? 0;
+        const bv = pb.nums[i] ?? 0;
+        if (av !== bv)
+            return av < bv ? -1 : 1;
+    }
+    if (pa.pre === null && pb.pre === null)
+        return 0;
+    if (pa.pre === null)
+        return 1;
+    if (pb.pre === null)
+        return -1;
+    const sa = pa.pre.split(".");
+    const sb = pb.pre.split(".");
+    const slen = Math.max(sa.length, sb.length);
+    for (let i = 0; i < slen; i++) {
+        const x = sa[i];
+        const y = sb[i];
+        if (x === undefined)
+            return -1;
+        if (y === undefined)
+            return 1;
+        const xn = parseInt(x, 10);
+        const yn = parseInt(y, 10);
+        const bothNumeric = !Number.isNaN(xn) && !Number.isNaN(yn);
+        if (bothNumeric) {
+            if (xn !== yn)
+                return xn < yn ? -1 : 1;
+        }
+        else if (x !== y) {
+            return x < y ? -1 : 1;
+        }
+    }
+    return 0;
+}
+function readJson(filePath) {
+    return JSON.parse(fs.readFileSync(filePath, "utf-8"));
+}
+export function readPackageVersion(exodusDir) {
+    try {
+        return readJson(path.join(exodusDir, "package.json")).version ?? "0.0.0";
+    }
+    catch {
+        return "0.0.0";
+    }
+}
+export function readOwnedCommands(exodusDir) {
+    const out = new Set();
+    for (const tier of ["base", "custom"]) {
+        const p = path.join(exodusDir, `.overlay-${tier}.json`);
+        if (!fs.existsSync(p))
+            continue;
+        try {
+            const m = JSON.parse(fs.readFileSync(p, "utf8"));
+            if (Array.isArray(m.ownedCommands)) {
+                for (const c of m.ownedCommands)
+                    if (typeof c === "string")
+                        out.add(c);
+            }
+        }
+        catch {
+        }
+    }
+    return [...out];
+}
+export function missingInstalledCommands(exodusDir, ownedCommands) {
+    return ownedCommands.filter((c) => !fs.existsSync(path.join(exodusDir, "dist", "commands", `${c}.js`)));
+}

package/dist/lib/scaffold.d.ts

@@ -0,0 +1,8 @@
+export declare const ENV_SCAFFOLD = "# Exodus config \u2014 paste your dashboard .env block below this line.\n# Get it from your Exodus dashboard -> Settings -> Claude Code -> \"Copy .env block\".\n# ONE key covers every brand you own; switch brands with brand subfolders or\n# `npx @aicopycoders/exodus brand use <slug>`, never by editing this file.\n";
+export declare function writeEnvScaffold(root: string): {
+    created: boolean;
+};
+export declare function ensureGitignore(root: string): void;
+export declare function writeSkills(root: string, srcOverride?: string): string[];
+export declare function writeReferences(root: string, srcOverride?: string): void;
+export declare function ensureBaseDirs(root: string): void;

package/dist/lib/scaffold.js

@@ -0,0 +1,67 @@
+import fs from "node:fs";
+import path from "node:path";
+import { skillsDir, referencesDir } from "./assets.js";
+export const ENV_SCAFFOLD = `# Exodus config — paste your dashboard .env block below this line.
+# Get it from your Exodus dashboard -> Settings -> Claude Code -> "Copy .env block".
+# ONE key covers every brand you own; switch brands with brand subfolders or
+# \`npx @aicopycoders/exodus brand use <slug>\`, never by editing this file.
+`;
+export function writeEnvScaffold(root) {
+    const envPath = path.join(root, ".env");
+    if (fs.existsSync(envPath))
+        return { created: false };
+    fs.writeFileSync(envPath, ENV_SCAFFOLD);
+    return { created: true };
+}
+export function ensureGitignore(root) {
+    const giPath = path.join(root, ".gitignore");
+    const lines = fs.existsSync(giPath)
+        ? fs.readFileSync(giPath, "utf8").split("\n")
+        : ["node_modules/", "output/*", "!output/.gitkeep"];
+    if (!lines.some((l) => l.trim() === ".env"))
+        lines.push(".env");
+    fs.writeFileSync(giPath, lines.join("\n").replace(/\n+$/, "") + "\n");
+}
+export function writeSkills(root, srcOverride) {
+    const src = skillsDir(srcOverride);
+    const dest = path.join(root, ".claude", "skills");
+    fs.mkdirSync(dest, { recursive: true });
+    const names = [];
+    for (const entry of fs.readdirSync(src, { withFileTypes: true })) {
+        if (!entry.isDirectory())
+            continue;
+        const target = path.join(dest, entry.name);
+        fs.rmSync(target, { recursive: true, force: true });
+        fs.cpSync(path.join(src, entry.name), target, { recursive: true });
+        names.push(entry.name);
+    }
+    return names;
+}
+export function writeReferences(root, srcOverride) {
+    let src;
+    try {
+        src = referencesDir(srcOverride);
+    }
+    catch {
+        return;
+    }
+    if (!fs.existsSync(src))
+        return;
+    const dest = path.join(root, "references");
+    fs.rmSync(dest, { recursive: true, force: true });
+    fs.cpSync(src, dest, { recursive: true });
+}
+export function ensureBaseDirs(root) {
+    const out = path.join(root, "output");
+    fs.mkdirSync(out, { recursive: true });
+    const keep = path.join(out, ".gitkeep");
+    if (!fs.existsSync(keep))
+        fs.writeFileSync(keep, "");
+    fs.mkdirSync(path.join(root, "state"), { recursive: true });
+    const exodusDir = path.join(root, ".exodus");
+    fs.mkdirSync(exodusDir, { recursive: true });
+    const statePath = path.join(exodusDir, "state.json");
+    if (!fs.existsSync(statePath)) {
+        fs.writeFileSync(statePath, JSON.stringify({ layoutVersion: 2 }, null, 2) + "\n");
+    }
+}

package/dist/lib/scout-hydrate.d.ts

@@ -0,0 +1 @@
+export declare function hydrateScoutIdeasCount<T extends Record<string, unknown>>(runId: string, data: T, fetchCount: (runId: string) => Promise<number | null>): Promise<T>;

package/dist/lib/scout-hydrate.js

@@ -0,0 +1,10 @@
+export async function hydrateScoutIdeasCount(runId, data, fetchCount) {
+    const generated = data["ideasGenerated"];
+    if (generated === 0 || generated === undefined) {
+        const count = await fetchCount(runId);
+        if (count !== null && typeof count === "number") {
+            data["ideasGenerated"] = count;
+        }
+    }
+    return data;
+}

package/dist/lib/state.d.ts

@@ -0,0 +1,6 @@
+export declare function findWorkspaceRoot(): string;
+export declare function getActiveBrand(): string | null;
+export declare function setActiveBrand(slug: string): void;
+export declare function clearActiveBrand(): void;
+export declare function getLayoutVersion(): number | null;
+export declare function setLayoutVersion(version: number): void;

package/dist/lib/state.js

@@ -0,0 +1,49 @@
+import fs from "node:fs";
+import path from "node:path";
+import { findParentRoot } from "./layout.js";
+export function findWorkspaceRoot() {
+    return findParentRoot();
+}
+function findStateDir() {
+    return path.join(findWorkspaceRoot(), ".exodus");
+}
+function statePath() {
+    return path.join(findStateDir(), "state.json");
+}
+function readState() {
+    const p = statePath();
+    if (!fs.existsSync(p))
+        return {};
+    try {
+        return JSON.parse(fs.readFileSync(p, "utf-8"));
+    }
+    catch {
+        return {};
+    }
+}
+function writeState(next) {
+    const dir = findStateDir();
+    fs.mkdirSync(dir, { recursive: true });
+    fs.writeFileSync(statePath(), JSON.stringify(next, null, 2) + "\n", "utf-8");
+}
+export function getActiveBrand() {
+    return readState().activeBrand ?? null;
+}
+export function setActiveBrand(slug) {
+    const s = readState();
+    s.activeBrand = slug;
+    writeState(s);
+}
+export function clearActiveBrand() {
+    const s = readState();
+    delete s.activeBrand;
+    writeState(s);
+}
+export function getLayoutVersion() {
+    return readState().layoutVersion ?? null;
+}
+export function setLayoutVersion(version) {
+    const s = readState();
+    s.layoutVersion = version;
+    writeState(s);
+}

package/dist/lib/template-constants.d.ts

@@ -0,0 +1,4 @@
+export declare const AD_TYPES: readonly ["before-after", "native-news", "testimonial", "bold", "meme", "screenshot", "hero", "holding-sign", "handwritten", "comment", "breaking-news", "lofi", "comparison", "infographic", "headline", "collage", "product-breakdown", "scientific", "animation", "founder-note", "carousel", "statistics", "post-it-notes", "happy-avatar", "problem-solution", "writing-on-body", "multi-testimonial", "receipt", "step-by-step", "sale-promotional-offer", "cost-of-inaction", "ugc", "quiz-interactive"];
+export type AdType = (typeof AD_TYPES)[number];
+export declare const AD_TYPE_NAMES: Record<AdType, string>;
+export declare const REPTILE_TRIGGERS: readonly ["ultra-real", "bizarre", "voyeur", "suffering", "gory", "sexual", "primal-fear", "odd-contrast", "inside-joke", "time-warp", "victory-lap", "selfie", "uncanny-objects"];

package/dist/lib/template-constants.js

@@ -0,0 +1,85 @@
+export const AD_TYPES = [
+    "before-after",
+    "native-news",
+    "testimonial",
+    "bold",
+    "meme",
+    "screenshot",
+    "hero",
+    "holding-sign",
+    "handwritten",
+    "comment",
+    "breaking-news",
+    "lofi",
+    "comparison",
+    "infographic",
+    "headline",
+    "collage",
+    "product-breakdown",
+    "scientific",
+    "animation",
+    "founder-note",
+    "carousel",
+    "statistics",
+    "post-it-notes",
+    "happy-avatar",
+    "problem-solution",
+    "writing-on-body",
+    "multi-testimonial",
+    "receipt",
+    "step-by-step",
+    "sale-promotional-offer",
+    "cost-of-inaction",
+    "ugc",
+    "quiz-interactive",
+];
+export const AD_TYPE_NAMES = {
+    "before-after": "Before / After",
+    "native-news": "Native News",
+    testimonial: "Testimonial",
+    bold: "Bold Typography",
+    meme: "Meme",
+    screenshot: "Screenshot",
+    hero: "Hero",
+    "holding-sign": "Holding Sign",
+    handwritten: "Handwritten Note",
+    comment: "Comment / Review",
+    "breaking-news": "Breaking News",
+    lofi: "Lo-Fi",
+    comparison: "Comparison",
+    infographic: "Infographic",
+    headline: "Headline + Image",
+    collage: "Curiosity Collage",
+    "product-breakdown": "Product Breakdown",
+    scientific: "Scientific Study",
+    animation: "Animation",
+    "founder-note": "Founder Note",
+    carousel: "Carousel",
+    statistics: "Statistics",
+    "post-it-notes": "Post-It Notes",
+    "happy-avatar": "Happy Avatar",
+    "problem-solution": "Problem-Solution",
+    "writing-on-body": "Writing On Body",
+    "multi-testimonial": "Multi-Testimonial",
+    receipt: "Receipt",
+    "step-by-step": "Step by Step",
+    "sale-promotional-offer": "Sale / Promotional Offer",
+    "cost-of-inaction": "Cost of Inaction",
+    ugc: "UGC",
+    "quiz-interactive": "Quiz / Interactive Self-Selection",
+};
+export const REPTILE_TRIGGERS = [
+    "ultra-real",
+    "bizarre",
+    "voyeur",
+    "suffering",
+    "gory",
+    "sexual",
+    "primal-fear",
+    "odd-contrast",
+    "inside-joke",
+    "time-warp",
+    "victory-lap",
+    "selfie",
+    "uncanny-objects",
+];

package/dist/lib/version.d.ts

@@ -0,0 +1 @@
+export declare function getVersion(): string;

package/dist/lib/version.js

@@ -0,0 +1,19 @@
+import { readFileSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+import { dirname, join, parse } from "node:path";
+export function getVersion() {
+    let dir = dirname(fileURLToPath(import.meta.url));
+    const { root } = parse(dir);
+    for (;;) {
+        try {
+            const pkg = JSON.parse(readFileSync(join(dir, "package.json"), "utf8"));
+            if (typeof pkg.version === "string")
+                return pkg.version;
+        }
+        catch {
+        }
+        if (dir === root)
+            return "unknown";
+        dir = dirname(dir);
+    }
+}

package/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "@aicopycoders/exodus",
+  "version": "2026.6.2400",
+  "description": "CLI + Claude Code skills for the Copycoders Exodus ad pipeline",
+  "type": "module",
+  "bin": {
+    "exodus": "./dist/bin/exodus.js"
+  },
+  "files": ["dist", "assets"],
+  "engines": {
+    "node": ">=20"
+  },
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  },
+  "scripts": {
+    "build": "rm -rf dist && tsc",
+    "bundle-assets": "node scripts/bundle-assets.mjs",
+    "prepack": "npm run build && npm run bundle-assets",
+    "dev": "tsx bin/exodus.ts"
+  },
+  "dependencies": {},
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "esbuild": "^0.25.0",
+    "tsx": "^4.7.0",
+    "typescript": "^5.4.0"
+  }
+}