@toon-protocol/git 1.0.0

package/dist/cli/rig.js

@@ -0,0 +1,1430 @@
+#!/usr/bin/env node
+import {
+  GitError,
+  GitRepoReader,
+  NonFastForwardError,
+  OversizeObjectsError,
+  executePush,
+  planPush,
+  serializeEventReceipt,
+  serializePushPlan,
+  serializePushResult
+} from "../chunk-4WFGAICZ.js";
+import {
+  buildComment,
+  buildIssue,
+  buildPatch,
+  buildStatus
+} from "../chunk-KXXHAUXL.js";
+import {
+  DEFAULT_DAEMON_PORT
+} from "../chunk-LJA7PPZI.js";
+import {
+  MAX_OBJECT_SIZE
+} from "../chunk-M7O4SEVW.js";
+
+// src/cli/rig.ts
+import { createInterface } from "readline/promises";
+
+// src/cli/events.ts
+import { readFile } from "fs/promises";
+import { parseArgs as parseArgs2 } from "util";
+import {
+  REPOSITORY_ANNOUNCEMENT_KIND,
+  STATUS_APPLIED_KIND,
+  STATUS_CLOSED_KIND,
+  STATUS_DRAFT_KIND,
+  STATUS_OPEN_KIND
+} from "@toon-protocol/core/nip34";
+
+// src/cli/daemon.ts
+var DaemonRouteError = class extends Error {
+  constructor(status, envelope) {
+    super(envelope.detail ?? envelope.error);
+    this.status = status;
+    this.envelope = envelope;
+    this.name = "DaemonRouteError";
+  }
+  status;
+  envelope;
+};
+var DaemonUnreachableError = class extends Error {
+  constructor(baseUrl, cause) {
+    super(
+      `toon-clientd control API is not reachable at ${baseUrl} \u2014 start the daemon (\`toon-clientd\`, shipped by @toon-protocol/client-mcp) and re-run, or use --standalone with TOON_CLIENT_MNEMONIC set` + (cause instanceof Error ? ` (${cause.message})` : "")
+    );
+    this.baseUrl = baseUrl;
+    this.name = "DaemonUnreachableError";
+  }
+  baseUrl;
+};
+var DaemonGitClient = class {
+  constructor(baseUrl, fetchImpl) {
+    this.baseUrl = baseUrl;
+    this.fetchImpl = fetchImpl;
+  }
+  baseUrl;
+  fetchImpl;
+  gitEstimate(req) {
+    return this.post("/git/estimate", req);
+  }
+  gitPush(req) {
+    return this.post("/git/push", req);
+  }
+  gitIssue(req) {
+    return this.post("/git/issue", req);
+  }
+  gitComment(req) {
+    return this.post("/git/comment", req);
+  }
+  gitPatch(req) {
+    return this.post("/git/patch", req);
+  }
+  gitStatus(req) {
+    return this.post("/git/status", req);
+  }
+  async post(path, body) {
+    let res;
+    try {
+      res = await this.fetchImpl(`${this.baseUrl}${path}`, {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify(body)
+      });
+    } catch (err) {
+      throw new DaemonUnreachableError(this.baseUrl, err);
+    }
+    const text = await res.text();
+    let parsed;
+    try {
+      parsed = text === "" ? {} : JSON.parse(text);
+    } catch {
+      throw new DaemonRouteError(res.status, {
+        error: "invalid_response",
+        detail: `daemon returned non-JSON (HTTP ${res.status}): ${text.slice(0, 200)}`
+      });
+    }
+    if (!res.ok) {
+      const envelope = parsed && typeof parsed === "object" && "error" in parsed ? parsed : { error: "http_error", detail: `HTTP ${res.status}` };
+      throw new DaemonRouteError(res.status, envelope);
+    }
+    return parsed;
+  }
+};
+
+// src/cli/mode.ts
+import { existsSync, readFileSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+function daemonBaseUrl(env) {
+  const raw = env["TOON_CLIENT_HTTP_PORT"];
+  const parsed = raw ? Number(raw) : NaN;
+  const port = Number.isFinite(parsed) && parsed > 0 ? parsed : DEFAULT_DAEMON_PORT;
+  return `http://127.0.0.1:${port}`;
+}
+async function probeDaemon(env, fetchImpl, timeoutMs = 1500) {
+  const baseUrl = daemonBaseUrl(env);
+  try {
+    const res = await fetchImpl(`${baseUrl}/status`, {
+      signal: AbortSignal.timeout(timeoutMs)
+    });
+    if (!res.ok) return { baseUrl, reachable: false };
+    const body = await res.json();
+    const probe = { baseUrl, reachable: true };
+    const pubkey = body?.identity?.nostrPubkey;
+    if (typeof pubkey === "string" && pubkey !== "") probe.identity = pubkey;
+    if (typeof body?.ready === "boolean") probe.ready = body.ready;
+    if (typeof body?.relay?.url === "string" && body.relay.url !== "") {
+      probe.relayUrl = body.relay.url;
+    }
+    if (typeof body?.feePerEvent === "string" && body.feePerEvent !== "") {
+      probe.feePerEvent = body.feePerEvent;
+    }
+    return probe;
+  } catch {
+    return { baseUrl, reachable: false };
+  }
+}
+function clientConfigPath(env) {
+  const dir = env["TOON_CLIENT_HOME"] ?? join(homedir(), ".toon-client");
+  return join(dir, "config.json");
+}
+function standaloneAvailability(env) {
+  const configPath = clientConfigPath(env);
+  if (env["TOON_CLIENT_MNEMONIC"]) {
+    return { available: true, source: "env", configPath };
+  }
+  if (existsSync(configPath)) {
+    try {
+      const file = JSON.parse(readFileSync(configPath, "utf8"));
+      if (typeof file.mnemonic === "string" && file.mnemonic !== "" || typeof file.keystorePath === "string" && file.keystorePath !== "") {
+        return { available: true, source: "config", configPath };
+      }
+    } catch {
+    }
+  }
+  return { available: false, configPath };
+}
+var NoPublisherError = class extends Error {
+  constructor(probe, standalone) {
+    super(
+      `no way to pay for this push \u2014 neither publisher mode is available:
+  \u2022 daemon: no toon-clientd control API at ${probe.baseUrl}/status \u2014 start it (\`toon-clientd\`, shipped by @toon-protocol/client-mcp) and re-run, or pass --daemon once it is up
+  \u2022 standalone: no identity found \u2014 set TOON_CLIENT_MNEMONIC (BIP-39 seed phrase) or configure ${standalone.configPath} (mnemonic / keystorePath), then re-run (or pass --standalone)`
+    );
+    this.name = "NoPublisherError";
+  }
+};
+async function selectMode(options) {
+  const { env, fetchImpl } = options;
+  if (options.daemon && options.standalone) {
+    throw new Error("--daemon and --standalone are mutually exclusive");
+  }
+  if (options.standalone) {
+    return {
+      mode: "standalone",
+      probe: { baseUrl: daemonBaseUrl(env), reachable: false }
+    };
+  }
+  const probe = await probeDaemon(env, fetchImpl);
+  if (options.daemon) return { mode: "daemon", probe };
+  if (probe.reachable && probe.identity) return { mode: "daemon", probe };
+  const standalone = standaloneAvailability(env);
+  if (standalone.available) return { mode: "standalone", probe };
+  throw new NoPublisherError(probe, standalone);
+}
+
+// src/cli/errors.ts
+var FUNDING_REMEDIATION = (command) => [
+  "Remediation:",
+  "  \u2022 fund the settlement wallet: run the toon_fund_wallet MCP tool (devnet faucet), or send gas/tokens to the wallet yourself",
+  "  \u2022 open (or top up) a payment channel: toon_open_channel / toon_channel_deposit",
+  `  \u2022 then re-run rig ${command}`
+];
+var UnconfiguredRepoAddressError = class extends Error {
+  constructor(missing) {
+    super(
+      `no ${missing} configured \u2014 this command addresses the repo as 30617:<ownerPubkey>:<repoId>. Run \`rig push\` once inside the repo (it persists toon.repoid/toon.owner/toon.relay to git config), or pass ${missing === "repository id" ? "--repo-id <id>" : "--owner <pubkey>"} explicitly (use --owner for repos you don't own).`
+    );
+    this.missing = missing;
+    this.name = "UnconfiguredRepoAddressError";
+  }
+  missing;
+};
+function nonFastForwardLines(refs) {
+  return [
+    "Push rejected: non-fast-forward update for:",
+    ...refs.map(
+      (r) => `  ${r.refname}  remote ${r.remoteSha.slice(0, 7)} is not an ancestor of local ${r.localSha.slice(0, 7)}`
+    ),
+    "The remote moved since your last push. Re-run with --force to overwrite it",
+    "WARNING: --force rewrites the published ref history for every reader of this repo."
+  ];
+}
+function oversizeLines(objects) {
+  return [
+    `Push rejected: ${objects.length} object(s) exceed the ${MAX_OBJECT_SIZE}-byte (95KB) upload limit:`,
+    ...objects.map(
+      (o) => `  ${o.path ?? o.sha}  ${o.type}, ${o.size} bytes`
+    ),
+    "Objects over 95KB are a hard error in v1 \u2014 split or remove the file(s) from history to push.",
+    "Large-object support is tracked in toon-client#235."
+  ];
+}
+function fromDaemonEnvelope(err, command) {
+  const { envelope, status } = err;
+  const json = { ...envelope, status };
+  switch (envelope.error) {
+    case "non_fast_forward": {
+      const refs = Array.isArray(envelope["refs"]) ? envelope["refs"] : [];
+      return { code: "non_fast_forward", lines: nonFastForwardLines(refs), json };
+    }
+    case "oversize_objects": {
+      const objects = Array.isArray(envelope["objects"]) ? envelope["objects"] : [];
+      return { code: "oversize_objects", lines: oversizeLines(objects), json };
+    }
+    case "bootstrapping":
+      return {
+        code: "bootstrapping",
+        lines: [
+          `toon-clientd is still bootstrapping: ${envelope.detail ?? "transport/channel coming up"}`,
+          "Retry in a few seconds. If it never becomes ready, check the toon-clientd logs."
+        ],
+        json
+      };
+    case "insufficient_gas":
+      return {
+        code: "insufficient_gas",
+        lines: [
+          `Payment failed: ${envelope.detail ?? "the settlement wallet cannot fund the channel"}`,
+          ...FUNDING_REMEDIATION(command)
+        ],
+        json
+      };
+    default:
+      return {
+        code: envelope.error,
+        lines: [
+          `rig ${command} failed (${envelope.error}, HTTP ${status})` + (envelope.detail ? `: ${envelope.detail}` : ""),
+          ...envelope.retryable ? ["This error is retryable \u2014 try again shortly."] : []
+        ],
+        json
+      };
+  }
+}
+function describeError(err, command = "push") {
+  if (err instanceof DaemonRouteError) return fromDaemonEnvelope(err, command);
+  if (err instanceof UnconfiguredRepoAddressError) {
+    return {
+      code: "unconfigured_repo_address",
+      lines: err.message.split("\n"),
+      json: { error: "unconfigured_repo_address", detail: err.message }
+    };
+  }
+  if (err instanceof DaemonUnreachableError) {
+    return {
+      code: "daemon_unreachable",
+      lines: [err.message],
+      json: { error: "daemon_unreachable", detail: err.message }
+    };
+  }
+  if (err instanceof NoPublisherError) {
+    return {
+      code: "no_publisher",
+      lines: err.message.split("\n"),
+      json: { error: "no_publisher", detail: err.message }
+    };
+  }
+  if (err instanceof NonFastForwardError) {
+    return {
+      code: "non_fast_forward",
+      lines: nonFastForwardLines(err.refs),
+      json: { error: "non_fast_forward", detail: err.message, refs: err.refs }
+    };
+  }
+  if (err instanceof OversizeObjectsError) {
+    return {
+      code: "oversize_objects",
+      lines: oversizeLines(err.objects),
+      json: {
+        error: "oversize_objects",
+        detail: err.message,
+        objects: err.objects
+      }
+    };
+  }
+  if (err instanceof GitError) {
+    return {
+      code: "git_error",
+      lines: [`git failed: ${err.message}`],
+      json: { error: "git_error", detail: err.message }
+    };
+  }
+  const name = err instanceof Error ? err.name : "";
+  const message = err instanceof Error ? err.message : String(err);
+  if (name === "DaemonIdentityConflictError") {
+    return {
+      code: "daemon_identity_conflict",
+      lines: [message, "Re-run without --standalone (or with --daemon) to push through the running daemon."],
+      json: { error: "daemon_identity_conflict", detail: message }
+    };
+  }
+  if (name === "MissingMnemonicError" || name === "MissingUplinkError") {
+    return {
+      code: name === "MissingMnemonicError" ? "missing_mnemonic" : "missing_uplink",
+      lines: [message],
+      json: { error: "standalone_unavailable", detail: message }
+    };
+  }
+  return {
+    code: "error",
+    lines: [`rig ${command} failed: ${message}`],
+    json: { error: "error", detail: message }
+  };
+}
+
+// src/cli/git-config.ts
+import { execFile } from "child_process";
+import { promisify } from "util";
+var execFileAsync = promisify(execFile);
+async function git(repoPath, args, allowExitCodes = []) {
+  try {
+    const { stdout } = await execFileAsync("git", args, {
+      cwd: repoPath,
+      encoding: "utf-8"
+    });
+    return { stdout, exitCode: 0 };
+  } catch (err) {
+    const e = err;
+    const exitCode = typeof e.code === "number" ? e.code : void 0;
+    if (exitCode !== void 0 && allowExitCodes.includes(exitCode)) {
+      return { stdout: e.stdout ?? "", exitCode };
+    }
+    throw new Error(
+      `git ${args.join(" ")} failed${exitCode !== void 0 ? ` (exit ${exitCode})` : ""}: ${(e.stderr ?? e.message ?? "").trim()}`
+    );
+  }
+}
+async function resolveRepoRoot(cwd) {
+  try {
+    const { stdout } = await execFileAsync(
+      "git",
+      ["rev-parse", "--show-toplevel"],
+      { cwd, encoding: "utf-8" }
+    );
+    const root = stdout.trim();
+    if (!root) throw new Error("empty rev-parse output");
+    return root;
+  } catch (err) {
+    const e = err;
+    throw new Error(
+      `not a git repository (run rig inside a repo): ${(e.stderr ?? e.message ?? "").trim()}`
+    );
+  }
+}
+async function readToonConfig(repoPath) {
+  const [repoId, owner, relays] = await Promise.all([
+    git(repoPath, ["config", "--get", "toon.repoid"], [1]),
+    git(repoPath, ["config", "--get", "toon.owner"], [1]),
+    git(repoPath, ["config", "--get-all", "toon.relay"], [1])
+  ]);
+  const config = {
+    relays: relays.stdout.split("\n").map((l) => l.trim()).filter(Boolean)
+  };
+  const id = repoId.stdout.trim();
+  if (repoId.exitCode === 0 && id) config.repoId = id;
+  const own = owner.stdout.trim();
+  if (owner.exitCode === 0 && own) config.owner = own;
+  return config;
+}
+async function writeToonConfig(repoPath, config) {
+  if (config.repoId !== void 0) {
+    await git(repoPath, ["config", "toon.repoid", config.repoId]);
+  }
+  if (config.owner !== void 0) {
+    await git(repoPath, ["config", "toon.owner", config.owner]);
+  }
+  if (config.relays !== void 0 && config.relays.length > 0) {
+    await git(repoPath, ["config", "--unset-all", "toon.relay"], [5]);
+    for (const relay of config.relays) {
+      await git(repoPath, ["config", "--add", "toon.relay", relay]);
+    }
+  }
+}
+
+// src/cli/push.ts
+import { basename } from "path";
+import { parseArgs } from "util";
+
+// src/cli/render.ts
+function formatNumber(value) {
+  return String(value).replace(/\B(?=(\d{3})+(?!\d))/g, ",");
+}
+function shortSha(sha) {
+  return sha ? sha.slice(0, 7) : "(none)";
+}
+function refLine(update) {
+  const arrow = `${shortSha(update.remoteSha)} \u2192 ${shortSha(update.localSha)}`;
+  return `  ${update.refname}  ${arrow}  (${update.kind})`;
+}
+function renderPlan(plan, mode) {
+  const lines = [];
+  lines.push(
+    `Push plan for repo "${plan.repoId}" (${mode} mode)` + (plan.announceNeeded ? " \u2014 first push, will announce (kind:30617)" : "")
+  );
+  lines.push("Refs:");
+  for (const update of plan.refUpdates) lines.push(refLine(update));
+  const est = plan.estimate;
+  const skipped = Object.keys(plan.knownShaToTxId).length;
+  lines.push(
+    `Objects: ${est.objectCount} to upload (${formatNumber(est.totalObjectBytes)} bytes)` + (skipped > 0 ? `; ${skipped} already on Arweave (free)` : "")
+  );
+  lines.push("Fees (base units):");
+  lines.push(
+    `  upload   ${est.objectCount} object(s), ${formatNumber(est.totalObjectBytes)} bytes   ${formatNumber(est.uploadFee)}`
+  );
+  lines.push(`  events   ${est.eventCount} event(s)   ${formatNumber(est.eventFees)}`);
+  lines.push(`  total    ${formatNumber(est.totalFee)}`);
+  lines.push("Writes are permanent and non-refundable.");
+  return lines;
+}
+function feeLabel(fee) {
+  return fee !== void 0 ? `${formatNumber(fee)} base units` : "the publisher's configured per-event fee";
+}
+function renderEventPlan(opts) {
+  return [
+    `Publish ${opts.action} (${opts.mode} mode)`,
+    `Repo: 30617:${opts.addr.ownerPubkey}:${opts.addr.repoId}`,
+    `Fee: ${feeLabel(opts.fee)}. Writes are permanent and non-refundable.`
+  ];
+}
+function renderEventReceipt(action, result) {
+  const lines = [
+    `Published ${action}: ${result.eventId}  paid ${formatNumber(result.feePaid)} base units`
+  ];
+  if (result.channelBalanceAfter !== void 0) {
+    lines.push(
+      `Channel balance after: ${formatNumber(result.channelBalanceAfter)} base units`
+    );
+  }
+  return lines;
+}
+function renderResult(result) {
+  const lines = [];
+  lines.push(`Pushed "${result.repoId}":`);
+  const paid = result.uploads.filter((u) => !u.skipped);
+  const skipped = result.uploads.filter((u) => u.skipped);
+  for (const upload of result.uploads) {
+    lines.push(
+      `  object ${upload.sha.slice(0, 12)}  ${upload.skipped ? "skipped (already stored)" : `paid ${formatNumber(upload.feePaid)}`}  ar:${upload.txId}`
+    );
+  }
+  lines.push(
+    `Uploads: ${paid.length} paid, ${skipped.length} skipped (content-addressed).`
+  );
+  if (result.announceReceipt) {
+    lines.push(
+      `Announcement (kind:30617): ${result.announceReceipt.eventId}  paid ${formatNumber(result.announceReceipt.feePaid)}`
+    );
+  }
+  lines.push(
+    `Refs event (kind:30618): ${result.refsReceipt.eventId}  paid ${formatNumber(result.refsReceipt.feePaid)}`
+  );
+  lines.push(
+    `Total paid: ${formatNumber(result.totalFeePaid)} base units (estimate was ${formatNumber(result.estimate.totalFee)})`
+  );
+  return lines;
+}
+
+// src/cli/push.ts
+var defaultLoadStandalone = async (env) => {
+  const mod = await import("../standalone-mode-UFMHGUOM.js");
+  return mod.createStandaloneContext(env);
+};
+var PUSH_USAGE = `Usage: rig push [refspecs...] [options]
+
+Push local git refs to TOON: uploads the object delta to Arweave (paid) and
+publishes the NIP-34 refs event (kind:30618; kind:30617 announce on first
+push). Writes are permanent and non-refundable.
+
+Refspecs are branch/tag names or full refnames; default is the current branch.
+
+Options:
+  --force            allow non-fast-forward ref updates (overwrites remote history)
+  --all              push all local branches
+  --tags             push all local tags
+  --yes              skip the fee confirmation (required when not a TTY)
+  --json             machine-readable plan/receipts; without --yes it is a pure
+                     estimate (nothing executed)
+  --relay <url>      relay URL (repeatable in daemon mode; standalone mode
+                     supports exactly one; default: git config toon.relay,
+                     then the mode's default relay)
+  --repo-id <id>     repository id / NIP-34 d-tag (default: git config
+                     toon.repoid, then the repo directory name)
+  --daemon           force daemon mode (toon-clientd control API)
+  --standalone       force standalone mode (embedded client from TOON_CLIENT_MNEMONIC)
+  -h, --help         show this help`;
+async function selectRefspecs(reader, positionals, all, tags) {
+  const { head, refs } = await reader.listRefs();
+  const byName = new Set(refs.map((r) => r.refname));
+  const selected = [];
+  const add = (refname) => {
+    if (!selected.includes(refname)) selected.push(refname);
+  };
+  for (const spec of positionals) {
+    if (byName.has(spec)) {
+      add(spec);
+    } else if (byName.has(`refs/heads/${spec}`)) {
+      add(`refs/heads/${spec}`);
+    } else if (byName.has(`refs/tags/${spec}`)) {
+      add(`refs/tags/${spec}`);
+    } else {
+      throw new Error(
+        `refspec ${JSON.stringify(spec)} matches no local branch or tag (ref deletion is out of scope in v1)`
+      );
+    }
+  }
+  if (all) {
+    for (const ref of refs) {
+      if (ref.refname.startsWith("refs/heads/")) add(ref.refname);
+    }
+  }
+  if (tags) {
+    for (const ref of refs) {
+      if (ref.refname.startsWith("refs/tags/")) add(ref.refname);
+    }
+  }
+  if (selected.length === 0) {
+    if (!head) {
+      throw new Error(
+        "HEAD is detached and no refspec was given \u2014 pass a branch/tag name, --all, or --tags"
+      );
+    }
+    add(head);
+  }
+  return selected;
+}
+function parsePushArgs(args) {
+  const { values, positionals } = parseArgs({
+    args,
+    options: {
+      force: { type: "boolean", default: false },
+      all: { type: "boolean", default: false },
+      tags: { type: "boolean", default: false },
+      yes: { type: "boolean", default: false },
+      json: { type: "boolean", default: false },
+      daemon: { type: "boolean", default: false },
+      standalone: { type: "boolean", default: false },
+      relay: { type: "string", multiple: true },
+      "repo-id": { type: "string" },
+      help: { type: "boolean", short: "h", default: false }
+    },
+    allowPositionals: true
+  });
+  const flags = {
+    force: values.force ?? false,
+    all: values.all ?? false,
+    tags: values.tags ?? false,
+    yes: values.yes ?? false,
+    json: values.json ?? false,
+    daemon: values.daemon ?? false,
+    standalone: values.standalone ?? false,
+    relay: values.relay ?? [],
+    help: values.help ?? false,
+    positionals
+  };
+  const repoId = values["repo-id"];
+  if (repoId !== void 0) flags.repoId = repoId;
+  return flags;
+}
+async function runPush(args, deps) {
+  const { io, env, fetchImpl } = deps;
+  let flags;
+  try {
+    flags = parsePushArgs(args);
+  } catch (err) {
+    io.err(err instanceof Error ? err.message : String(err));
+    io.err(PUSH_USAGE);
+    return 2;
+  }
+  if (flags.help) {
+    io.out(PUSH_USAGE);
+    return 0;
+  }
+  let standaloneCtx;
+  let standalonePlan;
+  try {
+    const repoRoot = await resolveRepoRoot(deps.cwd);
+    const toonConfig = await readToonConfig(repoRoot);
+    const repoId = flags.repoId ?? toonConfig.repoId ?? basename(repoRoot);
+    const reader = new GitRepoReader(repoRoot);
+    const refspecs = await selectRefspecs(
+      reader,
+      flags.positionals,
+      flags.all,
+      flags.tags
+    );
+    const explicitRelays = flags.relay.length > 0 ? flags.relay : toonConfig.relays.length > 0 ? toonConfig.relays : void 0;
+    const { mode, probe } = await selectMode({
+      daemon: flags.daemon,
+      standalone: flags.standalone,
+      env,
+      fetchImpl
+    });
+    let plan;
+    let identity;
+    let relaysUsed = explicitRelays;
+    const daemonClient = new DaemonGitClient(probe.baseUrl, fetchImpl);
+    const daemonRequest = {
+      repoPath: repoRoot,
+      repoId,
+      refspecs,
+      force: flags.force,
+      ...explicitRelays ? { relayUrls: explicitRelays } : {}
+    };
+    if (mode === "daemon") {
+      identity = probe.identity;
+      relaysUsed ??= probe.relayUrl ? [probe.relayUrl] : void 0;
+      plan = await daemonClient.gitEstimate(daemonRequest);
+    } else {
+      standaloneCtx = await (deps.loadStandalone ?? defaultLoadStandalone)(env);
+      identity = standaloneCtx.ownerPubkey;
+      relaysUsed ??= standaloneCtx.defaultRelayUrls;
+      if (relaysUsed && relaysUsed.length > 1) {
+        io.err(
+          `standalone mode publishes to a single relay, but ${relaysUsed.length} are configured (${relaysUsed.join(", ")}) \u2014 re-run with exactly one --relay <url> (or trim git config toon.relay). Nothing was uploaded or paid.`
+        );
+        return 1;
+      }
+      const remoteState = await standaloneCtx.fetchRemote({
+        ownerPubkey: standaloneCtx.ownerPubkey,
+        repoId,
+        relayUrls: relaysUsed
+      });
+      const feeRates = await standaloneCtx.publisher.getFeeRates();
+      const pushPlan = await planPush({
+        repoReader: reader,
+        remoteState,
+        feeRates,
+        repoId,
+        refs: refspecs,
+        force: flags.force
+      });
+      plan = serializePushPlan(pushPlan);
+      standalonePlan = { pushPlan, remoteState, reader, relaysUsed };
+    }
+    if (toonConfig.owner && identity && toonConfig.owner !== identity) {
+      io.err(
+        `warning: git config toon.owner (${toonConfig.owner.slice(0, 8)}\u2026) differs from the active ${mode} identity (${identity.slice(0, 8)}\u2026) \u2014 this push publishes under the ACTIVE identity's repo namespace, not the configured owner's`
+      );
+    }
+    const upToDate = plan.refUpdates.every((u) => u.kind === "up-to-date");
+    if (upToDate) {
+      if (flags.json) {
+        io.out(jsonOut({ command: "push", mode, repoId, executed: false, upToDate: true, plan }));
+      } else {
+        io.out("Everything up-to-date \u2014 nothing to push (and nothing paid).");
+      }
+      return 0;
+    }
+    if (!flags.json) {
+      for (const line of renderPlan(plan, mode)) io.out(line);
+    }
+    if (!flags.yes) {
+      if (flags.json) {
+        io.out(
+          jsonOut({
+            command: "push",
+            mode,
+            repoId,
+            executed: false,
+            upToDate: false,
+            plan,
+            hint: "estimate only \u2014 re-run with --yes to upload and publish (permanent, non-refundable)"
+          })
+        );
+        return 0;
+      }
+      if (!io.isInteractive) {
+        io.err(
+          "refusing to spend channel funds without confirmation in a non-interactive session \u2014 re-run with --yes (or use --json for an estimate)"
+        );
+        return 1;
+      }
+      const proceed = await io.confirm(
+        `Proceed with paid push (total ${plan.estimate.totalFee} base units)? [y/N] `
+      );
+      if (!proceed) {
+        io.err("aborted \u2014 nothing was uploaded or published.");
+        return 1;
+      }
+    }
+    let result;
+    if (mode === "daemon") {
+      result = await daemonClient.gitPush({ ...daemonRequest, confirm: true });
+    } else {
+      const cached = standalonePlan;
+      if (!cached || !standaloneCtx) {
+        throw new Error("internal: standalone plan cache missing");
+      }
+      const pushResult = await executePush({
+        plan: cached.pushPlan,
+        publisher: standaloneCtx.publisher,
+        remoteState: cached.remoteState,
+        repoReader: cached.reader,
+        relayUrls: cached.relaysUsed
+      });
+      result = serializePushResult(cached.pushPlan, pushResult);
+    }
+    if (flags.json) {
+      io.out(
+        jsonOut({ command: "push", mode, repoId, executed: true, upToDate: false, plan, result })
+      );
+    } else {
+      for (const line of renderResult(result)) io.out(line);
+    }
+    try {
+      await writeToonConfig(repoRoot, {
+        repoId,
+        ...identity ? { owner: identity } : {},
+        ...relaysUsed ? { relays: relaysUsed } : {}
+      });
+    } catch (err) {
+      io.err(
+        `warning: push succeeded but persisting git config failed: ${err instanceof Error ? err.message : String(err)}`
+      );
+    }
+    return 0;
+  } catch (err) {
+    const described = describeError(err);
+    if (flags.json) {
+      io.out(JSON.stringify({ command: "push", ...described.json }, null, 2));
+    } else {
+      for (const line of described.lines) io.err(line);
+    }
+    return 1;
+  } finally {
+    if (standaloneCtx) {
+      try {
+        await standaloneCtx.stop();
+      } catch {
+      }
+    }
+  }
+}
+function jsonOut(output) {
+  return JSON.stringify(output, null, 2);
+}
+
+// src/cli/events.ts
+var defaultReadStdin = async () => {
+  if (process.stdin.isTTY) return "";
+  const chunks = [];
+  for await (const chunk of process.stdin) chunks.push(chunk);
+  return Buffer.concat(chunks).toString("utf-8");
+};
+var COMMON_FLAGS_USAGE = `  --repo-id <id>       repository id / NIP-34 d-tag (default: git config toon.repoid)
+  --owner <pubkey>     repository owner pubkey, 64-char hex (default: git config
+                       toon.owner, then the active publisher identity)
+  --relay <url>        relay to publish to in standalone mode (default: git config
+                       toon.relay, then the mode's default; standalone supports
+                       exactly one relay \u2014 daemon mode publishes via its apex)
+  --yes                skip the fee confirmation (required when not a TTY)
+  --json               machine-readable receipt; without --yes it is a pure
+                       estimate (nothing published, exit 0)
+  --daemon             force daemon mode (toon-clientd control API)
+  --standalone         force standalone mode (embedded client from TOON_CLIENT_MNEMONIC)
+  -h, --help           show this help`;
+var ISSUE_USAGE = `Usage: rig issue create --title <title> [options]
+
+File an issue (kind:1621) against a TOON repo \u2014 a paid publish; writes are
+permanent and non-refundable. The repo address (30617:<owner>:<repoId>) comes
+from the toon.* git config keys \`rig push\` persists.
+
+Body source (exactly one): --body, --body-file, or piped stdin.
+
+Options:
+  --title <title>      issue title (subject tag) [required]
+  --body <text>        issue body (Markdown)
+  --body-file <path>   read the issue body from a file
+  --label <label>      label (t tag); repeatable
+${COMMON_FLAGS_USAGE}`;
+var COMMENT_USAGE = `Usage: rig comment <root-event-id> --body <text> [options]
+
+Comment (kind:1622) on an issue or patch \u2014 a paid publish; writes are
+permanent and non-refundable. <root-event-id> is the 64-char hex id of the
+kind:1621 issue / kind:1617 patch being commented on.
+
+Options:
+  --body <text>            comment body (Markdown) [required]
+  --parent-author <pubkey> pubkey of the TARGET event's author (p threading
+                           tag; default: the repo owner)
+  --marker <root|reply>    e-tag marker (default: root \u2014 commenting directly
+                           on the issue/patch)
+${COMMON_FLAGS_USAGE}`;
+var PR_USAGE = `Usage: rig pr create --title <title> (--range <range> | --patch-file <path>) [options]
+
+Publish a patch (kind:1617) whose content is REAL \`git format-patch\` output \u2014
+a paid publish; writes are permanent and non-refundable. --range runs
+\`git format-patch --stdout <range>\` in the local repository and derives the
+commit/parent-commit tags; --patch-file publishes a pre-generated patch
+verbatim. A multi-commit range publishes ONE kind:1617 event carrying the
+full series text \u2014 cover-letter threading (one event per commit) is out of
+scope in v1.
+
+Options:
+  --title <title>      patch/PR title (subject tag) [required]
+  --range <range>      revision range for format-patch: <rev>, <rev>..<rev>,
+                       or <rev>...<rev> (mutually exclusive with --patch-file)
+  --patch-file <path>  literal patch text to publish
+  --branch <name>      branch name (t tag)
+${COMMON_FLAGS_USAGE}`;
+var STATUS_USAGE = `Usage: rig status <target-event-id> <open|applied|closed|draft> [options]
+
+Set the status of an issue or patch \u2014 a paid publish; writes are permanent
+and non-refundable. Publishes kind:1630 (open), 1631 (applied), 1632
+(closed), or 1633 (draft) against the 64-char hex id of the target event,
+with the repo a-tag attached so readers can scope a status stream to the
+repository.
+
+Options:
+${COMMON_FLAGS_USAGE}`;
+var HEX64_RE = /^[0-9a-f]{64}$/;
+function assertHex64(value, what) {
+  if (!HEX64_RE.test(value)) {
+    throw new Error(
+      `${what} must be a 64-char lowercase hex id (got ${JSON.stringify(value)})`
+    );
+  }
+}
+var COMMON_OPTIONS = {
+  yes: { type: "boolean", default: false },
+  json: { type: "boolean", default: false },
+  daemon: { type: "boolean", default: false },
+  standalone: { type: "boolean", default: false },
+  relay: { type: "string", multiple: true },
+  "repo-id": { type: "string" },
+  owner: { type: "string" },
+  help: { type: "boolean", short: "h", default: false }
+};
+function pickCommon(values) {
+  const flags = {
+    yes: values["yes"] === true,
+    json: values["json"] === true,
+    daemon: values["daemon"] === true,
+    standalone: values["standalone"] === true,
+    relay: Array.isArray(values["relay"]) ? values["relay"] : [],
+    help: values["help"] === true
+  };
+  const repoId = values["repo-id"];
+  if (typeof repoId === "string") flags.repoId = repoId;
+  const owner = values["owner"];
+  if (typeof owner === "string") {
+    assertHex64(owner, "--owner");
+    flags.owner = owner;
+  }
+  return flags;
+}
+async function runEvent(opts) {
+  const { command, flags, deps, actionLabel } = opts;
+  const { io, env, fetchImpl } = deps;
+  let standaloneCtx;
+  try {
+    let toonConfig = { relays: [] };
+    try {
+      toonConfig = await readToonConfig(await resolveRepoRoot(deps.cwd));
+    } catch {
+    }
+    const repoId = flags.repoId ?? toonConfig.repoId;
+    if (!repoId) throw new UnconfiguredRepoAddressError("repository id");
+    const explicitRelays = flags.relay.length > 0 ? flags.relay : toonConfig.relays.length > 0 ? toonConfig.relays : void 0;
+    const { mode, probe } = await selectMode({
+      daemon: flags.daemon,
+      standalone: flags.standalone,
+      env,
+      fetchImpl
+    });
+    const daemonClient = new DaemonGitClient(probe.baseUrl, fetchImpl);
+    let identity;
+    let fee;
+    let relaysUsed = explicitRelays;
+    if (mode === "daemon") {
+      identity = probe.identity;
+      fee = probe.feePerEvent;
+    } else {
+      standaloneCtx = await (deps.loadStandalone ?? defaultLoadStandalone)(env);
+      identity = standaloneCtx.ownerPubkey;
+      relaysUsed ??= standaloneCtx.defaultRelayUrls;
+      if (relaysUsed.length > 1) {
+        io.err(
+          `standalone mode publishes to a single relay, but ${relaysUsed.length} are configured (${relaysUsed.join(", ")}) \u2014 re-run with exactly one --relay <url> (or trim git config toon.relay). Nothing was published or paid.`
+        );
+        return 1;
+      }
+      fee = (await standaloneCtx.publisher.getFeeRates()).eventFee.toString();
+    }
+    const owner = flags.owner ?? toonConfig.owner ?? identity;
+    if (!owner) throw new UnconfiguredRepoAddressError("repository owner");
+    const addr = { ownerPubkey: owner, repoId };
+    const event = await opts.buildEvent(addr);
+    const action = `kind:${event.kind} ${actionLabel}`;
+    if (!flags.json) {
+      for (const line of renderEventPlan({
+        action,
+        addr,
+        mode,
+        ...fee !== void 0 ? { fee } : {}
+      })) {
+        io.out(line);
+      }
+    }
+    if (!flags.yes) {
+      if (flags.json) {
+        io.out(
+          jsonOut2({
+            command,
+            mode,
+            repoAddr: addr,
+            kind: event.kind,
+            executed: false,
+            feeEstimate: fee ?? null,
+            hint: "estimate only \u2014 re-run with --yes to publish (permanent, non-refundable)"
+          })
+        );
+        return 0;
+      }
+      if (!io.isInteractive) {
+        io.err(
+          "refusing to spend channel funds without confirmation in a non-interactive session \u2014 re-run with --yes (or use --json for an estimate)"
+        );
+        return 1;
+      }
+      const proceed = await io.confirm(
+        `Proceed with paid publish (${feeLabel(fee)})? [y/N] `
+      );
+      if (!proceed) {
+        io.err("aborted \u2014 nothing was published.");
+        return 1;
+      }
+    }
+    let result;
+    if (mode === "daemon") {
+      result = await opts.sendDaemon(daemonClient, addr);
+    } else {
+      if (!standaloneCtx) throw new Error("internal: standalone context missing");
+      const receipt = await standaloneCtx.publisher.publishEvent(
+        event,
+        relaysUsed ?? []
+      );
+      result = serializeEventReceipt(event.kind, receipt);
+    }
+    if (flags.json) {
+      io.out(
+        jsonOut2({
+          command,
+          mode,
+          repoAddr: addr,
+          kind: result.kind,
+          executed: true,
+          feeEstimate: fee ?? null,
+          result
+        })
+      );
+    } else {
+      for (const line of renderEventReceipt(action, result)) io.out(line);
+    }
+    return 0;
+  } catch (err) {
+    const described = describeError(err, command);
+    if (flags.json) {
+      io.out(JSON.stringify({ command, ...described.json }, null, 2));
+    } else {
+      for (const line of described.lines) io.err(line);
+    }
+    return 1;
+  } finally {
+    if (standaloneCtx) {
+      try {
+        await standaloneCtx.stop();
+      } catch {
+      }
+    }
+  }
+}
+function jsonOut2(output) {
+  return JSON.stringify(output, null, 2);
+}
+async function runIssue(args, deps) {
+  const { io } = deps;
+  const [sub, ...rest] = args;
+  if (sub === "--help" || sub === "-h" || sub === "help") {
+    io.out(ISSUE_USAGE);
+    return 0;
+  }
+  if (sub !== "create") {
+    io.err(
+      sub === void 0 ? "missing subcommand: rig issue create" : `unknown rig issue subcommand: ${sub}`
+    );
+    io.err(ISSUE_USAGE);
+    return 2;
+  }
+  let flags;
+  let title;
+  let bodyFlag;
+  let bodyFile;
+  let labels;
+  try {
+    const { values } = parseArgs2({
+      args: rest,
+      options: {
+        ...COMMON_OPTIONS,
+        title: { type: "string" },
+        body: { type: "string" },
+        "body-file": { type: "string" },
+        label: { type: "string", multiple: true }
+      },
+      allowPositionals: false
+    });
+    flags = pickCommon(values);
+    if (!flags.help && (values.title === void 0 || values.title === "")) {
+      throw new Error("--title is required");
+    }
+    if (values.body !== void 0 && values["body-file"] !== void 0) {
+      throw new Error("--body and --body-file are mutually exclusive");
+    }
+    title = values.title ?? "";
+    bodyFlag = values.body;
+    bodyFile = values["body-file"];
+    labels = values.label ?? [];
+  } catch (err) {
+    io.err(err instanceof Error ? err.message : String(err));
+    io.err(ISSUE_USAGE);
+    return 2;
+  }
+  if (flags.help) {
+    io.out(ISSUE_USAGE);
+    return 0;
+  }
+  let body;
+  if (bodyFlag !== void 0) {
+    body = bodyFlag;
+  } else if (bodyFile !== void 0) {
+    try {
+      body = await readFile(bodyFile, "utf-8");
+    } catch (err) {
+      io.err(
+        `cannot read --body-file ${bodyFile}: ${err instanceof Error ? err.message : String(err)}`
+      );
+      return 2;
+    }
+  } else if (!io.isInteractive) {
+    body = await (deps.readStdin ?? defaultReadStdin)();
+  } else {
+    io.err("an issue body is required: pass --body/--body-file or pipe stdin");
+    io.err(ISSUE_USAGE);
+    return 2;
+  }
+  if (body.trim() === "") {
+    io.err("the issue body is empty \u2014 nothing to publish");
+    return 2;
+  }
+  return runEvent({
+    command: "issue",
+    flags,
+    deps,
+    actionLabel: `issue ${JSON.stringify(title)}`,
+    buildEvent: async (addr) => buildIssue(addr.ownerPubkey, addr.repoId, title, body, labels),
+    sendDaemon: (client, addr) => client.gitIssue({
+      repoAddr: addr,
+      title,
+      body,
+      ...labels.length > 0 ? { labels } : {}
+    })
+  });
+}
+async function runComment(args, deps) {
+  const { io } = deps;
+  let flags;
+  let rootEventId;
+  let body;
+  let parentAuthor;
+  let marker;
+  try {
+    const { values, positionals } = parseArgs2({
+      args,
+      options: {
+        ...COMMON_OPTIONS,
+        body: { type: "string" },
+        "parent-author": { type: "string" },
+        marker: { type: "string" }
+      },
+      allowPositionals: true
+    });
+    flags = pickCommon(values);
+    if (flags.help) {
+      io.out(COMMENT_USAGE);
+      return 0;
+    }
+    if (positionals.length !== 1) {
+      throw new Error(
+        positionals.length === 0 ? "<root-event-id> is required" : `expected exactly one <root-event-id>, got ${positionals.length} positionals`
+      );
+    }
+    rootEventId = positionals[0];
+    assertHex64(rootEventId, "<root-event-id>");
+    if (values.body === void 0 || values.body === "") {
+      throw new Error("--body is required");
+    }
+    body = values.body;
+    parentAuthor = values["parent-author"];
+    if (parentAuthor !== void 0) assertHex64(parentAuthor, "--parent-author");
+    const rawMarker = values.marker ?? "root";
+    if (rawMarker !== "root" && rawMarker !== "reply") {
+      throw new Error(`--marker must be root or reply (got ${JSON.stringify(rawMarker)})`);
+    }
+    marker = rawMarker;
+  } catch (err) {
+    io.err(err instanceof Error ? err.message : String(err));
+    io.err(COMMENT_USAGE);
+    return 2;
+  }
+  return runEvent({
+    command: "comment",
+    flags,
+    deps,
+    actionLabel: `comment on ${rootEventId.slice(0, 8)}\u2026`,
+    buildEvent: async (addr) => buildComment(
+      addr.ownerPubkey,
+      addr.repoId,
+      rootEventId,
+      parentAuthor ?? addr.ownerPubkey,
+      body,
+      marker
+    ),
+    sendDaemon: (client, addr) => client.gitComment({
+      repoAddr: addr,
+      rootEventId,
+      body,
+      marker,
+      ...parentAuthor !== void 0 ? { parentAuthorPubkey: parentAuthor } : {}
+    })
+  });
+}
+var PATCH_FROM_RE = /^From ([0-9a-f]{40}) /gm;
+function extractPatchShas(patchText) {
+  return [...patchText.matchAll(PATCH_FROM_RE)].map((m) => m[1]);
+}
+async function runPr(args, deps) {
+  const { io } = deps;
+  const [sub, ...rest] = args;
+  if (sub === "--help" || sub === "-h" || sub === "help") {
+    io.out(PR_USAGE);
+    return 0;
+  }
+  if (sub !== "create") {
+    io.err(
+      sub === void 0 ? "missing subcommand: rig pr create" : `unknown rig pr subcommand: ${sub}`
+    );
+    io.err(PR_USAGE);
+    return 2;
+  }
+  let flags;
+  let title;
+  let range;
+  let patchFile;
+  let branch;
+  try {
+    const { values } = parseArgs2({
+      args: rest,
+      options: {
+        ...COMMON_OPTIONS,
+        title: { type: "string" },
+        range: { type: "string" },
+        "patch-file": { type: "string" },
+        branch: { type: "string" }
+      },
+      allowPositionals: false
+    });
+    flags = pickCommon(values);
+    if (flags.help) {
+      io.out(PR_USAGE);
+      return 0;
+    }
+    if (values.title === void 0 || values.title === "") {
+      throw new Error("--title is required");
+    }
+    if (values.range === void 0 === (values["patch-file"] === void 0)) {
+      throw new Error("exactly one of --range or --patch-file is required");
+    }
+    title = values.title;
+    range = values.range;
+    patchFile = values["patch-file"];
+    branch = values.branch;
+  } catch (err) {
+    io.err(err instanceof Error ? err.message : String(err));
+    io.err(PR_USAGE);
+    return 2;
+  }
+  let prepared;
+  const prepare = async () => {
+    if (prepared) return prepared;
+    if (range !== void 0) {
+      const reader = new GitRepoReader(await resolveRepoRoot(deps.cwd));
+      const patchText = await reader.formatPatch(range);
+      if (patchText === "") {
+        throw new Error(
+          `range ${JSON.stringify(range)} selects no commits \u2014 nothing to publish`
+        );
+      }
+      const shas = extractPatchShas(patchText);
+      const parents = await reader.commitParents(shas);
+      const commits = shas.flatMap((sha) => {
+        const parentSha = parents.get(sha)?.[0];
+        return parentSha ? [{ sha, parentSha }] : [];
+      });
+      prepared = { patchText, commits };
+    } else {
+      const patchText = await readFile(patchFile, "utf-8");
+      if (patchText.trim() === "") {
+        throw new Error(`--patch-file ${patchFile} is empty \u2014 nothing to publish`);
+      }
+      prepared = { patchText, commits: [] };
+    }
+    return prepared;
+  };
+  return runEvent({
+    command: "pr",
+    flags,
+    deps,
+    actionLabel: `patch ${JSON.stringify(title)}`,
+    buildEvent: async (addr) => {
+      const { patchText, commits } = await prepare();
+      return buildPatch(
+        addr.ownerPubkey,
+        addr.repoId,
+        title,
+        commits,
+        branch,
+        patchText
+      );
+    },
+    sendDaemon: async (client, addr) => {
+      const { patchText, commits } = await prepare();
+      return client.gitPatch({
+        repoAddr: addr,
+        title,
+        patchText,
+        ...commits.length > 0 ? { commits } : {},
+        ...branch !== void 0 ? { branch } : {}
+      });
+    }
+  });
+}
+var STATUS_KIND_BY_VALUE = {
+  open: STATUS_OPEN_KIND,
+  applied: STATUS_APPLIED_KIND,
+  closed: STATUS_CLOSED_KIND,
+  draft: STATUS_DRAFT_KIND
+};
+function isStatusValue(value) {
+  return Object.hasOwn(STATUS_KIND_BY_VALUE, value);
+}
+async function runStatus(args, deps) {
+  const { io } = deps;
+  let flags;
+  let targetEventId;
+  let status;
+  try {
+    const { values, positionals } = parseArgs2({
+      args,
+      options: COMMON_OPTIONS,
+      allowPositionals: true
+    });
+    flags = pickCommon(values);
+    if (flags.help) {
+      io.out(STATUS_USAGE);
+      return 0;
+    }
+    if (positionals.length !== 2) {
+      throw new Error(
+        "expected exactly two arguments: <target-event-id> <open|applied|closed|draft>"
+      );
+    }
+    targetEventId = positionals[0];
+    assertHex64(targetEventId, "<target-event-id>");
+    const rawStatus = positionals[1];
+    if (!isStatusValue(rawStatus)) {
+      throw new Error(
+        `status must be one of open | applied | closed | draft (got ${JSON.stringify(rawStatus)})`
+      );
+    }
+    status = rawStatus;
+  } catch (err) {
+    io.err(err instanceof Error ? err.message : String(err));
+    io.err(STATUS_USAGE);
+    return 2;
+  }
+  return runEvent({
+    command: "status",
+    flags,
+    deps,
+    actionLabel: `status ${status} on ${targetEventId.slice(0, 8)}\u2026`,
+    buildEvent: async (addr) => {
+      const event = buildStatus(targetEventId, STATUS_KIND_BY_VALUE[status]);
+      event.tags.push([
+        "a",
+        `${REPOSITORY_ANNOUNCEMENT_KIND}:${addr.ownerPubkey}:${addr.repoId}`
+      ]);
+      return event;
+    },
+    sendDaemon: (client, addr) => client.gitStatus({ repoAddr: addr, targetEventId, status })
+  });
+}
+
+// src/cli/rig.ts
+var USAGE = `rig \u2014 push git repos to TOON (pay-to-write Nostr + Arweave)
+
+Usage: rig <command> [options]
+
+Commands:
+  push [refspecs...]         plan, price, confirm, and execute a paid push
+  issue create               file an issue (kind:1621) against a repo
+  comment <root-event-id>    comment (kind:1622) on an issue or patch
+  pr create                  publish a patch (kind:1617) with real
+                             \`git format-patch\` content
+  status <event-id> <state>  set an issue/patch status (kind:1630-1633):
+                             open | applied | closed | draft
+
+Run \`rig <command> --help\` for the command's flags. All writes are paid,
+permanent, and non-refundable; each command quotes its fee and asks for
+confirmation before spending (--yes skips, --json emits machine output).`;
+function makeIo() {
+  return {
+    out: (line) => process.stdout.write(`${line}
+`),
+    err: (line) => process.stderr.write(`${line}
+`),
+    isInteractive: Boolean(process.stdin.isTTY && process.stdout.isTTY),
+    confirm: async (question) => {
+      const rl = createInterface({
+        input: process.stdin,
+        output: process.stderr
+      });
+      try {
+        const answer = (await rl.question(question)).trim().toLowerCase();
+        return answer === "y" || answer === "yes";
+      } finally {
+        rl.close();
+      }
+    }
+  };
+}
+async function main() {
+  const [command, ...rest] = process.argv.slice(2);
+  const io = makeIo();
+  const deps = {
+    io,
+    env: process.env,
+    cwd: process.cwd(),
+    fetchImpl: fetch
+  };
+  switch (command) {
+    case "push":
+      return runPush(rest, deps);
+    case "issue":
+      return runIssue(rest, deps);
+    case "comment":
+      return runComment(rest, deps);
+    case "pr":
+      return runPr(rest, deps);
+    case "status":
+      return runStatus(rest, deps);
+    case "help":
+    case "--help":
+    case "-h":
+      io.out(USAGE);
+      io.out("");
+      io.out(PUSH_USAGE);
+      return 0;
+    case void 0:
+      io.err(USAGE);
+      return 2;
+    default:
+      io.err(`unknown command: ${command}`);
+      io.err(USAGE);
+      return 2;
+  }
+}
+main().then(
+  (code) => {
+    process.exitCode = code;
+  },
+  (err) => {
+    process.stderr.write(
+      `rig: unexpected error: ${err instanceof Error ? err.stack ?? err.message : String(err)}
+`
+    );
+    process.exitCode = 1;
+  }
+);
+//# sourceMappingURL=rig.js.map