@aicopycoders/exodus 2026.7.200-beta.11 → 2026.7.200-beta.13

package/dist/commands/bank.js

@@ -0,0 +1,346 @@
+import fs from "node:fs";
+import { apiGet, apiPost } from "../lib/client.js";
+import { formatApiError } from "../lib/format.js";
+import { getChannel } from "../lib/channel.js";
+import { missingRouteLine } from "../lib/route-support.js";
+export const helpText = `
+exodus bank — List, inspect, and promote entries into this brand's copy banks
+
+Usage:
+  exodus bank list [--json]
+  exodus bank show <key> [--json]
+  exodus bank promote <key> [text] [--file <path>] [options] [--json]
+
+Flags:
+  --json                 Machine-readable JSON output (includes ids + provenance)
+  --file <path>          (promote) Read the entry text from a file instead of an
+                         argument; piping text on stdin is a third option. A text
+                         argument and --file conflict (provide one, not both);
+                         stdin is read only when neither is given.
+  --awareness <pair>     (promote) Tag a body-bank entry with an awareness pair:
+                         unawareProblemAware | solutionProductAware | mostAware
+  --spend <n>            (promote) Win metric: ad spend (number)
+  --roas <n>             (promote) Win metric: return on ad spend (number)
+  --ctr <n>              (promote) Win metric: click-through rate (number)
+  --note <s>             (promote) Win metric: freeform note
+  --run <runId>          (promote) Provenance: the run this copy came from
+  --node <nodeId>        (promote) Provenance: the node this copy came from
+
+Banks are addressed by their well-known KEY (shown by \`bank list\`), never by an
+internal id. A fresh brand starts with six banks, all empty. \`bank show\` numbers
+entries newest-first with their source, win metrics, and age. \`bank promote\`
+appends a winning line to a bank; the server rejects an unknown key (listing the
+valid ones), empty/over-long text, and a bank that has hit its 2000-entry cap —
+those messages print verbatim.
+
+Examples:
+  exodus bank list
+  exodus bank show hooks
+  exodus bank promote hooks "Stop scrolling — your knees will thank you"
+  exodus bank promote body:solutionProductAware --file winner.txt --awareness solutionProductAware
+  cat winner.txt | exodus bank promote hooks
+  exodus bank promote hooks "..." --spend 4200 --roas 3.1 --ctr 1.8 --note "Q3 winner"
+  exodus bank promote hooks "..." --run wr_123 --node bot-4
+`.trim();
+export const AWARENESS_PAIRS = [
+    "unawareProblemAware",
+    "solutionProductAware",
+    "mostAware",
+];
+const LIST_PATH = "/api/v2/banks";
+const SHOW_PATH = "/api/v2/banks/show";
+const PROMOTE_PATH = "/api/v2/banks/promote";
+const FLYWHEEL_LINE = 'Winner Flywheel: "winner-promoted" dispatched — any workflow with an enabled ' +
+    "trigger starts a background run (watch: exodus workflow inbox)";
+const VALUE_FLAGS = new Set(["file", "awareness", "spend", "roas", "ctr", "note", "run", "node"]);
+const defaultDeps = {
+    get: (path) => apiGet(path),
+    post: (path, body) => apiPost(path, body),
+    readFile: (path) => fs.readFileSync(path, "utf-8"),
+    readStdin: () => fs.readFileSync(0, "utf-8"),
+    stdinIsTTY: () => !!process.stdin.isTTY,
+    channel: getChannel(),
+};
+function asErrorResult(res, json) {
+    return {
+        code: 1,
+        lines: json
+            ? [JSON.stringify({ ok: false, status: res.status, data: res.data })]
+            : [formatApiError(res)],
+    };
+}
+function table(headers, rows) {
+    const widths = headers.map((h, i) => Math.max(h.length, ...rows.map((row) => row[i]?.length ?? 0)));
+    const fmt = (row) => row.map((cell, i) => cell.padEnd(widths[i])).join("  ").trimEnd();
+    return [fmt(headers), fmt(headers.map((h) => "-".repeat(h.length))), ...rows.map(fmt)].join("\n");
+}
+export function relativeAge(value, now = Date.now()) {
+    const t = typeof value === "number" ? value : Date.parse(value);
+    if (!t || Number.isNaN(t))
+        return "unknown";
+    const diff = now - t;
+    if (diff < 0)
+        return "just now";
+    const sec = Math.floor(diff / 1000);
+    if (sec < 45)
+        return "just now";
+    const min = Math.floor(sec / 60);
+    if (min < 60)
+        return `${min}m ago`;
+    const hr = Math.floor(min / 60);
+    if (hr < 24)
+        return `${hr}h ago`;
+    const day = Math.floor(hr / 24);
+    if (day < 7)
+        return `${day}d ago`;
+    const wk = Math.floor(day / 7);
+    if (wk < 5)
+        return `${wk}w ago`;
+    const mo = Math.floor(day / 30);
+    if (mo < 12)
+        return `${mo}mo ago`;
+    return `${Math.floor(day / 365)}y ago`;
+}
+function winMetricsLine(wm) {
+    if (!wm)
+        return null;
+    const parts = [];
+    if (typeof wm.spend === "number")
+        parts.push(`spend=${wm.spend}`);
+    if (typeof wm.roas === "number")
+        parts.push(`roas=${wm.roas}`);
+    if (typeof wm.ctr === "number")
+        parts.push(`ctr=${wm.ctr}`);
+    if (wm.note)
+        parts.push(`note="${wm.note}"`);
+    return parts.length > 0 ? `     win: ${parts.join("  ")}` : null;
+}
+function textBlock(text) {
+    const lines = text.split("\n");
+    return lines.map((l) => `     ${l}`);
+}
+export function formatBankList(banks) {
+    if (banks.length === 0)
+        return "No banks found for the active brand.";
+    return table(["key", "name", "type", "entries"], banks.map((b) => [b.key, b.name, b.type, String(b.entryCount)]));
+}
+export function formatBankShow(res) {
+    const lines = [];
+    const { bank, entries } = res;
+    lines.push(`Bank — ${bank.name}`);
+    lines.push(`key:      ${bank.key}`);
+    lines.push(`type:     ${bank.type}`);
+    if (bank.awarenessPair)
+        lines.push(`awareness: ${bank.awarenessPair}`);
+    lines.push(`entries:  ${entries.length}`);
+    if (entries.length === 0) {
+        lines.push("");
+        lines.push("  (no entries yet — promote a winner with `exodus bank promote`)");
+        return lines.join("\n");
+    }
+    entries.forEach((entry, i) => {
+        lines.push("");
+        const badges = [`[${entry.source}]`];
+        if (entry.awarenessPair)
+            badges.push(entry.awarenessPair);
+        if (entry.humanEdited)
+            badges.push("edited");
+        badges.push(relativeAge(entry.createdAt));
+        lines.push(`${i + 1}. ${badges.join(" · ")}`);
+        lines.push(...textBlock(entry.text));
+        const win = winMetricsLine(entry.winMetrics);
+        if (win)
+            lines.push(win);
+    });
+    return lines.join("\n");
+}
+export function resolvePromoteText(opts) {
+    if (opts.arg !== undefined && opts.file !== undefined) {
+        throw new Error("provide exactly ONE entry text source, got 2: text argument + --file.");
+    }
+    if (opts.arg !== undefined)
+        return opts.arg;
+    if (opts.file !== undefined) {
+        try {
+            return opts.readFile(opts.file);
+        }
+        catch (e) {
+            const msg = e instanceof Error ? e.message : String(e);
+            throw new Error(`could not read --file "${opts.file}": ${msg}`);
+        }
+    }
+    if (!opts.stdinIsTTY()) {
+        const text = opts.readStdin();
+        if (text.trim() !== "")
+            return text;
+    }
+    throw new Error("no entry text — pass it as an argument, with --file <path>, or pipe it on stdin.");
+}
+export function parseWinMetrics(flags) {
+    const wm = {};
+    const num = (name) => {
+        const raw = flags[name];
+        if (raw === undefined)
+            return undefined;
+        if (typeof raw !== "string" || raw.trim() === "") {
+            throw new Error(`--${name} must be a number (got "${String(raw)}")`);
+        }
+        const n = Number(raw);
+        if (Number.isNaN(n))
+            throw new Error(`--${name} must be a number (got "${raw}")`);
+        return n;
+    };
+    const spend = num("spend");
+    const roas = num("roas");
+    const ctr = num("ctr");
+    if (spend !== undefined)
+        wm.spend = spend;
+    if (roas !== undefined)
+        wm.roas = roas;
+    if (ctr !== undefined)
+        wm.ctr = ctr;
+    if (typeof flags["note"] === "string")
+        wm.note = flags["note"];
+    return Object.keys(wm).length > 0 ? wm : undefined;
+}
+export function parseProvenance(flags) {
+    const prov = {};
+    if (typeof flags["run"] === "string")
+        prov.workflowRunId = flags["run"];
+    if (typeof flags["node"] === "string")
+        prov.nodeId = flags["node"];
+    return Object.keys(prov).length > 0 ? prov : undefined;
+}
+export function parseAwareness(flags) {
+    const raw = flags["awareness"];
+    if (raw === undefined)
+        return undefined;
+    if (typeof raw !== "string" || !AWARENESS_PAIRS.includes(raw)) {
+        throw new Error(`--awareness must be one of: ${AWARENESS_PAIRS.join(", ")} (got "${String(raw)}").`);
+    }
+    return raw;
+}
+export function buildPromoteBody(bankKey, text, flags) {
+    const body = { bankKey, text };
+    const awarenessPair = parseAwareness(flags);
+    if (awarenessPair)
+        body.awarenessPair = awarenessPair;
+    const winMetrics = parseWinMetrics(flags);
+    if (winMetrics)
+        body.winMetrics = winMetrics;
+    const provenance = parseProvenance(flags);
+    if (provenance)
+        body.provenance = provenance;
+    return body;
+}
+export async function listFlow(json, deps) {
+    const res = await deps.get(LIST_PATH);
+    const unsupported = missingRouteLine(res, "bank list", deps.channel);
+    if (unsupported)
+        return { code: 1, lines: [unsupported] };
+    if (!res.ok)
+        return asErrorResult(res, json);
+    const banks = res.data ?? [];
+    return { code: 0, lines: json ? [JSON.stringify(res.data)] : [formatBankList(banks)] };
+}
+export async function showFlow(key, json, deps) {
+    const res = await deps.get(`${SHOW_PATH}?key=${encodeURIComponent(key)}`);
+    const unsupported = missingRouteLine(res, "bank show", deps.channel);
+    if (unsupported)
+        return { code: 1, lines: [unsupported] };
+    if (!res.ok)
+        return asErrorResult(res, json);
+    return {
+        code: 0,
+        lines: json ? [JSON.stringify(res.data)] : [formatBankShow(res.data)],
+    };
+}
+export async function promoteFlow(key, arg, flags, json, deps) {
+    let body;
+    try {
+        const text = resolvePromoteText({
+            arg,
+            file: typeof flags["file"] === "string" ? flags["file"] : undefined,
+            readFile: deps.readFile,
+            readStdin: deps.readStdin,
+            stdinIsTTY: deps.stdinIsTTY,
+        });
+        body = buildPromoteBody(key, text, flags);
+    }
+    catch (e) {
+        return { code: 1, lines: [`Error: ${e instanceof Error ? e.message : String(e)}`] };
+    }
+    const res = await deps.post(PROMOTE_PATH, body);
+    const unsupported = missingRouteLine(res, "bank promote", deps.channel);
+    if (unsupported)
+        return { code: 1, lines: [unsupported] };
+    if (!res.ok)
+        return asErrorResult(res, json);
+    const data = res.data;
+    if (json)
+        return { code: 0, lines: [JSON.stringify(res.data)] };
+    return {
+        code: 0,
+        lines: [
+            `✓ Promoted to ${data.bankName}.`,
+            `entryId:  ${data.entryId}`,
+            FLYWHEEL_LINE,
+        ],
+    };
+}
+function parsePositional(args = process.argv.slice(3)) {
+    const out = [];
+    let i = 0;
+    while (i < args.length) {
+        const arg = args[i];
+        if (arg.startsWith("--")) {
+            const key = arg.slice(2).split("=", 1)[0] ?? "";
+            if (!arg.includes("=") && VALUE_FLAGS.has(key))
+                i += 2;
+            else
+                i++;
+            continue;
+        }
+        out.push(arg);
+        i++;
+    }
+    return out;
+}
+async function printResult(result) {
+    for (const line of result.lines)
+        console.log(line);
+    if (result.code !== 0)
+        process.exit(result.code);
+}
+export async function run(flags) {
+    const positional = parsePositional();
+    const [sub, ...rest] = positional;
+    const json = !!flags["json"];
+    if (!sub) {
+        console.log(helpText);
+        return;
+    }
+    if (sub === "list")
+        return printResult(await listFlow(json, defaultDeps));
+    if (sub === "show") {
+        const key = rest[0];
+        if (!key) {
+            console.error("Error: bank show requires <key>.");
+            console.log("Usage: exodus bank show <key> [--json]");
+            process.exit(1);
+        }
+        return printResult(await showFlow(key, json, defaultDeps));
+    }
+    if (sub === "promote") {
+        const key = rest[0];
+        if (!key) {
+            console.error("Error: bank promote requires <key>.");
+            console.log("Usage: exodus bank promote <key> [text] [--file <path>] [--json]");
+            process.exit(1);
+        }
+        return printResult(await promoteFlow(key, rest[1], flags, json, defaultDeps));
+    }
+    console.error(`Unknown subcommand: "${sub}"\n`);
+    console.log(helpText);
+    process.exit(1);
+}

package/dist/commands/keys.js

@@ -26,6 +26,7 @@ const PROVIDER_LABEL = {
     kie: "Kie.ai",
     imgflip: "Imgflip",
     scrapecreators: "ScrapeCreators",
+    apify: "Apify",
 };
 async function status() {
     let remote;

package/dist/commands/session.d.ts

@@ -0,0 +1,55 @@
+import { type ApiResponse } from "../lib/client.js";
+import { type Channel } from "../lib/channel.js";
+export declare const helpText: string;
+export interface SessionSummary {
+    _id: string;
+    title: string;
+    botSlug: string;
+    runId?: string;
+    nodeId?: string;
+    archived: boolean;
+    lastTouchedAt: number | string;
+    createdAt: number | string;
+}
+export interface SessionListResponse {
+    sessions: SessionSummary[];
+}
+export type SessionMessageRole = "system" | "user" | "assistant";
+export interface SessionMessage {
+    role: SessionMessageRole;
+    body: string;
+    createdAt: number | string;
+}
+export interface SessionShowResponse {
+    session: SessionSummary & {
+        promptText?: string;
+        model?: string;
+    };
+    messages: SessionMessage[];
+}
+export interface SessionChatResponse {
+    reply: string;
+}
+export interface SessionDeps {
+    get: (path: string) => Promise<ApiResponse<unknown>>;
+    postDashboard: (path: string, body: unknown, opts?: {
+        timeoutMs?: number;
+    }) => Promise<ApiResponse<unknown>>;
+    channel: Channel;
+}
+export interface FlowResult {
+    code: number;
+    lines: string[];
+}
+export declare function shortId(id: string): string;
+export declare function formatAge(value: number | string | undefined, now?: number): string;
+export declare function formatSessionList(sessions: SessionSummary[], now?: number): string;
+export declare function formatSessionShow(data: SessionShowResponse): string;
+export declare function listFlow(json: boolean, deps: SessionDeps): Promise<FlowResult>;
+export declare function showFlow(sessionId: string, opts: {
+    json: boolean;
+}, deps: SessionDeps): Promise<FlowResult>;
+export declare function chatFlow(sessionId: string, message: string, opts: {
+    json: boolean;
+}, deps: SessionDeps): Promise<FlowResult>;
+export declare function run(flags: Record<string, string | boolean>): Promise<void>;

package/dist/commands/session.js

@@ -0,0 +1,202 @@
+import { apiGet, apiPostDashboard } from "../lib/client.js";
+import { formatError } from "../lib/format.js";
+import { getChannel } from "../lib/channel.js";
+import { missingRouteLine } from "../lib/route-support.js";
+export const helpText = `
+exodus session — Inspect and continue workflow chat sessions
+
+Usage:
+  exodus session list [--json]
+  exodus session show <sessionId> [--json]
+  exodus session chat <sessionId> "message" [--json]
+
+Flags:
+  --json                 Machine-readable JSON output (the raw API response)
+
+Notes:
+  Sessions are born from workflow runs whose bots run in session-mode — you do
+  not create them here. "session list" shows the sessions on the active brand;
+  "session show" prints a session's turns (system rows are hidden in the human
+  view but kept in --json); "session chat" appends your message and prints the
+  assistant's reply. The chat route can take up to ~5 minutes to answer.
+
+Examples:
+  exodus session list
+  exodus session show sess_123
+  exodus session chat sess_123 "make the hook punchier"
+`.trim();
+const SESSIONS_PATH = "/api/v2/sessions";
+const SESSION_SHOW_PATH = "/api/v2/sessions/show";
+const CHAT_PATH = "/api/sessions/chat";
+const CHAT_TIMEOUT_MS = 320_000;
+const defaultDeps = {
+    get: (path) => apiGet(path),
+    postDashboard: (path, body, opts) => apiPostDashboard(path, body, opts),
+    channel: getChannel(),
+};
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+export function shortId(id) {
+    return id.length <= 12 ? id : `${id.slice(0, 11)}…`;
+}
+export function formatAge(value, now = Date.now()) {
+    if (value === undefined || value === null)
+        return "-";
+    const t = typeof value === "number" ? value : Date.parse(value);
+    if (Number.isNaN(t))
+        return "-";
+    const sec = Math.max(0, Math.floor((now - t) / 1000));
+    if (sec < 60)
+        return `${sec}s`;
+    const min = Math.floor(sec / 60);
+    if (min < 60)
+        return `${min}m`;
+    const hr = Math.floor(min / 60);
+    if (hr < 24)
+        return `${hr}h`;
+    return `${Math.floor(hr / 24)}d`;
+}
+function table(headers, rows) {
+    const widths = headers.map((h, i) => Math.max(h.length, ...rows.map((row) => row[i]?.length ?? 0)));
+    const fmt = (row) => row.map((cell, i) => cell.padEnd(widths[i])).join("  ").trimEnd();
+    return [fmt(headers), fmt(headers.map((h) => "-".repeat(h.length))), ...rows.map(fmt)].join("\n");
+}
+const NO_SESSIONS = "No sessions yet. Sessions are born from workflow runs whose bots run in session-mode.";
+export function formatSessionList(sessions, now = Date.now()) {
+    if (sessions.length === 0)
+        return NO_SESSIONS;
+    return table(["id", "title", "bot", "run", "age"], sessions.map((s) => [
+        shortId(s._id),
+        s.title || "(untitled)",
+        s.botSlug,
+        s.runId ? shortId(s.runId) : "-",
+        formatAge(s.lastTouchedAt, now),
+    ]));
+}
+export function formatSessionShow(data) {
+    const s = data.session;
+    const lines = [];
+    lines.push(`Session — ${s.title || "(untitled)"}`);
+    lines.push(`sessionId:  ${s._id}`);
+    lines.push(`bot:        ${s.botSlug}`);
+    lines.push(`run:        ${s.runId ?? "-"}`);
+    const turns = (data.messages ?? []).filter((m) => m.role !== "system");
+    lines.push("");
+    if (turns.length === 0) {
+        lines.push("(no messages yet)");
+    }
+    else {
+        for (const m of turns)
+            lines.push(`${m.role}: ${m.body}`);
+    }
+    return lines.join("\n");
+}
+function routeErrorText(data, status) {
+    if (isRecord(data)) {
+        const err = data.error;
+        if (typeof err === "string" && err)
+            return err;
+        if (isRecord(err) && typeof err.message === "string")
+            return err.message;
+        if (typeof data.message === "string" && data.message)
+            return data.message;
+    }
+    return `HTTP ${status}`;
+}
+function apiErrorResult(res, verb, json, channel) {
+    const missing = missingRouteLine(res, verb, channel);
+    if (missing) {
+        return {
+            code: 1,
+            lines: json
+                ? [JSON.stringify({ ok: false, status: res.status, error: missing })]
+                : [missing],
+        };
+    }
+    return {
+        code: 1,
+        lines: json
+            ? [JSON.stringify({ ok: false, status: res.status, data: res.data })]
+            : [formatError(res)],
+    };
+}
+export async function listFlow(json, deps) {
+    const res = await deps.get(SESSIONS_PATH);
+    if (!res.ok)
+        return apiErrorResult(res, "session list", json, deps.channel);
+    const data = res.data;
+    return {
+        code: 0,
+        lines: json ? [JSON.stringify(data)] : [formatSessionList(data.sessions ?? [])],
+    };
+}
+export async function showFlow(sessionId, opts, deps) {
+    const res = await deps.get(`${SESSION_SHOW_PATH}?sessionId=${encodeURIComponent(sessionId)}`);
+    if (!res.ok)
+        return apiErrorResult(res, "session show", opts.json, deps.channel);
+    const data = res.data;
+    return {
+        code: 0,
+        lines: opts.json ? [JSON.stringify(data)] : [formatSessionShow(data)],
+    };
+}
+export async function chatFlow(sessionId, message, opts, deps) {
+    const res = await deps.postDashboard(CHAT_PATH, { sessionId, text: message }, { timeoutMs: CHAT_TIMEOUT_MS });
+    if (!res.ok) {
+        const err = routeErrorText(res.data, res.status);
+        return {
+            code: 1,
+            lines: opts.json
+                ? [JSON.stringify({ ok: false, status: res.status, error: err })]
+                : [`exodus session chat: ${err} (HTTP ${res.status})`],
+        };
+    }
+    const data = res.data;
+    return {
+        code: 0,
+        lines: opts.json ? [JSON.stringify(data)] : [data.reply ?? ""],
+    };
+}
+function parsePositional(args = process.argv.slice(3)) {
+    return args.filter((a) => !a.startsWith("--"));
+}
+async function printResult(result) {
+    for (const line of result.lines)
+        console.log(line);
+    if (result.code !== 0)
+        process.exit(result.code);
+}
+export async function run(flags) {
+    const positional = parsePositional();
+    const [sub, ...rest] = positional;
+    const json = !!flags["json"];
+    if (!sub) {
+        console.log(helpText);
+        return;
+    }
+    if (sub === "list")
+        return printResult(await listFlow(json, defaultDeps));
+    if (sub === "show") {
+        const sessionId = rest[0];
+        if (!sessionId) {
+            console.error("Error: session show requires <sessionId>.");
+            console.log("Usage: exodus session show <sessionId> [--json]");
+            process.exit(1);
+        }
+        return printResult(await showFlow(sessionId, { json }, defaultDeps));
+    }
+    if (sub === "chat") {
+        const sessionId = rest[0];
+        const message = rest[1];
+        if (!sessionId || !message) {
+            console.error('Error: session chat requires <sessionId> and a "message".');
+            console.log('Usage: exodus session chat <sessionId> "message" [--json]');
+            process.exit(1);
+        }
+        return printResult(await chatFlow(sessionId, message, { json }, defaultDeps));
+    }
+    console.error(`Unknown subcommand: "${sub}"\n`);
+    console.log(helpText);
+    process.exit(1);
+}