@aicopycoders/exodus 2026.9.200 → 2026.9.1100-beta.1

package/dist/commands/comments.js

@@ -0,0 +1,198 @@
+import { count, dateOrDash, defaultMetaAdsDeps, errorFor, safeText, truncate, } from "../lib/meta-ads.js";
+export const helpText = `
+exodus comments — read the comments on your own synced Meta ads (read-only)
+
+The daily Meta sync stores the comments people left on the brand's ads, on both
+Facebook and Instagram. This reads them back. Commenter names and profile links
+are stripped server-side before they are ever stored — you get the words, not
+the person.
+
+Usage:
+  exodus comments list [--ad <adId>] [--platform x] [--limit n] [--json]
+
+Flags:
+  --ad <adId>        Only this ad's comments (ad ids come from exodus ads list)
+  --platform <x>     facebook | instagram — one surface only
+  --limit <n>        How many comments, 1–500 (default 100)
+  --json             Machine-readable JSON instead of the human list
+
+Notes:
+  • Newest first.
+  • Scopes to your active brand (exodus brand current).
+  • Nothing here posts, replies, hides or deletes — reading is all it does.
+  • Counts per ad live on \`exodus ads show <adId>\`.
+
+Examples:
+  exodus comments list
+  exodus comments list --ad 120210000000000
+  exodus comments list --platform instagram --limit 50
+  exodus comments list --ad 120210000000000 --json
+`.trim();
+export const PLATFORMS = ["facebook", "instagram"];
+export const VALUE_FLAGS = new Set(["ad", "platform", "limit"]);
+export const MAX_LIMIT = 500;
+export function parseCommentsFlags(flags) {
+    const options = {};
+    const ad = flags["ad"];
+    if (ad !== undefined) {
+        if (typeof ad !== "string" || !ad.trim()) {
+            return { ok: false, message: "--ad needs an ad id (see: exodus ads list)" };
+        }
+        options.adId = ad.trim();
+    }
+    const platform = flags["platform"];
+    if (platform !== undefined) {
+        if (typeof platform !== "string" ||
+            !PLATFORMS.includes(platform.trim().toLowerCase())) {
+            return {
+                ok: false,
+                message: `--platform must be one of: ${PLATFORMS.join(", ")} (got "${String(platform)}")`,
+            };
+        }
+        options.platform = platform.trim().toLowerCase();
+    }
+    const limitRaw = flags["limit"];
+    if (limitRaw !== undefined) {
+        const n = typeof limitRaw === "string" ? Number(limitRaw) : NaN;
+        if (!Number.isInteger(n) || n < 1 || n > MAX_LIMIT) {
+            return {
+                ok: false,
+                message: `--limit must be a whole number 1–${MAX_LIMIT} (got "${String(limitRaw)}")`,
+            };
+        }
+        options.limit = n;
+    }
+    return { ok: true, options };
+}
+export function commentsPath(options) {
+    const params = new URLSearchParams();
+    if (options.platform)
+        params.set("platform", options.platform);
+    if (options.limit !== undefined)
+        params.set("limit", String(options.limit));
+    const qs = params.toString();
+    const suffix = qs ? `?${qs}` : "";
+    return options.adId
+        ? `/api/v2/ads/${encodeURIComponent(options.adId)}/comments${suffix}`
+        : `/api/v2/comments${suffix}`;
+}
+const PLATFORM_TAGS = {
+    facebook: "fb",
+    instagram: "ig",
+};
+export function platformTag(platform) {
+    const clean = safeText(platform).toLowerCase();
+    if (!clean)
+        return "??";
+    return PLATFORM_TAGS[clean] ?? clean.slice(0, 2);
+}
+export function commentLines(comment, opts) {
+    const meta = [
+        `[${platformTag(comment.platform)}]`,
+        dateOrDash(comment.createdAt),
+        typeof comment.likeCount === "number" && comment.likeCount > 0
+            ? `${count(comment.likeCount)} like${comment.likeCount === 1 ? "" : "s"}`
+            : null,
+        comment.parentId ? "reply" : null,
+        opts.showAdId && comment.adId ? `ad ${safeText(comment.adId)}` : null,
+    ]
+        .filter(Boolean)
+        .join(" · ");
+    const text = truncate(comment.text, 400) || "(no text — media-only comment)";
+    return [`  ${meta}`, `    ${text}`];
+}
+export function formatComments(data, options) {
+    const comments = Array.isArray(data.comments) ? data.comments : [];
+    const scope = options.adId ? `ad ${options.adId}` : "this brand's ads";
+    const surface = options.platform ? ` on ${options.platform}` : "";
+    if (comments.length === 0) {
+        return [
+            `No stored comments for ${scope}${surface}.`,
+            "The daily Meta sync stores comments as it finds them — an ad with no comments yet, or one synced before comments landed, shows nothing here.",
+        ];
+    }
+    const total = typeof data.count === "number" ? data.count : comments.length;
+    const lines = [
+        `Comments (${comments.length}${total > comments.length ? ` of ${total}` : ""}) — ${scope}${surface}, newest first`,
+        "",
+    ];
+    const showAdId = !options.adId;
+    for (const comment of comments) {
+        lines.push(...commentLines(comment, { showAdId }));
+    }
+    lines.push("");
+    lines.push("Commenter names and links are stripped before storage — the words are all Exodus keeps.");
+    if (total > comments.length) {
+        lines.push(`Raise --limit (max ${MAX_LIMIT}) to see more.`);
+    }
+    return lines;
+}
+export async function listFlow(options, json, deps) {
+    const res = await deps.get(commentsPath(options));
+    if (!res.ok && res.status === 404 && options.adId && !json) {
+        const laddered = errorFor(res, "comments list", json, deps, (id) => `exodus comments list --account ${id}`);
+        if (laddered && laddered.lines[0]?.startsWith("this server does not support")) {
+            return laddered;
+        }
+        return {
+            code: 1,
+            lines: [
+                `No synced ad matches "${options.adId}".`,
+                "Ad ids come from `exodus ads list`.",
+            ],
+        };
+    }
+    const err = errorFor(res, "comments list", json, deps, (id) => `exodus ads list --account ${id}`);
+    if (err)
+        return err;
+    const data = (res.data ?? {});
+    if (json)
+        return { code: 0, lines: [JSON.stringify(data)] };
+    return { code: 0, lines: formatComments(data, options) };
+}
+export 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;
+}
+function printResult(result) {
+    for (const line of result.lines)
+        console.log(line);
+    for (const warning of result.warnings ?? [])
+        console.error(warning);
+    if (result.code !== 0)
+        process.exit(result.code);
+}
+export async function run(flags) {
+    const [sub] = parsePositional();
+    const json = flags["json"] === true;
+    if (!sub || sub === "help") {
+        console.log(helpText);
+        return;
+    }
+    if (sub === "list") {
+        const parsed = parseCommentsFlags(flags);
+        if (!parsed.ok) {
+            console.error(`Error: ${parsed.message}`);
+            console.log("Usage: exodus comments list [--ad <adId>] [--platform x] [--limit n] [--json]");
+            process.exit(1);
+        }
+        return printResult(await listFlow(parsed.options, json, defaultMetaAdsDeps));
+    }
+    console.error(`Unknown subcommand: "${sub}"\n`);
+    console.log(helpText);
+    process.exit(1);
+}

package/dist/commands/video.d.ts

@@ -0,0 +1,213 @@
+import { type ApiResponse } from "../lib/client.js";
+export declare const helpText: string;
+export interface ClipWord {
+    w: string;
+    s: number;
+    e: number;
+}
+export interface ClipQc {
+    verdict: "pass" | "fail";
+    attempts: number;
+}
+export interface ClipFinding {
+    check: string;
+    code: string;
+    severity: "fail" | "warn";
+    detail: string;
+}
+export type ArtifactSubset = {
+    type: "storyboard";
+    storyboard?: unknown;
+    storyboardJson?: string;
+} | {
+    type: "frames";
+    frames?: Array<{
+        sceneIndex: number;
+        imageUrl?: string;
+    }>;
+} | {
+    type: "image";
+    imageUrl?: string;
+} | {
+    type: "video";
+    sceneIndex?: number;
+    videoUrl?: string;
+    durationSec?: number;
+    words?: ClipWord[];
+    qc?: ClipQc;
+    final?: boolean;
+} | {
+    type: "audio";
+    sceneIndex?: number;
+    audioUrl?: string;
+    durationSec?: number;
+} | {
+    type: "text" | "primer" | "session" | "document";
+};
+export interface VideoRunNode {
+    nodeId: string;
+    kind: string;
+    status: "idle" | "running" | "done" | "failed" | "skipped";
+    error?: string;
+    outputs?: ArtifactSubset[];
+}
+export type BuilderPauseReason = "taste" | "repair" | "slots" | "call" | "checkpoint";
+export interface VideoRun {
+    _id: string;
+    status: string;
+    isTerminal: boolean;
+    error?: string;
+    pauseReason?: BuilderPauseReason;
+    pausedNodeId?: string;
+    nodes: VideoRunNode[];
+}
+export declare function asVideoRun(data: unknown): VideoRun;
+export interface NodeItem {
+    nodeId: string;
+    sceneIndex: number;
+    itemKind: string;
+    status: string;
+    error?: string;
+    attempt?: number;
+    flagged?: boolean;
+    findings?: ClipFinding[];
+}
+export interface ShowRow {
+    id: string;
+    name: string;
+    status?: string;
+    medium?: string;
+    styleSlug?: string;
+    ready?: boolean;
+    setupProgress?: {
+        set?: boolean;
+        cast?: boolean;
+        voices?: boolean;
+    };
+}
+export interface FlowResult {
+    code: number;
+    lines: string[];
+}
+export interface VideoDeps {
+    get: (path: string) => Promise<ApiResponse<unknown>>;
+    post: (path: string, body: unknown) => Promise<ApiResponse<unknown>>;
+    mkdirp: (dir: string) => void;
+    writeFile: (filePath: string, text: string) => void;
+    downloadToFile: (url: string, filePath: string) => Promise<void>;
+    readFile: (filePath: string) => string;
+    readFileBytes: (filePath: string) => Uint8Array;
+    statFile: (filePath: string) => {
+        size: number;
+    } | null;
+    uploadBytes: (uploadUrl: string, contentType: string, bytes: Uint8Array) => Promise<{
+        ok: boolean;
+        status: number;
+        storageId?: string;
+        body?: string;
+    }>;
+    probeDurationSec: (filePath: string) => number | null;
+    sleep: (ms: number) => Promise<void>;
+    now: () => number;
+    dashboardUrl: string;
+}
+export declare const defaultDeps: VideoDeps;
+export declare const VIDEO_NOT_FOUND_MESSAGE: string;
+export declare function videoApiError(res: ApiResponse<unknown>): string;
+export type RunStop = {
+    at: "running";
+    stage: string;
+} | {
+    at: "storyboard-gate";
+    nodeId?: string;
+} | {
+    at: "final-watch";
+} | {
+    at: "paused";
+    nodeId?: string;
+    reason?: string;
+} | {
+    at: "failed";
+    error?: string;
+} | {
+    at: "finished";
+    status: string;
+};
+export declare function classifyRun(run: VideoRun): RunStop;
+export declare function stageWord(stage: string): string;
+export declare function stopLines(stop: RunStop, runId: string, dashboardUrl: string): string[];
+export interface PullDownload {
+    file: string;
+    url: string;
+}
+export interface PullTextFile {
+    file: string;
+    body: string;
+}
+export interface ManifestScene {
+    sceneIndex: number;
+    durationSec: number | null;
+    clip: string | null;
+    words: string | null;
+    voice: string | null;
+    keyframe: string | null;
+    qc: ClipQc | null;
+    clipStatus: string;
+    error: string | null;
+    flagged: boolean;
+    findings: ClipFinding[];
+}
+export interface PullFailure {
+    file: string;
+    url: string;
+    error: string;
+}
+export interface VideoManifest {
+    runId: string;
+    pulledAt: string;
+    dashboardUrl: string;
+    storyboard: string | null;
+    reference: string | null;
+    music: string | null;
+    scenes: ManifestScene[];
+    failed: PullFailure[];
+}
+export interface PullPlan {
+    downloads: PullDownload[];
+    texts: PullTextFile[];
+    manifest: VideoManifest;
+}
+export declare function extensionFromUrl(url: string): string | undefined;
+export declare function scenePrefix(sceneIndex: number): string;
+export declare function planPull(run: VideoRun, items: NodeItem[], opts: {
+    pulledAt: string;
+    dashboardUrl: string;
+}): PullPlan;
+export declare function markPullFailure(manifest: VideoManifest, failure: PullFailure): void;
+export declare function missingSetupLabels(progress: ShowRow["setupProgress"]): string[];
+export declare function showsFlow(json: boolean, deps: VideoDeps): Promise<FlowResult>;
+export interface StartOptions {
+    showId: string;
+    scriptFile: string;
+    voicePath?: string;
+    music?: boolean;
+    wait: boolean;
+    json: boolean;
+}
+export declare function startFlow(opts: StartOptions, deps: VideoDeps): Promise<FlowResult>;
+export declare function waitFlow(runId: string, opts: {
+    json: boolean;
+    url?: string;
+    intervalMs?: number;
+    maxPolls?: number;
+}, deps: VideoDeps): Promise<FlowResult>;
+export declare function statusFlow(runId: string, json: boolean, deps: VideoDeps): Promise<FlowResult>;
+export declare function storyboardFlow(runId: string, json: boolean, deps: VideoDeps): Promise<FlowResult>;
+export declare function approveFlow(runId: string, json: boolean, deps: VideoDeps): Promise<FlowResult>;
+export declare function flagFlow(runId: string, note: string, json: boolean, deps: VideoDeps): Promise<FlowResult>;
+export declare function pullFlow(runId: string, dir: string, json: boolean, deps: VideoDeps): Promise<FlowResult>;
+export declare function parseMvhdDurationSec(bytes: Uint8Array): number | null;
+export declare const NO_DURATION_MESSAGE: string;
+export declare function uploadFlow(runId: string, filePath: string, durationFlag: string | undefined, json: boolean, deps: VideoDeps): Promise<FlowResult>;
+export declare function parsePositional(args?: string[]): string[];
+export declare function run(flags: Record<string, string | boolean>): Promise<void>;