@aicopycoders/exodus 2026.6.2400

package/dist/lib/format.js

@@ -0,0 +1,172 @@
+function stepIcon(status) {
+    if (status === "completed" || status === "done")
+        return "✓";
+    if (status === "failed" || status === "error")
+        return "✗";
+    return "…";
+}
+function formatSteps(steps) {
+    if (!Array.isArray(steps) || steps.length === 0)
+        return "";
+    const lines = steps.map((s) => {
+        if (typeof s !== "object" || s === null)
+            return `  ${stepIcon(null)} ${String(s)}`;
+        const step = s;
+        const name = step["label"] ?? step["name"] ?? step["key"] ?? step["step"] ?? step["id"] ?? "Step";
+        const status = step["status"];
+        const icon = stepIcon(status);
+        const detail = step["detail"] ?? step["message"];
+        const error = step["error"];
+        const parts = [];
+        if (detail)
+            parts.push(String(detail));
+        if (error && error !== detail)
+            parts.push(`error: ${String(error)}`);
+        const extra = parts.length > 0 ? ` — ${parts.join(" | ")}` : "";
+        return `  ${icon} ${String(name)}${extra}`;
+    });
+    return "\n**Steps:**\n" + lines.join("\n");
+}
+export function formatGeneration(data) {
+    const lines = [];
+    const status = data["status"] ?? "unknown";
+    lines.push(`## Generation Result`);
+    lines.push(`**Status:** ${status}`);
+    if (data["agentName"] || data["agent"]) {
+        lines.push(`**Agent:** ${data["agentName"] ?? data["agent"]}`);
+    }
+    const vType = data["variationType"];
+    const nVar = data["numVariations"];
+    if (typeof vType === "string" && typeof nVar === "number") {
+        lines.push(`**Config:** ${vType} × ${nVar}`);
+    }
+    if (data["googleDocUrl"] || data["docUrl"]) {
+        lines.push(`**Google Doc:** ${data["googleDocUrl"] ?? data["docUrl"]}`);
+    }
+    if (data["error"]) {
+        lines.push(`**Error:** ${data["error"]}`);
+    }
+    const steps = data["steps"];
+    if (steps) {
+        lines.push(formatSteps(steps));
+    }
+    if (Array.isArray(data["hooks"]) && data["hooks"].length > 0) {
+        lines.push(`\n**Hooks (${data["hooks"].length}):**`);
+        for (const hook of data["hooks"].slice(0, 10)) {
+            lines.push(`  - ${String(hook)}`);
+        }
+    }
+    if (Array.isArray(data["headlines"]) && data["headlines"].length > 0) {
+        lines.push(`\n**Headlines (${data["headlines"].length}):**`);
+        for (const h of data["headlines"].slice(0, 10)) {
+            lines.push(`  - ${String(h)}`);
+        }
+    }
+    if (data["adCopy"] || data["body"]) {
+        lines.push(`\n**Ad Copy:**\n${data["adCopy"] ?? data["body"]}`);
+    }
+    return lines.join("\n");
+}
+export function formatGenesisRun(data) {
+    const lines = [];
+    const status = data["status"] ?? "unknown";
+    lines.push(`## Genesis Run`);
+    lines.push(`**Status:** ${status}`);
+    if (data["awarenessLevel"] || data["awareness"]) {
+        lines.push(`**Awareness Level:** ${data["awarenessLevel"] ?? data["awareness"]}`);
+    }
+    if (data["inputMethod"] || data["method"]) {
+        lines.push(`**Input Method:** ${data["inputMethod"] ?? data["method"]}`);
+    }
+    if (data["googleDocUrl"] || data["docUrl"]) {
+        lines.push(`**Google Doc:** ${data["googleDocUrl"] ?? data["docUrl"]}`);
+    }
+    if (data["error"]) {
+        lines.push(`**Error:** ${data["error"]}`);
+    }
+    const hookCount = data["hookCount"] ??
+        (Array.isArray(data["hooks"]) ? data["hooks"].length : null);
+    if (hookCount !== null && hookCount !== undefined) {
+        lines.push(`**Hooks:** ${hookCount}`);
+    }
+    const headlineCount = data["headlineCount"] ??
+        (Array.isArray(data["headlines"]) ? data["headlines"].length : null);
+    if (headlineCount !== null && headlineCount !== undefined) {
+        lines.push(`**Headlines:** ${headlineCount}`);
+    }
+    const bodyCount = data["bodyCount"] ??
+        (Array.isArray(data["bodies"]) ? data["bodies"].length : null);
+    if (bodyCount !== null && bodyCount !== undefined) {
+        lines.push(`**Body Copies:** ${bodyCount}`);
+    }
+    if (data["durationMs"]) {
+        const secs = Math.round(Number(data["durationMs"]) / 1000);
+        lines.push(`**Duration:** ${secs}s`);
+    }
+    const steps = data["steps"];
+    if (steps) {
+        lines.push(formatSteps(steps));
+    }
+    if (data["document"] && !data["googleDocUrl"]) {
+        lines.push(`\n---\n**Document Output:**\n${data["document"]}`);
+    }
+    return lines.join("\n");
+}
+export function formatBrowse(generations) {
+    if (!Array.isArray(generations) || generations.length === 0) {
+        return "No generations found.";
+    }
+    const lines = [];
+    lines.push(`## Generations (${generations.length})`);
+    lines.push(`date | agent | status | doc`);
+    lines.push(`-----|-------|--------|----`);
+    for (const g of generations) {
+        if (typeof g !== "object" || g === null)
+            continue;
+        const gen = g;
+        const rawDate = gen["createdAt"] ?? gen["_creationTime"];
+        let date = "—";
+        if (typeof rawDate === "number") {
+            date = new Date(rawDate).toISOString().slice(0, 10);
+        }
+        else if (typeof rawDate === "string" && rawDate !== "—") {
+            const parsed = new Date(rawDate);
+            date = isNaN(parsed.getTime()) ? "—" : parsed.toISOString().slice(0, 10);
+        }
+        const agent = gen["agentName"] ?? gen["agentId"] ?? gen["agent"] ?? gen["pipeline"] ?? "—";
+        const status = gen["status"] ?? "—";
+        const doc = gen["googleDocUrl"] ?? gen["docUrl"] ?? "—";
+        lines.push(`${date} | ${agent} | ${status} | ${doc}`);
+    }
+    return lines.join("\n");
+}
+export function formatError(res) {
+    const lines = [];
+    lines.push(`## Error`);
+    lines.push(`**HTTP Status:** ${res.status}`);
+    if (res.data && typeof res.data === "object") {
+        const d = res.data;
+        const err = d["error"];
+        if (err && typeof err === "object") {
+            const e = err;
+            if (e["message"])
+                lines.push(`**Error:** ${e["message"]}`);
+            if (e["code"])
+                lines.push(`**Code:** ${e["code"]}`);
+        }
+        else if (err) {
+            lines.push(`**Error:** ${String(err)}`);
+        }
+        if (d["message"])
+            lines.push(`**Message:** ${d["message"]}`);
+        if (d["code"] && !(err && typeof err === "object"))
+            lines.push(`**Code:** ${d["code"]}`);
+        if (!err && !d["message"]) {
+            lines.push(`**Details:**\n\`\`\`json\n${JSON.stringify(res.data, null, 2)}\n\`\`\``);
+        }
+    }
+    else if (res.data) {
+        lines.push(`**Details:** ${String(res.data)}`);
+    }
+    return lines.join("\n");
+}

package/dist/lib/intel-format.d.ts

@@ -0,0 +1 @@
+export declare function formatIntelResult(data: Record<string, unknown>): string;

package/dist/lib/intel-format.js

@@ -0,0 +1,38 @@
+export function formatIntelResult(data) {
+    const lines = [];
+    lines.push("## Intel Analysis Result");
+    lines.push(`**Status:** ${data["status"] ?? "unknown"}`);
+    if (data["mode"])
+        lines.push(`**Mode:** ${data["mode"]}`);
+    if (data["phase"] !== undefined)
+        lines.push(`**Phase:** ${data["phase"]}`);
+    if (data["adsAnalyzed"] !== undefined)
+        lines.push(`**Ads Analyzed:** ${data["adsAnalyzed"]}`);
+    if (data["winnersFound"] !== undefined)
+        lines.push(`**Winners Found:** ${data["winnersFound"]}`);
+    if (data["losersFound"] !== undefined)
+        lines.push(`**Losers Found:** ${data["losersFound"]}`);
+    const attempted = data["combinationsAttempted"];
+    const succeeded = data["combinationsSucceeded"];
+    const total = data["combinationsCount"];
+    if (total !== undefined)
+        lines.push(`**Combinations (total):** ${total}`);
+    if (attempted !== undefined || succeeded !== undefined) {
+        lines.push(`**Phase 3 outputs:** ${succeeded ?? 0} of ${attempted ?? 0} attempted`);
+    }
+    else if (data["adsWritten"] !== undefined) {
+        lines.push(`**Ads Written:** ${data["adsWritten"]}`);
+    }
+    if (data["phase1DocUrl"])
+        lines.push(`**Phase 1 Doc:** ${data["phase1DocUrl"]}`);
+    if (data["phase3DocUrl"])
+        lines.push(`**Phase 3 Doc:** ${data["phase3DocUrl"]}`);
+    if (!data["phase1DocUrl"] && !data["phase3DocUrl"] && data["googleDocUrl"]) {
+        lines.push(`**Google Doc:** ${data["googleDocUrl"]}`);
+    }
+    if (data["googleSheetUrl"])
+        lines.push(`**Sheet:** ${data["googleSheetUrl"]}`);
+    if (data["error"])
+        lines.push(`**Error:** ${data["error"]}`);
+    return lines.join("\n");
+}

package/dist/lib/keys-sync.d.ts

@@ -0,0 +1,16 @@
+export declare const PROVIDER_ENV_MAP: Record<string, string>;
+export interface RemoteKeys {
+    keys: Record<string, string>;
+    failed: string[];
+}
+export declare function fetchRemoteKeys(): Promise<RemoteKeys>;
+export declare function resolveEnvFilePath(): string;
+export interface UpsertResult {
+    name: string;
+    action: "added" | "updated" | "unchanged";
+}
+export declare function upsertEnvVars(filePath: string, vars: Record<string, string>): UpsertResult[];
+export declare function mapKeysToEnvVars(keys: Record<string, string>): {
+    vars: Record<string, string>;
+    skipped: string[];
+};

package/dist/lib/keys-sync.js

@@ -0,0 +1,88 @@
+import fs from "node:fs";
+import path from "node:path";
+import { apiGetDashboard } from "./client.js";
+export const PROVIDER_ENV_MAP = {
+    genesis: "GENESIS_API_KEY",
+    anthropic: "ANTHROPIC_API_KEY",
+    openrouter: "OPENROUTER_API_KEY",
+    elevenlabs: "ELEVENLABS_API_KEY",
+    kie: "KIE_API_KEY",
+};
+export async function fetchRemoteKeys() {
+    const res = await apiGetDashboard("/api/settings/keys");
+    if (!res.ok) {
+        const msg = res.data?.error ??
+            `failed to fetch keys from dashboard (HTTP ${res.status})`;
+        throw new Error(msg);
+    }
+    return { keys: res.data.keys ?? {}, failed: res.data.failed ?? [] };
+}
+export function resolveEnvFilePath() {
+    let dir = process.cwd();
+    for (let i = 0; i <= 5; i++) {
+        const candidate = path.join(dir, ".env");
+        if (fs.existsSync(candidate) && fs.statSync(candidate).isFile()) {
+            return candidate;
+        }
+        const parent = path.dirname(dir);
+        if (parent === dir)
+            break;
+        dir = parent;
+    }
+    return path.join(process.cwd(), ".env");
+}
+export function upsertEnvVars(filePath, vars) {
+    let content = "";
+    try {
+        content = fs.readFileSync(filePath, "utf8");
+    }
+    catch {
+        content = "";
+    }
+    const lines = content.length ? content.split(/\r?\n/) : [];
+    const results = [];
+    for (const [name, value] of Object.entries(vars)) {
+        const formatted = `${name}=${formatEnvValue(value)}`;
+        const idx = lines.findIndex((l) => {
+            const t = l.trim();
+            if (!t || t.startsWith("#"))
+                return false;
+            const eq = t.indexOf("=");
+            return eq > 0 && t.slice(0, eq).trim() === name;
+        });
+        if (idx === -1) {
+            lines.push(formatted);
+            results.push({ name, action: "added" });
+        }
+        else if (lines[idx] === formatted) {
+            results.push({ name, action: "unchanged" });
+        }
+        else {
+            lines[idx] = formatted;
+            results.push({ name, action: "updated" });
+        }
+    }
+    let out = lines.join("\n");
+    if (!out.endsWith("\n"))
+        out += "\n";
+    fs.writeFileSync(filePath, out, { mode: 0o600 });
+    return results;
+}
+export function mapKeysToEnvVars(keys) {
+    const vars = {};
+    const skipped = [];
+    for (const [provider, value] of Object.entries(keys)) {
+        const envName = PROVIDER_ENV_MAP[provider];
+        if (envName)
+            vars[envName] = value;
+        else
+            skipped.push(provider);
+    }
+    return { vars, skipped };
+}
+function formatEnvValue(value) {
+    if (/[\s#'"]/.test(value)) {
+        return `"${value.replace(/"/g, '\\"')}"`;
+    }
+    return value;
+}

package/dist/lib/layout.d.ts

@@ -0,0 +1,38 @@
+export declare const BRAND_MARKER_FILE = ".exodus-brand.json";
+export interface BrandDirInfo {
+    slug: string;
+    name: string;
+    dir: string;
+}
+export type Layout = "v2" | "legacy";
+export interface ActiveBrand {
+    slug: string | null;
+    source: "folder" | "pointer" | null;
+}
+export declare function findParentRoot(startDir?: string): string;
+export declare function detectLayout(root?: string): Layout;
+export declare function listBrandDirs(root?: string): BrandDirInfo[];
+export declare function brandDirNameForSlug(slug: string): string;
+export declare function brandDirFor(root: string, slug: string): string;
+export declare function ensureBrandDir(root: string, brand: {
+    slug: string;
+    name?: string;
+}): {
+    dir: string;
+    created: boolean;
+};
+export declare function findBrandDirFromCwd(cwd?: string, root?: string): BrandDirInfo | null;
+export declare function resolveActiveBrand(opts?: {
+    cwd?: string;
+    root?: string;
+}): ActiveBrand;
+export declare function brandStateDir(opts?: {
+    slug?: string;
+    cwd?: string;
+    root?: string;
+}): string;
+export declare function brandOutputDir(opts?: {
+    slug?: string;
+    cwd?: string;
+    root?: string;
+}): string;

package/dist/lib/layout.js

@@ -0,0 +1,153 @@
+import fs from "node:fs";
+import path from "node:path";
+export const BRAND_MARKER_FILE = ".exodus-brand.json";
+const RESERVED_DIR_NAMES = new Set([
+    "exodus",
+    "references",
+    "output",
+    "state",
+    "docs",
+    "workspace",
+    "node_modules",
+    ".claude",
+    ".exodus",
+    ".backup",
+]);
+export function findParentRoot(startDir = process.cwd()) {
+    let dir = startDir;
+    for (let i = 0; i < 8; i++) {
+        if (fs.existsSync(path.join(dir, ".env")) ||
+            fs.existsSync(path.join(dir, ".exodus"))) {
+            return dir;
+        }
+        const parent = path.dirname(dir);
+        if (parent === dir)
+            break;
+        dir = parent;
+    }
+    return startDir;
+}
+function readStateFile(root) {
+    const p = path.join(root, ".exodus", "state.json");
+    if (!fs.existsSync(p))
+        return {};
+    try {
+        return JSON.parse(fs.readFileSync(p, "utf-8"));
+    }
+    catch {
+        return {};
+    }
+}
+function readBrandMarker(dir) {
+    const p = path.join(dir, BRAND_MARKER_FILE);
+    if (!fs.existsSync(p))
+        return null;
+    try {
+        const parsed = JSON.parse(fs.readFileSync(p, "utf-8"));
+        if (typeof parsed.slug !== "string" || !parsed.slug.trim())
+            return null;
+        const slug = parsed.slug.trim();
+        const name = typeof parsed.name === "string" && parsed.name.trim()
+            ? parsed.name.trim()
+            : slug;
+        return { slug, name };
+    }
+    catch {
+        return null;
+    }
+}
+export function detectLayout(root = findParentRoot()) {
+    if (readStateFile(root).layoutVersion === 2)
+        return "v2";
+    if (listBrandDirs(root).length > 0)
+        return "v2";
+    return "legacy";
+}
+export function listBrandDirs(root = findParentRoot()) {
+    let entries;
+    try {
+        entries = fs.readdirSync(root, { withFileTypes: true });
+    }
+    catch {
+        return [];
+    }
+    const out = [];
+    for (const entry of entries) {
+        if (!entry.isDirectory())
+            continue;
+        const dir = path.join(root, entry.name);
+        const marker = readBrandMarker(dir);
+        if (marker)
+            out.push({ ...marker, dir });
+    }
+    out.sort((a, b) => a.slug.localeCompare(b.slug));
+    return out;
+}
+export function brandDirNameForSlug(slug) {
+    return RESERVED_DIR_NAMES.has(slug) ? `${slug}-brand` : slug;
+}
+export function brandDirFor(root, slug) {
+    const existing = listBrandDirs(root).find((b) => b.slug === slug);
+    if (existing)
+        return existing.dir;
+    return path.join(root, brandDirNameForSlug(slug));
+}
+export function ensureBrandDir(root, brand) {
+    const dir = brandDirFor(root, brand.slug);
+    const created = !fs.existsSync(path.join(dir, BRAND_MARKER_FILE));
+    fs.mkdirSync(path.join(dir, "state"), { recursive: true });
+    fs.mkdirSync(path.join(dir, "output"), { recursive: true });
+    const marker = { slug: brand.slug, name: brand.name ?? brand.slug };
+    const markerPath = path.join(dir, BRAND_MARKER_FILE);
+    const existing = readBrandMarker(dir);
+    if (!existing || existing.name !== marker.name || existing.slug !== marker.slug) {
+        fs.writeFileSync(markerPath, JSON.stringify(marker, null, 2) + "\n", "utf-8");
+    }
+    return { dir, created };
+}
+export function findBrandDirFromCwd(cwd = process.cwd(), root = findParentRoot(cwd)) {
+    let dir = cwd;
+    for (let i = 0; i < 16; i++) {
+        const marker = readBrandMarker(dir);
+        if (marker)
+            return { ...marker, dir };
+        if (dir === root)
+            break;
+        const parent = path.dirname(dir);
+        if (parent === dir)
+            break;
+        dir = parent;
+    }
+    return null;
+}
+export function resolveActiveBrand(opts) {
+    const cwd = opts?.cwd ?? process.cwd();
+    const root = opts?.root ?? findParentRoot(cwd);
+    const fromFolder = findBrandDirFromCwd(cwd, root);
+    if (fromFolder)
+        return { slug: fromFolder.slug, source: "folder" };
+    const pointer = readStateFile(root).activeBrand;
+    if (pointer)
+        return { slug: pointer, source: "pointer" };
+    return { slug: null, source: null };
+}
+export function brandStateDir(opts) {
+    const cwd = opts?.cwd ?? process.cwd();
+    const root = opts?.root ?? findParentRoot(cwd);
+    if (detectLayout(root) === "v2") {
+        const slug = opts?.slug ?? resolveActiveBrand({ cwd, root }).slug;
+        if (slug)
+            return path.join(brandDirFor(root, slug), "state");
+    }
+    return path.join(root, "state");
+}
+export function brandOutputDir(opts) {
+    const cwd = opts?.cwd ?? process.cwd();
+    const root = opts?.root ?? findParentRoot(cwd);
+    if (detectLayout(root) === "v2") {
+        const slug = opts?.slug ?? resolveActiveBrand({ cwd, root }).slug;
+        if (slug)
+            return path.join(brandDirFor(root, slug), "output");
+    }
+    return path.join(root, "output");
+}

package/dist/lib/load-env.d.ts

@@ -0,0 +1 @@
+export declare function loadWorkspaceEnv(startDir?: string): void;

package/dist/lib/load-env.js

@@ -0,0 +1,47 @@
+import fs from "node:fs";
+import path from "node:path";
+export function loadWorkspaceEnv(startDir = process.cwd()) {
+    const envPath = findEnvFile(startDir, 8);
+    if (!envPath)
+        return;
+    let contents;
+    try {
+        contents = fs.readFileSync(envPath, "utf8");
+    }
+    catch {
+        return;
+    }
+    for (const rawLine of contents.split(/\r?\n/)) {
+        const line = rawLine.trim();
+        if (!line || line.startsWith("#"))
+            continue;
+        const eq = line.indexOf("=");
+        if (eq <= 0)
+            continue;
+        const key = line.slice(0, eq).trim();
+        if (!key || /[^A-Za-z0-9_]/.test(key))
+            continue;
+        if (process.env[key] !== undefined)
+            continue;
+        let value = line.slice(eq + 1).trim();
+        if ((value.startsWith('"') && value.endsWith('"')) ||
+            (value.startsWith("'") && value.endsWith("'"))) {
+            value = value.slice(1, -1);
+        }
+        process.env[key] = value;
+    }
+}
+function findEnvFile(startDir, maxLevels) {
+    let dir = startDir;
+    for (let i = 0; i <= maxLevels; i++) {
+        const candidate = path.join(dir, ".env");
+        if (fs.existsSync(candidate) && fs.statSync(candidate).isFile()) {
+            return candidate;
+        }
+        const parent = path.dirname(dir);
+        if (parent === dir)
+            break;
+        dir = parent;
+    }
+    return null;
+}

package/dist/lib/pixar-orchestrator-types.d.ts

@@ -0,0 +1,54 @@
+export type PixarResumeStage = "scriptPrep" | "parser" | "storyboard" | "castSheet" | "storyboardImages" | "voiceAndClips" | "stitch";
+export interface PixarRunPayload {
+    runId: string;
+    resumeFrom?: PixarResumeStage;
+}
+export interface PixarPausedResult {
+    paused: true;
+    status: string;
+}
+export interface PixarCompletedResult {
+    muxPlaybackId: string;
+    muxAssetId: string;
+    finalDurationSec: number;
+}
+export type PixarRunResult = PixarPausedResult | PixarCompletedResult;
+export interface PixarRunRow {
+    _id: string;
+    status: string;
+    failedStage?: string;
+    errorMessage?: string;
+    muxPlaybackId?: string;
+    muxAssetId?: string;
+    finalDurationSec?: number;
+    cost?: {
+        total?: number;
+    };
+    castSheetStorageId?: string;
+    voiceoverStorageIds?: string[];
+    silentClipStorageIds?: string[];
+    googleDocUrl?: string;
+}
+export interface PixarRunListItem {
+    _id: string;
+    status: string;
+    createdAt: number;
+    scriptInputMode?: "provided" | "generated";
+    finalDurationSec?: number;
+    muxPlaybackId?: string;
+    failedStage?: string;
+}
+export interface PixarBundle {
+    runPixarPipeline(payload: PixarRunPayload): Promise<PixarRunResult>;
+    resolveWorkspaceId(workspaceSlug: string): Promise<string | null>;
+    createRun(args: {
+        workspaceId: string;
+        triggeredByUserId: string;
+        script?: string;
+        scriptPrepBrief?: string;
+        refImageUrl?: string;
+        reviewMode: "auto" | "review";
+    }): Promise<string>;
+    fetchRun(runId: string): Promise<PixarRunRow | null>;
+    listRuns(workspaceId: string, limit?: number): Promise<PixarRunListItem[]>;
+}

package/dist/lib/pixar-orchestrator-types.js

@@ -0,0 +1 @@
+export {};

package/dist/lib/poll.d.ts

@@ -0,0 +1,14 @@
+export interface PollOptions {
+    path: string;
+    intervalMs?: number;
+    timeoutMs?: number;
+    terminalStatuses?: string[];
+    onProgress?: (data: Record<string, unknown>) => void;
+    isDone?: (data: Record<string, unknown>) => boolean;
+}
+export interface PollResult {
+    ok: boolean;
+    data: Record<string, unknown>;
+    timedOut: boolean;
+}
+export declare function pollUntilDone(opts: PollOptions): Promise<PollResult>;

package/dist/lib/poll.js

@@ -0,0 +1,32 @@
+import { apiGet } from "./client.js";
+const DEFAULT_TERMINAL_STATUSES = ["completed", "failed"];
+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 deadline = Date.now() + timeoutMs;
+    while (true) {
+        const res = await apiGet(path);
+        if (onProgress) {
+            onProgress(res.data);
+        }
+        const status = typeof res.data["status"] === "string" ? res.data["status"] : undefined;
+        if (!res.ok) {
+            return { ok: false, data: res.data, timedOut: false };
+        }
+        if (status === "failed") {
+            return { ok: false, data: res.data, timedOut: false };
+        }
+        const statusTerminal = status ? terminal.has(status) : false;
+        const customDone = isDone ? isDone(res.data) : true;
+        if (statusTerminal && customDone) {
+            return { ok: true, data: res.data, timedOut: false };
+        }
+        if (Date.now() + intervalMs > deadline) {
+            return { ok: false, data: res.data, timedOut: true };
+        }
+        await delay(intervalMs);
+    }
+}

package/dist/lib/preflight.d.ts

@@ -0,0 +1,18 @@
+export declare function hasBinary(name: string): boolean;
+export interface KeySyncResult {
+    pulled: string[];
+    failed: string[];
+    error?: string;
+}
+export declare function syncKeysToEnv(): Promise<KeySyncResult>;
+export interface RequiredKey {
+    label: string;
+    anyOf: string[];
+}
+export declare const PIXAR_REQUIRED_KEYS: RequiredKey[];
+export declare const PIXAR_MUX_ENV_VARS: string[];
+type Env = Record<string, string | undefined>;
+export declare function missingRequiredKeys(env: Env, required?: RequiredKey[]): string[];
+export declare function missingRequiredEnvVars(env: Env, required?: RequiredKey[]): string[];
+export declare function muxConfigured(env: Env): boolean;
+export {};