@aicopycoders/exodus 2026.7.200-beta.8 → 2026.8.1100

package/dist/lib/client.d.ts

@@ -8,6 +8,10 @@ export declare function apiGet<T>(path: string, opts?: {
     skipActiveBrand?: boolean;
     activeBrandOverride?: string;
 }): Promise<ApiResponse<T>>;
+export declare function apiGetText(path: string, opts?: {
+    skipActiveBrand?: boolean;
+    activeBrandOverride?: string;
+}): Promise<ApiResponse<string>>;
 export declare function apiPost<T>(path: string, body: unknown, opts?: {
     ccCommand?: string;
 }): Promise<ApiResponse<T>>;
@@ -20,4 +24,7 @@ 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>>;
+export declare function apiPostDashboard<T>(path: string, body: unknown, opts?: {
+    timeoutMs?: number;
+    activeBrandOverride?: string;
+}): Promise<ApiResponse<T>>;

package/dist/lib/client.js

@@ -108,6 +108,16 @@ export async function apiGet(path, opts) {
     }
     return { ok: res.ok, status: res.status, data: data };
 }
+export async function apiGetText(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();
+    return { ok: res.ok, status: res.status, data: text };
+}
 export async function apiPost(path, body, opts) {
     const { apiUrl, apiKey } = getConfig();
     const url = `${apiUrl}${path}`;
@@ -187,15 +197,29 @@ export async function apiGetDashboard(path, opts) {
     }
     return { ok: res.ok, status: res.status, data: data };
 }
-export async function apiPostDashboard(path, body) {
+export async function apiPostDashboard(path, body, opts) {
     const { apiKey } = getConfig();
     const url = `${getDashboardUrl()}${path}`;
-    const headers = buildHeaders(apiKey);
-    const res = await fetch(url, {
-        method: "POST",
-        headers,
-        body: JSON.stringify(body),
+    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: "POST",
+            headers,
+            body: JSON.stringify(body),
+            signal: controller?.signal,
+        });
+    }
+    finally {
+        if (timer)
+            clearTimeout(timer);
+    }
     const text = await res.text();
     let data;
     try {

package/dist/lib/format.d.ts

@@ -1,6 +1,13 @@
+export declare function displayRunStatus(raw: unknown, missing?: string): string;
+export declare function tickerRunStatus(raw: unknown): string;
 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 formatApiError(res: {
+    ok: boolean;
+    status: number;
+    data: unknown;
+}): string;
 export declare function formatError(res: {
     ok: boolean;
     status: number;

package/dist/lib/format.js

@@ -1,3 +1,21 @@
+import { normalizeRunStatus, runStatusLabel } from "./runStatus.js";
+export function displayRunStatus(raw, missing = "unknown") {
+    return typeof raw === "string" && raw.trim() ? runStatusLabel(raw) : missing;
+}
+const GENERIC_ACTIVE_STATUSES = new Set([
+    "queued",
+    "pending",
+    "running",
+    "processing",
+    "in-progress",
+]);
+export function tickerRunStatus(raw) {
+    if (typeof raw !== "string" || !raw.trim())
+        return "";
+    const canonical = normalizeRunStatus(raw);
+    const isPhaseWord = (canonical === "running" || canonical === "queued") && !GENERIC_ACTIVE_STATUSES.has(raw);
+    return isPhaseWord ? raw : runStatusLabel(raw);
+}
 function stepIcon(status) {
     if (status === "completed" || status === "done")
         return "✓";
@@ -29,9 +47,8 @@ function formatSteps(steps) {
 }
 export function formatGeneration(data) {
     const lines = [];
-    const status = data["status"] ?? "unknown";
     lines.push(`## Generation Result`);
-    lines.push(`**Status:** ${status}`);
+    lines.push(`**Status:** ${displayRunStatus(data["status"])}`);
     if (data["agentName"] || data["agent"]) {
         lines.push(`**Agent:** ${data["agentName"] ?? data["agent"]}`);
     }
@@ -69,9 +86,8 @@ export function formatGeneration(data) {
 }
 export function formatGenesisRun(data) {
     const lines = [];
-    const status = data["status"] ?? "unknown";
     lines.push(`## Genesis Run`);
-    lines.push(`**Status:** ${status}`);
+    lines.push(`**Status:** ${displayRunStatus(data["status"])}`);
     if (data["awarenessLevel"] || data["awareness"]) {
         lines.push(`**Awareness Level:** ${data["awarenessLevel"] ?? data["awareness"]}`);
     }
@@ -134,12 +150,43 @@ export function formatBrowse(generations) {
             date = isNaN(parsed.getTime()) ? "—" : parsed.toISOString().slice(0, 10);
         }
         const agent = gen["agentName"] ?? gen["agentId"] ?? gen["agent"] ?? gen["pipeline"] ?? "—";
-        const status = gen["status"] ?? "—";
+        const status = displayRunStatus(gen["status"], "—");
         const doc = gen["googleDocUrl"] ?? gen["docUrl"] ?? "—";
         lines.push(`${date} | ${agent} | ${status} | ${doc}`);
     }
     return lines.join("\n");
 }
+export function formatApiError(res) {
+    let message;
+    let remedy;
+    const d = res.data;
+    if (d && typeof d === "object" && !Array.isArray(d)) {
+        const rec = d;
+        const err = rec["error"];
+        if (typeof err === "string" && err) {
+            message = err;
+        }
+        else if (err && typeof err === "object") {
+            const e = err;
+            if (typeof e["message"] === "string" && e["message"])
+                message = e["message"];
+            if (typeof e["remedy"] === "string" && e["remedy"])
+                remedy = e["remedy"];
+        }
+        if (!message && typeof rec["message"] === "string" && rec["message"]) {
+            message = rec["message"];
+        }
+        if (!remedy && typeof rec["remedy"] === "string" && rec["remedy"]) {
+            remedy = rec["remedy"];
+        }
+    }
+    else if (typeof d === "string" && d.trim()) {
+        message = d.trim();
+    }
+    if (!message)
+        message = `HTTP ${res.status}`;
+    return remedy ? `${message}\nfix: ${remedy}` : message;
+}
 export function formatError(res) {
     const lines = [];
     lines.push(`## Error`);

package/dist/lib/intel-format.js

@@ -1,7 +1,8 @@
+import { displayRunStatus } from "./format.js";
 export function formatIntelResult(data) {
     const lines = [];
     lines.push("## Intel Analysis Result");
-    lines.push(`**Status:** ${data["status"] ?? "unknown"}`);
+    lines.push(`**Status:** ${displayRunStatus(data["status"])}`);
     if (data["mode"])
         lines.push(`**Mode:** ${data["mode"]}`);
     if (data["phase"] !== undefined)

package/dist/lib/keys-sync.js

@@ -11,6 +11,7 @@ export const PROVIDER_ENV_MAP = {
 export const SERVER_RESOLVED_PROVIDERS = new Set([
     "imgflip",
     "scrapecreators",
+    "apify",
 ]);
 export async function fetchRemoteKeys() {
     const res = await apiGetDashboard("/api/settings/keys");

package/dist/lib/poll.js

@@ -1,11 +1,11 @@
 import { apiGet } from "./client.js";
-const DEFAULT_TERMINAL_STATUSES = ["completed", "failed"];
+import { isTerminalRunStatus, normalizeRunStatus } from "./runStatus.js";
 function delay(ms) {
     return new Promise((resolve) => setTimeout(resolve, ms));
 }
 export async function pollUntilDone(opts) {
     const { path, intervalMs = 3000, timeoutMs = 600_000, terminalStatuses, onProgress, isDone, } = opts;
-    const terminal = new Set([...DEFAULT_TERMINAL_STATUSES, ...(terminalStatuses ?? [])]);
+    const extraTerminal = new Set(terminalStatuses ?? []);
     const deadline = Date.now() + timeoutMs;
     while (true) {
         const res = await apiGet(path);
@@ -16,10 +16,13 @@ export async function pollUntilDone(opts) {
         if (!res.ok) {
             return { ok: false, data: res.data, timedOut: false };
         }
-        if (status === "failed") {
+        const canonical = status ? normalizeRunStatus(status) : undefined;
+        if (canonical === "failed" || canonical === "cancelled") {
             return { ok: false, data: res.data, timedOut: false };
         }
-        const statusTerminal = status ? terminal.has(status) : false;
+        const statusTerminal = status
+            ? isTerminalRunStatus(status) || extraTerminal.has(status)
+            : false;
         const customDone = isDone ? isDone(res.data) : true;
         if (statusTerminal && customDone) {
             return { ok: true, data: res.data, timedOut: false };

package/dist/lib/route-support.d.ts

@@ -0,0 +1,4 @@
+import type { ApiResponse } from "./client.js";
+import { type Channel } from "./channel.js";
+export declare function isSemanticApiError(data: unknown): boolean;
+export declare function missingRouteLine(res: ApiResponse<unknown>, verb: string, channel?: Channel): string | undefined;

package/dist/lib/route-support.js

@@ -0,0 +1,22 @@
+import { getChannel } from "./channel.js";
+export function isSemanticApiError(data) {
+    if (typeof data !== "object" || data === null)
+        return false;
+    const record = data;
+    const topCode = record.code;
+    if (typeof topCode === "string" && topCode.length > 0)
+        return true;
+    const err = record.error;
+    if (typeof err !== "object" || err === null)
+        return false;
+    const nestedCode = err.code;
+    return typeof nestedCode === "string" && nestedCode.length > 0;
+}
+export function missingRouteLine(res, verb, channel = getChannel()) {
+    if (res.status !== 404)
+        return undefined;
+    if (isSemanticApiError(res.data))
+        return undefined;
+    return (`this server does not support ${verb} yet — ` +
+        `your backend has not been updated (channel: ${channel})`);
+}

package/dist/lib/runStatus.d.ts

@@ -0,0 +1,22 @@
+export declare const RUN_STATUSES: readonly ["queued", "running", "awaiting-approval", "succeeded", "succeeded-with-warnings", "failed", "cancelled"];
+export type RunStatus = (typeof RUN_STATUSES)[number];
+export declare const RUN_STATUS_LABELS: Record<RunStatus, string>;
+export type RunStatusTone = "pending" | "active" | "attention" | "success" | "warning" | "danger" | "muted";
+export declare const RUN_STATUS_TONES: Record<RunStatus, RunStatusTone>;
+export declare const LEGACY_RUN_STATUS_ALIASES: Record<string, RunStatus>;
+export declare function normalizeRunStatus(raw: string | null | undefined, fallback?: RunStatus): RunStatus;
+export declare function runStatusLabel(raw: string | null | undefined): string;
+export declare function runStatusTone(raw: string | null | undefined): RunStatusTone;
+export declare const TERMINAL_RUN_STATUSES: readonly ["succeeded", "succeeded-with-warnings", "failed", "cancelled"];
+export declare const ACTIVE_RUN_STATUSES: readonly ["queued", "running"];
+export declare function isTerminalRunStatus(raw: string | null | undefined): boolean;
+export declare function isActiveRunStatus(raw: string | null | undefined): boolean;
+export declare const WORKFLOW_RUN_STATUS_VALUES: readonly ["queued", "running", "awaiting-approval", "succeeded", "succeeded-with-warnings", "failed", "cancelled"];
+export declare const LEGACY_WORKFLOW_RUN_STATUS_VALUES: readonly ["awaiting-review", "completed", "partial", "canceled"];
+export declare function storedWorkflowStatusForms(status: RunStatus): string[];
+export declare function workflowRunPresentation(rawStatus: string | null | undefined, pauseReason?: string | null): {
+    status: RunStatus;
+    label: string;
+    tone: RunStatusTone;
+    detail?: string;
+};

package/dist/lib/runStatus.js

@@ -0,0 +1,139 @@
+export const RUN_STATUSES = [
+    "queued",
+    "running",
+    "awaiting-approval",
+    "succeeded",
+    "succeeded-with-warnings",
+    "failed",
+    "cancelled",
+];
+export const RUN_STATUS_LABELS = {
+    queued: "Queued",
+    running: "Running",
+    "awaiting-approval": "Awaiting approval",
+    succeeded: "Succeeded",
+    "succeeded-with-warnings": "Succeeded with warnings",
+    failed: "Failed",
+    cancelled: "Cancelled",
+};
+export const RUN_STATUS_TONES = {
+    queued: "pending",
+    running: "active",
+    "awaiting-approval": "attention",
+    succeeded: "success",
+    "succeeded-with-warnings": "warning",
+    failed: "danger",
+    cancelled: "muted",
+};
+export const LEGACY_RUN_STATUS_ALIASES = {
+    pending: "queued",
+    processing: "running",
+    "in-progress": "running",
+    walking: "running",
+    mining: "running",
+    scoring: "running",
+    selecting: "running",
+    writing: "running",
+    assembling: "running",
+    discovery: "running",
+    analyzing: "running",
+    combining: "running",
+    phase1_complete: "running",
+    phase2_complete: "running",
+    "phase1-running": "running",
+    "phase1-completed": "running",
+    "phase2-running": "running",
+    "script-prep-running": "running",
+    "parser-running": "running",
+    "storyboard-running": "running",
+    "cast-sheet-running": "running",
+    "storyboard-images-running": "running",
+    "voice-and-clips-running": "running",
+    stitching: "running",
+    extracting: "running",
+    ranking: "running",
+    conceptualizing: "running",
+    rendering: "running",
+    "awaiting-review": "awaiting-approval",
+    awaiting_hook_selection: "awaiting-approval",
+    paused: "awaiting-approval",
+    "script-review": "awaiting-approval",
+    "storyboard-review": "awaiting-approval",
+    "cast-sheet-review": "awaiting-approval",
+    completed: "succeeded",
+    complete: "succeeded",
+    done: "succeeded",
+    partial: "succeeded-with-warnings",
+    "partial-success": "succeeded-with-warnings",
+    "partial-error": "succeeded-with-warnings",
+    error: "failed",
+    stalled: "failed",
+    "verification-failed": "failed",
+    canceled: "cancelled",
+    superseded: "cancelled",
+};
+export function normalizeRunStatus(raw, fallback = "running") {
+    if (!raw)
+        return fallback;
+    if (RUN_STATUSES.includes(raw))
+        return raw;
+    return LEGACY_RUN_STATUS_ALIASES[raw] ?? fallback;
+}
+export function runStatusLabel(raw) {
+    return RUN_STATUS_LABELS[normalizeRunStatus(raw)];
+}
+export function runStatusTone(raw) {
+    return RUN_STATUS_TONES[normalizeRunStatus(raw)];
+}
+export const TERMINAL_RUN_STATUSES = [
+    "succeeded",
+    "succeeded-with-warnings",
+    "failed",
+    "cancelled",
+];
+export const ACTIVE_RUN_STATUSES = ["queued", "running"];
+export function isTerminalRunStatus(raw) {
+    return TERMINAL_RUN_STATUSES.includes(normalizeRunStatus(raw));
+}
+export function isActiveRunStatus(raw) {
+    return ACTIVE_RUN_STATUSES.includes(normalizeRunStatus(raw));
+}
+export const WORKFLOW_RUN_STATUS_VALUES = RUN_STATUSES;
+export const LEGACY_WORKFLOW_RUN_STATUS_VALUES = [
+    "awaiting-review",
+    "completed",
+    "partial",
+    "canceled",
+];
+const LEGACY_WORKFLOW_TWIN = {
+    "awaiting-approval": "awaiting-review",
+    succeeded: "completed",
+    "succeeded-with-warnings": "partial",
+    cancelled: "canceled",
+};
+export function storedWorkflowStatusForms(status) {
+    const twin = LEGACY_WORKFLOW_TWIN[status];
+    return twin ? [status, twin] : [status];
+}
+export function workflowRunPresentation(rawStatus, pauseReason) {
+    let status = normalizeRunStatus(rawStatus);
+    let detail;
+    if (status === "awaiting-approval") {
+        if (pauseReason === "call") {
+            status = "running";
+            detail = "sub-workflow";
+        }
+        else if (pauseReason === "slots") {
+            detail = "needs inputs";
+        }
+        else if (pauseReason === "repair") {
+            detail = "needs repair";
+        }
+    }
+    return {
+        status,
+        label: RUN_STATUS_LABELS[status],
+        tone: RUN_STATUS_TONES[status],
+        detail,
+    };
+}

package/dist/lib/workflowText.d.ts

@@ -0,0 +1,3 @@
+import type { WorkflowContractJson } from "../commands/workflow.js";
+export declare function workflowToYaml(contract: WorkflowContractJson): string;
+export declare function parseWorkflowText(text: string): unknown;

package/dist/lib/workflowText.js

@@ -0,0 +1,113 @@
+import yaml from "js-yaml";
+function canonicalizeValue(value) {
+    if (Array.isArray(value))
+        return value.map(canonicalizeValue);
+    if (value !== null && typeof value === "object") {
+        const src = value;
+        const out = {};
+        for (const key of Object.keys(src).sort()) {
+            out[key] = canonicalizeValue(src[key]);
+        }
+        return out;
+    }
+    return value;
+}
+function orderKeys(record, fixedOrder) {
+    const out = {};
+    for (const key of fixedOrder) {
+        if (record[key] !== undefined)
+            out[key] = record[key];
+    }
+    const fixed = new Set(fixedOrder);
+    for (const key of Object.keys(record).sort()) {
+        if (!fixed.has(key) && record[key] !== undefined)
+            out[key] = record[key];
+    }
+    return out;
+}
+function canonicalizeContract(contract) {
+    const root = contract;
+    const nodes = Array.isArray(root.nodes) ? root.nodes : [];
+    const edges = Array.isArray(root.edges) ? root.edges : [];
+    const canonicalNodes = nodes.map((n) => {
+        const rec = { ...n };
+        if (rec.position !== null && typeof rec.position === "object") {
+            rec.position = orderKeys(rec.position, ["x", "y"]);
+        }
+        if (rec.config !== null && typeof rec.config === "object") {
+            rec.config = canonicalizeValue(rec.config);
+        }
+        return orderKeys(rec, ["id", "kind", "position", "config"]);
+    });
+    const canonicalEdges = edges.map((e) => orderKeys({ ...e }, [
+        "id",
+        "source",
+        "sourceHandle",
+        "target",
+        "targetHandle",
+    ]));
+    const rootRecord = {
+        ...root,
+        nodes: canonicalNodes,
+        edges: canonicalEdges,
+    };
+    if (Array.isArray(root.slots)) {
+        rootRecord.slots = root.slots.map((s) => orderKeys({ ...s }, [
+            "id",
+            "label",
+            "state",
+            "nodeId",
+            "configKey",
+            "value",
+            "hint",
+        ]));
+    }
+    if (Array.isArray(root.triggers)) {
+        rootRecord.triggers = root.triggers.map((t) => orderKeys({ ...t }, [
+            "type",
+            "event",
+            "cron",
+            "enabled",
+        ]));
+    }
+    return orderKeys(rootRecord, [
+        "contract",
+        "version",
+        "workflowId",
+        "updatedAt",
+        "name",
+        "description",
+        "slots",
+        "triggers",
+        "nodes",
+        "edges",
+    ]);
+}
+export function workflowToYaml(contract) {
+    return yaml.dump(canonicalizeContract(contract), {
+        schema: yaml.CORE_SCHEMA,
+        lineWidth: -1,
+        noRefs: true,
+        sortKeys: false,
+        indent: 2,
+    });
+}
+export function parseWorkflowText(text) {
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+    }
+    let loaded;
+    try {
+        loaded = yaml.load(text, { schema: yaml.CORE_SCHEMA });
+    }
+    catch (error) {
+        const detail = error instanceof Error ? error.message : String(error);
+        throw new Error(`workflow file is not valid YAML or JSON: ${detail}`);
+    }
+    if (typeof loaded !== "object" || loaded === null || Array.isArray(loaded)) {
+        throw new Error("workflow file is not valid YAML or JSON");
+    }
+    return loaded;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aicopycoders/exodus",
-  "version": "2026.7.200-beta.8",
+  "version": "2026.8.1100",
   "description": "CLI + Claude Code skills for the Copycoders Exodus ad pipeline",
   "repository": {
     "type": "git",
@@ -28,8 +28,11 @@
     "prepack": "npm run build && npm run bundle-assets",
     "dev": "tsx bin/exodus.ts"
   },
-  "dependencies": {},
+  "dependencies": {
+    "js-yaml": "^4.1.1"
+  },
   "devDependencies": {
+    "@types/js-yaml": "^4.0.9",
     "@types/node": "^20.0.0",
     "esbuild": "^0.25.0",
     "tsx": "^4.7.0",