@officexapp/vidfarm-devcli 0.21.59 → 0.21.61

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

@@ -44,6 +44,18 @@ 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
+
+  BID AUCTION — let clippers name the price instead of taking yours
+  gigs request-bids --task "<brief>"  Post a task NOBODY can claim; they bid in the
+                                   comments. --sealed hides bids from each other,
+                                   --bell broadcasts it, --opening "$0.10".
+                                   Prints a share link that carries a gig invite,
+                                   so a clipper who never joined can join AND bid
+                                   on that one page. Price stays TBD.
+  gigs bids <task-id>              The bids on it, newest thread first
+  gigs award <task-id> --bid <id>  Reserve that SAME task for the winner and tell
+                                   them privately. Losing bidders see nothing.
+                                   Then: gigs approve <proof-id> --amount <usd>
     --price <usd>                  Price per delivered video (default 0.25; "tbd" allowed)
     --tags a,b --priority <n>      Routing hints (lower priority polls sooner)
     --angle/--hook/--url/--format  The usual brief fields
@@ -54,7 +66,10 @@ CLIENT (paid vidfarm plan — the key is read from your vidfarm account)
     --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 approve <proof-id> [machine] [--amount <usd>] [--feedback "<text>"]
+                                   --amount names the price for a TBD task (what
+                                   you agreed in the bid thread). Omit it on a
+                                   TBD proof and it pays the machine's base rate.
   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]
@@ -584,6 +599,178 @@ async function cmdAddTask(auth, values) {
         console.log(`  ${DIM}Nobody knows yet — broadcast it: vidfarm gigs ring-bell --title "…" --machine custom_requests${RESET}`);
     });
 }
+// ── The bid auction ─────────────────────────────────────────────────────────
+// A normal Custom Requests task is claimed by whoever polls first, at the
+// machine's price. A BID task inverts that: it is published `view_only` so
+// nobody can claim it, clippers post their price in the comment thread, and the
+// buyer awards one by flipping that SAME task to `reserved`. One record carries
+// the whole lifecycle, so the winner reads the entire negotiation on the task
+// they are about to do.
+//
+// The price stays `tbd` throughout. The deal is plain text in the thread, and
+// the real number is named once, at approval (`gigs approve --amount`), because
+// arrangements ("$5 now $5 on completion", "$12 for three") do not fit a float.
+/**
+ * The share link for a bid task. `/task/:gig/:id` is MEMBERS ONLY — Dollar
+ * Platoon shows a stranger the gig's join link instead of the task, and it
+ * ignores ?invite=. Only `/claim/:gig/:id?invite=<token>` admits a non-member:
+ * the "you have not joined" panel becomes "you are invited" and joining returns
+ * them to this task. A view-only task simply renders without the Accept button
+ * — the brief plus the comment thread — which is exactly the bidding page.
+ */
+function bidTaskUrl(gigId, taskId, inviteUrl) {
+    let token = "";
+    try {
+        token = new URL(inviteUrl).searchParams.get("invite") ?? "";
+    }
+    catch {
+        token = "";
+    }
+    const base = `https://dollarplatoon.com/${token ? "claim" : "task"}`
+        + `/${encodeURIComponent(gigId)}/${encodeURIComponent(taskId)}`;
+    return token ? `${base}?invite=${encodeURIComponent(token)}` : base;
+}
+async function cmdRequestBids(auth, values) {
+    const task = values.task?.trim();
+    if (!task)
+        throw new Error('gigs request-bids needs --task "<what you want made>".');
+    const gigId = await resolveGigId(auth, values.machine, "custom_requests");
+    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.");
+    // --sealed => each clipper reads only their own thread (no undercutting).
+    // Default is open: bidders see each other, which is fine because discovery
+    // runs UPWARD from the opening bid, unlike a procurement reverse auction.
+    const policy = values.sealed ? "private" : "public";
+    const url = new URL(webhook);
+    url.searchParams.set("availability", "view_only");
+    url.searchParams.set("price", "tbd");
+    url.searchParams.set("tags", String(values.tags ?? "vidfarm,bid"));
+    const published = await fetch(url, {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify({
+            task,
+            ...(values.url ? { url: String(values.url) } : {}),
+            ...(values.reference ? { reference_title: String(values.reference) } : {}),
+            starting_bid: String(values.opening ?? "$0.10"),
+            bidding: policy === "public" ? "open — reply with your price" : "sealed — your reply is private"
+        })
+    });
+    const publishText = await published.text();
+    let publishBody = {};
+    try {
+        publishBody = publishText ? JSON.parse(publishText) : {};
+    }
+    catch {
+        publishBody = {};
+    }
+    if (!published.ok)
+        throw new Error(`request-bids failed: ${publishBody?.error ?? `HTTP ${published.status}`}`);
+    // ONE task answers `message_id` (a string); only a batch answers `message_ids`.
+    const taskId = publishBody.message_id ?? publishBody.message_ids?.[0] ?? "";
+    if (!taskId)
+        throw new Error("Dollar Platoon accepted the task but returned no task id.");
+    await dp(auth, `/gigs/${encodeURIComponent(gigId)}/tasks/${encodeURIComponent(taskId)}/comments-policy`, {
+        method: "PATCH",
+        body: { policy }
+    });
+    const shareUrl = bidTaskUrl(gigId, taskId, await resolveInviteUrl(auth, gigId).catch(() => ""));
+    if (values.bell) {
+        await dp(auth, `/feeds/${VIDFARM_FEED_ID}/notifications`, {
+            method: "POST",
+            body: {
+                title: `Video wanted: ${task.slice(0, 120)}`,
+                subtext: `Bidding is ${policy === "public" ? "open" : "sealed"}. Opening bid ${values.opening ?? "$0.10"}.`,
+                destination_url: shareUrl,
+                tags: ["vidfarm", "video", "bid"]
+            }
+        }).catch((error) => {
+            console.log(`${YELLOW}!${RESET} Task posted, but the bell did not ring: ${error instanceof Error ? error.message : error}`);
+        });
+    }
+    out(Boolean(values.json), { gig_id: gigId, task_id: taskId, share_url: shareUrl, comments_policy: policy }, () => {
+        console.log(`${GREEN}✓${RESET} Bid request posted — ${BOLD}nobody can claim it${RESET}, they bid in the comments.`);
+        console.log(`  ${BOLD}${taskId}${RESET}  ${DIM}${policy === "public" ? "open bidding" : "sealed bids"} · price TBD${RESET}`);
+        console.log(`  ${BOLD}Share this:${RESET} ${shareUrl}`);
+        console.log(`  ${DIM}That link carries a gig invite — a clipper who never joined can join AND bid on that one page.${RESET}`);
+        if (!values.bell)
+            console.log(`  ${DIM}Nobody was notified. Add --bell to broadcast it to the vidfarm feed.${RESET}`);
+        console.log(`  ${DIM}Next: vidfarm gigs bids ${taskId}${RESET}`);
+    });
+}
+async function cmdBids(auth, values, positionals) {
+    const taskId = positionals[0];
+    if (!taskId)
+        throw new Error("gigs bids needs a task id: vidfarm gigs bids TASK_01H…");
+    const gigId = await resolveGigId(auth, values.machine, "custom_requests");
+    const body = await dp(auth, `/gigs/${encodeURIComponent(gigId)}/tasks/${encodeURIComponent(taskId)}/comments`);
+    const comments = body.comments ?? body.items ?? [];
+    // Root comments are the bids; replies underneath are the negotiation.
+    const bids = comments.filter((c) => !c.parent_id);
+    out(Boolean(values.json), { gig_id: gigId, task_id: taskId, bids }, () => {
+        if (!bids.length) {
+            console.log(`${DIM}No bids yet on ${taskId}.${RESET}`);
+            console.log(`  ${DIM}Nobody may know it exists — vidfarm gigs request-bids … --bell, or send them the share link.${RESET}`);
+            return;
+        }
+        for (const bid of bids) {
+            // author_mailbox_id comes back ONLY to the gig owner, and only on a
+            // WORKER's comment — it is what `gigs award` reserves the task for.
+            const who = bid.author_name ?? "gigworker";
+            console.log(`  ${BOLD}${bid.id}${RESET}  ${DIM}${who}${bid.author_mailbox_id ? "" : "  (no mailbox — cannot be awarded)"}${RESET}`);
+            console.log(`      ${short(String(bid.body ?? ""), 110)}`);
+        }
+        console.log("");
+        console.log(`${DIM}Award one: vidfarm gigs award ${taskId} --bid <comment-id>${RESET}`);
+    });
+}
+async function cmdAward(auth, values, positionals) {
+    const taskId = positionals[0];
+    const bidId = values.bid?.trim();
+    if (!taskId)
+        throw new Error("gigs award needs a task id: vidfarm gigs award TASK_01H… --bid TCOMMENT_01H…");
+    if (!bidId)
+        throw new Error('gigs award needs --bid <comment-id>. See them with: vidfarm gigs bids <task-id>');
+    const gigId = await resolveGigId(auth, values.machine, "custom_requests");
+    const body = await dp(auth, `/gigs/${encodeURIComponent(gigId)}/tasks/${encodeURIComponent(taskId)}/comments`);
+    const comments = body.comments ?? body.items ?? [];
+    const winner = comments.find((c) => c.id === bidId);
+    if (!winner)
+        throw new Error(`No bid ${bidId} on ${taskId}. List them: vidfarm gigs bids ${taskId}`);
+    const mailbox = winner.author_mailbox_id ?? "";
+    if (!mailbox) {
+        throw new Error("Dollar Platoon did not identify that bidder. Only the gig OWNER sees a commenter's mailbox — check you are using the buyer's key, not a gigworker key.");
+    }
+    // The SAME task flips from view_only to reserved. No new task, so the winner
+    // reads the whole negotiation on the record they are about to work.
+    await dp(auth, `/gigs/${encodeURIComponent(gigId)}/tasks/${encodeURIComponent(taskId)}/availability`, {
+        method: "PATCH",
+        body: { availability: "reserved", reserved_for: mailbox }
+    });
+    const shareUrl = bidTaskUrl(gigId, taskId, await resolveInviteUrl(auth, gigId).catch(() => ""));
+    // A private reply has exactly two readers — its author and the person it
+    // answers — so the losing bidders never see the agreed terms.
+    await dp(auth, `/gigs/${encodeURIComponent(gigId)}/tasks/${encodeURIComponent(taskId)}/comments`, {
+        method: "POST",
+        body: {
+            body: values.message?.trim()
+                || `You won this one. It is reserved for you — accept it here: ${shareUrl}`,
+            parent_id: bidId,
+            private: true
+        }
+    });
+    out(Boolean(values.json), { gig_id: gigId, task_id: taskId, reserved_for: mailbox, share_url: shareUrl }, () => {
+        console.log(`${GREEN}✓${RESET} ${BOLD}${taskId}${RESET} reserved for ${BOLD}${winner.author_name ?? mailbox}${RESET}.`);
+        console.log(`  ${DIM}They were told privately. The other bidders saw nothing.${RESET}`);
+        console.log(`  ${DIM}${shareUrl}${RESET}`);
+        console.log("");
+        console.log(`${YELLOW}The task is still priced TBD${RESET}${DIM} — name the agreed amount when you approve their proof:${RESET}`);
+        console.log(`  ${DIM}vidfarm gigs approve <proof-id> --amount 8.00${RESET}`);
+        console.log(`  ${DIM}Approve without --amount and it silently pays the machine's base rate, not what you agreed.${RESET}`);
+    });
+}
 async function cmdProofs(auth, values, positional) {
     const gigId = await resolveGigId(auth, positional, "inbound_offers");
     const body = await dp(auth, `/gigs/${encodeURIComponent(gigId)}/proofs`, {
@@ -617,10 +804,34 @@ async function cmdReview(auth, values, positionals, action) {
         body.feedback = String(values.feedback);
     if (action === "reject")
         body.rejection_tag = values.tag ? String(values.tag) : "not_selected";
+    // --amount names the price at APPROVAL. This is the only moment a TBD task
+    // gets its real number, and a bid task is TBD by design: the deal was agreed
+    // in plain text in the comment thread, not on the record. Dollar Platoon
+    // accepts an amount only while `locked_price` is null (a TBD proof, or one
+    // carrying the worker's own asking_price) — anything else answers 409, since
+    // a price a worker already agreed to can never be lowered at review.
+    //
+    // "TBD is not $0": approving a TBD proof with NO amount silently falls back
+    // to the gig's base rate, so an $8 bid pays $0.25 and the price locks on the
+    // spot with no way back. Warn loudly rather than let that pass unnoticed.
+    let amount = null;
+    if (action === "approve" && values.amount !== undefined && String(values.amount).trim() !== "") {
+        const parsed = Number(String(values.amount).trim().replace(/^\$/, ""));
+        if (!Number.isFinite(parsed) || parsed < 0) {
+            throw new Error(`--amount must be a positive number of dollars, got "${values.amount}".`);
+        }
+        amount = Math.round(parsed * 100) / 100;
+        body.amount = amount;
+    }
     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.`);
+            const locked = typeof result?.locked_price === "number" ? result.locked_price : null;
+            console.log(`${GREEN}✓${RESET} Approved ${BOLD}${proofId}${RESET}${locked != null ? ` at ${BOLD}$${locked.toFixed(2)}${RESET}` : ""} — it pays out on the next rollup.`);
+            if (amount == null && locked != null) {
+                console.log(`  ${DIM}No --amount given, so it locked at the machine's own price.${RESET}`);
+                console.log(`  ${YELLOW}If this came from a bid, that is NOT what you agreed${RESET}${DIM} — bid tasks are priced TBD and the number lives in the comment thread. Use --amount <usd>.${RESET}`);
+            }
         }
         else {
             console.log(`${GREEN}✓${RESET} Rejected ${BOLD}${proofId}${RESET} as ${BOLD}${body.rejection_tag}${RESET}.`);
@@ -1430,6 +1641,14 @@ function options() {
         tag: { type: "string" },
         title: { type: "string" },
         subtext: { type: "string" },
+        // Bid auction (request-bids / bids / award).
+        sealed: { type: "boolean" },
+        bell: { type: "boolean" },
+        opening: { type: "string" },
+        reference: { type: "string" },
+        bid: { type: "string" },
+        message: { type: "string" },
+        amount: { type: "string" },
         registry: { type: "boolean" },
         funded: { type: "boolean" },
         name: { type: "string" },
@@ -1471,6 +1690,11 @@ export async function runGigsCommand(argv) {
         case "queue": return cmdTasks(auth, values, rest[0]);
         case "add-task":
         case "task": return cmdAddTask(auth, values);
+        case "request-bids":
+        case "request":
+        case "invite-bids": return cmdRequestBids(auth, values);
+        case "bids": return cmdBids(auth, values, rest);
+        case "award": return cmdAward(auth, values, rest);
         case "proofs":
         case "submissions": return cmdProofs(auth, values, rest[0]);
         case "approve":

package/dist/src/devcli/skill-docs.js

@@ -117,6 +117,8 @@ export const PACK_TOPICS = [
         blurb: "The 5-stage ladder — what the viewer knows, what the video must do, and what it may ask for" },
     { topic: "problem-angles", aliases: ["angle", "lenses", "problem-angle"], doc: "references/content-ideas.md", heading: "The problem angles",
         blurb: "44 angles on the problem — hold the frame, change the angle when a topic is \"already covered\"" },
+    { topic: "ad-formats", aliases: ["ad-format", "formats", "format", "executions"], doc: "references/content-ideas.md", heading: "The ad formats",
+        blurb: "40 ad formats — what the finished video IS (iphone notes, tier list, trustpilot reviews, warning), and the honesty rule for the ones that imitate a record" },
     { topic: "meme-recaption", // `meme_recaption` needs no alias: resolvePackTopic folds `_` to `-` first.
         aliases: ["meme", "recaption", "meme-caption"], doc: "references/editor-workflows.md", heading: "Writing a meme recaption",
         blurb: "Recaption a meme at a pain or a win the niche knows — the cold-viewer test. Building one from scratch? the full format is vidfarm.cc/experimental/meme-recaption.md" },
@@ -248,6 +250,18 @@ export function loadAngleBank(name = DEFAULT_PACK) {
     const { frames, families } = parseBulletBank(contents, "The problem angles", true);
     return { angles: frames, families };
 }
+/**
+ * The ad-format bank — the FOURTH axis. A frame says what the video is the
+ * story of and an angle says which side of the problem it comes from; a format
+ * says what the finished thing IS (an iPhone note, a tier list, a warning
+ * label). Left unnamed, a director shoots the same talking head all month, so
+ * it belongs next to the other banks rather than in the prose nobody reads.
+ */
+export function loadAdFormatBank(name = DEFAULT_PACK) {
+    const { contents } = readPackDoc("references/content-ideas.md", name);
+    const { frames, families } = parseBulletBank(contents, "The ad formats", true);
+    return { formats: frames, families };
+}
 export function loadAwarenessLadder(name = DEFAULT_PACK) {
     const { contents } = readPackDoc("references/content-ideas.md", name);
     const section = extractSection(contents, "The awareness ladder");