shinjuku-shielded 0.3.175 → 0.3.176

package/README.md

@@ -6,13 +6,13 @@ answers privately, in a terminal chat or for your agent app. Its `mcp`
 command runs a local MCP server (stdio) for your agent. Your keys never
 leave your machine.
 
-This is version 0.3.175. The npm packages `shinjuku-shield` and
+This is version 0.3.176. The npm packages `shinjuku-shield` and
 `shinjuku-shielded` hold the same files. The command is `shinjuku`.
 
 ## Set up
 
 ```sh
-npx -y shinjuku@0.3.175 setup
+npx -y shinjuku@0.3.176 setup
 ```
 
 Setup offers to install the `shinjuku` command and, on Windows, adds npm's
@@ -35,13 +35,13 @@ Every wallet command works after `shinjuku`, for example `shinjuku balance`,
 Claude Code:
 
 ```sh
-claude mcp add --scope user shinjuku -- npx -y --no-audit --no-fund shinjuku-shield@0.3.175 mcp
+claude mcp add --scope user shinjuku -- npx -y --no-audit --no-fund shinjuku-shield@0.3.176 mcp
 ```
 
 Claude Desktop (`claude_desktop_config.json`) or Cursor (`~/.cursor/mcp.json`):
 
 ```json
-{ "mcpServers": { "shinjuku": { "command": "npx", "args": ["-y", "--no-audit", "--no-fund", "shinjuku-shield@0.3.175", "mcp"] } } }
+{ "mcpServers": { "shinjuku": { "command": "npx", "args": ["-y", "--no-audit", "--no-fund", "shinjuku-shield@0.3.176", "mcp"] } } }
 ```
 
 On native Windows, if the host cannot find `npx`, use `"command": "cmd"` and
@@ -54,7 +54,7 @@ Codex (the Codex app and Codex CLI read the same file, `~/.codex/config.toml`):
 ```toml
 [mcp_servers.shinjuku]
 command = "npx"
-args = ["-y", "--no-audit", "--no-fund", "shinjuku-shield@0.3.175", "mcp"]
+args = ["-y", "--no-audit", "--no-fund", "shinjuku-shield@0.3.176", "mcp"]
 startup_timeout_sec = 120
 tool_timeout_sec = 300
 ```

package/manifest.json

@@ -1,9 +1,9 @@
 {
   "schema": "carbon-shielded-wallet/bundle-manifest/v1",
   "file": "shinjuku-wallet.mjs",
-  "sha256": "dd3bab15896a11e725fd452abbfd4fbad9b412640201141c884a77bd6c81d5dd",
-  "bytes": 9395751,
-  "sourceCommit": "9dc2ed8abb49b3cce01ddd09f43128cc0aa5c885",
+  "sha256": "eb8212021af756602a223fcb5e329e0eaf488b7b276850014abef3c6a917eb81",
+  "bytes": 9401666,
+  "sourceCommit": "d6237649219078cad2c31a571967809dc888a3fc",
   "sourceDirty": false,
   "installRecordMatchesLockfile": true,
   "releaseRule": "valid only when two fresh npm ci --ignore-scripts builds on different OSes give the same sha256; installRecordMatchesLockfile true means every entry npm installed equals its package-lock.json entry and every entry not marked optional, devOptional included, is installed: an optional entry (a package for another platform) may be absent",
@@ -1038,5 +1038,5 @@
       "version": "1.8.0"
     }
   ],
-  "publishedAt": "2026-11-05T23:21:41.970Z"
+  "publishedAt": "2026-11-06T00:15:32.603Z"
 }

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "shinjuku-shielded",
-  "version": "0.3.175",
+  "version": "0.3.176",
   "mcpName": "io.github.ShinjukuStaition/shinjuku-mcp",
   "description": "Shinjuku Shielded, the private x402 facilitator on Solana: the self-custody wallet CLI and its MCP server. Shield, pay, and unshield USDC from any MCP agent, under caps you set.",
-  "shinjukuRelease": "dd3bab15",
-  "shinjukuSha256": "dd3bab15896a11e725fd452abbfd4fbad9b412640201141c884a77bd6c81d5dd",
+  "shinjukuRelease": "eb821202",
+  "shinjukuSha256": "eb8212021af756602a223fcb5e329e0eaf488b7b276850014abef3c6a917eb81",
   "license": "SEE LICENSE IN LICENSE.txt",
   "author": "Shinjuku Shielded",
   "homepage": "https://github.com/ShinjukuStaition/shinjuku-shield#readme",

package/shinjuku-wallet.mjs

@@ -137281,8 +137281,29 @@ ${canonical5}`;
       return "not_known";
     }
   }
-  function newestSendCancel() {
-    const found = newestSendJob();
+  function sendTransactionOf(requestId, job = jobs.get(`unshield:${toRecordId(requestId)}`)) {
+    const fromJob = typeof job?.result?.exitTransaction === "string" ? job.result.exitTransaction : void 0;
+    let fromRecord;
+    try {
+      const record = session.openStore().readWal(`self-pay-${moneyId(requestId)}`);
+      fromRecord = typeof record?.exitTransaction === "string" ? record.exitTransaction : void 0;
+    } catch {
+      fromRecord = void 0;
+    }
+    if (fromJob && fromRecord && fromJob !== fromRecord) return { conflict: true };
+    const tx = fromJob ?? fromRecord;
+    return tx ? { tx } : {};
+  }
+  const CANCEL_SEND_WAIT_MS = 15e3;
+  async function newestSendCancel({ signal } = {}) {
+    let found = newestSendJob();
+    if (found?.state === "sending" && !signal?.aborted) {
+      const until = Date.now() + CANCEL_SEND_WAIT_MS;
+      while (found.state === "sending" && !signal?.aborted && Date.now() < until) {
+        await stageOrTimeout(found.job, until - Date.now(), signal);
+        found = { job: found.job, state: sendJobState(found.job) };
+      }
+    }
     const receipts2 = "wallet_receipts (kind moves) shows each send of this wallet and its state";
     if (!found) {
       return refuse12(
@@ -137303,8 +137324,15 @@ ${canonical5}`;
         { ...ids, sendState: "confirming" }
       );
     }
+    const sent = state2 === "sent" || state2 === "sending" ? sendTransactionOf(job.requestId, job) : {};
+    const txFields = sent.tx ? { exitTransaction: sent.tx } : {};
     if (state2 === "sent") {
-      return refuse12("mcp_unshield_cancel_done", `${what} was already sent; nothing was changed`, `Nothing to stop. Tell the user it was sent; ${receipts2}, with its transaction`, { ...ids, sendState: "sent" });
+      return refuse12(
+        "mcp_unshield_cancel_done",
+        `${what} was already sent${sent.tx ? ` (transaction ${sent.tx})` : ""}; nothing was changed`,
+        sent.tx ? `Nothing to stop. Tell the user it was sent, with transaction ${sent.tx}` : `Nothing to stop. Tell the user it was sent; call wallet_receipts (kind moves) for its transaction and give the user that transaction${sent.conflict ? " (the wallet's two records of it disagree, so check wallet_receipts)" : ""}`,
+        { ...ids, sendState: "sent", ...txFields }
+      );
     }
     if (state2 === "ended") {
       return refuse12(
@@ -137324,11 +137352,31 @@ ${canonical5}`;
     }
     return refuse12(
       "mcp_unshield_cancel_sending",
-      `the user confirmed ${what} and it is being sent now; a confirmed send cannot be stopped; nothing was changed`,
-      `Nothing was stopped. Tell the user the send goes on and cannot be cancelled; ${receipts2} (it shows when it lands). Do not call wallet_unshield for it again`,
-      { ...ids, sendState: "sending" }
+      `the user confirmed ${what} and it is being sent now${sent.tx ? ` (transaction ${sent.tx}; the wallet confirms it)` : ""}; a confirmed send cannot be stopped; nothing was changed`,
+      `Nothing was stopped. Tell the user the send goes on and cannot be cancelled${sent.tx ? `, with transaction ${sent.tx}` : ""}. ` + sendRetryNext(job.requestId, sent, { amountAtomic: job.amountAtomic, to: job.to }),
+      { ...ids, sendState: "sending", ...txFields }
     );
   }
+  const sendRetryNext = (requestId, sent = {}, { amountAtomic, to } = {}) => `Then call wallet_unshield with request_id "${requestId}"${amountAtomic ? `, amount_atomic "${amountAtomic}"` : ""}${to ? `, and to "${to}"` : ""} (the same arguments: it reads this same send, finishes it after a restart, never asks again and never sends twice) until it answers done, and give the user its transaction${sent.conflict ? " (the wallet's two records of it disagree now: check wallet_receipts)" : ""}; do not offer the history in place of it. Do not call wallet_cancel with this request_id: for a send in parts that stops its unsent payments`;
+  function stageOrTimeout(job, ms, signal) {
+    return new Promise((resolve43) => {
+      let timer;
+      const done = () => {
+        clearTimeout(timer);
+        job.stageWaiters?.delete(done);
+        signal?.removeEventListener?.("abort", done);
+        resolve43();
+      };
+      if (signal?.aborted) {
+        resolve43();
+        return;
+      }
+      (job.stageWaiters ??= /* @__PURE__ */ new Set()).add(done);
+      signal?.addEventListener?.("abort", done, { once: true });
+      timer = setTimeout(done, Math.max(0, ms));
+      timer.unref?.();
+    });
+  }
   function cancelMatches(store, requestId) {
     const found = [];
     let float;
@@ -137610,7 +137658,7 @@ ${canonical5}`;
   const cancel = {
     name: "wallet_cancel",
     title: "Close or stop one unfinished request",
-    description: `Use this when the user says "stop that send", also after this app stopped a call before its answer (then never say nothing was sent: leave request_id out and this reads the newest send of this session, or says to check wallet_receipts), or wants to stop something unfinished, by its request_id: a payment (pay_for_service or inference_chat) that can no longer settle, so its reserved balance comes back; a private send in smaller payments (an older wallet version started it): its smaller payments not sent yet stop and stay in the balance; a wallet_add_funds address nothing reached: it closes. A single send (one exit, a send of the whole balance too) cannot be stopped: the answer says its state. A private send's stop is written under the wallet lock: when another step of this wallet holds it (one of the smaller payments being sent, a payment), this call waits for that step, up to about ${CALL_BUDGET_MS / 1e3} s. Only an answer with cancelled: true means the stop is saved; an answer with stage cancelling means nothing is stopped yet: call wallet_cancel again. It finds the request by itself; when one request_id names two of these, pass kind. A payment whose bytes never left the wallet closes at once. A sent payment closes only once the chain proves it can never land (usually about two minutes after its quote expired); until then it is refused, because closing earlier could let a retry pay twice. Pays nothing and moves nothing.`,
+    description: `Use this when the user says "stop that send", also after this app stopped a call before its answer (then never say nothing was sent: leave request_id out and this reads the newest send of this session, or says to check wallet_receipts), or wants to stop something unfinished, by its request_id: a payment (pay_for_service or inference_chat) that can no longer settle, so its reserved balance comes back; a private send in smaller payments (an older wallet version started it): its smaller payments not sent yet stop and stay in the balance; a wallet_add_funds address nothing reached: it closes. A single send (one exit, a send of the whole balance too) cannot be stopped: the answer says its state and, once it is out, its transaction (exitTransaction; without request_id it waits up to 15 s for it): give the user that transaction. A private send's stop is written under the wallet lock: when another step of this wallet holds it (one of the smaller payments being sent, a payment), this call waits for that step, up to about ${CALL_BUDGET_MS / 1e3} s. Only an answer with cancelled: true means the stop is saved; an answer with stage cancelling means nothing is stopped yet: call wallet_cancel again. It finds the request by itself; when one request_id names two of these, pass kind. A payment whose bytes never left the wallet closes at once. A sent payment closes only once the chain proves it can never land (usually about two minutes after its quote expired); until then it is refused, because closing earlier could let a retry pay twice. Pays nothing and moves nothing.`,
     inputSchema: {
       type: "object",
       properties: {
@@ -137620,10 +137668,10 @@ ${canonical5}`;
       additionalProperties: false
     },
     annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: true },
-    async run(args, { progress: progress2 } = {}) {
+    async run(args, { progress: progress2, signal } = {}) {
       const startedAt = Date.now();
       const requestId = args?.request_id;
-      if (requestId === void 0 && (args?.kind === void 0 || args.kind === "send")) return cancelWords(newestSendCancel());
+      if (requestId === void 0 && (args?.kind === void 0 || args.kind === "send")) return cancelWords(await newestSendCancel({ signal }));
       if (typeof requestId !== "string" || !REQUEST_ID4.test(requestId)) {
         return refuse12("mcp_argument_invalid", "request_id must be 1-128 characters of A-Z a-z 0-9 . _ : -", "pass the request_id of the payment, send, or address to close");
       }
@@ -138927,6 +138975,7 @@ ${canonical5}`;
     const changed = job.changed;
     job.changed = void 0;
     changed?.resolve();
+    if (job.stageWaiters?.size) for (const wake of [...job.stageWaiters]) wake();
   }
   async function begin(kind, args, { waitMs, ask = true, startedAt = Date.now(), progress: progress2, canProgress = false, signal, rpcId } = {}) {
     const spec = KINDS[kind];
@@ -139992,20 +140041,22 @@ ${canonical5}`;
     const what = `the send of ${usdcText3(record.amountAtomic)} USDC to ${record.mcpTo.slice(0, 4)}...${record.mcpTo.slice(-4)}`;
     const call = `call wallet_unshield with request_id "${requestId}", amount_atomic "${record.amountAtomic}", and to "${record.mcpTo}"`;
     const ask = `${call} to see its progress (it never sends twice)`;
+    const sent = state2 === "sent" || state2 === "sending" ? sendTransactionOf(requestId) : {};
+    const txFields = sent.tx ? { exitTransaction: sent.tx } : {};
     if (state2 === "sent") {
       return refuse12(
         "mcp_unshield_cancel_done",
-        `${what} was already sent; nothing was changed`,
-        `Nothing to stop. Tell the user it was sent; ${call} to read its transaction (exitTransaction; it never sends twice)`,
-        { requestId, sendState: "sent" }
+        `${what} was already sent${sent.tx ? ` (transaction ${sent.tx})` : ""}; nothing was changed`,
+        sent.tx ? `Nothing to stop. Tell the user it was sent, with transaction ${sent.tx}` : `Nothing to stop. Tell the user it was sent; call wallet_receipts (kind moves) for its transaction and give the user that transaction${sent.conflict ? " (the wallet's two records of it disagree, so check wallet_receipts)" : ""}`,
+        { requestId, sendState: "sent", ...txFields }
       );
     }
     const how = sendNowWords(state2, intent);
     return refuse12(
       state2 === "sending" ? "mcp_unshield_cancel_sending" : "mcp_unshield_cancel_single",
-      `${what} ${how}; a send of one exit cannot be stopped; nothing was changed`,
-      `Nothing was stopped. Tell the user ${what} ${how} and cannot be cancelled; ${ask}`,
-      { requestId, sendState: state2 ?? record.state }
+      `${what} ${how}${sent.tx ? ` (transaction ${sent.tx}; the wallet confirms it)` : ""}; a send of one exit cannot be stopped; nothing was changed`,
+      state2 === "sending" ? `Nothing was stopped. Tell the user ${what} ${how} and cannot be cancelled${sent.tx ? `, with transaction ${sent.tx}` : ""}. ${sendRetryNext(requestId, sent, { amountAtomic: record.amountAtomic, to: record.mcpTo })}` : `Nothing was stopped. Tell the user ${what} ${how} and cannot be cancelled; ${ask}`,
+      { requestId, sendState: state2 ?? record.state, ...txFields }
     );
   }
   async function cancelUnshield(args, { startedAt = Date.now(), progress: progress2 } = {}) {
@@ -157972,7 +158023,41 @@ var PROGRESS = /^(downloading the setup files|tor: |history: )/;
 var LABEL = /^ {2}([a-z][a-z -]{1,12}?)( {2,}|(?<=^ {2}.{12}) )(\S.*)$/;
 var COMMAND = /^ {2}(npx |shinjuku |claude |codex |cursor |\$ )/;
 var NEXT = /^(Next|Status|Home|Then): ?(.*)$/;
-function paintSetupLine(line, paint2) {
+var NOT_PROSE = /^\s|[\\/`$]|\s--|\bnpx\b|\biwr\b|\bshinjuku [a-z]/;
+var wrapWidth = (columns) => Number.isSafeInteger(columns) && columns >= 40 ? columns - 1 : void 0;
+function wrapWords(text3, width) {
+  const lines = [];
+  let line = "";
+  for (const word2 of text3.split(" ")) {
+    if (line && `${line} ${word2}`.length > width) {
+      lines.push(line);
+      line = word2;
+    } else line = line ? `${line} ${word2}` : word2;
+  }
+  if (line) lines.push(line);
+  return lines;
+}
+function proseKind(line) {
+  if (NOT_PROSE.test(line)) return void 0;
+  if (DONE.test(line)) return { mark: ["\u25C6 ", "crim"], cls: "verm" };
+  if (FAIL.test(line)) return { mark: ["\u25CB ", "crim"], cls: "crim" };
+  if (WARN.test(line)) return { mark: ["! ", "verm"], cls: "verm" };
+  if (STEP.test(line)) return { mark: ["\u25C6 ", "crim"], cls: "bone" };
+  if (PROGRESS.test(line) || COMMAND.test(line) || LABEL.test(line)) return void 0;
+  if (NEXT.test(line)) return { cls: "bone", next: true };
+  return { cls: "dim" };
+}
+function paintSetupLine(line, paint2, columns) {
+  const width = wrapWidth(columns);
+  const kind = width && line.length > width && !line.includes("\x1B[") ? proseKind(line) : void 0;
+  if (kind) {
+    const indent = kind.mark ? "  " : "";
+    const pieces = wrapWords(line, width - indent.length);
+    if (pieces.length > 1) {
+      const first = kind.mark ? paint2([kind.mark, [pieces[0], kind.cls]]) : kind.next ? paintSetupLine(pieces[0], paint2) : paint2([[pieces[0], kind.cls]]);
+      return [first, ...pieces.slice(1).map((piece) => paint2([[indent, ""], [piece, kind.cls]]))].join("\n");
+    }
+  }
   if (line === "" || line.includes("\x1B[")) return line;
   if (DONE.test(line)) return paint2([["\u25C6 ", "crim"], [line, "verm"]]);
   if (FAIL.test(line)) return paint2([["\u25CB ", "crim"], [line, "crim"]]);
@@ -157990,20 +158075,20 @@ var THEME_CHILD_ENV = "SHINJUKU_WALLET_THEMED";
 function terminalThemeOn({ stdout = process.stdout, env = process.env } = {}) {
   return Boolean(stdout?.isTTY) && (env.CI ?? "") === "" && env.TERM !== "dumb";
 }
-function paintChunk(chunk, paint2) {
+function paintChunk(chunk, paint2, columns) {
   if (typeof chunk !== "string") return chunk;
   const text3 = chunk;
   if (text3.includes("\x1B") || text3.length <= 2 || !/[A-Za-z]/.test(text3)) return chunk;
   return text3.split("\n").map((line) => {
     const [, back, rest] = /^(\r*)([^]*)$/.exec(line);
-    return rest.trim() === "" ? line : `${back}${paintSetupLine(rest, paint2)}`;
+    return rest.trim() === "" ? line : `${back}${paintSetupLine(rest, paint2, back ? void 0 : columns)}`;
   }).join("\n");
 }
 function themeStreams(paint2, streams = [process.stdout, process.stderr]) {
   const undo = streams.map((stream) => {
     const original = stream.write;
     stream.write = function themedWrite(chunk, ...rest) {
-      return original.call(stream, paintChunk(chunk, paint2), ...rest);
+      return original.call(stream, paintChunk(chunk, paint2, stream.isTTY ? stream.columns : void 0), ...rest);
     };
     return () => {
       stream.write = original;
@@ -158030,10 +158115,16 @@ function commandFooter(columns = 80, { stream = process.stdout, env = process.en
 ` : "";
 }
 function themedIo(io, paint2) {
-  const draw = (text3) => String(text3).split("\n").map((line) => paintSetupLine(line, paint2)).join("\n");
-  return { ...io, out: (text3) => io.out(draw(text3)), err: (text3) => io.err(draw(text3)) };
-}
-var themedAsk = (ask, paint2) => (prompt, ...rest) => String(prompt).startsWith("? ") || String(prompt).includes("\x1B[") ? ask(prompt, ...rest) : ask(paint2([["? ", "crim"], [String(prompt), "bone"]]), ...rest);
+  const draw = (text3, stream) => String(text3).split("\n").map((line) => paintSetupLine(line, paint2, stream?.isTTY ? stream.columns : void 0)).join("\n");
+  return { ...io, out: (text3) => io.out(draw(text3, process.stdout)), err: (text3) => io.err(draw(text3, process.stderr)) };
+}
+var themedAsk = (ask, paint2, stream = process.stdout) => (prompt, ...rest) => {
+  const text3 = String(prompt);
+  if (text3.startsWith("? ") || text3.includes("\x1B[")) return ask(prompt, ...rest);
+  const width = stream?.isTTY ? wrapWidth(stream.columns) : void 0;
+  const pieces = width && text3.length + 2 > width && !NOT_PROSE.test(text3) ? wrapWords(text3, width - 2) : [text3];
+  return ask([paint2([["? ", "crim"], [pieces[0], "bone"]]), ...pieces.slice(1).map((piece) => paint2([["  ", ""], [piece, "bone"]]))].join("\n"), ...rest);
+};
 function setupHeader(paint2, columns = 80, title = "set up the wallet") {
   return `\x1B[0m\x1B[2J\x1B[H${commandHeader(columns, title)}
 `;