@officexapp/vidfarm-devcli 0.21.58 → 0.21.60

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

@@ -20,6 +20,7 @@
 import { parseArgs } from "node:util";
 import { readFileSync } from "node:fs";
 import { readStoredAuth } from "./auth-store.js";
+import { verifyProof } from "./proof-verify.js";
 const BOLD = "\x1b[1m";
 const DIM = "\x1b[2m";
 const GREEN = "\x1b[32m";
@@ -82,15 +83,47 @@ GIGWORKER — "help me earn on vidfarm" (free — bring your own key: export DOL
 
   delivering, and getting paid:
   gigs upload <file> [--prefix p]  Put a file on DollarPlatoon's own s3, get a durable url
+  gigs verify-proof --proof <url> [--proof <url>…]     RUN THIS BEFORE YOU SUBMIT. No key needed.
+                                   Loads every url the way a stranger's browser would (no cookie,
+                                   no login) and refuses a dead link, a 403 bucket, an HTML error
+                                   body, or a presigned url whose read access expires. Also checks
+                                   you did not swap the two halves of the delivery.
+    --clean-master <file>          …the master you are about to seal (checked on disk)
+    --private-note "<text>"        …the note you are about to send
+    --clean-in-proof               "the proof url IS my final cut and I meant that" — silences it
+    --strict                       warnings fail too    Exits non-zero on any failure.
   gigs submit <gig-id> --task <task-id> --proof <url> [--proof <url>…]
+                                   Runs verify-proof first and REFUSES to send a broken proof
+                                   (--skip-verify overrides, at your own risk).
     --clean-master <file>          Upload it and seal it in the private note. THE WATERMARKED
                                    cut goes in --proof; the clean master goes here, and the
                                    buyer cannot read it until a rollup has actually paid you.
     --private-note "<text>"        Anything else that follows the master (ProRes, project
-                                   files, music licence id). 8000 chars, cannot be added later.
+                                   files, music licence id). 8000 chars, and on a SUBMITTED
+                                   proof it cannot be changed — withdraw it first, or draft it.
     --mailbox <id> --tags a,b --note "<text>"   (--note is the PUBLIC feedback field)
+    --ask <usd>                    Quote your own price (machines with price offers on). An
+                                   ask is a QUOTE — the buyer must approve at that number.
+    --draft                        Save it WITHOUT sending. No review clock, no webhook, the
+                                   buyer sees nothing. (same as: gigs draft <gig-id> …)
     Watch the cut and approve it BEFORE this call — a rejection scores on your
     wallet and clients read it as a trust score on your public profile.
+
+  drafts, and the undo (a proof is NOT one-way while it is still pending):
+  gigs draft <gig-id> --task <id> --proof <url>        Save without sending. Claims the task.
+  gigs drafts <gig-id>             Your unsent drafts on that machine
+  gigs edit-draft <gig-id> <proof-id> [--proof <url>…] [--private-note "<t>"] [--ask <usd>]
+                                   Change an unsent draft. --private-note "" clears it.
+  gigs send <gig-id> <proof-id>    Send a draft. The price is snapshotted NOW, not when you
+                                   saved it, and the review clock starts here.
+  gigs withdraw <gig-id> <proof-id>   THE UNDO. Pulls a pending proof back to draft, stops the
+                                   review clock, and hides it from the buyer again.
+                                   (aliases: undo, unsend)
+                                   Works ONLY while the proof is pending. Once the buyer has
+                                   approved or rejected it the verdict is theirs, and anything
+                                   inside a rollup or already paid is final.
+  gigs discard <gig-id> <proof-id>    Delete a draft and free its task. Drafts only — a
+                                   submitted proof stays on the record. (alias: delete-draft)
   gigs proof <gig-id> <proof-id>   Read your own proof back: paid_out_at + the private note
   gigs earnings                    Your rollups + totals. (aliases: rollups, paid)
   gigs mine                        Your mailboxes across every gig
@@ -100,12 +133,14 @@ GIGWORKER — "help me earn on vidfarm" (free — bring your own key: export DOL
 
   e.g. DOLLARPLATOON_API_KEY=… vidfarm gigs earn
        vidfarm gigs check "https://dollarplatoon.com/gig/GIG_01H…/join?invite=abc"
+       vidfarm gigs verify-proof --proof https://…/final-watermarked.mp4 --clean-master ./final-clean.mp4
        vidfarm gigs submit GIG_01H… --task TASK_01H… \\
          --proof https://…/final-watermarked.mp4 --clean-master ./final-clean.mp4
        vidfarm gigs add-task --task "60s explainer for acme.com" --price 0.25 \\
          --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."
+       vidfarm gigs withdraw GIG_01H… PRF_01H…    # sent the wrong cut — take it back
 
   Building the video is a separate job: https://vidfarm.cc/agentic-clipper.md is the loop,
   and https://vidfarm.cc/flash-harness.md is how to build it on a weak model.`;
@@ -1019,6 +1054,55 @@ async function cmdClaim(auth, values, positionals) {
         console.log(`${DIM}  vidfarm gigs submit ${gigId} --task ${tasks[0]?.id ?? "<task-id>"} --proof <public mp4 url>${RESET}`);
     });
 }
+// ── the pre-submit sanity check ──────────────────────────────────────────────
+/** Print one verify result the same way from `verify-proof` and from `submit`. */
+function printVerify(result, strict) {
+    const paint = (check) => {
+        const badge = check.level === "fail" ? `${RED}✗ FAIL${RESET}` : check.level === "warn" ? `${YELLOW}! WARN${RESET}` : `${GREEN}✓ OK  ${RESET}`;
+        console.log(`  ${badge} ${BOLD}${check.code}${RESET} ${DIM}${short(check.target, 70)}${RESET}`);
+        console.log(`         ${check.message}`);
+        if (check.hint)
+            console.log(`         ${DIM}${check.hint}${RESET}`);
+    };
+    for (const check of result.checks)
+        paint(check);
+    console.log("");
+    if (result.failures.length) {
+        console.log(`${RED}DO NOT SUBMIT${RESET} — ${result.failures.length} failure${result.failures.length === 1 ? "" : "s"}. A buyer who cannot play it passes on it, and once they have ruled you cannot take it back.`);
+    }
+    else if (result.warnings.length && strict) {
+        console.log(`${YELLOW}HOLD${RESET} — --strict, so ${result.warnings.length} warning${result.warnings.length === 1 ? "" : "s"} count as failures.`);
+    }
+    else if (result.warnings.length) {
+        console.log(`${GREEN}✓ The links load.${RESET} ${DIM}Read the ${result.warnings.length} warning${result.warnings.length === 1 ? "" : "s"} above before you send it.${RESET}`);
+    }
+    else {
+        console.log(`${GREEN}✓ CLEARED${RESET} ${DIM}— every link plays for a stranger and the two halves of the delivery are the right way round.${RESET}`);
+    }
+}
+/**
+ * `vidfarm gigs verify-proof` — needs NO api key on purpose. A share-link worker
+ * with no account, and an agent that has not logged in yet, both have to be able
+ * to check a proof before it is sent. Exits 2 on any failure so it chains:
+ * `verify-proof … && gigs submit …`.
+ */
+export async function cmdVerifyProof(values) {
+    const proofs = [].concat(values.proof ?? []);
+    if (!proofs.length) {
+        throw new Error("gigs verify-proof needs at least one --proof <url>: vidfarm gigs verify-proof --proof https://…/final-watermarked.mp4");
+    }
+    const strict = Boolean(values.strict);
+    const result = await verifyProof({
+        proofs,
+        privateNote: values["private-note"] ? String(values["private-note"]) : undefined,
+        cleanMaster: values["clean-master"] ? String(values["clean-master"]) : undefined,
+        cleanInProof: Boolean(values["clean-in-proof"])
+    }, { probe: values["no-network"] !== true });
+    const blocked = !result.ok || (strict && result.warnings.length > 0);
+    out(Boolean(values.json), { ...result, may_submit: !blocked, strict }, () => printVerify(result, strict));
+    if (blocked)
+        process.exitCode = 2;
+}
 async function cmdSubmit(auth, values, positionals) {
     const gigId = positionals[0];
     if (!gigId)
@@ -1031,6 +1115,55 @@ async function cmdSubmit(auth, values, positionals) {
         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) : [];
+    // `gigs draft` is this same command with the flag forced on. A draft is stored
+    // and claims its task, but nothing is delivered: no review clock, no webhook,
+    // and the buyer's dashboard and proof list both filter it out.
+    const asDraft = Boolean(values.draft);
+    // THE SANITY CHECK, BEFORE THE BUYER SEES IT. A pending proof CAN be pulled
+    // back (`gigs withdraw`), but only until the buyer rules on it — and the two
+    // ways a finished video loses the payout are both mechanical and both faster
+    // than a rejection: the link does not load for the buyer, or the public half
+    // and the escrowed half were swapped. Both are checkable, so neither is left
+    // to memory. This runs BEFORE the clean-master upload so a broken proof costs
+    // no bytes. A draft delivers nothing, so there it only warns.
+    if (!values["skip-verify"] && !asDraft) {
+        const check = await verifyProof({
+            proofs,
+            privateNote: values["private-note"] ? String(values["private-note"]) : undefined,
+            cleanMaster: values["clean-master"] ? String(values["clean-master"]) : undefined,
+            cleanInProof: Boolean(values["clean-in-proof"])
+        });
+        if (!check.ok) {
+            if (values.json)
+                console.log(JSON.stringify({ ok: false, submitted: false, verify: check }, null, 2));
+            else
+                printVerify(check, false);
+            throw new Error("Refusing to submit: the pre-submit check failed (see above). Fix it, or re-run with --skip-verify if you are certain the buyer can play that url.");
+        }
+        if (check.warnings.length && !values.json) {
+            for (const warning of check.warnings) {
+                console.log(`${YELLOW}!${RESET} ${BOLD}${warning.code}${RESET} ${warning.message}`);
+                if (warning.hint)
+                    console.log(`  ${DIM}${warning.hint}${RESET}`);
+            }
+        }
+    }
+    else if (asDraft && !values["skip-verify"] && !values.json) {
+        // A draft is the one place a broken link is not a mistake — it is usually a
+        // placeholder for a render that has not finished. So the check still runs
+        // and still prints, but it never refuses. `gigs send` is the gate.
+        const check = await verifyProof({
+            proofs,
+            privateNote: values["private-note"] ? String(values["private-note"]) : undefined,
+            cleanMaster: values["clean-master"] ? String(values["clean-master"]) : undefined,
+            cleanInProof: Boolean(values["clean-in-proof"])
+        });
+        for (const problem of [...check.failures, ...check.warnings]) {
+            console.log(`${YELLOW}!${RESET} ${BOLD}${problem.code}${RESET} ${problem.message}`);
+        }
+        if (check.failures.length)
+            console.log(`${DIM}Draft saved anyway — fix these before ${BOLD}gigs send${RESET}${DIM}, which does refuse.${RESET}`);
+    }
     // The escrowed half of the delivery. `proofs[]` is a PUBLIC playable url — the
     // buyer can download it and so can anyone they forward it to — so the
     // watermarked cut goes there and the clean master goes in `private_note`,
@@ -1054,11 +1187,21 @@ async function cmdSubmit(auth, values, positionals) {
             ...(values.mailbox ? { mailbox_id: String(values.mailbox) } : {}),
             ...(tags.length ? { tags } : {}),
             ...(values.note ? { feedback: String(values.note) } : {}),
-            ...(privateNote ? { private_note: privateNote } : {})
+            ...(privateNote ? { private_note: privateNote } : {}),
+            ...(values.ask ? { asking_price: Number(values.ask) } : {}),
+            ...(asDraft ? { draft: true } : {})
         }
     });
     const proof = result.proof ?? result;
     out(Boolean(values.json), result, () => {
+        if (asDraft) {
+            console.log(`${GREEN}✓${RESET} Draft saved on ${BOLD}${gigId}${RESET} ${DIM}${proof.id ?? result.proof_id ?? ""}${RESET}`);
+            console.log(`  ${DIM}The buyer sees nothing. No review clock, no webhook, and it counts as no submission.${RESET}`);
+            console.log(`  ${DIM}It DOES hold the task against your open-task cap until you send or discard it.${RESET}`);
+            console.log(`  ${DIM}Edit it: vidfarm gigs edit-draft ${gigId} ${proof.id ?? "<proof-id>"} --proof <url>${RESET}`);
+            console.log(`  ${DIM}Send it: vidfarm gigs send ${gigId} ${proof.id ?? "<proof-id>"}   ${RESET}${DIM}— the price is snapshotted then, not now.${RESET}`);
+            return;
+        }
         console.log(`${GREEN}✓${RESET} Submitted to ${BOLD}${gigId}${RESET} ${DIM}${proof.id ?? result.proof_id ?? ""}${RESET}`);
         if (privateNote) {
             // The response field is the ONLY confirmation the note was stored, and a
@@ -1069,14 +1212,151 @@ async function cmdSubmit(auth, values, positionals) {
             }
             else {
                 console.log(`  ${RED}!${RESET} ${BOLD}private_note_locked was not returned — the note may not have saved.${RESET}`);
-                console.log(`    ${DIM}You cannot patch a note onto a proof afterwards. Check it now: vidfarm gigs proof ${gigId} ${proof.id ?? "<proof-id>"}${RESET}`);
+                console.log(`    ${DIM}A SUBMITTED proof's note cannot be patched. Check it now: vidfarm gigs proof ${gigId} ${proof.id ?? "<proof-id>"}${RESET}`);
+                console.log(`    ${DIM}If it is missing, withdraw and re-send: vidfarm gigs withdraw ${gigId} ${proof.id ?? "<proof-id>"}${RESET}`);
             }
         }
         else {
             console.log(`  ${DIM}No private note sent. If that url is your CLEAN master, the buyer now has it before paying — see --clean-master.${RESET}`);
         }
         console.log(`  ${DIM}The buyer swipes this in a deck — a link that needs a login is a proof they cannot watch.${RESET}`);
-        console.log(`  ${DIM}A proof cannot be unsent. Agents: only submit a cut the gigworker approved, unless they asked for auto-submit.${RESET}`);
+        console.log(`  ${DIM}Wrong cut? vidfarm gigs withdraw ${gigId} ${proof.id ?? "<proof-id>"} takes it back — but only until the buyer rules on it.${RESET}`);
+        console.log(`  ${DIM}Agents: only submit a cut the gigworker approved, unless they asked for auto-submit. The undo is a repair, not a licence.${RESET}`);
+    });
+}
+// ── drafts and the undo ──────────────────────────────────────────────────────
+//
+// A submitted proof is NOT one-way. Dollar Platoon models delivery in two
+// halves, and vidfarm used to expose only the second one:
+//
+//   draft  ──send──▶  pending  ──buyer rules──▶  approved / rejected
+//     ▲                  │
+//     └────withdraw──────┘   (pending only, and never once a rollup carries it)
+//
+// The line the worker actually needs is where the undo STOPS: the buyer's
+// verdict is theirs, so a rejection cannot be withdrawn — that would erase it
+// from the reputation record it belongs to. Everything before that is revisable.
+/** Shared arg shape for the four proof-level draft commands. */
+function draftTarget(positionals, verb) {
+    const [gigRef, proofId] = positionals;
+    if (!gigRef || !proofId) {
+        throw new Error(`gigs ${verb} needs a gig id and a proof id: vidfarm gigs ${verb} GIG_01H… PRF_01H…`);
+    }
+    return { gigId: parseGigRef(gigRef).gigId, proofId };
+}
+/**
+ * `gigs withdraw` — the undo. The web app labels this button "Undo" so it does
+ * not read as a withdrawal of money, and this command is the same endpoint.
+ */
+async function cmdWithdraw(auth, values, positionals) {
+    const { gigId, proofId } = draftTarget(positionals, "withdraw");
+    const body = await dp(auth, `/gigs/${encodeURIComponent(gigId)}/proofs/${encodeURIComponent(proofId)}/withdraw`, { method: "POST" });
+    out(Boolean(values.json), body, () => {
+        if (body.already_draft) {
+            console.log(`${GREEN}✓${RESET} ${BOLD}${proofId}${RESET} was already a draft — nothing was sent, so there was nothing to take back.`);
+        }
+        else {
+            console.log(`${GREEN}✓${RESET} Withdrew ${BOLD}${proofId}${RESET} back to ${BOLD}draft${RESET}.`);
+            console.log(`  ${DIM}The review clock stopped and the buyer can no longer see it.${RESET}`);
+            console.log(`  ${DIM}Re-sending restarts that clock from zero — the buyer gets a full window on the new cut.${RESET}`);
+        }
+        console.log(`  ${DIM}Fix it: vidfarm gigs edit-draft ${gigId} ${proofId} --proof <url>${RESET}`);
+        console.log(`  ${DIM}Send it: vidfarm gigs send ${gigId} ${proofId}${RESET}`);
+    });
+}
+/** `gigs edit-draft` — change an unsent draft. Submitted proofs are frozen. */
+async function cmdEditDraft(auth, values, positionals) {
+    const { gigId, proofId } = draftTarget(positionals, "edit-draft");
+    const proofs = [].concat(values.proof ?? []);
+    const body = {};
+    if (proofs.length)
+        body.proofs = proofs;
+    // An empty string is the documented way to CLEAR either field, so the test is
+    // "was the flag present", never "is the value truthy".
+    if (values["private-note"] !== undefined)
+        body.private_note = String(values["private-note"]) || null;
+    if (values.ask !== undefined)
+        body.asking_price = String(values.ask) === "" ? null : Number(values.ask);
+    if (!Object.keys(body).length) {
+        throw new Error("gigs edit-draft needs something to change: --proof <url>, --private-note \"<text>\", or --ask <usd>. Pass an empty string to clear a note or an ask.");
+    }
+    const result = await dp(auth, `/gigs/${encodeURIComponent(gigId)}/proofs/${encodeURIComponent(proofId)}/draft`, { method: "PATCH", body });
+    out(Boolean(values.json), result, () => {
+        console.log(`${GREEN}✓${RESET} Updated draft ${BOLD}${proofId}${RESET} ${DIM}${(result.updated ?? Object.keys(body)).join(", ")}${RESET}`);
+        console.log(`  ${DIM}The task it fulfils cannot be changed. To move it, discard this draft and start again.${RESET}`);
+        console.log(`  ${DIM}Send it: vidfarm gigs send ${gigId} ${proofId}${RESET}`);
+    });
+}
+/**
+ * `gigs send` — put a draft in front of the buyer. This is the gate the draft
+ * itself is not: it runs the same pre-send check as `gigs submit`, because this
+ * is the call that starts the review clock and fires the buyer's webhook.
+ */
+async function cmdSendDraft(auth, values, positionals) {
+    const { gigId, proofId } = draftTarget(positionals, "send");
+    if (!values["skip-verify"]) {
+        const current = await dp(auth, `/gigs/${encodeURIComponent(gigId)}/proofs/${encodeURIComponent(proofId)}`);
+        const proof = current.proof ?? current;
+        const links = (Array.isArray(proof.proofs) ? proof.proofs : []).filter((p) => typeof p === "string" && /^https?:\/\//i.test(String(p)));
+        if (links.length) {
+            const check = await verifyProof({ proofs: links, cleanInProof: Boolean(values["clean-in-proof"]) });
+            if (!check.ok) {
+                if (values.json)
+                    console.log(JSON.stringify({ ok: false, sent: false, verify: check }, null, 2));
+                else
+                    printVerify(check, false);
+                throw new Error("Refusing to send: the draft's links failed the pre-send check (see above). Fix them with gigs edit-draft, or re-run with --skip-verify.");
+            }
+        }
+    }
+    const body = await dp(auth, `/gigs/${encodeURIComponent(gigId)}/proofs/${encodeURIComponent(proofId)}/submit`, { method: "POST" });
+    out(Boolean(values.json), body, () => {
+        console.log(`${GREEN}✓${RESET} Sent ${BOLD}${proofId}${RESET} to ${BOLD}${gigId}${RESET}${body.resubmitted ? ` ${DIM}(re-sent)${RESET}` : ""}`);
+        if (typeof body.locked_price === "number") {
+            // Snapshotted HERE, not when the draft was saved — the buyer may have
+            // repriced the task while the draft sat, so this is the number that pays.
+            console.log(`  ${DIM}Locked price: $${body.locked_price.toFixed(2)} — snapshotted now, not when you saved the draft.${RESET}`);
+        }
+        else if (body.locked_price === null) {
+            console.log(`  ${DIM}The task is TBD, so the amount is set at approval. That is not $0.${RESET}`);
+        }
+        console.log(`  ${DIM}Changed your mind? vidfarm gigs withdraw ${gigId} ${proofId} — until the buyer rules on it.${RESET}`);
+    });
+}
+/** `gigs discard` — delete a draft and free its task_identifier. */
+async function cmdDiscard(auth, values, positionals) {
+    const { gigId, proofId } = draftTarget(positionals, "discard");
+    const body = await dp(auth, `/gigs/${encodeURIComponent(gigId)}/proofs/${encodeURIComponent(proofId)}`, { method: "DELETE" });
+    out(Boolean(values.json), body, () => {
+        console.log(`${GREEN}✓${RESET} Deleted draft ${BOLD}${proofId}${RESET}.`);
+        // The duplicate guard counts drafts, so an abandoned one blocks its own task
+        // for good. Deleting it is what unblocks a fresh proof against that task.
+        console.log(`  ${DIM}Its task is free again — you can start a new proof against it.${RESET}`);
+        console.log(`  ${DIM}Your claim on the task is untouched. Walk away and task_timeout recycles it.${RESET}`);
+    });
+}
+/** `gigs drafts <gig-id>` — the unsent work the buyer cannot see. */
+async function cmdDrafts(auth, values, positionals) {
+    const gigRef = positionals[0];
+    if (!gigRef)
+        throw new Error("gigs drafts needs a gig id: vidfarm gigs drafts GIG_01H…");
+    const { gigId } = parseGigRef(gigRef);
+    const body = await dp(auth, `/gigs/${encodeURIComponent(gigId)}/proofs`, { query: { status: "draft" } });
+    const rows = body.proofs ?? body.items ?? body.data ?? [];
+    out(Boolean(values.json), body, () => {
+        if (!rows.length) {
+            console.log(`${DIM}No drafts on this machine. Save one: vidfarm gigs draft ${gigId} --task <task-id> --proof <url>${RESET}`);
+            return;
+        }
+        for (const row of rows) {
+            console.log(`  ${BOLD}${row.id}${RESET}  ${DIM}draft${row.task_identifier ? " · " + row.task_identifier : ""}${RESET}`);
+            const link = proofLink(row);
+            if (link)
+                console.log(`      ${DIM}${short(link, 100)}${RESET}`);
+        }
+        console.log("");
+        console.log(`${DIM}Each one holds its task against your open-task cap. Send it, or discard it.${RESET}`);
+        console.log(`${DIM}  vidfarm gigs send ${gigId} ${rows[0]?.id ?? "<proof-id>"}   ·   vidfarm gigs discard ${gigId} ${rows[0]?.id ?? "<proof-id>"}${RESET}`);
     });
 }
 /**
@@ -1160,6 +1440,12 @@ function options() {
         note: { type: "string" },
         "private-note": { type: "string" },
         "clean-master": { type: "string" },
+        "clean-in-proof": { type: "boolean" },
+        draft: { type: "boolean" },
+        ask: { type: "string" },
+        "skip-verify": { type: "boolean" },
+        "no-network": { type: "boolean" },
+        strict: { type: "boolean" },
         prefix: { type: "string" }
     };
 }
@@ -1172,6 +1458,11 @@ export async function runGigsCommand(argv) {
     const parsed = parseArgs({ args: argv.slice(1), allowPositionals: true, options: options() });
     const values = parsed.values;
     const rest = parsed.positionals;
+    // The pre-submit check talks to nobody's API — it fetches the worker's own
+    // links the way a stranger would. Dispatch it BEFORE the key is resolved, so a
+    // share-link worker with no account can still check a proof before sending it.
+    if (["verify-proof", "check-proof", "preflight", "verify"].includes(sub))
+        return cmdVerifyProof(values);
     const auth = await resolveAuth(values);
     switch (sub) {
         case "machines":
@@ -1200,6 +1491,18 @@ export async function runGigsCommand(argv) {
         case "claim":
         case "poll": return cmdClaim(auth, values, rest);
         case "submit": return cmdSubmit(auth, values, rest);
+        // `draft` is `submit --draft`, so the flag is forced rather than duplicated.
+        case "draft": return cmdSubmit(auth, { ...values, draft: true }, rest);
+        case "drafts": return cmdDrafts(auth, values, rest);
+        case "edit-draft":
+        case "revise": return cmdEditDraft(auth, values, rest);
+        case "send":
+        case "send-draft": return cmdSendDraft(auth, values, rest);
+        case "withdraw":
+        case "undo":
+        case "unsend": return cmdWithdraw(auth, values, rest);
+        case "discard":
+        case "delete-draft": return cmdDiscard(auth, values, rest);
         case "proof": return cmdProof(auth, values, rest);
         case "upload": return cmdUpload(auth, values, rest);
         case "earnings":