@toon-protocol/rig 2.4.1 → 2.6.0

package/dist/cli/rig.js

@@ -6,6 +6,7 @@ import {
   OversizeObjectsError,
   collectRepoObjects,
   executePush,
+  hexToNpub,
   isSafeRefname,
   missingObjectsMessage,
   ownerToHex,
@@ -17,7 +18,7 @@ import {
   setHeadSymref,
   updateRef,
   writeGitObjects
-} from "../chunk-W2SDL2PE.js";
+} from "../chunk-NIRC5LFS.js";
 import {
   DEFAULT_KEYSTORE_PASSWORD,
   MissingIdentityError,
@@ -27,6 +28,15 @@ import {
   readClientConfigFile,
   resolveIdentity
 } from "../chunk-XGFBDUQX.js";
+import {
+  ChannelMapStore,
+  channelStatus,
+  defaultDaemonPort,
+  resolveChannelPaths
+} from "../chunk-SW7ZHMGS.js";
+import {
+  MAX_OBJECT_SIZE
+} from "../chunk-B5ISARMU.js";
 import {
   COMMENT_KIND,
   authorizedStatusAuthors,
@@ -39,15 +49,6 @@ import {
   parseMaintainers,
   queryRelay
 } from "../chunk-3HRFDH7H.js";
-import {
-  ChannelMapStore,
-  channelStatus,
-  defaultDaemonPort,
-  resolveChannelPaths
-} from "../chunk-SW7ZHMGS.js";
-import {
-  MAX_OBJECT_SIZE
-} from "../chunk-X2CZPPDM.js";
 
 // src/cli/rig.ts
 import { createInterface as createInterface2 } from "readline/promises";
@@ -59,6 +60,9 @@ import { createRequire } from "module";
 import { parseArgs as parseArgs3 } from "util";
 
 // src/cli/daemon-session.ts
+function daemonSupportsGit(probe) {
+  return Array.isArray(probe.capabilities) && probe.capabilities.includes("git");
+}
 function daemonBaseUrl(env) {
   const raw = env["TOON_CLIENT_HTTP_PORT"];
   const parsed = raw ? Number(raw) : NaN;
@@ -83,6 +87,11 @@ async function probeDaemon(env, fetchImpl, timeoutMs = 1500) {
     if (typeof body?.feePerEvent === "string" && body.feePerEvent !== "") {
       probe.feePerEvent = body.feePerEvent;
     }
+    if (Array.isArray(body?.capabilities)) {
+      probe.capabilities = body.capabilities.filter(
+        (c) => typeof c === "string"
+      );
+    }
     return probe;
   } catch {
     return { baseUrl, reachable: false };
@@ -98,6 +107,19 @@ var DaemonRouteError = class extends Error {
   status;
   envelope;
 };
+var DaemonTooOldForGitError = class extends Error {
+  constructor(baseUrl, pubkey) {
+    const holds = pubkey !== void 0 && pubkey !== "" ? ` holds this identity (${pubkey.slice(0, 8)}\u2026)` : " holds this identity";
+    super(
+      `toon-clientd at ${baseUrl}${holds} but is too old to handle git operations (missing /git routes). Upgrade the daemon (npm i -g @toon-protocol/client-mcp@latest, then restart it) \u2014 or stop it to let rig run standalone.`
+    );
+    this.baseUrl = baseUrl;
+    this.pubkey = pubkey;
+    this.name = "DaemonTooOldForGitError";
+  }
+  baseUrl;
+  pubkey;
+};
 var DaemonUnreachableError = class extends Error {
   constructor(baseUrl, cause) {
     super(
@@ -109,12 +131,14 @@ var DaemonUnreachableError = class extends Error {
   baseUrl;
 };
 var DaemonGitClient = class {
-  constructor(baseUrl, fetchImpl) {
+  constructor(baseUrl, fetchImpl, pubkey) {
     this.baseUrl = baseUrl;
     this.fetchImpl = fetchImpl;
+    this.pubkey = pubkey;
   }
   baseUrl;
   fetchImpl;
+  pubkey;
   gitEstimate(req) {
     return this.post("/git/estimate", req);
   }
@@ -144,6 +168,9 @@ var DaemonGitClient = class {
     } catch (err) {
       throw new DaemonUnreachableError(this.baseUrl, err);
     }
+    if (res.status === 404) {
+      throw new DaemonTooOldForGitError(this.baseUrl, this.pubkey);
+    }
     const text = await res.text();
     let parsed;
     try {
@@ -174,12 +201,15 @@ async function resolvePaidSession(options) {
       warn: options.warn
     });
     if (identity.pubkey === probe.identity) {
+      if (!daemonSupportsGit(probe)) {
+        throw new DaemonTooOldForGitError(probe.baseUrl, identity.pubkey);
+      }
       options.warn(
         `rig: paid path: daemon \u2014 toon-clientd at ${probe.baseUrl} holds this identity (${identity.pubkey.slice(0, 8)}\u2026), delegating`
       );
       return {
         path: "daemon",
-        client: new DaemonGitClient(probe.baseUrl, fetchImpl),
+        client: new DaemonGitClient(probe.baseUrl, fetchImpl, identity.pubkey),
         baseUrl: probe.baseUrl,
         identity: {
           pubkey: identity.pubkey,
@@ -263,7 +293,7 @@ var NotAGitRepositoryError = class extends Error {
   constructor(cwd) {
     super(
       `not a git repository: ${cwd}
-rig works inside an existing repo \u2014 create one first with \`git init\` (rig never runs it for you), then re-run.`
+rig can create one for you: re-run \`rig init --git-init\` (in a terminal, plain \`rig init\` offers the same via a prompt). Or run \`git init\` yourself first, then re-run.`
     );
     this.name = "NotAGitRepositoryError";
   }
@@ -401,6 +431,18 @@ function describeError(err, command = "push") {
       json: { error: "daemon_unreachable", detail: err.message }
     };
   }
+  if (err instanceof DaemonTooOldForGitError) {
+    return {
+      code: "daemon_too_old_for_git",
+      lines: err.message.split("\n"),
+      json: {
+        error: "daemon_too_old_for_git",
+        detail: err.message,
+        baseUrl: err.baseUrl,
+        ...err.pubkey !== void 0 ? { pubkey: err.pubkey } : {}
+      }
+    };
+  }
   const name = err instanceof Error ? err.name : "";
   const message = err instanceof Error ? err.message : String(err);
   if (name === "DaemonIdentityConflictError") {
@@ -507,8 +549,9 @@ function renderPlan(plan) {
   for (const update of plan.refUpdates) lines.push(refLine(update));
   const est = plan.estimate;
   const skipped = Object.keys(plan.knownShaToTxId).length;
+  const emptySkipped = est.skippedEmptyCount ?? 0;
   lines.push(
-    `Objects: ${est.objectCount} to upload (${formatNumber(est.totalObjectBytes)} bytes)` + (skipped > 0 ? `; ${skipped} already on Arweave (free)` : "")
+    `Objects: ${est.objectCount} to upload (${formatNumber(est.totalObjectBytes)} bytes)` + (skipped > 0 ? `; ${skipped} already on Arweave (free)` : "") + (emptySkipped > 0 ? `; ${emptySkipped} empty blob${emptySkipped === 1 ? "" : "s"} skipped (reconstructed on clone)` : "")
   );
   lines.push("Fees (base units):");
   lines.push(
@@ -554,6 +597,12 @@ function renderResult(result) {
   lines.push(
     `Uploads: ${paid.length} paid, ${skipped.length} skipped (content-addressed).`
   );
+  const emptySkipped = result.estimate.skippedEmptyCount ?? 0;
+  if (emptySkipped > 0) {
+    lines.push(
+      `Empty blobs: ${emptySkipped} skipped (zero-byte, not uploaded \u2014 reconstructed on clone).`
+    );
+  }
   if (result.announceReceipt) {
     lines.push(
       `Announcement (kind:30617): ${result.announceReceipt.eventId}  paid ${formatNumber(result.announceReceipt.feePaid)}`
@@ -607,6 +656,14 @@ async function resolveRepoRoot(cwd) {
     );
   }
 }
+async function initGitRepository(dir) {
+  try {
+    await git(dir, ["init", "--initial-branch=main"]);
+  } catch {
+    await git(dir, ["init"]);
+    await git(dir, ["symbolic-ref", "HEAD", "refs/heads/main"]);
+  }
+}
 async function readToonConfig(repoPath) {
   const [repoId, owner, relays] = await Promise.all([
     git(repoPath, ["config", "--get", "toon.repoid"], [1]),
@@ -639,6 +696,10 @@ async function listGitRemotes(repoPath) {
   }
   return remotes;
 }
+async function setGitAuthor(repoPath, author) {
+  await git(repoPath, ["config", "--local", "user.name", author.name]);
+  await git(repoPath, ["config", "--local", "user.email", author.email]);
+}
 async function addGitRemote(repoPath, name, url) {
   await git(repoPath, ["remote", "add", name, url]);
 }
@@ -905,7 +966,7 @@ function loadPaidSession(deps, relayUrl) {
   });
 }
 var defaultLoadStandalone = async (options) => {
-  const mod = await import("../standalone-mode-VH2XPOPK.js");
+  const mod = await import("../standalone-mode-WEMJBHME.js");
   return mod.createStandaloneContext(options);
 };
 function identityReport(ctx) {
@@ -946,7 +1007,20 @@ Options:
   --repo-id <id>     repository id / NIP-34 d-tag (default: git config
                      toon.repoid \u2014 run \`rig init\` to set it)
   -h, --help         show this help`;
-async function selectRefspecs(reader, positionals, all, tags) {
+function noSuchRefMessage(spec, head, refs, remoteName) {
+  const branches = refs.filter((r) => r.refname.startsWith("refs/heads/")).map((r) => r.refname.slice("refs/heads/".length));
+  const current = head && head.startsWith("refs/heads/") ? head.slice("refs/heads/".length) : void 0;
+  let msg = `no local branch or tag ${JSON.stringify(spec)}`;
+  if (current) {
+    msg += ` \u2014 your current branch is ${JSON.stringify(current)} (did you mean \`rig push ${remoteName} ${current}\`?)`;
+  } else if (branches.length > 0) {
+    msg += ` \u2014 local branches: ${branches.join(", ")}`;
+  } else {
+    msg += " \u2014 this repository has no branches yet (make a commit first)";
+  }
+  return msg;
+}
+async function selectRefspecs(reader, positionals, all, tags, remoteName = "origin") {
   const { head, refs } = await reader.listRefs();
   const byName = new Set(refs.map((r) => r.refname));
   const selected = [];
@@ -960,10 +1034,12 @@ async function selectRefspecs(reader, positionals, all, tags) {
       add(`refs/heads/${spec}`);
     } else if (byName.has(`refs/tags/${spec}`)) {
       add(`refs/tags/${spec}`);
-    } else {
+    } else if (spec.startsWith(":")) {
       throw new Error(
-        `refspec ${JSON.stringify(spec)} matches no local branch or tag (ref deletion is out of scope in v1)`
+        `deleting remote refs (${JSON.stringify(spec)}) is out of scope in v1`
       );
+    } else {
+      throw new Error(noSuchRefMessage(spec, head, refs, remoteName));
     }
   }
   if (all) {
@@ -1060,7 +1136,8 @@ async function runPush(args, deps) {
       reader,
       refspecArgs,
       flags.all,
-      flags.tags
+      flags.tags,
+      remoteName ?? "origin"
     );
     const resolved = await resolveRelays({
       relayFlags: flags.relay,
@@ -1215,14 +1292,26 @@ async function runPush(args, deps) {
 // src/cli/balance.ts
 var BALANCE_USAGE = `Usage: rig balance [--json]
 
-Show the active identity's money: on-chain wallet balances (per configured
-chain, read from the settlement chain the payment channels actually use) and
-recorded payment-channel holdings (deposited / claimed / available). Free \u2014
-reads chain RPCs and local state only; nothing is signed or paid.
+Show the active identity's money: the full on-chain wallet view \u2014 native coin
+plus USDC on every configured chain (EVM / Solana / Mina) \u2014 and recorded
+payment-channel holdings (deposited / claimed / available). Free \u2014 reads chain
+RPCs and local state only; nothing is signed or paid. An unreachable chain RPC
+degrades to a per-chain notice without failing the others.
 
 Options:
   --json      machine-readable envelope (base units as strings)
   -h, --help  show this help`;
+function formatUnits(amount, decimals) {
+  if (decimals === void 0 || decimals <= 0) return amount;
+  const neg = amount.startsWith("-");
+  const digits = (neg ? amount.slice(1) : amount).padStart(decimals + 1, "0");
+  const whole = digits.slice(0, digits.length - decimals);
+  const frac = digits.slice(digits.length - decimals).replace(/0+$/, "");
+  return (neg ? "-" : "") + (frac ? `${whole}.${frac}` : whole);
+}
+function renderAmount(a) {
+  return `${a.symbol ?? "token"} ${formatUnits(a.amount, a.decimals)}`;
+}
 async function runBalance(args, deps) {
   const { io: io2, env } = deps;
   let json = false;
@@ -1254,7 +1343,7 @@ async function runBalance(args, deps) {
       requireUplink: false
     });
     const identity = identityReport(ctx);
-    const wallet = ctx.money ? await ctx.money.walletBalances() : [];
+    const wallet = ctx.money ? await ctx.money.walletChainBalances() : [];
     const store = new ChannelMapStore(resolveChannelPaths(env));
     const channels = store.list().filter((record) => record.identity === identity.pubkey).map((record) => {
       const watermark = store.readWatermark(record.channelId);
@@ -1291,13 +1380,23 @@ async function runBalance(args, deps) {
     io2.out("Wallet (on-chain):");
     if (wallet.length === 0) {
       io2.out(
-        "  (no balance readable \u2014 no chain configured, the RPC is unreachable, or the chain's keys derive only during a client start)"
+        "  (no chain configured for this identity \u2014 nothing to read)"
       );
     }
-    for (const balance of wallet) {
-      io2.out(
-        `  ${balance.chain.padEnd(7)} ${balance.address}  ${balance.amount}` + (balance.asset ? ` ${balance.asset}` : " base units") + (balance.assetScale !== void 0 ? ` (scale ${balance.assetScale})` : "")
-      );
+    for (const chain of wallet) {
+      io2.out(`  ${chain.chainKey.padEnd(11)} ${chain.address}`);
+      if (chain.unreadable) {
+        io2.out(
+          `    unreadable (RPC unreachable)` + (chain.error ? ` \u2014 ${chain.error}` : "")
+        );
+        continue;
+      }
+      const assets = [...chain.native ? [chain.native] : [], ...chain.tokens];
+      if (assets.length === 0) {
+        io2.out("    (no balance readable)");
+        continue;
+      }
+      io2.out(`    ${assets.map(renderAmount).join("   ")}`);
     }
     io2.out("");
     io2.out("Channels (recorded):");
@@ -3432,24 +3531,37 @@ import { join as join2 } from "path";
 import { parseArgs as parseArgs9 } from "util";
 var DEVNET_FAUCET_URL = "https://faucet.devnet.toonprotocol.dev";
 var CHAINS = ["evm", "solana", "mina"];
+var CHAIN_CHOICES = [...CHAINS, "all"];
+var NATIVE_COIN = {
+  evm: "ETH",
+  solana: "SOL",
+  mina: "MINA"
+};
 var FUND_USAGE = `Usage: rig fund [options]
 
 Drip devnet test funds to the active identity's wallet \u2014 free (the faucet
-pays). The identity comes from RIG_MNEMONIC (env or a project .env) or the
+pays). By default funds ALL supported chains (evm + solana + mina), each drip
+covering the native coin AND USDC, so the wallet matches the multi-chain
+\`rig balance\` view in one run. The per-chain drips run in parallel and are
+independent \u2014 one chain's faucet failing does not abort the others (exit 0
+only when every targeted chain funded; exit 1 if any failed, with the
+per-chain breakdown always shown).
+
+The identity comes from RIG_MNEMONIC (env or a project .env) or the
 ~/.toon-client keystore/config; the faucet from TOON_CLIENT_FAUCET_URL, the
 faucetUrl config field, or the deployed devnet faucet when the network is
 devnet \u2014 including when a configured *.devnet.toonprotocol.dev origin infers
 it (a devnet relay/proxy/btp endpoint, or the git origin remote from
 \`rig remote add origin <devnet relay>\`). The faucet drips a FIXED amount per
-chain (there is no --amount). On a
-network without a faucet, prints the wallet address(es) to fund externally
-instead.
+chain (there is no --amount). On a network without a faucet, prints the wallet
+address(es) to fund externally instead.
 
 Options:
-  --chain <chain>      evm | solana | mina (default: TOON_CLIENT_CHAIN, the
-                       \`chain\` config field, else evm)
+  --chain <chain>      evm | solana | mina | all \u2014 fund one chain, or all
+                       (default: all supported chains)
   --address <address>  fund this address instead of the identity's own
-  --json               machine-readable envelope
+                       (requires an explicit single --chain)
+  --json               machine-readable envelope (per-chain results array)
   -h, --help           show this help`;
 var SHARED_DEVNET_SUFFIX = ".devnet.toonprotocol.dev";
 function devnetHost(url) {
@@ -3543,9 +3655,14 @@ async function runFund(args, deps) {
     chainFlag = values.chain;
     addressFlag = values.address;
     json = values.json ?? false;
-    if (chainFlag !== void 0 && !CHAINS.includes(chainFlag)) {
+    if (chainFlag !== void 0 && !CHAIN_CHOICES.includes(chainFlag)) {
       throw new Error(
-        `--chain must be one of ${CHAINS.join(" | ")}, got ${JSON.stringify(chainFlag)}`
+        `--chain must be one of ${CHAIN_CHOICES.join(" | ")}, got ${JSON.stringify(chainFlag)}`
+      );
+    }
+    if (addressFlag !== void 0 && (chainFlag === void 0 || chainFlag === "all")) {
+      throw new Error(
+        "--address requires an explicit single --chain (evm | solana | mina) \u2014 a single address cannot fund every chain"
       );
     }
   } catch (err) {
@@ -3555,12 +3672,7 @@ async function runFund(args, deps) {
   }
   try {
     const { file } = readFundConfig(env);
-    const chain = chainFlag ?? env["TOON_CLIENT_CHAIN"] ?? file.chain ?? "evm";
-    if (!CHAINS.includes(chain)) {
-      throw new Error(
-        `configured settlement chain ${JSON.stringify(chain)} has no faucet \u2014 pass --chain ${CHAINS.join(" | ")}`
-      );
-    }
+    const targetChains = chainFlag === void 0 || chainFlag === "all" ? [...CHAINS] : [chainFlag];
     const network = env["TOON_CLIENT_NETWORK"] ?? file.network;
     const canInfer = network === void 0 || network === "custom";
     const originRelays = canInfer ? await resolveOriginRelays(deps.cwd) : [];
@@ -3596,7 +3708,6 @@ async function runFund(args, deps) {
           identity,
           funded: false,
           network: network ?? null,
-          chain,
           addresses,
           guidance
         });
@@ -3610,46 +3721,85 @@ async function runFund(args, deps) {
       io2.out(`  mina    ${addresses.mina ?? "(no key derived \u2014 optional mina-signer dependency missing)"}`);
       return 0;
     }
-    const address = addressFlag ?? addresses[chain];
-    if (!address) {
-      throw new Error(
-        `no ${chain} address could be derived for this identity \u2014 pass an explicit --address (for mina, install the optional mina-signer dependency)`
-      );
-    }
     const timeoutEnv = env["TOON_CLIENT_FAUCET_TIMEOUT_MS"];
-    const timeout = timeoutEnv && Number.isFinite(Number(timeoutEnv)) ? Number(timeoutEnv) : file.faucetTimeoutMs ?? (chain === "mina" ? 13e4 : 9e4);
+    const timeoutFor = (chain) => {
+      if (timeoutEnv && Number.isFinite(Number(timeoutEnv))) return Number(timeoutEnv);
+      if (file.faucetTimeoutMs !== void 0) return file.faucetTimeoutMs;
+      return chain === "mina" ? 13e4 : 9e4;
+    };
     if (!json && inferredDevnet) {
       io2.out(
         `Inferred network 'devnet' from the configured origin ${devnetOrigin} (network was ${JSON.stringify(network ?? "custom")}). Set TOON_CLIENT_NETWORK explicitly to override.`
       );
     }
     if (!json) {
+      const list = targetChains.join(", ");
       io2.out(
-        `Requesting ${chain} drip from ${faucetUrl} for ${address} \u2026` + (chain === "mina" ? " (mina settles slowly; this can take ~2 minutes)" : "")
+        `Requesting ${targetChains.length === 1 ? "" : "parallel "}drip${targetChains.length === 1 ? "" : "s"} from ${faucetUrl} for ${list} \u2026` + (targetChains.includes("mina") ? " (mina settles slowly; this can take ~2 minutes)" : "")
       );
     }
-    const { response } = await client.fundWallet(faucetUrl, address, chain, {
-      timeout,
-      ...deps.fetchImpl ? { fetchImpl: deps.fetchImpl } : {}
+    const singleChain = targetChains.length === 1;
+    const drips = targetChains.map(async (chain) => {
+      const address = (singleChain ? addressFlag : void 0) ?? addresses[chain];
+      if (!address) {
+        return {
+          chain,
+          funded: false,
+          address: null,
+          error: `no ${chain} address could be derived for this identity` + (chain === "mina" ? " (install the optional mina-signer dependency)" : "")
+        };
+      }
+      const started = Date.now();
+      try {
+        const { response } = await client.fundWallet(faucetUrl, address, chain, {
+          timeout: timeoutFor(chain),
+          ...deps.fetchImpl ? { fetchImpl: deps.fetchImpl } : {}
+        });
+        return {
+          chain,
+          funded: true,
+          address,
+          response,
+          elapsedMs: Date.now() - started
+        };
+      } catch (err) {
+        return {
+          chain,
+          funded: false,
+          address,
+          error: err instanceof Error ? err.message : String(err),
+          elapsedMs: Date.now() - started
+        };
+      }
     });
+    const results = await Promise.all(drips);
+    const allFunded = results.every((r) => r.funded);
     if (json) {
       io2.emitJson({
         command: "fund",
         identity,
-        funded: true,
+        funded: allFunded,
         network: effectiveNetwork ?? null,
-        chain,
-        address,
         faucetUrl,
-        response,
+        results,
         ...inferredDevnet ? { inferredDevnetFrom: devnetOrigin } : {}
       });
-      return 0;
+      return allFunded ? 0 : 1;
+    }
+    for (const r of results) {
+      const label = r.chain.padEnd(6);
+      const addr = r.address ? ` \u2192 ${r.address}` : "";
+      if (r.funded) {
+        const slow = r.elapsedMs !== void 0 && r.elapsedMs >= 5e3;
+        const time = slow ? ` (${Math.round(r.elapsedMs / 1e3)}s)` : "";
+        io2.out(`  ${label} \u2713 funded (${NATIVE_COIN[r.chain]} + USDC)${addr}${time}`);
+      } else {
+        io2.out(`  ${label} \u2717${addr} \u2014 ${r.error ?? "failed"}`);
+      }
     }
-    io2.out(`Faucet drip succeeded: ${chain} \u2192 ${address}`);
     io2.out(renderIdentityLine(identity));
     io2.out("Re-check with `rig balance` (a drip can take a few blocks to land).");
-    return 0;
+    return allFunded ? 0 : 1;
   } catch (err) {
     return emitCliError(io2, json, "fund", err);
   }
@@ -4093,6 +4243,82 @@ async function defaultReadSecretLine(prompt, isInteractive) {
 // src/cli/init.ts
 import { basename as basename2 } from "path";
 import { parseArgs as parseArgs11 } from "util";
+
+// src/cli/git-author.ts
+var PROFILE_KIND = 0;
+var DEFAULT_PROFILE_TIMEOUT_MS = 3e3;
+var PROFILE_TIMEOUT_ENV = "RIG_PROFILE_TIMEOUT_MS";
+function isWebSocketRelay(url) {
+  return /^wss?:\/\//i.test(url);
+}
+function displayNameFromKind0(content) {
+  let parsed;
+  try {
+    parsed = JSON.parse(content);
+  } catch {
+    return void 0;
+  }
+  if (typeof parsed !== "object" || parsed === null) return void 0;
+  const fields = parsed;
+  for (const key of ["display_name", "name"]) {
+    const value = fields[key];
+    if (typeof value === "string" && value.trim() !== "") return value.trim();
+  }
+  return void 0;
+}
+async function resolveGitAuthor(options) {
+  const npub = hexToNpub(options.pubkey);
+  const email = `${npub}@nostr`;
+  const fallback = { name: npub, email, npub, source: "npub" };
+  const { relayUrl } = options;
+  if (relayUrl === void 0 || !isWebSocketRelay(relayUrl)) {
+    return fallback;
+  }
+  const query = options.queryRelayImpl ?? queryRelay;
+  const timeoutMs = options.timeoutMs ?? DEFAULT_PROFILE_TIMEOUT_MS;
+  const factory = options.webSocketFactory ?? defaultWebSocketFactory2;
+  try {
+    const events = await query(
+      relayUrl,
+      { kinds: [PROFILE_KIND], authors: [options.pubkey], limit: 20 },
+      timeoutMs,
+      factory
+    );
+    let latest;
+    for (const event of events) {
+      if (event.kind !== PROFILE_KIND) continue;
+      if (event.pubkey !== options.pubkey) continue;
+      if (!latest || event.created_at > latest.created_at) {
+        latest = { created_at: event.created_at, content: event.content };
+      }
+    }
+    if (latest) {
+      const name = displayNameFromKind0(latest.content);
+      if (name !== void 0) {
+        return { name, email, npub, source: "profile" };
+      }
+    }
+  } catch {
+  }
+  return fallback;
+}
+function profileTimeoutFromEnv(env) {
+  const raw = env[PROFILE_TIMEOUT_ENV]?.trim();
+  if (!raw) return void 0;
+  const ms = Number.parseInt(raw, 10);
+  return Number.isFinite(ms) && ms > 0 ? ms : void 0;
+}
+function defaultWebSocketFactory2(url) {
+  const ctor = globalThis.WebSocket;
+  if (!ctor) {
+    throw new Error(
+      "No global WebSocket constructor (Node >= 22 required) for the kind:0 read"
+    );
+  }
+  return new ctor(url);
+}
+
+// src/cli/init.ts
 var INIT_USAGE = `Usage: rig init [options]
 
 Set up the current git repository for rig (one-shot, idempotent, free):
@@ -4101,19 +4327,35 @@ keystore/config), then writes toon.repoid and toon.owner to the repo's
 LOCAL git config. Re-running updates and reports; it never errors on an
 already-initialized repo. The seed phrase is never written anywhere.
 
+It also sets the repo's LOCAL git commit-author from your nostr identity
+(never --global) so \`rig commit\`/\`git commit\` work out of the box and every
+commit is attributed to the signer: user.email = <npub>@nostr, user.name =
+your kind:0 profile display name when published (read best-effort from a
+relay, latest-wins) else the npub. Re-running refreshes the name from a
+now-readable profile.
+
 The follow-up step is adding a relay: \`rig remote add origin <relay-url>\`
 (a real git remote \u2014 \`git remote -v\` shows it). A deprecated v0.1
 \`git config toon.relay\` is migrated to the origin remote automatically
 when no origin exists (the old key stays readable and is removed in v0.3).
 
-When NO identity resolves, init does not dead-end: in a terminal it offers to
-generate one (\`Create a new identity now? [y/N]\`), and \`--generate-identity\`
-does it non-interactively (equivalent to \`rig identity create\` \u2014 the phrase
-is shown once to back up). Nothing is ever auto-generated without your yes.
+When the directory is NOT inside a git repository, init does not dead-end: in
+a terminal it offers to create one (\`Initialize a git repository here?
+[y/N]\`), and \`--git-init\` does it non-interactively. Likewise, when NO
+identity resolves it offers to generate one (\`Create a new identity now?
+[y/N]\`), and \`--generate-identity\` does it non-interactively (equivalent to
+\`rig identity create\` \u2014 the phrase is shown once to back up). Nothing \u2014 repo
+or identity \u2014 is ever created without your yes. \`--git-init
+--generate-identity\` is a fully non-interactive fresh setup.
 
 Options:
   --repo-id <id>       repository id / NIP-34 d-tag (default: the existing
                        toon.repoid, then the repo directory basename)
+  --git-init           when the cwd is not a git repo, run \`git init\` here
+                       first, then proceed (no prompt)
+  --relay <url>        relay to read your kind:0 profile from for the git
+                       author name (default: origin/toon.relay, then the
+                       genesis seed; skipped if none is resolvable)
   --generate-identity  when no identity resolves, mint a fresh one (no prompt)
   --json               machine-readable report
   -h, --help           show this help`;
@@ -4122,6 +4364,8 @@ function parseInitArgs(args) {
     args,
     options: {
       "repo-id": { type: "string" },
+      "git-init": { type: "boolean", default: false },
+      relay: { type: "string" },
       "generate-identity": { type: "boolean", default: false },
       json: { type: "boolean", default: false },
       help: { type: "boolean", short: "h", default: false }
@@ -4132,6 +4376,7 @@ function parseInitArgs(args) {
     throw new Error(`rig init takes no positional arguments`);
   }
   const flags = {
+    gitInit: values["git-init"] ?? false,
     generateIdentity: values["generate-identity"] ?? false,
     json: values.json ?? false,
     help: values.help ?? false
@@ -4141,8 +4386,46 @@ function parseInitArgs(args) {
     if (repoId.trim() === "") throw new Error("--repo-id must not be empty");
     flags.repoId = repoId;
   }
+  const relay = values.relay;
+  if (relay !== void 0) {
+    if (relay.trim() === "") throw new Error("--relay must not be empty");
+    flags.relay = relay.trim();
+  }
   return flags;
 }
+function isWebSocketRelay2(url) {
+  return /^wss?:\/\//i.test(url);
+}
+async function resolveProfileRelay(flagRelay, originRelay, toonRelays) {
+  const candidates = [
+    flagRelay,
+    originRelay,
+    ...toonRelays
+  ].filter((u) => u !== void 0 && isWebSocketRelay2(u));
+  if (candidates[0] !== void 0) return candidates[0];
+  try {
+    const { loadGenesisSeed } = await import("../network-bootstrap-WNSHRC5P.js");
+    const seed = loadGenesisSeed();
+    if (seed?.relayUrl && isWebSocketRelay2(seed.relayUrl)) return seed.relayUrl;
+  } catch {
+  }
+  return void 0;
+}
+async function resolveOrInitGitRepo(deps, flags) {
+  const { io: io2 } = deps;
+  try {
+    return { repoRoot: await resolveRepoRoot(deps.cwd), initialized: false };
+  } catch {
+    let doInit = flags.gitInit;
+    if (!doInit && io2.isInteractive && !flags.json) {
+      io2.err("Not a git repository \u2014 rig keeps its config and objects in one.");
+      doInit = await io2.confirm("Initialize a git repository here? [y/N] ");
+    }
+    if (!doInit) throw new NotAGitRepositoryError(deps.cwd);
+    await initGitRepository(deps.cwd);
+    return { repoRoot: await resolveRepoRoot(deps.cwd), initialized: true };
+  }
+}
 async function resolveOrGenerateIdentity(deps, flags) {
   const { io: io2, env } = deps;
   const resolve2 = deps.resolveIdentityImpl ?? resolveIdentity;
@@ -4188,12 +4471,7 @@ async function runInit(args, deps) {
     return 0;
   }
   try {
-    let repoRoot;
-    try {
-      repoRoot = await resolveRepoRoot(deps.cwd);
-    } catch {
-      throw new NotAGitRepositoryError(deps.cwd);
-    }
+    const { repoRoot, initialized: initializedGitRepo } = await resolveOrInitGitRepo(deps, flags);
     const { identity, generated } = await resolveOrGenerateIdentity(deps, flags);
     const existing = await readToonConfig(repoRoot);
     const repoId = flags.repoId ?? existing.repoId ?? basename2(repoRoot);
@@ -4212,10 +4490,26 @@ async function runInit(args, deps) {
     }
     const origin = remotes.find((r) => r.name === "origin");
     const originRelay = origin !== void 0 && origin.urls.length === 1 && isRelayUrl(origin.urls[0]) ? origin.urls[0] : void 0;
+    const profileRelay = await resolveProfileRelay(
+      flags.relay,
+      originRelay,
+      existing.relays
+    );
+    const resolveAuthor = deps.resolveGitAuthorImpl ?? resolveGitAuthor;
+    const gitAuthor = await resolveAuthor({
+      pubkey: identity.pubkey,
+      relayUrl: profileRelay,
+      ...profileTimeoutFromEnv(deps.env) !== void 0 ? { timeoutMs: profileTimeoutFromEnv(deps.env) } : {}
+    });
+    await setGitAuthor(repoRoot, {
+      name: gitAuthor.name,
+      email: gitAuthor.email
+    });
     if (flags.json) {
       const output = {
         command: "init",
         repoRoot,
+        initializedGitRepo,
         repoId,
         owner: identity.pubkey,
         identity: {
@@ -4228,6 +4522,11 @@ async function runInit(args, deps) {
         remotes,
         origin: originRelay ?? null,
         migratedToonRelay,
+        gitAuthor: {
+          name: gitAuthor.name,
+          email: gitAuthor.email,
+          source: gitAuthor.source
+        },
         changed,
         ...generated ? {
           generatedIdentity: {
@@ -4251,6 +4550,7 @@ async function runInit(args, deps) {
       for (const line of createdIdentityBanner(generated)) io2.out(line);
       if (generated.shadowedBy) io2.err(shadowNote(generated.shadowedBy));
     }
+    if (initializedGitRepo) io2.out(`Created a git repository at ${repoRoot}`);
     io2.out(`Initialized rig for ${repoRoot}`);
     io2.out(renderIdentityLine(identity));
     io2.out(
@@ -4259,6 +4559,9 @@ async function runInit(args, deps) {
     io2.out(
       `  toon.owner  = ${identity.pubkey}` + (changed.owner ? "" : " (unchanged)") + (existing.owner && changed.owner ? ` (was ${existing.owner})` : "")
     );
+    io2.out(
+      `Git author: ${gitAuthor.name} <${gitAuthor.email}> (from ${gitAuthor.source === "profile" ? "nostr profile" : "npub"})`
+    );
     if (originRelay !== void 0) {
       io2.out(
         `  origin      = ${originRelay}` + (migratedToonRelay ? " (migrated from git config toon.relay)" : "")