@officexapp/vidfarm-devcli 0.21.62 → 0.21.64

package/dist/src/devcli/marketplace-console.js

@@ -0,0 +1,1418 @@
+// `vidfarm shop` and `vidfarm purchases` — the PACK MARKETPLACE from a terminal.
+//
+// ── what this is, and what `vidfarm gigs` is ────────────────────────────────
+//
+// `gigs` talks to DOLLAR PLATOON: mailboxes, tasks, proofs, payouts. It is the
+// money rail underneath, and it knows nothing about shops or pack cards.
+//
+// THIS module talks to VIDFARM, and it is the storefront on top:
+//
+//   vidfarm shop        the VENDOR. Open a shop, put pack cards on the shelf,
+//                       take orders, deliver them, get paid, answer reviews.
+//   vidfarm purchases   the BUYER. Read the shelf, buy a pack, talk to the
+//                       vendor, tear it open, rule on it, accept or refund.
+//
+// One person is usually both — a buyer on one order and a vendor on the next —
+// which is why the two verbs share this file and one API key.
+//
+// EVERY ROUTE IS UNDER /api/v1/marketplace/. Until 2026-08-29 the marketplace
+// was HTML forms and 302s, so none of this was reachable without a browser;
+// the routes those pages now share are what this module drives.
+//
+// Auth: `vidfarm login`, or VIDFARM_API_KEY, or --api-key. Same key as the rest
+// of the devcli. The marketplace is paid-only, so a free key answers 402.
+import { parseArgs } from "node:util";
+import { readFileSync } from "node:fs";
+import { readStoredAuth } from "./auth-store.js";
+const BOLD = "\x1b[1m";
+const DIM = "\x1b[2m";
+const GREEN = "\x1b[32m";
+const YELLOW = "\x1b[33m";
+const RED = "\x1b[31m";
+const CYAN = "\x1b[1m\x1b[36m";
+const RESET = "\x1b[0m";
+const API = "/api/v1/marketplace";
+/**
+ * A sentence for the person at the keyboard, never a bug.
+ *
+ * `name` is what cli.ts matches on to print the message WITHOUT a stack — a
+ * refused refund and a missing flag are the CLI talking, and a stack trace
+ * there reads as "vidfarm is broken".
+ */
+class MarketplaceError extends Error {
+    name = "MarketplaceError";
+}
+function resolveCtx(values) {
+    const stored = readStoredAuth(values.home);
+    const host = String(values.host ?? process.env.VIDFARM_HOST ?? stored?.host ?? "https://vidfarm.cc").trim().replace(/\/+$/, "");
+    const apiKey = String(values["api-key"] ?? process.env.VIDFARM_API_KEY ?? stored?.apiKey ?? "").trim();
+    if (!apiKey) {
+        throw new MarketplaceError([
+            "No vidfarm API key.",
+            "  Run `vidfarm login`, or export VIDFARM_API_KEY=…, or pass --api-key <key>.",
+            "  The marketplace is paid-only — a free key reaches these routes and is refused with 402."
+        ].join("\n"));
+    }
+    return { host, apiKey, json: Boolean(values.json) };
+}
+async function call(ctx, method, path, init = {}) {
+    const url = new URL(path, ctx.host);
+    for (const [key, value] of Object.entries(init.query ?? {})) {
+        if (value !== undefined && value !== null && value !== "")
+            url.searchParams.set(key, value);
+    }
+    const headers = {
+        // Vidfarm authenticates on `vidfarm-api-key` ONLY. It never reads a Bearer
+        // token, so a Bearer-only request resolves to an anonymous caller.
+        "vidfarm-api-key": ctx.apiKey,
+        accept: "application/json"
+    };
+    if (init.body !== undefined)
+        headers["content-type"] = "application/json";
+    let response;
+    try {
+        response = await fetch(url, {
+            method: method.toUpperCase(),
+            headers,
+            body: init.body === undefined ? undefined : JSON.stringify(init.body)
+        });
+    }
+    catch (error) {
+        throw new MarketplaceError(`Could not reach ${ctx.host}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    const text = await response.text();
+    let body = null;
+    try {
+        body = text ? JSON.parse(text) : null;
+    }
+    catch {
+        body = null;
+    }
+    return { status: response.status, ok: response.ok, body };
+}
+/**
+ * Fail loudly, with the server's own sentence.
+ *
+ * The API answers every refusal as a sentence for a human — "This order was
+ * accepted and paid out. A refund is no longer possible." — so reprinting a
+ * bare status code would be throwing away the only useful part.
+ */
+function assertOk(result, action) {
+    if (result.ok && result.body?.ok !== false)
+        return;
+    const detail = typeof result.body?.error === "string" ? ` — ${result.body.error}` : "";
+    const hint = result.status === 401
+        ? "\n  Sign in: `vidfarm login`."
+        : result.status === 402
+            ? "\n  The marketplace is paid-only. Upgrade at /pricing."
+            : result.status === 404 && typeof result.body?.create_with === "string"
+                ? `\n  ${result.body.create_with}`
+                : "";
+    throw new MarketplaceError(`${action} failed (${result.status})${detail}.${hint}`);
+}
+function emit(ctx, body) {
+    if (!ctx.json)
+        return false;
+    process.stdout.write(`${JSON.stringify(body, null, 2)}\n`);
+    return true;
+}
+// ── formatting ──────────────────────────────────────────────────────────────
+function money(value) {
+    const parsed = Number(value);
+    return Number.isFinite(parsed) ? `$${parsed.toFixed(2)}` : "$—";
+}
+/**
+ * What an order cost, in words.
+ *
+ * "$0.00" on a free order reads as a bug, and worse, it reads as a PAID order
+ * that went wrong — which is the one thing it must never look like, because
+ * the two rails have opposite undo rules. Never derive this from the number:
+ * a zero total reached any other way still has escrow behind it.
+ */
+export function orderPrice(order) {
+    return order.is_free ? "FREE" : money(order.total_usd);
+}
+function shortDate(value) {
+    const raw = String(value ?? "");
+    return raw ? raw.slice(0, 10) : "—";
+}
+/**
+ * The one word that says whose move it is.
+ *
+ * Derived from the order the same way both web pages derive it, because
+ * `status` alone cannot answer it: a `funded` order is waiting on the VENDOR,
+ * a `delivered` one on the BUYER, and an order with a standing change request
+ * is back on the vendor whatever its status says.
+ */
+export function orderStage(order) {
+    if (order.refunded_at)
+        return { label: order.is_free ? "cancelled" : "refunded", colour: DIM };
+    // A FREE order is never "paid out" — nobody was paid. It closed, and the
+    // buyer's files were released by the approval itself.
+    if (order.settled_at)
+        return { label: order.is_free ? "closed" : "paid out", colour: GREEN };
+    if (order.refund_requested_at) {
+        return { label: order.is_free ? "cancel asked" : "refund asked", colour: YELLOW };
+    }
+    if (order.changes_requested_at)
+        return { label: "changes asked", colour: YELLOW };
+    if (order.delivery_id)
+        return { label: "delivered", colour: CYAN };
+    // "UNFUNDED" is the vendor's do-not-work signal, and it is meaningless on the
+    // free rail: a free order carries no deposit BY DESIGN and is still real work
+    // the vendor agreed to. Flagging it red would train vendors to abandon it.
+    if (!order.funded && !order.is_free)
+        return { label: "UNFUNDED", colour: RED };
+    return { label: "waiting on vendor", colour: YELLOW };
+}
+function printOrderRow(order, opts = {}) {
+    const stage = orderStage(order);
+    const who = opts.showBuyer && (order.buyer_name || order.buyer_email)
+        ? ` · ${String(order.buyer_name || order.buyer_email)}`
+        : "";
+    console.log(`  ${BOLD}${order.order_id}${RESET}  ${order.machine_title}`
+        + `  ${DIM}${order.packs}× pack · ${order.video_count} videos · ${orderPrice(order)}`
+        + `${who} · ${shortDate(order.created_at)}${RESET}`
+        + `  ${stage.colour}${stage.label}${RESET}`
+        + (order.is_free ? `  ${CYAN}free first order${RESET}` : ""));
+}
+function printCardRow(card) {
+    const shelf = card.listed
+        ? `${GREEN}on the shelf${RESET}`
+        : card.approved
+            ? `${DIM}switched off${RESET}`
+            : `${YELLOW}awaiting review${RESET}`;
+    console.log(`  ${BOLD}${card.title}${RESET}  ${DIM}[${card.machine_id}]${RESET}`
+        + `  ${money(card.price_per_lot_usd)} / ${card.lot_size} videos`
+        + `${card.delivery_estimate ? ` ${DIM}· ${card.delivery_estimate}${RESET}` : ""}  ${shelf}`);
+}
+// ── flag plumbing ───────────────────────────────────────────────────────────
+function baseOptions() {
+    return {
+        host: { type: "string" },
+        "api-key": { type: "string" },
+        home: { type: "string" },
+        json: { type: "boolean", default: false }
+    };
+}
+function shopOptions() {
+    return {
+        ...baseOptions(),
+        name: { type: "string" },
+        slug: { type: "string" },
+        headline: { type: "string" },
+        bio: { type: "string" },
+        avatar: { type: "string" },
+        contact: { type: "string" },
+        title: { type: "string" },
+        note: { type: "string" },
+        "lot-size": { type: "string" },
+        price: { type: "string" },
+        delivery: { type: "string" },
+        accent: { type: "string" },
+        icon: { type: "string" },
+        caveat: { type: "string" },
+        require: { type: "string", multiple: true },
+        live: { type: "boolean" },
+        template: { type: "string" },
+        poster: { type: "string" },
+        video: { type: "string" },
+        status: { type: "string" },
+        machine: { type: "string" },
+        item: { type: "string", multiple: true },
+        "items-file": { type: "string" },
+        "items-json": { type: "string" },
+        "reply-to": { type: "string" },
+        reason: { type: "string" },
+        to: { type: "string" },
+        amount: { type: "string" },
+        refresh: { type: "boolean", default: false },
+        unseen: { type: "boolean", default: false }
+    };
+}
+function purchasesOptions() {
+    return {
+        ...baseOptions(),
+        shop: { type: "string" },
+        packs: { type: "string" },
+        notes: { type: "string" },
+        answer: { type: "string", multiple: true },
+        limit: { type: "string" },
+        "reply-to": { type: "string" },
+        reason: { type: "string" },
+        ask: { type: "boolean", default: false },
+        tag: { type: "string" },
+        note: { type: "string" },
+        comment: { type: "string" },
+        value: { type: "string" },
+        speed: { type: "string" },
+        quality: { type: "string" },
+        support: { type: "string" },
+        unseen: { type: "boolean", default: false },
+        yes: { type: "boolean", default: false, short: "y" }
+    };
+}
+function optionalNumber(value) {
+    if (value === undefined || value === null || value === "")
+        return undefined;
+    const parsed = Number(value);
+    if (!Number.isFinite(parsed))
+        throw new MarketplaceError(`"${String(value)}" is not a number.`);
+    return parsed;
+}
+function optionalText(value) {
+    return value === undefined ? undefined : String(value);
+}
+/** `--require "id=Label=hint"`, or `"Label"` on its own for a new row. */
+export function parseRequirements(values) {
+    if (!values || !values.length)
+        return undefined;
+    return values.map((raw) => {
+        const parts = String(raw).split("=");
+        if (parts.length >= 3) {
+            return { id: parts[0].trim(), label: parts[1].trim(), hint: parts.slice(2).join("=").trim() };
+        }
+        if (parts.length === 2)
+            return { id: "", label: parts[0].trim(), hint: parts[1].trim() };
+        return { id: "", label: String(raw).trim(), hint: "" };
+    });
+}
+/**
+ * The delivered items.
+ *
+ * `--item "<preview>::<master>::<note>"`, and either URL half may be a
+ * `|`-separated list to make that item a slideshow. `|` is not legal in a URL
+ * without percent-encoding, so it can never be part of one by accident — which
+ * is exactly why it is the separator and a comma is not.
+ *
+ * `--items-file` / `--items-json` take the API's own shape for anything this
+ * cannot say.
+ */
+export function parseDeliveryItems(values) {
+    const fromJson = (raw) => {
+        let parsed;
+        try {
+            parsed = JSON.parse(raw);
+        }
+        catch (error) {
+            throw new MarketplaceError(`That items JSON did not parse: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        const list = Array.isArray(parsed) ? parsed : parsed?.items;
+        if (!Array.isArray(list))
+            throw new MarketplaceError("Items JSON must be a list, or { items: [...] }.");
+        return list.map((entry) => ({
+            preview_urls: [].concat(entry?.preview_urls ?? entry?.preview_url ?? []),
+            master_urls: [].concat(entry?.master_urls ?? entry?.master_url ?? []),
+            note: String(entry?.note ?? "")
+        }));
+    };
+    if (values["items-file"])
+        return fromJson(readFileSync(String(values["items-file"]), "utf8"));
+    if (values["items-json"])
+        return fromJson(String(values["items-json"]));
+    const items = values.item ?? [];
+    if (!items.length) {
+        throw new MarketplaceError([
+            "Nothing to deliver. Name the files:",
+            '  --item "https://…/preview.mp4"',
+            '  --item "https://…/preview.mp4::https://…/master.mp4::the hook lands at 0:02"',
+            "  A slideshow is one item whose halves are |-separated lists of frame URLs.",
+            "  Or pass the whole delivery: --items-file items.json"
+        ].join("\n"));
+    }
+    return items.map((raw) => {
+        const [preview = "", master = "", note = ""] = String(raw).split("::");
+        const split = (value) => value.split("|").map((url) => url.trim()).filter(Boolean);
+        return { preview_urls: split(preview), master_urls: split(master), note: note.trim() };
+    });
+}
+// ═══════════════════════════════════════════════════════════════════════════
+// vidfarm shop — THE VENDOR
+// ═══════════════════════════════════════════════════════════════════════════
+export const SHOP_HELP = `vidfarm shop — your storefront on the vidfarm marketplace (VENDOR side)
+
+  A shop holds PACK CARDS. A card is one offer — "7 videos, $35, 3-5 days" — and
+  a buyer orders a pack from it. Every card waits for a manual review before it
+  reaches the public shelf; \`shop\` tells you which state each one is in.
+
+  NEW SHOP. The platform can mark a shop so that every buyer's FIRST order there
+  is free — one pack, $0. You cannot set it or clear it; \`shop\` reports it, and
+  an operator grants it. Those orders are REAL WORK with no deposit behind them,
+  they never pay out, and the buyer's approval is final. Work them normally.
+
+  Earning WITHOUT a shop? You do not need one — read vidfarm.cc/agentic-clipper.md
+  and use \`vidfarm gigs\`. A shop is how buyers come to you instead.
+
+  THE SHOP
+  shop                                Your shop, your cards, their state    → GET  ${API}/shop
+  shop open --name "<shop name>"      Create it, or edit it                 → POST ${API}/shop/profile
+    --slug <address> (once, at creation) --headline "…" --bio "…"
+    --avatar <url> --contact <url>
+  shop hide | shop show               Take the whole shop off the shelf / put it back
+  shop sync                           Pull gigs you own from Dollar Platoon → POST ${API}/shop/sync
+
+  THE PACK CARDS
+  shop cards                          List them
+  shop card <machineId>               One card, with its example videos
+  shop new-card --title "…" --lot-size <n> --price <usd>
+    --delivery "3-5 days" --note "…" --caveat "before you buy…"
+    --accent <hue> --icon <name> --live
+    --require "Your brand kit=a Drive or Figma link"   (repeatable)
+  shop edit-card <machineId> [same flags]   Only what you pass changes
+  shop on <machineId> | shop off <machineId>          Switch it on/off for buyers
+  shop remove-card <machineId>
+  shop add-example <machineId> --template <templateId> [--title --note --poster --video]
+  shop drop-example <machineId> <templateId>
+
+  THE ORDERS
+  shop orders [--status <s>] [--machine <id>]         Your queue      → GET  ${API}/shop/orders
+  shop order <orderId>                                One order, whole, with its thread
+  shop say <orderId> "<message>" [--reply-to <commentId>]
+  shop deliver <orderId> --item "<preview>[::<master>][::<note>]"     → POST …/fulfil
+    Repeat --item once per video. Deliver again to REVISE — what you
+    send replaces the pack. --items-file <file.json> for anything complex.
+  shop refund <orderId> [--reason "…"]                You sign it; the buyer pays no gas
+
+  REVIEWS, MONEY, NEWS
+  shop reviews                                        Your reviews and the summary
+  shop reply <reviewId> "<answer>"                    One answer per review, forever
+  shop earnings [--machine <id>] [--refresh]          The payout rollup
+  shop withdraw --to 0x… --amount <usdc>              USDC only. ETH is your gas.
+  shop inbox [--unseen]                               New orders, payouts, reviews
+
+  Every command takes --json. Auth: \`vidfarm login\` / VIDFARM_API_KEY / --api-key.`;
+async function cmdShopShow(ctx) {
+    const result = await call(ctx, "GET", `${API}/shop`);
+    assertOk(result, "shop");
+    if (emit(ctx, result.body))
+        return;
+    const shop = result.body.shop;
+    if (!shop) {
+        console.log(`${DIM}No shop on this account yet.${RESET}`);
+        console.log(`  Open one:  ${BOLD}vidfarm shop open --name "Your Shop Name"${RESET}`);
+        return;
+    }
+    console.log(`${BOLD}${shop.display_name}${RESET}  ${DIM}/${shop.shop_slug}${RESET}`
+        + (shop.hidden ? `  ${YELLOW}HIDDEN${RESET}` : ""));
+    if (shop.headline)
+        console.log(`  ${shop.headline}`);
+    console.log(`  ${CYAN}${shop.shop_url}${RESET}`);
+    if (shop.new_shop) {
+        // The vendor cannot set this and cannot clear it — it is a promise the
+        // PLATFORM makes to buyers, so the console reports it rather than offering
+        // it. Reported at all because it changes what the vendor is agreeing to:
+        // real work, no deposit behind it.
+        console.log(`  ${GREEN}NEW SHOP${RESET} — every buyer's first order here is free, one pack at $0.`);
+        console.log(`  ${DIM}Those orders carry no deposit and the buyer's approval is final.`
+            + ` Work them like any other order. Granted by the platform; ask an operator to change it.${RESET}`);
+    }
+    if (!result.body.dollarplatoon_connected) {
+        console.log(`  ${YELLOW}No Dollar Platoon key on this account — your cards cannot take a paid order.${RESET}`);
+        console.log(`  ${DIM}Connect it at ${ctx.host}/settings/marketplace${RESET}`);
+    }
+    const cards = result.body.machines ?? [];
+    console.log(`\n${BOLD}Pack cards${RESET} ${DIM}(${cards.length})${RESET}`);
+    if (!cards.length) {
+        console.log(`  ${DIM}None yet — vidfarm shop new-card --title "…" --lot-size 7 --price 35${RESET}`);
+        return;
+    }
+    for (const card of cards)
+        printCardRow(card);
+}
+async function cmdShopOpen(ctx, values, hidden) {
+    // Read first, so `shop hide` and a headline-only edit do not blank the rest.
+    // The API keeps what it is not told about, but the NAME is required on every
+    // save — sending an empty one would be a 400 on an otherwise valid edit.
+    const current = await call(ctx, "GET", `${API}/shop`);
+    assertOk(current, "shop");
+    const shop = current.body.shop;
+    const name = optionalText(values.name) ?? shop?.display_name ?? "";
+    if (!name) {
+        throw new MarketplaceError('A new shop needs a name: vidfarm shop open --name "Your Shop Name"');
+    }
+    const body = {
+        display_name: name,
+        shop_slug: optionalText(values.slug) ?? shop?.shop_slug ?? "",
+        headline: optionalText(values.headline) ?? shop?.headline ?? "",
+        bio: optionalText(values.bio) ?? shop?.bio ?? "",
+        avatar_url: optionalText(values.avatar) ?? shop?.avatar_url ?? "",
+        contact_url: optionalText(values.contact) ?? shop?.contact_url ?? "",
+        hidden: hidden ?? Boolean(shop?.hidden)
+    };
+    const result = await call(ctx, "POST", `${API}/shop/profile`, { body });
+    assertOk(result, "shop open");
+    if (emit(ctx, result.body))
+        return;
+    const saved = result.body.shop;
+    console.log(`${GREEN}Saved.${RESET} ${BOLD}${saved.display_name}${RESET} ${DIM}/${saved.shop_slug}${RESET}`
+        + (saved.hidden ? `  ${YELLOW}HIDDEN${RESET}` : ""));
+    console.log(`  ${CYAN}${saved.shop_url}${RESET}`);
+}
+function cardBodyFrom(values, machineId) {
+    return {
+        ...(machineId ? { machine_id: machineId } : {}),
+        title: optionalText(values.title) ?? "",
+        note: optionalText(values.note),
+        lot_size: optionalNumber(values["lot-size"]),
+        price_per_lot_usd: optionalNumber(values.price),
+        delivery_estimate: optionalText(values.delivery),
+        contact_url: optionalText(values.contact),
+        accent: optionalText(values.accent),
+        icon: optionalText(values.icon),
+        before_you_buy_note: optionalText(values.caveat),
+        requirements: parseRequirements(values.require),
+        // Omitted, not false. `--live` is a boolean flag, so its absence cannot be
+        // told apart from "off" — sending `false` would delist a card on every
+        // price edit. The API leaves the switch alone when the key is missing, and
+        // a brand-new card starts off either way.
+        visible: values.live === undefined ? undefined : Boolean(values.live)
+    };
+}
+async function cmdNewCard(ctx, values) {
+    if (!values.title)
+        throw new MarketplaceError('A card needs a --title, e.g. --title "UGC starter pack".');
+    if (values["lot-size"] === undefined || values.price === undefined) {
+        throw new MarketplaceError("A card needs --lot-size <videos per pack> and --price <usd per pack>.");
+    }
+    const result = await call(ctx, "POST", `${API}/shop/machines`, { body: cardBodyFrom(values) });
+    assertOk(result, "shop new-card");
+    if (emit(ctx, result.body))
+        return;
+    console.log(`${GREEN}Card created.${RESET}`);
+    printCardRow(result.body.machine);
+    if (result.body.note)
+        console.log(`  ${YELLOW}${result.body.note}${RESET}`);
+    if (result.body.warning)
+        console.log(`  ${YELLOW}${result.body.warning}${RESET}`);
+}
+async function cmdEditCard(ctx, values, machineId) {
+    if (!machineId)
+        throw new MarketplaceError("Which card? vidfarm shop edit-card <machineId> …");
+    // Read the card first, for the TITLE. Every other field the API leaves alone
+    // when it is not told about it, but a blank title clamps to "Untitled
+    // machine" — so a price-only edit would rename the card. Reading also turns
+    // a wrong id into a sentence instead of a 400 from the save.
+    const current = await call(ctx, "GET", `${API}/shop`);
+    assertOk(current, "shop");
+    const card = (current.body.machines ?? []).find((row) => row.machine_id === machineId);
+    if (!card)
+        throw new MarketplaceError(`No card "${machineId}" on your shop.`);
+    const body = cardBodyFrom(values, machineId);
+    if (!body.title)
+        body.title = card.title;
+    const result = await call(ctx, "POST", `${API}/shop/machines`, { body });
+    assertOk(result, "shop edit-card");
+    if (emit(ctx, result.body))
+        return;
+    console.log(`${GREEN}Saved.${RESET}`);
+    printCardRow(result.body.machine);
+    if (result.body.warning)
+        console.log(`  ${YELLOW}${result.body.warning}${RESET}`);
+}
+async function cmdCardVisibility(ctx, machineId, visible) {
+    if (!machineId)
+        throw new MarketplaceError(`Which card? vidfarm shop ${visible ? "on" : "off"} <machineId>`);
+    const result = await call(ctx, "POST", `${API}/shop/machines/${encodeURIComponent(machineId)}/visibility`, { body: { visible } });
+    assertOk(result, "shop visibility");
+    if (emit(ctx, result.body))
+        return;
+    printCardRow(result.body.machine);
+}
+async function cmdCardDetail(ctx, machineId) {
+    if (!machineId)
+        throw new MarketplaceError("Which card? vidfarm shop card <machineId>");
+    const result = await call(ctx, "GET", `${API}/shop`);
+    assertOk(result, "shop");
+    const card = (result.body.machines ?? []).find((row) => row.machine_id === machineId);
+    if (!card)
+        throw new MarketplaceError(`No card "${machineId}" on your shop.`);
+    if (emit(ctx, card))
+        return;
+    printCardRow(card);
+    if (card.note)
+        console.log(`  ${card.note}`);
+    if (card.before_you_buy_note)
+        console.log(`  ${DIM}Before you buy: ${card.before_you_buy_note}${RESET}`);
+    if (card.requirements?.length) {
+        console.log(`  ${BOLD}The buyer must supply${RESET}`);
+        for (const row of card.requirements) {
+            console.log(`    ${row.label}${row.hint ? ` ${DIM}— ${row.hint}${RESET}` : ""} ${DIM}[${row.id}]${RESET}`);
+        }
+    }
+    console.log(`  ${BOLD}Examples${RESET} ${DIM}(${(card.examples ?? []).length})${RESET}`);
+    for (const example of card.examples ?? []) {
+        console.log(`    ${example.title || example.template_id} ${DIM}[${example.template_id}]${RESET}`);
+    }
+    console.log(`  ${CYAN}${card.machine_url}${RESET}`);
+}
+async function cmdOrders(ctx, values) {
+    const result = await call(ctx, "GET", `${API}/shop/orders`, {
+        query: { status: optionalText(values.status), machine: optionalText(values.machine) }
+    });
+    assertOk(result, "shop orders");
+    if (emit(ctx, result.body))
+        return;
+    const orders = result.body.orders ?? [];
+    if (!orders.length) {
+        console.log(`${DIM}No orders yet.${RESET}`);
+        return;
+    }
+    console.log(`${BOLD}${orders.length} order${orders.length === 1 ? "" : "s"}${RESET}`);
+    for (const order of orders)
+        printOrderRow(order, { showBuyer: true });
+    console.log(`\n${DIM}Deliver one:  vidfarm shop deliver <orderId> --item "<preview>::<master>"${RESET}`);
+}
+async function cmdOrderDetail(ctx, orderId) {
+    if (!orderId)
+        throw new MarketplaceError("Which order? vidfarm shop order <orderId>");
+    const result = await call(ctx, "GET", `${API}/shop/orders/${encodeURIComponent(orderId)}`);
+    assertOk(result, "shop order");
+    if (emit(ctx, result.body))
+        return;
+    const { order, buyer, delivery, thread, review } = result.body;
+    printOrderRow({ ...order, buyer_name: buyer?.name, buyer_email: buyer?.email }, { showBuyer: true });
+    if (order.is_free) {
+        // A vendor reading "$0" needs to know it is the promotion and not a broken
+        // order — and needs to know the undo rules are inverted before they ask a
+        // buyer to "just approve it".
+        console.log(`  ${CYAN}This is the buyer's free first order.${RESET}`
+            + ` ${DIM}No deposit, no payout, and their approval closes it for good.${RESET}`);
+    }
+    if (order.notes)
+        console.log(`\n${BOLD}Their brief${RESET}\n  ${order.notes.replace(/\n/g, "\n  ")}`);
+    if (order.answers?.length) {
+        console.log(`\n${BOLD}What they supplied${RESET}`);
+        for (const answer of order.answers)
+            console.log(`  ${answer.label}: ${CYAN}${answer.url}${RESET}`);
+    }
+    console.log(`\n${BOLD}Delivery${RESET}`);
+    if (!delivery) {
+        console.log(`  ${YELLOW}Nothing sent yet.${RESET}`);
+        console.log(`  ${DIM}vidfarm shop deliver ${order.order_id} --item "<preview>::<master>"${RESET}`);
+    }
+    else {
+        console.log(`  ${delivery.items.length} item(s) · ${delivery.opened_at ? "opened" : "not opened yet"}`
+            + (delivery.revisions_requested ? ` · ${delivery.revisions_requested} revision(s) asked` : ""));
+        if (delivery.changes_requested_at) {
+            console.log(`  ${YELLOW}Changes asked:${RESET} ${delivery.changes_requested_note ?? ""}`);
+        }
+        for (const item of delivery.items) {
+            const verdict = item.verdict === "approved"
+                ? `${GREEN}kept${RESET}`
+                : item.verdict === "rejected" ? `${RED}passed${RESET}` : `${DIM}not ruled on${RESET}`;
+            console.log(`    ${item.item_id} ${verdict}${item.rejection_tag ? ` ${DIM}(${item.rejection_tag})${RESET}` : ""}`);
+        }
+    }
+    if (thread) {
+        console.log(`\n${BOLD}Thread${RESET} ${DIM}(${thread.comments.length})${RESET}`);
+        if (thread.error)
+            console.log(`  ${YELLOW}${thread.error}${RESET}`);
+        for (const comment of thread.comments) {
+            console.log(`  ${comment.mine ? BOLD : ""}${comment.author || comment.role}${RESET}`
+                + ` ${DIM}${shortDate(comment.created_at)} [${comment.id}]${RESET}`);
+            console.log(`    ${String(comment.body).replace(/\n/g, "\n    ")}`);
+        }
+    }
+    if (review) {
+        console.log(`\n${BOLD}Their review${RESET}  ${review.overall}/5`);
+        if (review.comment)
+            console.log(`  ${review.comment}`);
+        if (!review.reply)
+            console.log(`  ${DIM}vidfarm shop reply ${review.review_id} "<your answer>"${RESET}`);
+    }
+    console.log(`\n  ${CYAN}${order.vendor_url}${RESET}`);
+}
+async function cmdDeliver(ctx, values, orderId) {
+    if (!orderId)
+        throw new MarketplaceError("Which order? vidfarm shop deliver <orderId> --item …");
+    const items = parseDeliveryItems(values);
+    const result = await call(ctx, "POST", `${API}/shop/orders/${encodeURIComponent(orderId)}/fulfil`, { body: { items } });
+    assertOk(result, "shop deliver");
+    if (emit(ctx, result.body))
+        return;
+    console.log(`${GREEN}${result.body.message}${RESET}`);
+    console.log(`  Pack: ${CYAN}${result.body.delivery_url}${RESET}`);
+    if (result.body.warning) {
+        // The files ARE with the buyer. Only the money rail did not hear about it,
+        // and running the same command again is the retry.
+        console.log(`  ${YELLOW}${result.body.warning}${RESET}`);
+        console.log(`  ${DIM}The buyer can see the pack. Run the same command again to retry the proof.${RESET}`);
+    }
+}
+async function cmdShopSay(ctx, values, orderId, message) {
+    if (!orderId || !message)
+        throw new MarketplaceError('vidfarm shop say <orderId> "<message>"');
+    const result = await call(ctx, "POST", `${API}/shop/orders/${encodeURIComponent(orderId)}/comment`, { body: { body: message, parent_id: optionalText(values["reply-to"]) ?? "" } });
+    assertOk(result, "shop say");
+    if (emit(ctx, result.body))
+        return;
+    console.log(`${GREEN}Posted.${RESET}`);
+}
+async function cmdShopRefund(ctx, values, orderId) {
+    if (!orderId)
+        throw new MarketplaceError("Which order? vidfarm shop refund <orderId>");
+    const result = await call(ctx, "POST", `${API}/shop/orders/${encodeURIComponent(orderId)}/refund`, { body: { reason: optionalText(values.reason) ?? "" } });
+    assertOk(result, "shop refund");
+    if (emit(ctx, result.body))
+        return;
+    console.log(`${GREEN}${result.body.message}${RESET}`);
+    if (result.body.tx_hash)
+        console.log(`  ${DIM}tx ${result.body.tx_hash}${RESET}`);
+}
+async function cmdShopReviews(ctx) {
+    const result = await call(ctx, "GET", `${API}/shop/reviews`);
+    assertOk(result, "shop reviews");
+    if (emit(ctx, result.body))
+        return;
+    const summary = result.body.summary ?? {};
+    console.log(`${BOLD}${summary.overall ?? 0}/5${RESET} ${DIM}from ${summary.count ?? 0} review(s)${RESET}`);
+    for (const review of result.body.reviews ?? []) {
+        console.log(`\n  ${BOLD}${review.overall}/5${RESET} ${review.author_name}`
+            + ` ${DIM}${shortDate(review.created_at)} [${review.review_id}]${RESET}`
+            + (review.verified ? ` ${GREEN}verified${RESET}` : ""));
+        if (review.comment)
+            console.log(`    ${review.comment}`);
+        if (review.reply)
+            console.log(`    ${DIM}You: ${review.reply}${RESET}`);
+    }
+}
+async function cmdShopReply(ctx, reviewId, reply) {
+    if (!reviewId || !reply)
+        throw new MarketplaceError('vidfarm shop reply <reviewId> "<answer>"');
+    const result = await call(ctx, "POST", `${API}/shop/reviews/${encodeURIComponent(reviewId)}/reply`, { body: { reply } });
+    assertOk(result, "shop reply");
+    if (emit(ctx, result.body))
+        return;
+    console.log(`${GREEN}Replied.${RESET} ${DIM}One answer per review — this cannot be edited.${RESET}`);
+}
+async function cmdEarnings(ctx, values) {
+    const result = await call(ctx, "GET", `${API}/shop/analytics`, {
+        query: { machine: optionalText(values.machine), refresh: values.refresh ? "1" : undefined }
+    });
+    assertOk(result, "shop earnings");
+    if (emit(ctx, result.body))
+        return;
+    const totals = result.body.scope?.totals ?? {};
+    console.log(`${BOLD}${result.body.shop_slug}${RESET} ${DIM}as of ${result.body.generated_at}`
+        + `${result.body.stale ? " (cached)" : ""}${RESET}`);
+    console.log(`  Paid out   ${GREEN}${money(totals.payoutsUsd)}${RESET} ${DIM}${totals.payouts ?? 0} order(s)${RESET}`);
+    console.log(`  In escrow  ${YELLOW}${money(totals.pendingUsd)}${RESET} ${DIM}${totals.pending ?? 0} order(s)${RESET}`);
+    console.log(`  Refunded   ${DIM}${money(totals.refundedUsd)} · ${totals.refunded ?? 0} order(s)${RESET}`);
+    console.log(`  Ordered    ${money(totals.ordersUsd)} ${DIM}${totals.orders ?? 0} order(s)${RESET}`);
+    if (result.body.shop_slug && totals.orders && !totals.ordersUsd) {
+        // Real orders totalling nothing is what a New Shop's early history looks
+        // like. Without this line it reads as a broken rollup.
+        console.log(`  ${DIM}Orders at $0 are free first orders — they close without a payout.${RESET}`);
+    }
+    for (const machine of result.body.machines ?? []) {
+        console.log(`    ${machine.label || machine.machineId} ${DIM}${money(machine.totals?.payoutsUsd)} paid out${RESET}`);
+    }
+}
+async function cmdWithdraw(ctx, values) {
+    const to = optionalText(values.to)?.trim() ?? "";
+    const amount = optionalNumber(values.amount);
+    if (!to || amount === undefined) {
+        throw new MarketplaceError("vidfarm shop withdraw --to 0x… --amount <usdc>   (USDC only)");
+    }
+    const result = await call(ctx, "POST", `${API}/shop/withdraw`, { body: { to_address: to, amount, currency: "usdc" } });
+    if (!result.ok || result.body?.ok === false) {
+        // NEVER suggest a retry here. A transfer can reach the mempool even when it
+        // reports a failure, and a blind second press is how a double-send happens.
+        const detail = result.body?.error ? ` — ${result.body.error}` : "";
+        const advice = result.body?.detail ? `\n  ${result.body.detail}` : "";
+        throw new MarketplaceError(`shop withdraw failed (${result.status})${detail}.${advice}`);
+    }
+    if (emit(ctx, result.body))
+        return;
+    console.log(`${GREEN}Sent ${money(result.body.amount)} USDC.${RESET}`);
+    if (result.body.tx_hash)
+        console.log(`  ${DIM}tx ${result.body.tx_hash}${RESET}`);
+}
+async function cmdInbox(ctx, values) {
+    const result = await call(ctx, "GET", `${API}/notifications`, {
+        query: { filter: values.unseen ? "unseen" : undefined }
+    });
+    assertOk(result, "notifications");
+    if (emit(ctx, result.body))
+        return;
+    console.log(`${BOLD}${result.body.unseen}${RESET} unseen ${DIM}of ${result.body.total}${RESET}`);
+    for (const row of result.body.notifications ?? []) {
+        const seen = row.seen ? DIM : BOLD;
+        console.log(`  ${seen}${row.title ?? row.kind ?? "(no title)"}${RESET}`
+            + ` ${DIM}${shortDate(row.createdAt ?? row.created_at)}${RESET}`);
+        if (row.body)
+            console.log(`    ${DIM}${row.body}${RESET}`);
+        if (row.href || row.url)
+            console.log(`    ${CYAN}${ctx.host}${row.href ?? row.url}${RESET}`);
+    }
+}
+export async function runShopCommand(argv) {
+    const sub = (argv[0] ?? "").toLowerCase();
+    if (["help", "--help", "-h"].includes(sub)) {
+        console.log(SHOP_HELP);
+        return;
+    }
+    const parsed = parseArgs({ args: argv, allowPositionals: true, options: shopOptions() });
+    const values = parsed.values;
+    const rest = parsed.positionals.slice(1);
+    const ctx = resolveCtx(values);
+    switch (sub) {
+        case "":
+        case "status":
+        case "cards":
+        case "machines": return cmdShopShow(ctx);
+        case "open":
+        case "profile":
+        case "create": return cmdShopOpen(ctx, values);
+        case "hide": return cmdShopOpen(ctx, values, true);
+        case "show":
+        case "unhide": return cmdShopOpen(ctx, values, false);
+        case "sync": {
+            const result = await call(ctx, "POST", `${API}/shop/sync`);
+            assertOk(result, "shop sync");
+            if (emit(ctx, result.body))
+                return;
+            console.log(`${GREEN}Synced.${RESET} ${result.body.linked} linked, ${result.body.imported} imported.`);
+            console.log(`${DIM}An imported machine arrives switched OFF and unapproved — importing never publishes.${RESET}`);
+            return;
+        }
+        case "card": return cmdCardDetail(ctx, rest[0] ?? "");
+        case "new-card":
+        case "add-card": return cmdNewCard(ctx, values);
+        case "edit-card":
+        case "edit": return cmdEditCard(ctx, values, rest[0] ?? "");
+        case "on": return cmdCardVisibility(ctx, rest[0] ?? "", true);
+        case "off": return cmdCardVisibility(ctx, rest[0] ?? "", false);
+        case "remove-card":
+        case "delete-card": {
+            const machineId = rest[0] ?? "";
+            if (!machineId)
+                throw new MarketplaceError("Which card? vidfarm shop remove-card <machineId>");
+            const result = await call(ctx, "DELETE", `${API}/shop/machines/${encodeURIComponent(machineId)}`);
+            assertOk(result, "shop remove-card");
+            if (emit(ctx, result.body))
+                return;
+            console.log(`${GREEN}Removed.${RESET}`);
+            return;
+        }
+        case "add-example": {
+            const machineId = rest[0] ?? "";
+            const templateId = optionalText(values.template) ?? rest[1] ?? "";
+            if (!machineId || !templateId) {
+                throw new MarketplaceError("vidfarm shop add-example <machineId> --template <templateId>");
+            }
+            const result = await call(ctx, "POST", `${API}/shop/machines/${encodeURIComponent(machineId)}/examples`, {
+                body: {
+                    template_id: templateId,
+                    title: optionalText(values.title) ?? "",
+                    note: optionalText(values.note) ?? "",
+                    poster_url: optionalText(values.poster) ?? "",
+                    video_url: optionalText(values.video) ?? ""
+                }
+            });
+            assertOk(result, "shop add-example");
+            if (emit(ctx, result.body))
+                return;
+            console.log(`${GREEN}Example added.${RESET}`);
+            return;
+        }
+        case "drop-example":
+        case "remove-example": {
+            const machineId = rest[0] ?? "";
+            const templateId = rest[1] ?? optionalText(values.template) ?? "";
+            if (!machineId || !templateId) {
+                throw new MarketplaceError("vidfarm shop drop-example <machineId> <templateId>");
+            }
+            const result = await call(ctx, "DELETE", `${API}/shop/machines/${encodeURIComponent(machineId)}/examples/${encodeURIComponent(templateId)}`);
+            assertOk(result, "shop drop-example");
+            if (emit(ctx, result.body))
+                return;
+            console.log(`${GREEN}Example removed.${RESET}`);
+            return;
+        }
+        case "orders":
+        case "queue": return cmdOrders(ctx, values);
+        case "order": return cmdOrderDetail(ctx, rest[0] ?? "");
+        case "say":
+        case "comment":
+        case "reply-order": return cmdShopSay(ctx, values, rest[0] ?? "", rest.slice(1).join(" "));
+        case "deliver":
+        case "fulfil":
+        case "fulfill": return cmdDeliver(ctx, values, rest[0] ?? "");
+        case "refund": return cmdShopRefund(ctx, values, rest[0] ?? "");
+        case "reviews": return cmdShopReviews(ctx);
+        case "reply": return cmdShopReply(ctx, rest[0] ?? "", rest.slice(1).join(" "));
+        case "earnings":
+        case "analytics": return cmdEarnings(ctx, values);
+        case "withdraw": return cmdWithdraw(ctx, values);
+        case "inbox":
+        case "notifications": return cmdInbox(ctx, values);
+        default:
+            console.error(`Unknown shop subcommand: ${sub}\n`);
+            console.log(SHOP_HELP);
+            process.exitCode = 1;
+    }
+}
+// ═══════════════════════════════════════════════════════════════════════════
+// vidfarm purchases — THE BUYER
+// ═══════════════════════════════════════════════════════════════════════════
+export const PURCHASES_HELP = `vidfarm purchases — buy packs of videos on the marketplace (BUYER side)
+
+  A vendor puts PACK CARDS on the shelf. You order a pack, your USDC goes into
+  escrow, they deliver, you rule on it, and accepting is what pays them.
+
+  AN ORDER ENDS THREE WAYS, and only one is reversible:
+    accept    approve and pay. FINAL, in both directions.
+    changes   free. Nothing moves — the vendor re-delivers and you rule again.
+    refund    the escrow comes back to you. Whoever signs it pays the gas.
+              On a FREE order this is a cancel: it closes the order and returns
+              nothing, because nothing was taken.
+
+  FIRST ORDER FREE — some shops are marked NEW SHOP by the platform, and your
+  first order there is one pack at $0. \`purchases shelf\` flags the offer;
+  \`purchases pack\` says whether YOU still have yours. It is one per shop, not
+  one per card, and it changes the rules: no deposit, nothing to refund, and
+  YOUR APPROVAL IS FINAL — it releases the files at once, with no payout step
+  after it to hold anything back. Cancelling does not give the free order back.
+
+  THE SHELF
+  purchases shelf [--shop <slug>]        What is for sale        → GET  ${API}/shelf
+  purchases pack <shop>/<machineId>      One card, its examples, reviews, and
+                                         whether your free first order is still there
+
+  BUYING
+  purchases buy <shop>/<machineId> [--packs <n>] [--notes "<brief>"]
+    --answer <requirementId>=<url>       Once per field the card demands (repeatable)
+    -y                                   Skip the confirmation
+                                         → POST ${API}/purchases
+
+  YOUR ORDERS
+  purchases                              Everything you bought    → GET  ${API}/purchases
+  purchases order <orderId>              One order, with its thread and files
+  purchases say <orderId> "<message>" [--reply-to <commentId>]
+  purchases files <orderId>              The delivered URLs (masters after payout)
+
+  RULING ON A PACK
+  purchases open <orderId>               Tear it — a one-time event
+  purchases rate <orderId> <itemId> keep|pass [--tag <why>] [--note "…"]
+  purchases accept <orderId>             Approve and pay. IRREVERSIBLE.
+  purchases changes <orderId> "<what to fix>"       Free. Escrow untouched.
+  purchases refund <orderId> [--ask] [--reason "…"]
+    --ask                                Ask the VENDOR to sign it, so it costs you no gas
+  purchases cancel-refund <orderId>      Drop a standing ask
+  purchases review <orderId> --value 5 --speed 5 --quality 5 --support 5 [--comment "…"]
+
+  purchases inbox [--unseen]             Deliveries, comments, refunds
+
+  Every command takes --json. Auth: \`vidfarm login\` / VIDFARM_API_KEY / --api-key.`;
+/** `<shopSlug>/<machineId>`, or `--shop <slug>` plus a bare machine id. */
+export function splitPackRef(ref, values) {
+    const raw = String(ref ?? "").trim();
+    const explicitShop = optionalText(values.shop)?.trim() ?? "";
+    if (raw.includes("/")) {
+        const [shop, ...machine] = raw.split("/");
+        return { shop: shop.trim(), machine: machine.join("/").trim() };
+    }
+    if (explicitShop && raw)
+        return { shop: explicitShop, machine: raw };
+    throw new MarketplaceError("Name the pack as <shopSlug>/<machineId> — `vidfarm purchases shelf` lists both.");
+}
+/**
+ * Does THIS account still have its free first order at this shop?
+ *
+ * A separate call on purpose. The shelf is shared-cached and can only say that
+ * the OFFER exists (`shop.new_shop`); the entitlement is per-account, so it has
+ * its own no-store route.
+ *
+ * Fails CLOSED — an unreachable answer is `false`, which prices the order at
+ * the paid number. Showing $0 and then charging is the one direction that is
+ * unforgivable, so this only ever LOWERS a price it already showed.
+ */
+async function freeOrderAvailable(ctx, shopSlug) {
+    const result = await call(ctx, "GET", `${API}/free-order-status/${encodeURIComponent(shopSlug)}`)
+        .catch(() => null);
+    return result?.ok === true && result.body?.free_available === true;
+}
+/** The three sentences a buyer must read BEFORE they consent to a free order. */
+const FREE_ORDER_TERMS = [
+    "It is ONE pack, at $0, and you get one per shop — not one per card.",
+    "Nothing is deposited, so there is no escrow and nothing to refund.",
+    "YOUR APPROVAL IS FINAL and releases the files at once. There is no payout to hold back,"
+        + " so accepting is the whole transaction."
+];
+async function cmdShelf(ctx, values) {
+    const result = await call(ctx, "GET", `${API}/shelf`, {
+        query: { shop: optionalText(values.shop), limit: optionalText(values.limit) }
+    });
+    assertOk(result, "purchases shelf");
+    if (emit(ctx, result.body))
+        return;
+    const packs = result.body.packs ?? [];
+    if (!packs.length) {
+        console.log(`${DIM}Nothing on the shelf right now.${RESET}`);
+        return;
+    }
+    console.log(`${BOLD}${packs.length} pack${packs.length === 1 ? "" : "s"} for sale${RESET}`);
+    for (const pack of packs) {
+        console.log(`\n  ${BOLD}${pack.title}${RESET} ${DIM}by ${pack.shop.display_name}${RESET}`
+            // The OFFER, which is the same for everybody and safe on a cached list.
+            // Whether YOU still have yours is answered by `purchases pack`.
+            + (pack.shop.new_shop ? `  ${GREEN}FIRST ORDER FREE${RESET}` : ""));
+        console.log(`    ${money(pack.price_per_lot_usd)} for ${pack.lot_size} videos`
+            + `${pack.delivery_estimate ? ` ${DIM}· ${pack.delivery_estimate}${RESET}` : ""}`);
+        if (pack.note)
+            console.log(`    ${DIM}${pack.note}${RESET}`);
+        console.log(`    ${DIM}buy:${RESET} ${BOLD}vidfarm purchases buy ${pack.shop_slug}/${pack.machine_id}${RESET}`);
+    }
+}
+async function cmdPack(ctx, values, ref) {
+    const { shop, machine } = splitPackRef(ref, values);
+    const result = await call(ctx, "GET", `${API}/shelf/${encodeURIComponent(shop)}/${encodeURIComponent(machine)}`);
+    assertOk(result, "purchases pack");
+    if (emit(ctx, result.body))
+        return;
+    const pack = result.body.pack;
+    console.log(`${BOLD}${pack.title}${RESET} ${DIM}by ${result.body.shop.display_name}${RESET}`);
+    console.log(`  ${money(pack.price_per_lot_usd)} for ${pack.lot_size} videos`
+        + `${pack.delivery_estimate ? ` · ${pack.delivery_estimate}` : ""}`);
+    if (pack.note)
+        console.log(`  ${pack.note}`);
+    // The card above is a cached, public answer. THIS is the per-account one, and
+    // it is the only place that can say the word "you".
+    if (result.body.shop.new_shop) {
+        if (await freeOrderAvailable(ctx, result.body.shop.shop_slug)) {
+            console.log(`\n  ${GREEN}Your first order at this shop is FREE — one pack, $0.${RESET}`);
+            for (const term of FREE_ORDER_TERMS)
+                console.log(`  ${DIM}· ${term}${RESET}`);
+        }
+        else {
+            console.log(`\n  ${DIM}This shop offers a free first order, but you have already used yours.`
+                + ` This one is ${money(pack.price_per_lot_usd)}.${RESET}`);
+        }
+    }
+    if (pack.before_you_buy_note) {
+        console.log(`\n  ${YELLOW}Before you buy${RESET}\n  ${pack.before_you_buy_note}`);
+    }
+    if (pack.requirements?.length) {
+        console.log(`\n  ${BOLD}You must supply${RESET}`);
+        for (const row of pack.requirements) {
+            console.log(`    --answer ${row.id}=<url>   ${row.label}${row.hint ? ` ${DIM}(${row.hint})${RESET}` : ""}`);
+        }
+    }
+    const summary = result.body.review_summary ?? {};
+    if (summary.count)
+        console.log(`\n  ${BOLD}${summary.overall}/5${RESET} ${DIM}from ${summary.count} review(s)${RESET}`);
+    for (const example of pack.examples ?? []) {
+        console.log(`    example: ${CYAN}${example.video_url ?? example.poster_url ?? example.template_id}${RESET}`);
+    }
+    console.log(`\n  ${CYAN}${pack.machine_url}${RESET}`);
+}
+async function cmdBuy(ctx, values, ref) {
+    const { shop, machine } = splitPackRef(ref, values);
+    const packs = Math.max(1, Math.round(optionalNumber(values.packs) ?? 1));
+    // Read the card FIRST. The price comes off the machine on the server either
+    // way, so this is not about arithmetic — it is so the confirmation names the
+    // real number, and so a missing `--answer` is caught before any money moves.
+    const card = await call(ctx, "GET", `${API}/shelf/${encodeURIComponent(shop)}/${encodeURIComponent(machine)}`);
+    assertOk(card, "purchases buy");
+    const pack = card.body.pack;
+    const answers = {};
+    for (const raw of values.answer ?? []) {
+        const index = String(raw).indexOf("=");
+        if (index < 1)
+            throw new MarketplaceError(`--answer must be <requirementId>=<url>, got "${raw}".`);
+        answers[String(raw).slice(0, index).trim()] = String(raw).slice(index + 1).trim();
+    }
+    const missing = (pack.requirements ?? []).filter((row) => !answers[row.id]);
+    if (missing.length) {
+        throw new MarketplaceError([
+            `This vendor will not start without ${missing.length} more link(s):`,
+            ...missing.map((row) => `  --answer ${row.id}=<url>   ${row.label}`)
+        ].join("\n"));
+    }
+    const total = Math.round(packs * Number(pack.price_per_lot_usd) * 100) / 100;
+    // ── is this one free? ──
+    //
+    // ADVISORY, and only ever downward. The order route claims the free pack
+    // again with a conditional write, so a stale yes here cannot mint a free
+    // order — it can only produce a confirmation that was too generous, and the
+    // server then charges the real price. Which is why this is read BEFORE the
+    // confirmation and never after: quoting $0 and then charging is the one
+    // direction a buyer cannot forgive.
+    const free = card.body.shop.new_shop === true
+        && await freeOrderAvailable(ctx, card.body.shop.shop_slug);
+    // A free order is ONE pack whatever was asked for — the free rail prices a
+    // whole order at $0 and cannot discount part of one. Say so before they
+    // consent, rather than silently delivering a third of what they typed.
+    if (free && packs > 1 && !ctx.json) {
+        console.error(`${YELLOW}Your free first order is ONE pack. `
+            + `Ordering ${packs} would be charged in full — drop --packs to take the free one.${RESET}`);
+    }
+    if (!values.yes && !ctx.json) {
+        console.log(`${BOLD}${packs} × ${pack.title}${RESET} from ${card.body.shop.display_name}`);
+        if (free && packs === 1) {
+            console.log(`  ${pack.lot_size} videos · ${GREEN}${BOLD}FREE${RESET}`
+                + ` ${DIM}— your first order at this shop${RESET}`);
+            // THE CONSENT POINT. "Free" is the part a buyer reads; the part they must
+            // read is that free costs them the undo. On this rail there is no escrow
+            // to hold back and approval ends the order outright.
+            for (const term of FREE_ORDER_TERMS)
+                console.log(`  ${YELLOW}· ${term}${RESET}`);
+        }
+        else {
+            console.log(`  ${packs * pack.lot_size} videos · ${BOLD}${money(total)}${RESET} into escrow now`);
+        }
+        if (pack.before_you_buy_note)
+            console.log(`  ${YELLOW}${pack.before_you_buy_note}${RESET}`);
+        console.log(`\n  ${DIM}Add -y to place it.${RESET}`);
+        return;
+    }
+    const result = await call(ctx, "POST", `${API}/purchases`, {
+        body: {
+            shop_slug: shop,
+            machine_id: machine,
+            packs,
+            notes: optionalText(values.notes) ?? "",
+            answers,
+            // One key per attempt. A retry of THIS command reuses it, so a flaky
+            // connection cannot mint a second deposit for the same order.
+            idempotency_key: `devcli_${shop}_${machine}_${packs}_${Date.now()}`
+        }
+    });
+    // A funded-but-unrecorded failure still carries an order id, and that id is
+    // the difference between a recoverable order and a payment nobody can name.
+    if (!result.ok || result.body?.ok === false) {
+        const lines = [`purchases buy failed (${result.status}) — ${result.body?.error ?? "unknown error"}.`];
+        if (result.body?.order_id) {
+            lines.push(`  The order exists: ${result.body.order_id}`);
+            lines.push(`  ${result.body.funded ? "YOUR MONEY MOVED." : "No deposit was taken."}`
+                + ` vidfarm purchases order ${result.body.order_id}`);
+        }
+        if (result.body?.retryable)
+            lines.push("  This one is safe to try again.");
+        throw new MarketplaceError(lines.join("\n"));
+    }
+    if (emit(ctx, result.body))
+        return;
+    console.log(`${GREEN}${result.body.replay ? "Already ordered." : "Ordered."}${RESET}`
+        + ` ${BOLD}${result.body.order_id}${RESET}`);
+    // THE SERVER DECIDED, not the check above. The claim is a conditional write
+    // and this is its answer, so a race that lost prints the price it was charged.
+    console.log(`  ${result.body.video_count} videos · `
+        + (result.body.free ? `${GREEN}FREE — your first order at this shop${RESET}` : money(result.body.total_usd))
+        + ` · ${result.body.funded
+            ? (result.body.free ? `${GREEN}live${RESET}` : `${GREEN}funded${RESET}`)
+            // On the free rail there is nothing to fund, so an unfunded free order
+            // means it never reached Dollar Platoon at all — a different fault, and
+            // it needs a different sentence.
+            : (result.body.free
+                ? `${YELLOW}NOT live — it did not reach Dollar Platoon${RESET}`
+                : `${YELLOW}NOT funded — no deposit was taken${RESET}`)}`);
+    if (result.body.free) {
+        console.log(`  ${YELLOW}Your approval on this order is FINAL and releases the files at once.${RESET}`);
+    }
+    console.log(`  ${CYAN}${ctx.host}${result.body.order_url}${RESET}`);
+}
+async function cmdPurchasesList(ctx) {
+    const result = await call(ctx, "GET", `${API}/purchases`);
+    assertOk(result, "purchases");
+    if (emit(ctx, result.body))
+        return;
+    const rows = result.body.purchases ?? [];
+    if (!rows.length) {
+        console.log(`${DIM}Nothing bought yet — vidfarm purchases shelf${RESET}`);
+        return;
+    }
+    for (const row of rows) {
+        console.log(`  ${BOLD}${row.order_id ?? row.delivery_id}${RESET}  ${row.machine_title}`
+            + ` ${DIM}from ${row.shop_name} · ${orderPrice(row)} · ${shortDate(row.created_at)}${RESET}`
+            + `  ${row.opened_at ? `${DIM}opened${RESET}` : `${CYAN}sealed${RESET}`}  ${row.status}`);
+    }
+}
+async function fetchOrder(ctx, orderId) {
+    if (!orderId)
+        throw new MarketplaceError("Which order? Run `vidfarm purchases` to list them.");
+    const result = await call(ctx, "GET", `${API}/purchases/${encodeURIComponent(orderId)}`);
+    assertOk(result, "purchases order");
+    return result.body;
+}
+async function cmdPurchaseDetail(ctx, orderId) {
+    const body = await fetchOrder(ctx, orderId);
+    if (emit(ctx, body))
+        return;
+    const { order, delivery, thread, review, can } = body;
+    printOrderRow(order);
+    console.log(`  ${CYAN}${order.buyer_url}${RESET}`);
+    if (delivery) {
+        console.log(`\n${BOLD}The pack${RESET} ${DIM}${delivery.items.length} item(s)`
+            + `${delivery.opened_at ? "" : " · still sealed"}${RESET}`);
+        if (!delivery.masters_released) {
+            // Two rails, two release rules, and the difference matters to a buyer
+            // deciding whether to accept: on a paid order the payout unlocks the
+            // masters, on a free one the approval does it by itself.
+            console.log(order.is_free
+                ? `  ${YELLOW}Masters are locked until you accept. On a free order accepting IS the end — there is no payout after it.${RESET}`
+                : `  ${YELLOW}Masters are locked until you accept and the payout lands.${RESET}`);
+        }
+        for (const item of delivery.items) {
+            const verdict = item.verdict === "approved"
+                ? `${GREEN}kept${RESET}`
+                : item.verdict === "rejected" ? `${RED}passed${RESET}` : `${DIM}not ruled on${RESET}`;
+            console.log(`  ${BOLD}${item.item_id}${RESET} ${verdict}${item.note ? ` ${DIM}${item.note}${RESET}` : ""}`);
+            for (const url of item.preview_urls)
+                console.log(`    preview ${CYAN}${url}${RESET}`);
+            for (const url of item.master_urls)
+                console.log(`    master  ${CYAN}${url}${RESET}`);
+        }
+        if (body.zip_url)
+            console.log(`  ${DIM}all of it: ${body.zip_url}${RESET}`);
+    }
+    else {
+        console.log(`\n${DIM}Nothing delivered yet.${RESET}`);
+    }
+    if (thread?.comments?.length) {
+        console.log(`\n${BOLD}Thread${RESET}`);
+        for (const comment of thread.comments) {
+            console.log(`  ${comment.mine ? BOLD : ""}${comment.author || comment.role}${RESET}`
+                + ` ${DIM}${shortDate(comment.created_at)} [${comment.id}]${RESET}`);
+            console.log(`    ${String(comment.body).replace(/\n/g, "\n    ")}`);
+        }
+    }
+    if (review)
+        console.log(`\n${BOLD}Your review${RESET} ${review.overall}/5`);
+    const moves = [
+        can?.accept
+            ? (order.is_free ? "accept (FINAL, nothing charged)" : `accept (pays ${money(order.total_usd)}, FINAL)`)
+            : null,
+        can?.request_changes ? "changes (free)" : null,
+        // "refund" on an order that cost nothing reads as a bug. Same route either
+        // way — it closes the order — but the word has to match what happened.
+        can?.refund ? (order.is_free ? "cancel" : "refund") : null,
+        can?.review ? "review" : null
+    ].filter(Boolean);
+    if (moves.length)
+        console.log(`\n${DIM}You can: ${moves.join(" · ")}${RESET}`);
+}
+async function cmdFiles(ctx, orderId) {
+    const body = await fetchOrder(ctx, orderId);
+    const items = body.delivery?.items ?? [];
+    if (emit(ctx, { masters_released: Boolean(body.delivery?.masters_released), items }))
+        return;
+    if (!items.length) {
+        console.log(`${DIM}Nothing delivered yet.${RESET}`);
+        return;
+    }
+    for (const item of items) {
+        for (const url of item.master_urls.length ? item.master_urls : item.preview_urls)
+            console.log(url);
+    }
+    if (!body.delivery?.masters_released) {
+        console.error(`${YELLOW}Watermarked previews only — the masters unlock when you accept.${RESET}`);
+    }
+}
+async function cmdOpenPack(ctx, orderId) {
+    const body = await fetchOrder(ctx, orderId);
+    const deliveryId = body.delivery?.delivery_id;
+    if (!deliveryId)
+        throw new MarketplaceError("There is nothing delivered on that order yet.");
+    const result = await call(ctx, "POST", `${API}/deliveries/${encodeURIComponent(deliveryId)}/open`, { body: {} });
+    assertOk(result, "purchases open");
+    if (emit(ctx, result.body))
+        return;
+    console.log(`${GREEN}Torn open.${RESET} ${body.delivery.items.length} item(s) inside.`);
+    console.log(`${DIM}Rule on each: vidfarm purchases rate ${orderId} <itemId> keep|pass${RESET}`);
+}
+async function cmdRate(ctx, values, orderId, itemId, verdictWord) {
+    const word = String(verdictWord ?? "").toLowerCase();
+    const verdict = ["keep", "approve", "approved", "yes"].includes(word)
+        ? "approved"
+        : ["pass", "reject", "rejected", "no"].includes(word) ? "rejected" : "";
+    if (!itemId || !verdict) {
+        throw new MarketplaceError("vidfarm purchases rate <orderId> <itemId> keep|pass");
+    }
+    const body = await fetchOrder(ctx, orderId);
+    const deliveryId = body.delivery?.delivery_id;
+    if (!deliveryId)
+        throw new MarketplaceError("There is nothing delivered on that order yet.");
+    const result = await call(ctx, "POST", `${API}/deliveries/${encodeURIComponent(deliveryId)}/verdict`, {
+        body: {
+            item_id: itemId,
+            verdict,
+            rejection_tag: optionalText(values.tag) ?? null,
+            note: optionalText(values.note) ?? null
+        }
+    });
+    assertOk(result, "purchases rate");
+    if (emit(ctx, result.body))
+        return;
+    console.log(`${GREEN}Recorded.${RESET} ${result.body.decided}/${result.body.total} ruled on.`);
+    if (result.body.complete) {
+        // Deliberately BOTH doors. A verdict is vidfarm's note of what the buyer
+        // thought; accepting pays for the pack in full whatever those notes say.
+        console.log(`${DIM}All of them. Now: vidfarm purchases accept ${orderId}${RESET}`);
+        console.log(`${DIM}      or:  vidfarm purchases changes ${orderId} "<what to fix>"  (free)${RESET}`);
+    }
+}
+async function cmdAccept(ctx, values, orderId) {
+    const body = await fetchOrder(ctx, orderId);
+    const free = body.order.is_free === true;
+    if (!values.yes && !ctx.json) {
+        // The one command in this file that cannot be undone. It gets a
+        // confirmation for the same reason the web card has a dialog — and a FREE
+        // order needs it MORE, not less: nothing is charged, so the only thing the
+        // buyer is spending is their right to send the pack back.
+        console.log(free
+            ? `${BOLD}Accepting closes this order for good. Nothing is charged — it is your free first order.${RESET}`
+            : `${BOLD}Accepting pays ${money(body.order.total_usd)} to ${body.order.shop_name}, in full.${RESET}`);
+        console.log(free
+            ? `  Your verdict is FINAL and releases the files at once. There is no payout to hold back,`
+                + ` so this IS the end of the order — you cannot ask for changes afterwards.`
+            : `  Dollar Platoon's verdict is FINAL — there is no undo, and no partial payment.`);
+        const rejected = (body.delivery?.items ?? []).filter((item) => item.verdict === "rejected").length;
+        if (rejected) {
+            console.log(free
+                ? `  ${YELLOW}You marked ${rejected} video(s) wrong. Accepting takes the pack as it is.${RESET}`
+                : `  ${YELLOW}You marked ${rejected} video(s) wrong. Accepting pays for them anyway.${RESET}`);
+            console.log(`  ${YELLOW}Free alternative: vidfarm purchases changes ${orderId} "<what to fix>"${RESET}`);
+        }
+        console.log(`\n  ${DIM}Add -y to accept.${RESET}`);
+        return;
+    }
+    const result = await call(ctx, "POST", `${API}/purchases/${encodeURIComponent(orderId)}/accept`, { body: {} });
+    assertOk(result, "purchases accept");
+    if (emit(ctx, result.body))
+        return;
+    console.log(`${GREEN}${result.body.message}${RESET}`);
+    // Approved-but-unsettled is real and recoverable, and it is a PAID-rail
+    // state only: on the free rail the approval is the whole transaction, so
+    // there is no second call left to fail.
+    if (!result.body.settled && !free) {
+        // Never tell this buyer to accept again — there is nothing left to approve.
+        console.log(`${YELLOW}The verdict landed but the payout did not. Do NOT accept again — retry the payout shortly.${RESET}`);
+    }
+}
+async function cmdChanges(ctx, orderId, note) {
+    if (!orderId || !note)
+        throw new MarketplaceError('vidfarm purchases changes <orderId> "<what to fix>"');
+    const result = await call(ctx, "POST", `${API}/purchases/${encodeURIComponent(orderId)}/request-changes`, { body: { note } });
+    assertOk(result, "purchases changes");
+    if (emit(ctx, result.body))
+        return;
+    console.log(`${GREEN}${result.body.message}${RESET}`);
+}
+async function cmdBuyerRefund(ctx, values, orderId) {
+    if (!orderId)
+        throw new MarketplaceError("Which order? vidfarm purchases refund <orderId>");
+    const result = await call(ctx, "POST", `${API}/purchases/${encodeURIComponent(orderId)}/refund`, {
+        body: { mode: values.ask ? "ask" : "self", reason: optionalText(values.reason) ?? "" }
+    });
+    assertOk(result, "purchases refund");
+    if (emit(ctx, result.body))
+        return;
+    // The server's own sentence already knows which rail it was on — a free
+    // order gets "cancelled", a paid one "refunded" — so it is printed as-is
+    // rather than reworded here.
+    console.log(`${GREEN}${result.body.message}${RESET}`);
+    if (result.body.tx_hash)
+        console.log(`  ${DIM}tx ${result.body.tx_hash}${RESET}`);
+    // A spent free order does NOT come back. Said here because this is the one
+    // command that spends it, and a buyer cancelling to "re-order properly"
+    // would otherwise find out by being charged.
+    if (result.body.free_spent) {
+        console.log(`  ${YELLOW}Your free first order at this shop stays used. `
+            + `A new order here will be charged.${RESET}`);
+    }
+}
+async function cmdReview(ctx, values, orderId) {
+    const axes = ["value", "speed", "quality", "support"];
+    const scores = {};
+    for (const axis of axes) {
+        const score = optionalNumber(values[axis]);
+        if (score === undefined) {
+            throw new MarketplaceError("Score all four: --value --speed --quality --support, each 1-5."
+                + "\n  A missing axis would be saved as a one-star you did not write.");
+        }
+        scores[axis] = score;
+    }
+    const result = await call(ctx, "POST", `${API}/purchases/${encodeURIComponent(orderId)}/review`, {
+        body: { ...scores, comment: optionalText(values.comment) ?? "" }
+    });
+    assertOk(result, "purchases review");
+    if (emit(ctx, result.body))
+        return;
+    console.log(result.body.duplicate
+        ? `${DIM}You already reviewed this order.${RESET}`
+        : `${GREEN}Posted. ${result.body.overall}/5${RESET}`);
+}
+export async function runPurchasesCommand(argv) {
+    const sub = (argv[0] ?? "").toLowerCase();
+    if (["help", "--help", "-h"].includes(sub)) {
+        console.log(PURCHASES_HELP);
+        return;
+    }
+    const parsed = parseArgs({ args: argv, allowPositionals: true, options: purchasesOptions() });
+    const values = parsed.values;
+    const rest = parsed.positionals.slice(1);
+    const ctx = resolveCtx(values);
+    switch (sub) {
+        case "":
+        case "list":
+        case "orders": return cmdPurchasesList(ctx);
+        case "shelf":
+        case "browse":
+        case "packs": return cmdShelf(ctx, values);
+        case "pack":
+        case "card": return cmdPack(ctx, values, rest[0] ?? "");
+        case "buy":
+        case "order-pack": return cmdBuy(ctx, values, rest[0] ?? "");
+        case "order":
+        case "show": return cmdPurchaseDetail(ctx, rest[0] ?? "");
+        case "files":
+        case "download": return cmdFiles(ctx, rest[0] ?? "");
+        case "say":
+        case "comment": {
+            const orderId = rest[0] ?? "";
+            const message = rest.slice(1).join(" ");
+            if (!orderId || !message)
+                throw new MarketplaceError('vidfarm purchases say <orderId> "<message>"');
+            const result = await call(ctx, "POST", `${API}/purchases/${encodeURIComponent(orderId)}/comment`, { body: { body: message, parent_id: optionalText(values["reply-to"]) ?? "" } });
+            assertOk(result, "purchases say");
+            if (emit(ctx, result.body))
+                return;
+            console.log(`${GREEN}Posted.${RESET}`);
+            return;
+        }
+        case "open":
+        case "tear": return cmdOpenPack(ctx, rest[0] ?? "");
+        case "rate":
+        case "verdict": return cmdRate(ctx, values, rest[0] ?? "", rest[1] ?? "", rest[2] ?? "");
+        case "accept":
+        case "approve": return cmdAccept(ctx, values, rest[0] ?? "");
+        case "changes":
+        case "request-changes":
+        case "revise": return cmdChanges(ctx, rest[0] ?? "", rest.slice(1).join(" ") || (optionalText(values.note) ?? ""));
+        case "refund":
+        case "cancel": return cmdBuyerRefund(ctx, values, rest[0] ?? "");
+        case "cancel-refund":
+        case "drop-refund": {
+            const orderId = rest[0] ?? "";
+            if (!orderId)
+                throw new MarketplaceError("Which order? vidfarm purchases cancel-refund <orderId>");
+            const result = await call(ctx, "POST", `${API}/purchases/${encodeURIComponent(orderId)}/refund/cancel-request`, { body: {} });
+            assertOk(result, "purchases cancel-refund");
+            if (emit(ctx, result.body))
+                return;
+            console.log(`${GREEN}${result.body.message}${RESET}`);
+            return;
+        }
+        case "review":
+        case "rate-vendor": return cmdReview(ctx, values, rest[0] ?? "");
+        case "inbox":
+        case "notifications": return cmdInbox(ctx, values);
+        default:
+            console.error(`Unknown purchases subcommand: ${sub}\n`);
+            console.log(PURCHASES_HELP);
+            process.exitCode = 1;
+    }
+}
+//# sourceMappingURL=marketplace-console.js.map