@officexapp/vidfarm-devcli 0.21.45 → 0.21.47

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

@@ -0,0 +1,651 @@
+// `vidfarm gigs` — the vending machines, from BOTH sides, in the terminal.
+//
+// CLIENT (paid vidfarm plan): list your two standing machines, post a task into
+// Custom Requests, read the queue, read the proofs that came back, approve or
+// reject them, and ring the bell so every listening agent sees the new work.
+//
+// GIGWORKER (free, no vidfarm account at all): bring your own dollarplatoon.com
+// api key, read the feed to find clients, join a machine, claim a task, and
+// submit your proof.
+//
+// Everything here talks to Dollar Platoon's own API. The key is resolved in
+// this order:
+//   1. --dp-key <key>
+//   2. DOLLARPLATOON_API_KEY   (dollarplatoon.com)
+//   3. GIGDESK_API_KEY         (gigdesk.cc — same key family, Bearer auth)
+//   4. the vidfarm account's own key, fetched from
+//      GET /api/v1/user/me/marketplace with VIDFARM_API_KEY (paid plans only)
+// So a client who already ran `vidfarm login` needs no extra setup, and a
+// gigworker who has never heard of vidfarm needs only their own key.
+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 RESET = "\x1b[0m";
+/** The shared vidfarm feed: the registry + notification stream every client's machines are listed in. */
+const VIDFARM_FEED_ID = "FEED_01M0BCTVTKSDFZQVEY1RXA4NJK";
+// Two standing invites exist for that feed. The read+register+publish one is
+// PRIVATE — signup applies it server-side (services/dollarplatoon.ts) for paid
+// clients, who are the only ones allowed to list a machine. This module ships in
+// the public npm package, so it may only ever carry the read-only invite: every
+// `gigs join-feed` caller is a gigworker who just needs to see the work.
+/** Standing reusable read-only invite for that feed — public by design. */
+const VIDFARM_FEED_READ_INVITE = "MDFNMEJDVFZUWjVaUEFHNDlO";
+const DEFAULT_DP_API = "https://dollarplatoon.com/api";
+const GIGDESK_API = "https://gigdesk.cc/api";
+export const GIGS_HELP = `vidfarm gigs — your vending machines, both sides of them
+
+CLIENT (paid vidfarm plan — the key is read from your vidfarm account)
+  gigs machines                    Your two standing machines + gig ids + invite links
+  gigs tasks [machine]             What is waiting in the Custom Requests queue
+  gigs add-task --task "<brief>"   Post a task into Custom Requests
+    --price <usd>                  Price per delivered video (default 0.50; "tbd" allowed)
+    --tags a,b --priority <n>      Routing hints (lower priority polls sooner)
+    --angle/--hook/--url/--format  The usual brief fields
+    --assets-link <url>            A READ share link to the footage they may use
+    --upload-link <url>            An UPLOAD share link they drop deliverables into
+    --subfolder <name>             The subfolder you want their work in
+    --proof <text>                 Proof requirement (repeatable)
+    --body <file.json>             Send this JSON as the whole task instead
+  gigs proofs [machine]            Submitted videos, newest first
+    --status <pending|approved|rejected>  --limit <n>
+  gigs approve <proof-id> [machine] [--feedback "<text>"]
+  gigs reject  <proof-id> [machine] [--tag not_selected] [--feedback "<text>"]
+                                   not_selected = a pass; it costs the worker NO reputation
+  gigs ring-bell --title "<t>" [--subtext "<s>"] [--machine inbound_offers]
+                                   Broadcast to every agent on the vidfarm feed
+
+GIGWORKER (free — bring your own key: export DOLLARPLATOON_API_KEY=…)
+  gigs work                        Work waiting in every machine you joined  → GET /work/available
+  gigs feed                        Who is asking for videos right now (notifications)
+    --registry                     Every machine listed in the feed, joinable
+    --limit <n>
+  gigs join-feed [--name "<you>"]  Join the shared vidfarm feed, read-only (needed to read it)
+  gigs join <gig-id> [--invite <token>] [--name "<you>"] [--wallet 0x…]
+  gigs claim <gig-id> [--count 2]  Claim task(s) off a FIFO queue machine
+  gigs submit <gig-id> --task <task-id> --proof <url> [--proof <url>…]
+    --mailbox <id> --tags a,b --note "<text>"
+  gigs mine                        Your mailboxes across every gig
+
+  Common: --dp-key <key> · --json · --host <vidfarm url> (for the key lookup)
+
+  e.g. vidfarm gigs add-task --task "60s explainer for acme.com" --price 0.50 \\
+         --upload-link "https://vidfarm.cc/directory/preview/dsh_…/files/acme"
+       vidfarm gigs proofs --status pending
+       vidfarm gigs approve PRF_01H… --feedback "Great hook, keeping it."
+       DOLLARPLATOON_API_KEY=… vidfarm gigs work`;
+/**
+ * "You have no key yet, here is how to get one" — the single most common first
+ * run for a gigworker, and a deliberate instruction rather than a bug. cli.ts
+ * prints these without a stack trace and files no crash report.
+ */
+export class GigsAuthMissingError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "GigsAuthMissingError";
+    }
+}
+async function resolveAuth(values) {
+    const explicit = values["dp-key"]?.trim();
+    if (explicit)
+        return { key: explicit, api: DEFAULT_DP_API, source: "--dp-key" };
+    const dp = (process.env.DOLLARPLATOON_API_KEY ?? "").trim();
+    if (dp)
+        return { key: dp, api: DEFAULT_DP_API, source: "DOLLARPLATOON_API_KEY" };
+    const gd = (process.env.GIGDESK_API_KEY ?? "").trim();
+    if (gd)
+        return { key: gd, api: GIGDESK_API, source: "GIGDESK_API_KEY" };
+    const account = await loadVidfarmMarketplace(values);
+    if (account?.dollarplatoon_api_key) {
+        return {
+            key: account.dollarplatoon_api_key,
+            api: account.dollarplatoon_api_url || DEFAULT_DP_API,
+            source: "your vidfarm account"
+        };
+    }
+    throw new GigsAuthMissingError([
+        "No Dollar Platoon key found.",
+        "  Client:     run `vidfarm login` (paid plan) — the key comes from your account.",
+        "  Gigworker:  export DOLLARPLATOON_API_KEY=… from https://dollarplatoon.com/gigworker/settings",
+        "  Or pass it directly: --dp-key <key>"
+    ].join("\n"));
+}
+let marketplaceCache;
+/** The paid client's own key + machines, straight from their vidfarm account. */
+async function loadVidfarmMarketplace(values) {
+    if (marketplaceCache !== undefined)
+        return marketplaceCache;
+    // `vidfarm login` already stored a key — use it, so a logged-in client needs
+    // no env var at all. Explicit flags and env still win.
+    const stored = readStoredAuth();
+    const apiKey = (values["api-key"] ?? process.env.VIDFARM_API_KEY ?? stored?.apiKey ?? "").trim();
+    const host = ((values.host ?? process.env.VIDFARM_HOST ?? stored?.host ?? "https://vidfarm.cc").trim()).replace(/\/+$/, "");
+    if (!apiKey) {
+        marketplaceCache = null;
+        return null;
+    }
+    try {
+        const response = await fetch(`${host}/api/v1/user/me/marketplace`, {
+            headers: { authorization: `Bearer ${apiKey}`, accept: "application/json" }
+        });
+        const body = await response.json().catch(() => ({}));
+        if (!response.ok) {
+            // 402/409 are meaningful: not paid, or no key connected yet. Surface them
+            // rather than falling through to a bare "no key found". Everything else —
+            // above all a 401 from a stale `vidfarm login` — must fall through: this
+            // lookup is the LAST resort in resolveAuth, and a gigworker who never had
+            // a vidfarm account needs its "here is how to get a key" message, not a
+            // bare "Unauthorized" from a client-side route they were never using.
+            if (body?.error && (response.status === 402 || response.status === 409))
+                throw new Error(body.error);
+            marketplaceCache = null;
+            return null;
+        }
+        marketplaceCache = body;
+        return body;
+    }
+    catch (error) {
+        if (error instanceof Error && error.message && !/fetch failed/i.test(error.message))
+            throw error;
+        marketplaceCache = null;
+        return null;
+    }
+}
+// ── transport ────────────────────────────────────────────────────────────────
+async function dp(auth, path, init = {}) {
+    const url = new URL(auth.api + path);
+    for (const [key, value] of Object.entries(init.query ?? {})) {
+        if (value != null && value !== "")
+            url.searchParams.set(key, value);
+    }
+    const response = await fetch(url, {
+        method: init.method ?? "GET",
+        headers: {
+            // DollarPlatoon authenticates ONLY on x-api-key — a Bearer token alone is
+            // rejected with "Missing x-api-key header" before the key is even read.
+            // GigDesk documents Bearer and accepts x-api-key too, so sending both is
+            // correct for either host and keeps this transport host-agnostic.
+            "x-api-key": auth.key,
+            authorization: `Bearer ${auth.key}`,
+            accept: "application/json",
+            ...(init.body === undefined ? {} : { "content-type": "application/json" })
+        },
+        body: init.body === undefined ? undefined : JSON.stringify(init.body)
+    });
+    const text = await response.text();
+    let json = {};
+    try {
+        json = text ? JSON.parse(text) : {};
+    }
+    catch {
+        json = { error: text.slice(0, 300) };
+    }
+    if (!response.ok) {
+        const message = typeof json?.error === "string" ? json.error : `HTTP ${response.status}`;
+        throw new Error(`dollarplatoon ${path} — ${message}`);
+    }
+    return json;
+}
+// ── machine resolution ───────────────────────────────────────────────────────
+const MACHINE_ALIASES = {
+    custom: "custom_requests",
+    custom_requests: "custom_requests",
+    requests: "custom_requests",
+    queue: "custom_requests",
+    inbound: "inbound_offers",
+    inbound_offers: "inbound_offers",
+    offers: "inbound_offers",
+    pitches: "inbound_offers"
+};
+/** Both machines, found by their stable `vidfarm_vm_<slug>` tag. */
+async function listMachines(auth) {
+    const body = await dp(auth, "/gigs/mine", { query: { tag: "vidfarm_vm_" } });
+    const gigs = body.gigs ?? body.data ?? [];
+    return gigs.map((gig) => {
+        const tag = (gig.tags ?? []).find((t) => typeof t === "string" && t.startsWith("vidfarm_vm_")) ?? "";
+        return {
+            slug: tag.slice("vidfarm_vm_".length) || "other",
+            title: String(gig.title ?? gig.id ?? ""),
+            gigId: String(gig.id ?? ""),
+            distribution: gig.distribution ? String(gig.distribution) : undefined,
+            inviteUrl: typeof gig.invite_url === "string" ? gig.invite_url : null
+        };
+    }).filter((m) => m.gigId);
+}
+/** A gig id, a machine slug, or (default) the machine this command is about. */
+async function resolveGigId(auth, raw, fallbackSlug) {
+    const value = (raw ?? "").trim();
+    if (/^GIG_/i.test(value))
+        return value;
+    const wanted = MACHINE_ALIASES[value.toLowerCase()] ?? fallbackSlug;
+    const machines = await listMachines(auth);
+    const match = machines.find((m) => m.slug === wanted);
+    if (!match) {
+        throw new Error(`No "${wanted}" vending machine on this account. Run: vidfarm gigs machines`);
+    }
+    return match.gigId;
+}
+// ── formatting ───────────────────────────────────────────────────────────────
+function out(json, value, human) {
+    if (json) {
+        console.log(JSON.stringify(value, null, 2));
+        return;
+    }
+    human();
+}
+function short(value, max = 90) {
+    const text = typeof value === "string" ? value : value == null ? "" : JSON.stringify(value);
+    const flat = text.replace(/\s+/g, " ").trim();
+    return flat.length > max ? flat.slice(0, max - 1) + "…" : flat;
+}
+/** Dig the playable link out of a proof — workers scatter it across fields. */
+function proofLink(proof) {
+    const proofs = Array.isArray(proof.proofs) ? proof.proofs : [];
+    const direct = proofs.find((p) => typeof p === "string" && /^https?:\/\//.test(p));
+    if (direct)
+        return String(direct);
+    const note = typeof proof.feedback === "string" ? proof.feedback : "";
+    const found = /https?:\/\/\S+/.exec(note);
+    return found ? found[0] : "";
+}
+// ── client commands ──────────────────────────────────────────────────────────
+async function cmdMachines(auth, values) {
+    const machines = await listMachines(auth);
+    out(Boolean(values.json), { machines }, () => {
+        if (!machines.length) {
+            console.log(`${DIM}No vending machines on this key yet. A paid vidfarm account gets two; open ${RESET}https://vidfarm.cc/marketplace/buyer${DIM} once to create them.${RESET}`);
+            return;
+        }
+        for (const machine of machines) {
+            console.log(`  ${BOLD}${machine.title}${RESET}  ${DIM}${machine.slug} · ${machine.gigId}${machine.distribution ? " · " + machine.distribution : ""}${RESET}`);
+            if (machine.inviteUrl)
+                console.log(`      ${DIM}invite: ${machine.inviteUrl}${RESET}`);
+        }
+    });
+}
+async function cmdTasks(auth, values, positional) {
+    const gigId = await resolveGigId(auth, positional, "custom_requests");
+    const body = await dp(auth, `/gigs/${encodeURIComponent(gigId)}/queue`, { query: { limit: values.limit } });
+    const tasks = body.tasks ?? body.queue ?? body.messages ?? [];
+    out(Boolean(values.json), body, () => {
+        if (!tasks.length) {
+            console.log(`${DIM}Queue is empty — post one: vidfarm gigs add-task --task "<brief>"${RESET}`);
+            return;
+        }
+        for (const task of tasks) {
+            const claimed = task.claimed_by || task.mailbox_id ? " · claimed" : "";
+            console.log(`  ${BOLD}${short(task.subject ?? task.id, 60)}${RESET}  ${DIM}[${task.id}]${claimed}${RESET}`);
+            if (task.payload)
+                console.log(`      ${DIM}${short(task.payload, 110)}${RESET}`);
+        }
+    });
+}
+async function cmdAddTask(auth, values) {
+    const gigId = await resolveGigId(auth, values.machine, "custom_requests");
+    // The publisher webhook (with its security token) lives on the gig record.
+    const gig = await dp(auth, `/gigs/${encodeURIComponent(gigId)}`);
+    const webhook = gig.gig?.webhook ?? gig.webhook ?? "";
+    if (!webhook)
+        throw new Error("That machine has no publisher webhook — open it on dollarplatoon.com and check the gig.");
+    let payload;
+    if (values.body) {
+        payload = JSON.parse(readFileSync(String(values.body), "utf8"));
+    }
+    else {
+        const task = values.task?.trim();
+        if (!task)
+            throw new Error('gigs add-task needs --task "<brief>" (or --body <file.json>).');
+        const proofs = [].concat(values.proof ?? []);
+        payload = {
+            task,
+            ...(values.angle ? { angle: String(values.angle) } : {}),
+            ...(values.hook ? { hook: String(values.hook) } : {}),
+            ...(values.url ? { url: String(values.url) } : {}),
+            ...(values.format ? { format: String(values.format) } : {}),
+            // The file-handover layer: a read link to the footage, an upload link for
+            // the deliverable, and the subfolder the worker should create in it.
+            ...(values["assets-link"] ? { assets_link: String(values["assets-link"]) } : {}),
+            ...(values["upload-link"] ? { upload_link: String(values["upload-link"]) } : {}),
+            ...(values.subfolder ? { upload_subfolder: String(values.subfolder) } : {}),
+            ...(proofs.length ? { proof_requirements: proofs } : {})
+        };
+    }
+    const url = new URL(webhook);
+    const price = values.price === undefined ? "0.50" : String(values.price);
+    url.searchParams.set("price", price);
+    if (values.tags)
+        url.searchParams.set("tags", String(values.tags));
+    if (values.priority !== undefined)
+        url.searchParams.set("priority", String(values.priority));
+    if (values["assign-to"])
+        url.searchParams.set("assign_to", String(values["assign-to"]));
+    const response = await fetch(url, {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify(payload)
+    });
+    const text = await response.text();
+    let body = {};
+    try {
+        body = text ? JSON.parse(text) : {};
+    }
+    catch {
+        body = { raw: text.slice(0, 300) };
+    }
+    if (!response.ok)
+        throw new Error(`add-task failed: ${body?.error ?? `HTTP ${response.status}`}`);
+    out(Boolean(values.json), body, () => {
+        const ids = (body.message_ids ?? []).join(", ");
+        console.log(`${GREEN}✓${RESET} Task posted to ${BOLD}${gigId}${RESET} at ${BOLD}$${price}${RESET}/video ${DIM}${ids}${RESET}`);
+        console.log(`  ${DIM}Nobody knows yet — broadcast it: vidfarm gigs ring-bell --title "…" --machine custom_requests${RESET}`);
+    });
+}
+async function cmdProofs(auth, values, positional) {
+    const gigId = await resolveGigId(auth, positional, "inbound_offers");
+    const body = await dp(auth, `/gigs/${encodeURIComponent(gigId)}/proofs`, {
+        query: { status: values.status, limit: values.limit }
+    });
+    const proofs = body.proofs ?? body.data ?? [];
+    out(Boolean(values.json), body, () => {
+        if (!proofs.length) {
+            console.log(`${DIM}No proofs on this machine yet.${RESET}`);
+            return;
+        }
+        for (const proof of proofs) {
+            const price = typeof proof.locked_price === "number" ? ` · $${proof.locked_price.toFixed(2)}` : "";
+            console.log(`  ${BOLD}${proof.id}${RESET}  ${DIM}${proof.status ?? ""}${price}${proof.task_identifier ? " · " + proof.task_identifier : ""}${RESET}`);
+            const link = proofLink(proof);
+            if (link)
+                console.log(`      ${link}`);
+        }
+        console.log("");
+        console.log(`${DIM}Keep one: vidfarm gigs approve <proof-id>   ·   Pass: vidfarm gigs reject <proof-id> --tag not_selected${RESET}`);
+        console.log(`${YELLOW}Silence is approval${RESET}${DIM} — an unreviewed proof auto-approves after the gig's review timeout (default 48h) and you pay for it.${RESET}`);
+    });
+}
+async function cmdReview(auth, values, positionals, action) {
+    const proofId = positionals[0];
+    if (!proofId)
+        throw new Error(`gigs ${action} needs a proof id: vidfarm gigs ${action} PRF_01H…`);
+    const gigId = await resolveGigId(auth, positionals[1], "inbound_offers");
+    const body = { action };
+    if (values.feedback)
+        body.feedback = String(values.feedback);
+    if (action === "reject")
+        body.rejection_tag = values.tag ? String(values.tag) : "not_selected";
+    const result = await dp(auth, `/gigs/${encodeURIComponent(gigId)}/proofs/${encodeURIComponent(proofId)}`, { method: "PATCH", body });
+    out(Boolean(values.json), result, () => {
+        if (action === "approve") {
+            console.log(`${GREEN}✓${RESET} Approved ${BOLD}${proofId}${RESET} — it pays out on the next rollup.`);
+        }
+        else {
+            console.log(`${GREEN}✓${RESET} Rejected ${BOLD}${proofId}${RESET} as ${BOLD}${body.rejection_tag}${RESET}.`);
+            if (body.rejection_tag === "not_selected") {
+                console.log(`  ${DIM}not_selected costs the worker no reputation — the right tag for "good, not this time".${RESET}`);
+            }
+        }
+    });
+}
+async function cmdRingBell(auth, values) {
+    const title = values.title?.trim();
+    if (!title)
+        throw new Error('gigs ring-bell needs --title "<what you want made>".');
+    const slug = MACHINE_ALIASES[String(values.machine ?? "inbound_offers").toLowerCase()] ?? "inbound_offers";
+    const machines = await listMachines(auth);
+    const machine = machines.find((m) => m.slug === slug);
+    if (!machine)
+        throw new Error(`No "${slug}" machine on this account. Run: vidfarm gigs machines`);
+    let destination = machine.inviteUrl ?? "";
+    if (!destination) {
+        // Registering the gig in the feed returns its reusable join link.
+        const registered = await dp(auth, `/feeds/${VIDFARM_FEED_ID}/registry`, {
+            method: "POST",
+            body: { gig_id: machine.gigId, tags: ["vidfarm", "video", slug] }
+        }).catch(() => ({}));
+        destination = registered.invite_url ?? "";
+    }
+    if (!destination)
+        throw new Error("That machine has no invite link yet — open it once on vidfarm.cc/marketplace/buyer.");
+    const result = await dp(auth, `/feeds/${VIDFARM_FEED_ID}/notifications`, {
+        method: "POST",
+        body: {
+            title,
+            subtext: String(values.subtext ?? ""),
+            destination_url: destination,
+            tags: ["vidfarm", "video", slug]
+        }
+    });
+    out(Boolean(values.json), result, () => {
+        console.log(`${GREEN}✓${RESET} Bell rung on ${BOLD}${machine.title}${RESET} — every agent on the vidfarm feed sees it.`);
+        console.log(`  ${DIM}${destination}${RESET}`);
+        console.log(`  ${DIM}Ring it when something CHANGED (new batch, new price, new format) — an empty bell teaches agents to ignore you.${RESET}`);
+    });
+}
+// ── gigworker commands ───────────────────────────────────────────────────────
+async function cmdWork(auth, values) {
+    const body = await dp(auth, "/work/available", { query: { only_with_work: "true", limit: values.limit } });
+    const rows = body.mailboxes ?? body.work ?? body.data ?? [];
+    out(Boolean(values.json), body, () => {
+        if (!rows.length) {
+            console.log(`${DIM}Nothing waiting in the machines you joined. Find new clients: vidfarm gigs feed${RESET}`);
+            return;
+        }
+        for (const row of rows) {
+            const count = row.available ?? row.pending_count ?? row.count ?? "";
+            console.log(`  ${BOLD}${short(row.gig_title ?? row.gig_id, 60)}${RESET}  ${DIM}${row.gig_id ?? ""}${count !== "" ? ` · ${count} waiting` : ""}${RESET}`);
+        }
+        console.log("");
+        console.log(`${DIM}Claim one: vidfarm gigs claim <gig-id>   then   vidfarm gigs submit <gig-id> --task <task-id> --proof <mp4 url>${RESET}`);
+    });
+}
+async function cmdFeed(auth, values) {
+    const registry = Boolean(values.registry);
+    const path = registry ? `/feeds/${VIDFARM_FEED_ID}/registry` : `/feeds/${VIDFARM_FEED_ID}/notifications`;
+    const body = await dp(auth, path, { query: { limit: values.limit ?? "50" } }).catch((error) => {
+        // A non-member gets 404 on EVERY feed route — never 403 — so a stranger cannot
+        // confirm a feed exists. 404 is therefore the code this actually fires on; the
+        // others are kept for a revoked key or a lost membership.
+        if (/40[134]/.test(error.message)) {
+            throw new Error("You are not on the vidfarm feed yet — join it first: vidfarm gigs join-feed");
+        }
+        throw error;
+    });
+    const rows = body.notifications ?? body.entries ?? body.registry ?? body.data ?? [];
+    out(Boolean(values.json), body, () => {
+        if (!rows.length) {
+            console.log(`${DIM}Nothing on the feed right now.${RESET}`);
+            return;
+        }
+        for (const row of rows) {
+            console.log(`  ${BOLD}${short(row.title ?? row.gig_title ?? row.note, 70)}${RESET}`);
+            if (row.subtext)
+                console.log(`      ${DIM}${short(row.subtext, 100)}${RESET}`);
+            const link = row.destination_url ?? row.invite_url ?? "";
+            if (link)
+                console.log(`      ${link}`);
+        }
+        console.log("");
+        console.log(`${DIM}${registry ? "Join one with its invite link, then: vidfarm gigs work" : "Every entry links at a machine you can join right now."}${RESET}`);
+    });
+}
+async function cmdJoinFeed(auth, values) {
+    const result = await dp(auth, `/feeds/${VIDFARM_FEED_ID}/join`, {
+        method: "POST",
+        body: { invite: VIDFARM_FEED_READ_INVITE, ...(values.name ? { display_name: String(values.name) } : {}) }
+    });
+    out(Boolean(values.json), result, () => {
+        console.log(`${GREEN}✓${RESET} On the vidfarm feed. Read it: ${BOLD}vidfarm gigs feed${RESET}`);
+    });
+}
+async function cmdJoin(auth, values, positionals) {
+    const raw = positionals[0];
+    if (!raw)
+        throw new Error("gigs join needs a gig id or an invite URL: vidfarm gigs join GIG_01H… --invite <token>");
+    // An invite URL carries both halves: .../gig/<gigId>/join?invite=<token>
+    let gigId = raw;
+    let invite = values.invite ? String(values.invite) : "";
+    if (/^https?:\/\//i.test(raw)) {
+        const url = new URL(raw);
+        const found = url.pathname.split("/").find((s) => /^GIG_/i.test(s));
+        if (found)
+            gigId = found;
+        invite = invite || url.searchParams.get("invite") || "";
+    }
+    const result = await dp(auth, `/gigs/${encodeURIComponent(gigId)}/mailboxes`, {
+        method: "POST",
+        body: {
+            ...(values.name ? { name: String(values.name) } : {}),
+            ...(invite ? { invite } : {}),
+            ...(values.wallet ? { wallet_address: String(values.wallet) } : {})
+        }
+    });
+    out(Boolean(values.json), result, () => {
+        const mailbox = result.mailbox?.id ?? result.id ?? "";
+        console.log(`${GREEN}✓${RESET} Joined ${BOLD}${gigId}${RESET}${mailbox ? ` ${DIM}mailbox ${mailbox}${RESET}` : ""}`);
+        console.log(`  ${DIM}Now: vidfarm gigs work   ·   vidfarm gigs claim ${gigId}${RESET}`);
+    });
+}
+async function cmdClaim(auth, values, positionals) {
+    const gigId = positionals[0];
+    if (!gigId)
+        throw new Error("gigs claim needs a gig id: vidfarm gigs claim GIG_01H… [--count 2]");
+    const count = values.count === undefined ? 2 : Math.trunc(Number(values.count));
+    const result = await dp(auth, `/gigs/${encodeURIComponent(gigId)}/queue/poll`, { method: "POST", body: { count } });
+    const tasks = result.tasks ?? [];
+    out(Boolean(values.json), result, () => {
+        if (!tasks.length) {
+            console.log(`${DIM}Nothing claimable in that queue right now.${RESET}`);
+            return;
+        }
+        for (const task of tasks) {
+            console.log(`  ${BOLD}${task.id}${RESET}  ${short(task.subject, 70)}`);
+            if (task.payload)
+                console.log(`      ${short(task.payload, 400)}`);
+        }
+        console.log("");
+        console.log(`${DIM}Submit with the task's OWN id — that is what claims it to you:${RESET}`);
+        console.log(`${DIM}  vidfarm gigs submit ${gigId} --task ${tasks[0]?.id ?? "<task-id>"} --proof <public mp4 url>${RESET}`);
+    });
+}
+async function cmdSubmit(auth, values, positionals) {
+    const gigId = positionals[0];
+    if (!gigId)
+        throw new Error("gigs submit needs a gig id: vidfarm gigs submit GIG_01H… --task <id> --proof <url>");
+    const proofs = [].concat(values.proof ?? []);
+    if (!proofs.length)
+        throw new Error("gigs submit needs at least one --proof <public mp4 url>.");
+    const taskId = values.task?.trim();
+    if (!taskId) {
+        throw new Error("gigs submit needs --task <task-id>. On a queue machine that is the POLLED task's id (never the subject line) — it is what claims the task to you.");
+    }
+    const tags = values.tags ? String(values.tags).split(",").map((t) => t.trim()).filter(Boolean) : [];
+    const result = await dp(auth, `/gigs/${encodeURIComponent(gigId)}/proofs`, {
+        method: "POST",
+        body: {
+            task_identifier: taskId,
+            proofs,
+            ...(values.mailbox ? { mailbox_id: String(values.mailbox) } : {}),
+            ...(tags.length ? { tags } : {}),
+            ...(values.note ? { feedback: String(values.note) } : {})
+        }
+    });
+    out(Boolean(values.json), result, () => {
+        console.log(`${GREEN}✓${RESET} Submitted to ${BOLD}${gigId}${RESET} ${DIM}${result.proof_id ?? result.id ?? ""}${RESET}`);
+        console.log(`  ${DIM}The buyer swipes this in a deck — a link that needs a login is a proof they cannot watch.${RESET}`);
+    });
+}
+async function cmdMine(auth, values) {
+    const body = await dp(auth, "/mailboxes/mine", { query: { limit: values.limit } });
+    const rows = body.mailboxes ?? body.data ?? [];
+    out(Boolean(values.json), body, () => {
+        if (!rows.length) {
+            console.log(`${DIM}You have not joined any gigs yet. Find one: vidfarm gigs feed${RESET}`);
+            return;
+        }
+        for (const row of rows) {
+            console.log(`  ${BOLD}${short(row.gig_title ?? row.gig_id, 60)}${RESET}  ${DIM}${row.gig_id ?? ""} · mailbox ${row.id ?? ""}${RESET}`);
+        }
+    });
+}
+// ── dispatch ─────────────────────────────────────────────────────────────────
+function options() {
+    return {
+        "dp-key": { type: "string" },
+        "api-key": { type: "string" },
+        host: { type: "string" },
+        json: { type: "boolean" },
+        machine: { type: "string" },
+        task: { type: "string" },
+        body: { type: "string" },
+        price: { type: "string" },
+        tags: { type: "string" },
+        priority: { type: "string" },
+        "assign-to": { type: "string" },
+        angle: { type: "string" },
+        hook: { type: "string" },
+        url: { type: "string" },
+        format: { type: "string" },
+        "assets-link": { type: "string" },
+        "upload-link": { type: "string" },
+        subfolder: { type: "string" },
+        proof: { type: "string", multiple: true },
+        status: { type: "string" },
+        limit: { type: "string" },
+        feedback: { type: "string" },
+        tag: { type: "string" },
+        title: { type: "string" },
+        subtext: { type: "string" },
+        registry: { type: "boolean" },
+        name: { type: "string" },
+        invite: { type: "string" },
+        wallet: { type: "string" },
+        count: { type: "string" },
+        mailbox: { type: "string" },
+        note: { type: "string" }
+    };
+}
+export async function runGigsCommand(argv) {
+    const sub = (argv[0] ?? "help").toLowerCase();
+    if (["help", "--help", "-h", ""].includes(sub)) {
+        console.log(GIGS_HELP);
+        return;
+    }
+    const parsed = parseArgs({ args: argv.slice(1), allowPositionals: true, options: options() });
+    const values = parsed.values;
+    const rest = parsed.positionals;
+    const auth = await resolveAuth(values);
+    switch (sub) {
+        case "machines":
+        case "vending": return cmdMachines(auth, values);
+        case "tasks":
+        case "queue": return cmdTasks(auth, values, rest[0]);
+        case "add-task":
+        case "task": return cmdAddTask(auth, values);
+        case "proofs":
+        case "submissions": return cmdProofs(auth, values, rest[0]);
+        case "approve":
+        case "keep": return cmdReview(auth, values, rest, "approve");
+        case "reject":
+        case "pass": return cmdReview(auth, values, rest, "reject");
+        case "ring-bell":
+        case "bell": return cmdRingBell(auth, values);
+        case "work":
+        case "available": return cmdWork(auth, values);
+        case "feed": return cmdFeed(auth, values);
+        case "join-feed": return cmdJoinFeed(auth, values);
+        case "join": return cmdJoin(auth, values, rest);
+        case "claim":
+        case "poll": return cmdClaim(auth, values, rest);
+        case "submit": return cmdSubmit(auth, values, rest);
+        case "mine":
+        case "mailboxes": return cmdMine(auth, values);
+        default:
+            console.error(`Unknown gigs subcommand: ${sub}\n`);
+            console.log(GIGS_HELP);
+            process.exitCode = 1;
+    }
+}
+//# sourceMappingURL=marketplace-gigs.js.map