@aicopycoders/exodus 2026.6.2902 → 2026.7.200-beta.10

package/dist/commands/winners.js

@@ -0,0 +1,401 @@
+import fs from "node:fs";
+import path from "node:path";
+import { apiGet, apiPost } from "../lib/client.js";
+import { formatError } from "../lib/format.js";
+import { pollUntilDone } from "../lib/poll.js";
+export const helpText = `
+exodus winners — Import your own brand's winning ads as generative fuel
+
+Your agent (holding the Meta Ads MCP) assembles a winner-package JSON of
+designated ad-account winners; this command pushes it into Exodus. Each
+winner lands as a swipe row under an auto-created own-brand entry, enriched
+server-side (Ad Library match → scrape, or your pushed media files), and
+surfaces in generation selection with its verdict.
+
+Usage:
+  exodus winners import <file.json | ->        Push a winner package (- reads stdin)
+  exodus winners status <importId>             Re-poll an import later
+  exodus winners list                          Winners Exodus already holds
+
+Import flags:
+  --dry-run      Local schema check + server dry-run: reports would-create vs
+                 would-update per winner. Zero writes, no media upload.
+  --no-wait      Return the importId immediately instead of polling
+  --json         Machine-readable JSON output
+
+Notes:
+  • Scopes to your active brand's workspace (exodus brand current).
+  • Requires your Scrape Creators API key (Settings → Keys) — the own-page
+    match scrape bills your account.
+  • Re-pushing the same file is safe: no duplicate rows, the verdict snapshot
+    is replaced wholesale, and previously gap-filled winners that now match
+    upgrade in place. Winners absent from a re-push are untouched.
+  • assets paths in the package resolve relative to the JSON file's folder.
+
+Examples:
+  exodus winners import winners.json
+  exodus winners import winners.json --dry-run
+  cat winners.json | exodus winners import -
+  exodus winners status k97abc...
+  exodus winners list
+`.trim();
+export function validatePackageLocally(pkg) {
+    const errors = [];
+    const warnings = [];
+    let winnerCount = 0;
+    if (pkg === null || typeof pkg !== "object") {
+        return { ok: false, errors: ["package is not a JSON object"], warnings, winnerCount };
+    }
+    const p = pkg;
+    if (p.version !== 1)
+        errors.push("version must be 1");
+    const source = (p.source ?? {});
+    if (typeof source.pageId !== "string" || !source.pageId.trim())
+        errors.push("source.pageId is required (the scrape target + own-brand key)");
+    if (typeof source.pageName !== "string" || !source.pageName.trim())
+        errors.push("source.pageName is required (names the own-brand entry)");
+    if (typeof source.adAccountId !== "string" || !source.adAccountId.trim())
+        errors.push("source.adAccountId is required");
+    if (!Array.isArray(p.winners) || p.winners.length === 0) {
+        errors.push("winners array is required and must be non-empty");
+        return { ok: errors.length === 0, errors, warnings, winnerCount };
+    }
+    winnerCount = p.winners.length;
+    const seen = new Set();
+    p.winners.forEach((raw, i) => {
+        const label = `winner #${i + 1}`;
+        if (raw === null || typeof raw !== "object") {
+            warnings.push(`${label}: not an object — the server will reject it`);
+            return;
+        }
+        const w = raw;
+        const id = typeof w.accountAdId === "string" ? w.accountAdId : undefined;
+        if (!id)
+            warnings.push(`${label}: missing accountAdId`);
+        else if (seen.has(id))
+            warnings.push(`${label} (${id}): duplicate accountAdId`);
+        else
+            seen.add(id);
+        if (w.format !== "video" && w.format !== "image")
+            warnings.push(`${label}${id ? ` (${id})` : ""}: format must be "video" or "image"`);
+        const verdict = (w.verdict ?? {});
+        if (typeof verdict.sentence !== "string" || !verdict.sentence.trim())
+            warnings.push(`${label}${id ? ` (${id})` : ""}: missing verdict.sentence`);
+        if ((typeof w.bodyText !== "string" || !w.bodyText.trim()) &&
+            (typeof w.headline !== "string" || !w.headline.trim()))
+            warnings.push(`${label}${id ? ` (${id})` : ""}: needs bodyText or headline`);
+    });
+    return { ok: errors.length === 0, errors, warnings, winnerCount };
+}
+export function contentTypeFor(filePath) {
+    const ext = path.extname(filePath).toLowerCase();
+    const map = {
+        ".jpg": "image/jpeg",
+        ".jpeg": "image/jpeg",
+        ".png": "image/png",
+        ".webp": "image/webp",
+        ".gif": "image/gif",
+        ".mp4": "video/mp4",
+        ".m4v": "video/mp4",
+        ".mov": "video/quicktime",
+        ".webm": "video/webm",
+    };
+    return map[ext] ?? "application/octet-stream";
+}
+export async function run(flags) {
+    const positional = parsePositional();
+    const [sub, ...rest] = positional;
+    if (sub === "import")
+        return runImport(rest, flags);
+    if (sub === "status")
+        return runStatus(rest, flags);
+    if (sub === "list")
+        return runList(flags);
+    if (!sub) {
+        console.log(helpText);
+        return;
+    }
+    console.error(`Unknown subcommand: "${sub}"\n`);
+    console.log(helpText);
+    process.exit(1);
+}
+function parsePositional() {
+    return process.argv.slice(3).filter((a) => !a.startsWith("--"));
+}
+async function runImport(positional, flags) {
+    const json = !!flags["json"];
+    const dryRun = !!flags["dry-run"] || !!flags["dryRun"];
+    const noWait = flags["wait"] === false || flags["no-wait"] === true;
+    const fileArg = positional[0];
+    if (!fileArg) {
+        console.error("Error: a package file is required (or - for stdin)");
+        console.log("Usage: exodus winners import <file.json | ->");
+        process.exit(1);
+    }
+    let rawText;
+    let baseDir;
+    if (fileArg === "-") {
+        rawText = fs.readFileSync(0, "utf-8");
+        baseDir = process.cwd();
+    }
+    else {
+        if (!fs.existsSync(fileArg)) {
+            console.error(`Error: file not found: ${fileArg}`);
+            process.exit(1);
+        }
+        rawText = fs.readFileSync(fileArg, "utf-8");
+        baseDir = path.dirname(path.resolve(fileArg));
+    }
+    let pkg;
+    try {
+        pkg = JSON.parse(rawText);
+    }
+    catch (err) {
+        console.error(`Error: package is not valid JSON: ${err instanceof Error ? err.message : err}`);
+        process.exit(1);
+    }
+    const validation = validatePackageLocally(pkg);
+    if (!validation.ok) {
+        if (json) {
+            console.log(JSON.stringify({ ok: false, errors: validation.errors }));
+        }
+        else {
+            console.error("Package failed local validation:");
+            for (const e of validation.errors)
+                console.error(`  • ${e}`);
+        }
+        process.exit(1);
+    }
+    if (!json) {
+        for (const w of validation.warnings)
+            console.error(`Warning: ${w}`);
+    }
+    const winners = (pkg.winners ?? []).filter((w) => w !== null && typeof w === "object");
+    const missingFiles = [];
+    for (const w of winners) {
+        const assets = (w.assets ?? {});
+        for (const key of ["imagePath", "videoPath", "posterPath"]) {
+            const p = assets[key];
+            if (typeof p === "string" && p.trim() && !fs.existsSync(path.resolve(baseDir, p))) {
+                missingFiles.push(p);
+            }
+        }
+    }
+    if (!dryRun && missingFiles.length > 0) {
+        console.error("Error: referenced asset file(s) not found:");
+        for (const f of missingFiles)
+            console.error(`  • ${f}`);
+        process.exit(1);
+    }
+    if (dryRun) {
+        const res = await apiPost("/api/v2/winners", {
+            ...pkg,
+            dryRun: true,
+        });
+        if (!res.ok) {
+            if (json)
+                console.log(JSON.stringify({ ok: false, status: res.status, data: res.data }));
+            else
+                console.log(formatError(res));
+            process.exit(1);
+        }
+        if (json) {
+            console.log(JSON.stringify({ ok: true, ...res.data, localWarnings: validation.warnings }));
+            return;
+        }
+        const per = res.data.perWinner ?? [];
+        const creates = per.filter((p) => p.action === "create").length;
+        const updates = per.filter((p) => p.action === "update").length;
+        console.log("Dry run — no writes, no Trigger fire, no media upload.");
+        console.log(res.data.wouldCreateBrand
+            ? "  own-brand entry: would be created"
+            : `  own-brand entry: exists (${res.data.brandName ?? "?"})`);
+        console.log(`  winners: ${creates} would-create, ${updates} would-update`);
+        for (const p of per)
+            console.log(`    ${p.accountAdId}  ${p.action}`);
+        for (const r of res.data.rejected ?? []) {
+            console.log(`    ${r.accountAdId}  would-reject (${r.reason})`);
+        }
+        if (res.data.scrapecreatorsKey === "missing") {
+            console.log("\nHeads up: no Scrape Creators key on your account — a real import will fail.");
+            console.log("Add it in Settings → Keys (get one at scrapecreators.com).");
+        }
+        return;
+    }
+    for (const w of winners) {
+        const assets = (w.assets ?? {});
+        const swapped = {};
+        const pairs = [
+            ["imagePath", "imageStorageId"],
+            ["videoPath", "videoStorageId"],
+            ["posterPath", "posterStorageId"],
+        ];
+        for (const [pathKey, idKey] of pairs) {
+            const rel = assets[pathKey];
+            if (typeof rel !== "string" || !rel.trim())
+                continue;
+            const abs = path.resolve(baseDir, rel);
+            const storageId = await uploadAsset(abs, json);
+            if (!storageId)
+                process.exit(1);
+            swapped[idKey] = storageId;
+        }
+        if (Object.keys(swapped).length > 0) {
+            w.assets = swapped;
+        }
+        else {
+            delete w.assets;
+        }
+    }
+    const res = await apiPost("/api/v2/winners", pkg);
+    if (!res.ok || !res.data.importId) {
+        if (json)
+            console.log(JSON.stringify({ ok: false, status: res.status, data: res.data }));
+        else
+            console.log(formatError(res));
+        process.exit(1);
+    }
+    const importId = res.data.importId;
+    if (noWait) {
+        if (json) {
+            console.log(JSON.stringify({ ok: true, importId, triggerRunId: res.data.triggerRunId, accepted: res.data.accepted, rejected: res.data.rejected }));
+            return;
+        }
+        console.log(`Import started: ${importId}`);
+        console.log(`  accepted: ${res.data.accepted ?? "?"} winner(s)`);
+        for (const r of res.data.rejected ?? []) {
+            console.log(`  rejected: ${r.accountAdId} (${r.reason})`);
+        }
+        console.log(`\nPoll: exodus winners status ${importId}`);
+        return;
+    }
+    if (!json) {
+        console.log(`Import started: ${importId} — waiting for outcomes…`);
+    }
+    let lastStatus = "";
+    const poll = await pollUntilDone({
+        path: `/api/v2/winners/imports/${importId}`,
+        terminalStatuses: ["done"],
+        onProgress: (data) => {
+            const status = typeof data.status === "string" ? data.status : "";
+            if (!json && status && status !== lastStatus) {
+                lastStatus = status;
+                console.log(`  status: ${status}`);
+            }
+        },
+    });
+    const outcome = poll.data;
+    if (json) {
+        console.log(JSON.stringify({ ok: poll.ok, timedOut: poll.timedOut, ...outcome }));
+        if (!poll.ok)
+            process.exit(1);
+        return;
+    }
+    if (poll.timedOut) {
+        console.log(`Timed out waiting. Re-poll: exodus winners status ${importId}`);
+        process.exit(1);
+    }
+    printOutcomeTable(outcome);
+    if (!poll.ok)
+        process.exit(1);
+}
+async function uploadAsset(absPath, json) {
+    const upRes = await apiPost("/api/v2/winners/upload-url", {});
+    if (!upRes.ok || !upRes.data.uploadUrl) {
+        if (json)
+            console.log(JSON.stringify({ ok: false, step: "upload-url", data: upRes.data }));
+        else
+            console.log(formatError(upRes));
+        return null;
+    }
+    const bytes = fs.readFileSync(absPath);
+    const put = await fetch(upRes.data.uploadUrl, {
+        method: "POST",
+        headers: { "Content-Type": contentTypeFor(absPath) },
+        body: new Blob([bytes]),
+    });
+    if (!put.ok) {
+        const text = await put.text().catch(() => "(unreadable)");
+        if (json)
+            console.log(JSON.stringify({ ok: false, step: "upload", status: put.status }));
+        else
+            console.error(`Error uploading ${path.basename(absPath)}: ${put.status} ${text.slice(0, 200)}`);
+        return null;
+    }
+    const { storageId } = (await put.json());
+    if (!storageId) {
+        console.error(`Error: no storageId returned for ${path.basename(absPath)}`);
+        return null;
+    }
+    if (!json)
+        console.log(`  uploaded ${path.basename(absPath)}`);
+    return storageId;
+}
+function printOutcomeTable(data) {
+    const winners = data.winners ?? [];
+    console.log(`\nImport ${data.importId ?? "?"}: ${data.status ?? "?"}`);
+    if (data.error)
+        console.log(`  error: ${data.error}`);
+    const created = winners.filter((w) => w.created === true).length;
+    const updated = winners.filter((w) => w.created === false).length;
+    console.log(`  ${winners.length} winner(s): ${created} created, ${updated} updated`);
+    for (const w of winners) {
+        let detail = "";
+        if (w.outcome === "partial" && w.missing?.length)
+            detail = ` (missing: ${w.missing.join(", ")})`;
+        if (w.outcome === "rejected" && w.reason)
+            detail = ` (${w.reason})`;
+        console.log(`    ${w.accountAdId}  ${w.outcome}${detail}`);
+    }
+}
+async function runStatus(positional, flags) {
+    const importId = positional[0];
+    if (!importId) {
+        console.error("Error: importId is required");
+        console.log("Usage: exodus winners status <importId>");
+        process.exit(1);
+    }
+    const json = !!flags["json"];
+    const res = await apiGet(`/api/v2/winners/imports/${encodeURIComponent(importId)}`);
+    if (!res.ok) {
+        if (json)
+            console.log(JSON.stringify({ ok: false, status: res.status, data: res.data }));
+        else
+            console.log(formatError(res));
+        process.exit(1);
+    }
+    if (json) {
+        console.log(JSON.stringify({ ok: true, ...res.data }));
+        return;
+    }
+    printOutcomeTable(res.data);
+}
+async function runList(flags) {
+    const json = !!flags["json"];
+    const res = await apiGet("/api/v2/winners");
+    if (!res.ok) {
+        if (json)
+            console.log(JSON.stringify({ ok: false, status: res.status, data: res.data }));
+        else
+            console.log(formatError(res));
+        process.exit(1);
+    }
+    const winners = res.data.winners ?? [];
+    if (json) {
+        console.log(JSON.stringify({ ok: true, winners }));
+        return;
+    }
+    if (winners.length === 0) {
+        console.log("No imported winners yet. Push some: exodus winners import <file.json>");
+        return;
+    }
+    console.log(`Winners (${winners.length}):`);
+    for (const w of winners) {
+        const status = w.enrichmentStatus === "partial"
+            ? `partial${w.enrichmentMissing?.length ? ` (missing: ${w.enrichmentMissing.join(", ")})` : ""}`
+            : (w.enrichmentStatus ?? "?");
+        const when = w.designatedAt ? new Date(w.designatedAt).toLocaleDateString() : "?";
+        console.log(`  ${w.sourceAdId ?? w.id}  [${w.format}]  ${status}  designated=${when}`);
+        console.log(`    ${w.verdictSentence}`);
+    }
+}

package/dist/commands/workflow.d.ts

@@ -0,0 +1,298 @@
+import { type ApiResponse } from "../lib/client.js";
+import { type PollOptions, type PollResult } from "../lib/poll.js";
+export declare const helpText: string;
+export type WorkflowNodeKind = "brief" | "bot" | "primer" | "image" | "rig" | "storyboard" | "reference" | "scene-frames" | "video" | "voiceover" | "output";
+export interface WorkflowNode {
+    id: string;
+    kind: WorkflowNodeKind;
+    position: {
+        x: number;
+        y: number;
+    };
+    config: Record<string, unknown>;
+}
+export interface WorkflowEdge {
+    id: string;
+    source: string;
+    sourceHandle: string;
+    target: string;
+    targetHandle: string;
+}
+export interface WorkflowContractJson {
+    contract: "exodus-workflow";
+    version: number;
+    workflowId?: string;
+    updatedAt?: string;
+    name: string;
+    description?: string;
+    nodes: WorkflowNode[];
+    edges: WorkflowEdge[];
+}
+export interface UnresolvedWorkflowRef {
+    nodeId: string;
+    ref: "persona" | "primer";
+    value: string;
+    message: string;
+}
+export interface WorkflowImportResult {
+    name: string;
+    created: boolean;
+    workflowId?: string;
+    nodeCount: number;
+    edgeCount: number;
+    unresolved: UnresolvedWorkflowRef[];
+    warnings: string[];
+}
+export type GraphIssueCode = "bad-shape" | "unknown-kind" | "duplicate-node-id" | "dangling-edge" | "unknown-port" | "type-mismatch" | "duplicate-input" | "cycle" | "missing-required-input" | "bad-config";
+export interface GraphIssue {
+    code: GraphIssueCode;
+    message: string;
+    nodeId?: string;
+    edgeId?: string;
+    portId?: string;
+    remedy?: string;
+}
+export type WorkflowImportErrorCode = "invalid-graph" | "conflict" | "forbidden" | "not-found";
+export interface WorkflowImportError {
+    code: WorkflowImportErrorCode;
+    message: string;
+    issues?: GraphIssue[];
+    currentUpdatedAt?: string;
+}
+export type WorkflowPortType = "text" | "primer" | "image" | "rig" | "storyboard" | "frames" | "video" | "audio";
+export type WorkflowPrimerKind = "body" | "hook" | "headline" | "summary";
+export type WorkflowDurationSpec = {
+    kind: "fixed";
+    values: number[];
+} | {
+    kind: "range";
+    min: number;
+    max: number;
+};
+export interface CatalogVideoModel {
+    id: string;
+    label: string;
+    durations: WorkflowDurationSpec;
+    audioTogglable: boolean;
+}
+export type WorkflowParamKind = "select" | "text" | "textarea" | "toggle" | "number" | "multiselect";
+export interface CatalogInput {
+    id: string;
+    label: string;
+    accepts: WorkflowPortType[];
+    required: boolean;
+    multi?: boolean;
+    primerKinds?: WorkflowPrimerKind[];
+}
+export interface CatalogParam {
+    key: string;
+    label: string;
+    kind: WorkflowParamKind;
+    options?: string[];
+    min?: number;
+    max?: number;
+    required?: boolean;
+    help?: string;
+    default?: string;
+}
+export interface CatalogBot {
+    slug: string;
+    name: string;
+    blurb: string;
+    category: string;
+    categoryLabel: string;
+    inputs: CatalogInput[];
+    params: CatalogParam[];
+    outputType: string;
+    splitsOutput: boolean;
+}
+export interface WorkflowCatalog {
+    catalog: "exodus-workflow-catalog";
+    version: 1;
+    bots: CatalogBot[];
+    vocabulary: {
+        nodeKinds: string[];
+        briefSources: string[];
+        primerKinds: string[];
+        imageModels: string[];
+        aspectRatios: string[];
+        imageQuantityModes: string[];
+        videoModels: CatalogVideoModel[];
+        categories: Array<{
+            id: string;
+            label: string;
+        }>;
+    };
+    customBot: {
+        slug: "custom";
+        configKey: "customSlug";
+        inputs: CatalogInput[];
+        summaryOnlySlugs: string[];
+        notes: string;
+    };
+}
+export type WorkflowBriefSource = "text" | "swipe-ad" | "swipe-bundle" | "organic-url" | "ad-url";
+export interface WorkflowInputDescriptor {
+    fieldName: string;
+    nodeId: string;
+    source: WorkflowBriefSource;
+    required: boolean;
+    description?: string;
+    bundleSize?: number;
+}
+export interface WorkflowPrerequisiteDescriptor {
+    primerKind: WorkflowPrimerKind;
+    nodeIds: string[];
+}
+export interface WorkflowOutputDescriptor {
+    type: "text" | "image" | "video" | "audio" | "frames" | "storyboard";
+    label: string;
+    nodeId: string;
+    botSlug?: string;
+}
+export interface WorkflowDescribeResponse {
+    workflowId: string;
+    name: string;
+    description?: string;
+    updatedAt: string;
+    inputs: WorkflowInputDescriptor[];
+    prerequisites: Array<WorkflowPrerequisiteDescriptor & {
+        stored: boolean;
+    }>;
+    outputs: WorkflowOutputDescriptor[];
+}
+export interface WorkflowListItem {
+    _id: string;
+    name: string;
+    description?: string;
+    nodeCount: number;
+    edgeCount: number;
+    createdAt: string;
+    updatedAt: string;
+    isCrossBrand?: boolean;
+    homeBrandName?: string | null;
+}
+export interface WorkflowListResponse {
+    workflows: WorkflowListItem[];
+}
+export type WorkflowRunStatus = "queued" | "running" | "awaiting-review" | "completed" | "partial" | "failed" | "canceled";
+export type WorkflowNodeRunStatus = "idle" | "running" | "done" | "failed" | "skipped";
+export type WorkflowArtifact = {
+    type: "text";
+    text: string;
+    label?: string;
+} | {
+    type: "primer";
+    text: string;
+    primerKind: string;
+} | {
+    type: "image";
+    storageId: string;
+    imageUrl?: string;
+};
+export interface WorkflowRunOutput {
+    nodeId: string;
+    botSlug?: string;
+    type: "text" | "image" | "video" | "audio" | "frames" | "storyboard";
+    label: string;
+    text?: string;
+    imageUrl?: string;
+    imageId?: string;
+    videoUrl?: string;
+    audioUrl?: string;
+    durationSec?: number;
+    sceneIndex?: number;
+    final?: boolean;
+    frames?: Array<{
+        sceneIndex: number;
+        imageUrl?: string;
+    }>;
+    storyboardJson?: string;
+}
+export interface WorkflowRunNode {
+    nodeId: string;
+    kind: string;
+    status: WorkflowNodeRunStatus;
+    error?: string;
+    startedAt?: number;
+    completedAt?: number;
+    outputs: WorkflowArtifact[];
+}
+export interface WorkflowCounts {
+    done: number;
+    failed: number;
+    skipped: number;
+    total: number;
+}
+export interface WorkflowRun {
+    _id: string;
+    workflowId: string;
+    workflowName: string;
+    status: WorkflowRunStatus;
+    error?: string;
+    counts?: WorkflowCounts;
+    inputs: Record<string, string>;
+    triggerRunId?: string;
+    createdAt: number;
+    startedAt?: number;
+    completedAt?: number;
+    isTerminal: boolean;
+    nodes: WorkflowRunNode[];
+    outputs?: WorkflowRunOutput[];
+}
+export type WorkflowRunProjection = Omit<WorkflowRun, "nodes"> & {
+    nodes?: never;
+};
+export interface WorkflowRunDeps {
+    get: (path: string) => Promise<ApiResponse<unknown>>;
+    post: (path: string, body: unknown) => Promise<ApiResponse<unknown>>;
+    readFile: (path: string) => string;
+    writeFile: (path: string, text: string) => void;
+    poll: (opts: PollOptions) => Promise<PollResult>;
+}
+export interface FlowResult {
+    code: number;
+    lines: string[];
+}
+interface RunFlowOptions {
+    inputs: Record<string, string>;
+    wait: boolean;
+    json: boolean;
+    onProgressLine?: (line: string) => void;
+}
+export declare function parseInputFlags(args: string[], readFile?: (path: string) => string): Record<string, string>;
+export declare function formatWorkflowList(workflows: WorkflowListItem[]): string;
+export declare function formatRecentRuns(runs: WorkflowRunProjection[]): string;
+export declare function formatImportSummary(result: WorkflowImportResult, mode?: {
+    dryRun?: boolean;
+    update?: boolean;
+}): string;
+export declare function formatWorkflowRun(run: WorkflowRun): string;
+export declare function formatDescribe(res: WorkflowDescribeResponse): string;
+export declare function formatBotsList(catalog: WorkflowCatalog, category?: string): string;
+export declare function formatBotDetail(bot: CatalogBot): string;
+export declare function resolveWorkflowId(ref: string, deps: WorkflowRunDeps): Promise<string>;
+export declare function listFlow(json: boolean, deps: WorkflowRunDeps): Promise<FlowResult>;
+export declare function describeFlow(workflowRef: string, opts: {
+    json: boolean;
+}, deps: WorkflowRunDeps): Promise<FlowResult>;
+export declare function botsFlow(opts: {
+    category?: string;
+    slug?: string;
+    json: boolean;
+}, deps: WorkflowRunDeps): Promise<FlowResult>;
+export declare function runFlow(workflowRef: string, opts: RunFlowOptions, deps: WorkflowRunDeps): Promise<FlowResult>;
+export declare function statusFlow(opts: {
+    id?: string;
+    json: boolean;
+}, deps: WorkflowRunDeps): Promise<FlowResult>;
+export declare function exportFlow(workflowRef: string, opts: {
+    out?: string;
+}, deps: WorkflowRunDeps): Promise<FlowResult>;
+export declare function importFlow(file: string, opts: {
+    dryRun: boolean;
+    json: boolean;
+    update?: string;
+}, deps: WorkflowRunDeps): Promise<FlowResult>;
+export declare function run(flags: Record<string, string | boolean>): Promise<void>;
+export {};