shinjuku-shield 0.3.102 → 0.3.103

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.102. The npm packages `shinjuku-shield` and
+This is version 0.3.103. The npm packages `shinjuku-shield` and
 `shinjuku-shielded` hold the same files. The command is `shinjuku`.
 
 ## Set up
 
 ```sh
-npx -y --no-audit --no-fund shinjuku-shield@0.3.102 setup
+npx -y --no-audit --no-fund shinjuku-shield@0.3.103 setup
 ```
 
 Setup makes the wallet on this machine, a private passphrase file, and the
@@ -24,7 +24,7 @@ server to that host's config.
 ## The `shinjuku` command
 
 ```sh
-npm install -g --no-audit --no-fund shinjuku@0.3.102
+npm install -g --no-audit --no-fund shinjuku@0.3.103
 shinjuku help
 ```
 
@@ -36,13 +36,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.102 mcp
+claude mcp add --scope user shinjuku -- npx -y --no-audit --no-fund shinjuku-shield@0.3.103 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.102", "mcp"] } } }
+{ "mcpServers": { "shinjuku": { "command": "npx", "args": ["-y", "--no-audit", "--no-fund", "shinjuku-shield@0.3.103", "mcp"] } } }
 ```
 
 On native Windows, if the host cannot find `npx`, use `"command": "cmd"` and

package/manifest.json

@@ -1,9 +1,9 @@
 {
   "schema": "carbon-shielded-wallet/bundle-manifest/v1",
   "file": "shinjuku-wallet.mjs",
-  "sha256": "3a9841626e4a97d756f610278b4e03f2571b556a7b06207c418a850b2b5200bf",
-  "bytes": 12797194,
-  "sourceCommit": "ca9b414196f12b2512f5457cb0160b58c8a36b25",
+  "sha256": "b5da74cb566cf4df5a7381cbb3eb28797aff16377f170472b6fcefce230db2a2",
+  "bytes": 12800520,
+  "sourceCommit": "b5ed9d0ff1a26115297f6e4dc56473ca9b053446",
   "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",
@@ -1297,5 +1297,5 @@
       "version": "1.8.0"
     }
   ],
-  "publishedAt": "2026-10-24T14:57:43.313Z"
+  "publishedAt": "2026-10-24T16:04:06.349Z"
 }

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "shinjuku-shield",
-  "version": "0.3.102",
+  "version": "0.3.103",
   "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": "3a984162",
-  "shinjukuSha256": "3a9841626e4a97d756f610278b4e03f2571b556a7b06207c418a850b2b5200bf",
+  "shinjukuRelease": "b5da74cb",
+  "shinjukuSha256": "b5da74cb566cf4df5a7381cbb3eb28797aff16377f170472b6fcefce230db2a2",
   "license": "SEE LICENSE IN LICENSE.txt",
   "author": "Shinjuku Shielded",
   "homepage": "https://github.com/ShinjukuStaition/shinjuku-shield#readme",

package/shinjuku-wallet.mjs

@@ -50123,6 +50123,7 @@ function whenRequestsSent(match, { count: count2 = 1, maxMs = 40, settled } = {}
       }
     }
     timer = setTimeout(() => done(false), maxMs);
+    timer.unref?.();
     sent.subscribe(onSent);
     failed.subscribe(onFailed);
     settled?.then(() => done(false), () => done(false));
@@ -96324,8 +96325,12 @@ function returnArrivedFloatRefundBudgets(store, snapshot) {
   for (const name of store.listWal()) {
     if (!name.startsWith(FLOAT_PAYMENT_WAL_PREFIX)) continue;
     const record = store.readWal(name);
-    if (record?.schema !== FLOAT_PAYMENT_SCHEMA) continue;
-    if (record.state !== "refund_pending" || typeof record.innerRequestId !== "string") continue;
+    if (record?.schema !== FLOAT_PAYMENT_SCHEMA || typeof record.innerRequestId !== "string") continue;
+    if (record.state === "submitted") {
+      if (refundArrived(snapshot, record.refundTo)) releaseRefundedReservation({ store, requestId: record.innerRequestId });
+      continue;
+    }
+    if (record.state !== "refund_pending") continue;
     const arrivedNow = refundArrived(snapshot, record.refundTo);
     if (arrivedNow) releaseRefundedReservation({ store, requestId: record.innerRequestId });
     const outcome = arrivedNow ? "refund_arrived" : record.refundOutcome === void 0 && refundCountStopped(record, refreshedAtMs, knowsRecipients) ? "refund_not_seen" : void 0;
@@ -105409,6 +105414,16 @@ function lazyProofEntry(store, name) {
     return String(read()?.state);
   } };
 }
+function floatRefundNoteHeld(snapshot, refundTo) {
+  const outputs = Array.isArray(snapshot?.outputs) ? snapshot.outputs : [];
+  let address5;
+  try {
+    address5 = decodeShieldedSolanaP03Address(String(refundTo));
+  } catch {
+    return false;
+  }
+  return outputs.some((output2) => output2?.kind === "note" && output2.diversifier === address5.diversifier.toString() && output2.recipientX === address5.recipientX.toString());
+}
 function classify(name, record) {
   const state = String(record?.state);
   if (name.startsWith("deposit-") && record?.schema === DEPOSIT_WAL_SCHEMA) {
@@ -105481,8 +105496,10 @@ function computeBalance({ store, snapshotRead, source = "local", now = Date.now(
     ...entry.record.relay?.approvedOnChain ? { approvalStanding: true } : {}
   }));
   const receipts = records.filter((entry) => entry.type === "payment" && entry.phase === "done");
-  const refunded = new Set(records.filter((entry) => entry.type === "float-payment" && entry.state === "refund_pending").map((entry) => entry.record.innerRequestId).filter((id) => typeof id === "string"));
-  const paid = receipts.filter((entry) => !String(entry.record.url ?? "").startsWith(SELF_PAY_ORIGIN2) && !String(entry.record.url ?? "").includes(POOL_MOVE_PATH2) && !refunded.has(entry.record.requestId));
+  const refunded = new Set(records.filter((entry) => entry.type === "float-payment" && (entry.state === "refund_pending" || entry.state === "submitted" && floatRefundNoteHeld(snapshotRead?.snapshot, entry.record.refundTo))).map((entry) => entry.record.innerRequestId).filter((id) => typeof id === "string"));
+  const sellerReceipts = receipts.filter((entry) => !String(entry.record.url ?? "").startsWith(SELF_PAY_ORIGIN2) && !String(entry.record.url ?? "").includes(POOL_MOVE_PATH2));
+  const paid = sellerReceipts.filter((entry) => !refunded.has(entry.record.requestId));
+  const refundedPaid = sellerReceipts.filter((entry) => refunded.has(entry.record.requestId));
   const sum2 = (values) => values.reduce((total, value) => total + BigInt(value ?? "0"), 0n);
   const config = state.config ?? {};
   const capOrNone = (value) => String(value) === NO_LIMIT_ATOMIC2 ? "none" : value;
@@ -105506,6 +105523,8 @@ function computeBalance({ store, snapshotRead, source = "local", now = Date.now(
     pendingDeposits,
     paidAtomic: sum2(paid.map((entry) => paymentAmount(entry.record))).toString(),
     paidReceipts: paid.length,
+    refundedAtomic: sum2(refundedPaid.map((entry) => paymentAmount(entry.record))).toString(),
+    refundedPayments: refundedPaid.length,
     unshieldedAtomic: sum2(records.filter((entry) => entry.type === "unshield" && entry.phase === "done" && !entry.name.startsWith(POCKET_FILL_RECORD) && !entry.name.startsWith(MERGE_RECORD)).map((entry) => entry.record.amountAtomic)).toString(),
     ...budget ? { budget } : {},
     lastRefresh: null
@@ -105833,6 +105852,7 @@ var init_balance = __esm({
     init_config();
     init_commandName();
     init_requestId();
+    init_ShieldedSolanaP03QuoteCrypto();
     PAY_ME_WAL_SCHEMA = "carbon-shielded-wallet/pay-me/v1";
     BALANCE_SNAPSHOT_SCHEMA = "carbon-shielded-wallet/balance-snapshot/v1";
     BALANCE_SNAPSHOT_FILE = "balance-snapshot.json";
@@ -128665,7 +128685,9 @@ ${canonical5}`;
       const sellerTransaction = view2.sellerTransaction ?? knownSellerTransfer(record) ?? (SIGNATURE_TEXT.test(String(read ?? "")) ? read : null);
       row(name.slice(FLOAT_PAYMENT_WAL_PREFIX.length), record, { ...view2, sellerTransaction }, {
         scheme: "exact",
-        ...sellerTransaction === null ? { note: "the seller served this request, so it was paid and no refund comes; it sent no transfer signature, and Shinjuku has not reported the landed transfer yet (a later wallet_receipts shows it)" } : {}
+        // RC1 (mcp56 pass of 0.3.102, hypernatt): this said "a later wallet_receipts shows it", but Shinjuku drops a final
+        // row's link fields, landedTransaction too (float.mjs retain, owner decision 4), about 1 s after the settle.
+        ...sellerTransaction === null ? { note: "the seller served this request, so it was paid and no refund comes; the seller sent no transfer signature, and Shinjuku keeps no link between this payment and its transfer once the payment is final, so this receipt has no seller transaction to show" } : {}
       });
     }
     for (const name of names) {
@@ -134319,7 +134341,7 @@ var init_tools = __esm({
     capRaiseText = (flag3) => {
       if (capFlagFromLaunchLine(flag3)) {
         const both = flag3 === "--max-payment" ? " (raise the 24-hour payment limit there too when it is below the new amount: the wallet does not start with it lower)" : "";
-        return `The ${capName(flag3)} is set in this app's wallet entry; only the user (your owner) can change it there${both}, with amounts in USDC like 0.5, then reconnect the wallet (restart the agent host). Where the entry is: Claude Desktop: claude_desktop_config.json; Cursor: ~/.cursor/mcp.json; Claude Code: claude mcp get shinjuku-shielded shows the entry, then claude mcp remove shinjuku-shielded and claude mcp add it again with the new value; Hermes: config.yaml. Running setup does not change this limit: the value in the entry wins over the limit setup records.`;
+        return `The ${capName(flag3)} is set in this app's wallet entry; only the user (your owner) can change it there${both}, with amounts in USDC like 0.5, then reconnect the wallet (restart the agent host). Where the entry is: Claude Desktop: claude_desktop_config.json; Cursor: ~/.cursor/mcp.json; Claude Code: claude mcp get ${MCP_SERVER_NAME} shows the entry (an entry added by hand can have another name: claude mcp list shows it), then claude mcp remove ${MCP_SERVER_NAME} and claude mcp add it again with the new value; Hermes: config.yaml. Running setup does not change this limit: the value in the entry wins over the limit setup records.`;
       }
       return `The ${capName(flag3)} comes from the wallet's settings. To change it, the user runs ${terminalCommand2("limits")} in a terminal: it asks each limit as a question (amounts in USDC like 0.5, or Enter for no limit). Then the user restarts the agent host.`;
     };
@@ -136052,6 +136074,7 @@ __export(chat_exports, {
   DEFAULT_MODEL: () => DEFAULT_MODEL2,
   chatCaps: () => chatCaps,
   hideProgressLines: () => hideProgressLines,
+  holdProgressLines: () => holdProgressLines,
   isProgressLine: () => isProgressLine,
   knownPrivateBalance: () => knownPrivateBalance,
   leastAnswerAtomic: () => leastAnswerAtomic,
@@ -136151,6 +136174,33 @@ function hideProgressLines(stream = process.stderr) {
     stream.write = original;
   };
 }
+function holdProgressLines(stream = process.stderr) {
+  const original = stream.write;
+  const held = [];
+  stream.write = function write(chunk, encoding, callback) {
+    const text3 = typeof chunk === "string" ? chunk : Buffer.from(chunk).toString(typeof encoding === "string" ? encoding : "utf8");
+    let passed = "";
+    let kept2 = 0;
+    for (const line of text3.split(/(?<=\n)/)) {
+      if (line.endsWith("\n") && PROGRESS_LINE.test(line)) {
+        held.push(line);
+        kept2 += 1;
+      } else passed += line;
+    }
+    if (kept2 === 0) return original.call(stream, chunk, encoding, callback);
+    const done = typeof encoding === "function" ? encoding : callback;
+    if (passed) return original.call(stream, passed, done);
+    if (typeof done === "function") done();
+    return true;
+  };
+  let released = false;
+  return () => {
+    if (released) return;
+    released = true;
+    stream.write = original;
+    if (held.length) original.call(stream, held.join(""));
+  };
+}
 function errorCodeOf(error) {
   if (error?.name === "InferenceError" && typeof error.code === "string") return error.code;
   if (error?.name === "SpendRefusalError" && typeof error.error === "string") return error.error;
@@ -162559,7 +162609,7 @@ async function runCurl(values, deps) {
 ${CURL_USEPOD_NEXT}`, { cause: error });
       else throw curlFailure(error);
     } finally {
-      await session.close();
+      await closeTimed(session, "curl-price");
     }
   }
   if (response) return curlOutput(response, values, deps, probeId);
@@ -162597,10 +162647,31 @@ ${CURL_USEPOD_NEXT}`, { cause: error });
       }
       throw curlFailure(error);
     }
+    sessionMark(session)("curl-paid-returned");
+    return await curlOutput(response, values, deps, requestId);
   } finally {
-    await session.close();
+    await closeTimed(session, "curl");
+  }
+}
+function sessionMark(session) {
+  let mark = () => {
+  };
+  try {
+    if (typeof session.timing === "function") mark = session.timing();
+  } catch {
   }
-  return curlOutput(response, values, deps, requestId);
+  return (phase) => {
+    try {
+      mark(phase);
+    } catch {
+    }
+  };
+}
+async function closeTimed(session, what) {
+  const mark = sessionMark(session);
+  mark(`${what}-close-start`);
+  await session.close();
+  mark(`${what}-closed`);
 }
 async function curlOutput(response, values, deps, requestId) {
   const io = deps.io;
@@ -162823,11 +162894,19 @@ async function runInfer(values, deps) {
     }
   } catch (error) {
     if (quiet && !given && !NOTHING_PAID_TEXT.test(String(error?.message ?? ""))) values.set(INFER_STOPPED_ID, requestId);
+    stopWatch();
+    await closeTimed(session, "infer");
     throw error;
+  }
+  stopWatch();
+  try {
+    sessionMark(session)("infer-paid-returned");
+    inferOutput(result, { values, io, model, quiet, requestId });
   } finally {
-    stopWatch();
-    await session.close();
+    await closeTimed(session, "infer");
   }
+}
+function inferOutput(result, { values, io, model, quiet, requestId }) {
   const paid = String(result.paidAtomic ?? "?");
   const paidText = usdcOr(result.paidAtomic);
   const stopped = result.finishReason === "length" ? " (the answer stopped at --max-tokens)" : "";
@@ -167901,6 +167980,7 @@ function defaultDependencies() {
      * what happened. Ctrl-C, or an input that ends, now stops the command with QuestionCancelled (one plain line).
      */
     ask: (question) => new Promise((resolveAnswer, rejectAnswer) => {
+      const releaseProgress = holdProgressLines(process.stderr);
       const prompt = createInterface2({ input: process.stdin, output: process.stderr, terminal: true });
       let answered2 = false;
       let interrupted = false;
@@ -167910,6 +167990,7 @@ function defaultDependencies() {
         prompt.close();
       });
       prompt.on("close", () => {
+        releaseProgress();
         if (!answered2) rejectAnswer(new QuestionCancelled(interrupted));
       });
       prompt.question(question, (answer) => {