@toon-protocol/client-mcp 0.18.0 → 0.19.0

package/README.md

@@ -288,11 +288,11 @@ The integration suite lives in `src/__integration__/`.
 
 ## Publishing
 
-This package is **published to npm automatically by CI/CD**, in lockstep with the
-repo's release tag (the same `vX.Y.Z` semantic-release cuts for
-`@toon-protocol/relay`). On a release, `publish-relay-images.yml` builds
-this package, sets its version to the tag, and runs
-`pnpm --filter @toon-protocol/client-mcp publish --access public`.
+This package is **published to npm automatically by CI/CD** via
+[changesets](https://github.com/changesets/changesets): `.github/workflows/release.yml`
+runs `pnpm changeset publish` on every push to `main`, using the org `NPM_TOKEN`
+secret. It ships whenever a changeset targeting it lands — independently of any
+other repo's release cadence. Never run `npm publish` manually.
 
 It is **self-contained**: its `@toon-protocol/*` workspace deps (`client`, `core`)
 are **bundled into `dist`** at build time (tsup `noExternal`), so the published
@@ -302,5 +302,3 @@ packages (`fastify`, `@modelcontextprotocol/sdk`, `nostr-tools`, `viem`, `ws`,
 `@solana/web3.js`) installed only when you use those chains.
 A guard test (`src/package-structure.test.ts`) fails the build if a
 `@toon-protocol/*` runtime dep ever leaks in.
-
-To publish manually: `pnpm --filter @toon-protocol/client-mcp build && pnpm --filter @toon-protocol/client-mcp publish --access public`.

package/dist/{chunk-56TTQYS7.js → chunk-3PGURFAM.js}

@@ -2,7 +2,7 @@ import { createRequire as __cr } from 'module'; const require = __cr(import.meta
 import {
   ControlApiError,
   DaemonUnreachableError
-} from "./chunk-LSPAGZXL.js";
+} from "./chunk-OGMD7Z2F.js";
 
 // ../views/dist/tool-names.js
 var PUBLISH_TOOL = "toon_publish_unsigned";
@@ -1870,4 +1870,4 @@ export {
   TOOL_DEFINITIONS,
   dispatchTool
 };
-//# sourceMappingURL=chunk-56TTQYS7.js.map
+//# sourceMappingURL=chunk-3PGURFAM.js.map

package/dist/{chunk-FXPDLGDN.js → chunk-ITONR5ML.js}

@@ -3,6 +3,7 @@ import {
   AdaptiveDeltaController,
   DEFAULT_KEYSTORE_PASSWORD,
   ILP_PEER_INFO_KIND,
+  InMemoryPreimageRetentionStore,
   InMemoryReceivedClaimStore,
   JsonFileReceivedClaimStore,
   JsonFileSwapControllerStateStore,
@@ -15,14 +16,14 @@ import {
   extractArweaveTxId,
   fundWallet,
   generateKeystore,
-  ingestReceivedClaims,
+  ingestAndReveal,
   isEventExpired,
   loadMinaSignerClient,
   mintExecutionCondition,
   parseIlpPeerInfo,
   readConfigFile,
   streamSwap
-} from "./chunk-LSPAGZXL.js";
+} from "./chunk-OGMD7Z2F.js";
 
 // src/daemon/first-run.ts
 import { existsSync, mkdirSync, writeFileSync } from "fs";
@@ -835,7 +836,7 @@ async function fetchRemoteState(options) {
   };
 }
 
-// ../rig/dist/chunk-NIRC5LFS.js
+// ../rig/dist/chunk-PG5PUKDR.js
 import { execFile, spawn } from "child_process";
 import { promisify } from "util";
 import { execFile as execFile2, spawn as spawn2 } from "child_process";
@@ -1033,6 +1034,42 @@ var GitRepoReader = class {
     }
     return objects;
   }
+  /**
+   * List every blob (file) reachable from a ref's root tree, recursively,
+   * with the path it is served at (#368: the ar.io site manifest join key).
+   * Uses `git ls-tree -r -z` — NUL-terminated records so binary/spaced paths
+   * survive verbatim, and no path quoting to undo. Submodule (`commit`)
+   * gitlink entries and directories are excluded; only real file blobs remain.
+   */
+  async listBlobs(rev) {
+    assertRevision(rev, "ref");
+    const { stdout } = await this.git(["ls-tree", "-r", "-z", rev, "--"]);
+    const blobs = [];
+    for (const record of stdout.split("\0")) {
+      if (!record) continue;
+      const tab = record.indexOf("	");
+      if (tab === -1) {
+        throw new GitError(
+          `unexpected ls-tree record: ${JSON.stringify(record)}`,
+          void 0,
+          ""
+        );
+      }
+      const meta = record.slice(0, tab);
+      const path = record.slice(tab + 1);
+      const [, type, sha] = meta.split(" ");
+      if (type !== "blob") continue;
+      if (!sha || !FULL_SHA_RE.test(sha)) {
+        throw new GitError(
+          `unexpected ls-tree object id: ${JSON.stringify(record)}`,
+          void 0,
+          ""
+        );
+      }
+      blobs.push({ path, sha });
+    }
+    return blobs;
+  }
   /** Run git feeding `input` on stdin; resolves collected stdout bytes. */
   runWithStdin(args, input) {
     return new Promise((resolve2, reject) => {
@@ -1432,7 +1469,10 @@ async function executePush(options) {
         sha: object.sha,
         type: object.type,
         body,
-        repoId: plan.repoId
+        repoId: plan.repoId,
+        // #368: the path the blob was reached by drives its Content-Type; a
+        // non-blob object (no path) uploads as octet-stream.
+        ...object.path ? { path: object.path } : {}
       });
       merged.set(object.sha, receipt.txId);
       totalFeePaid += receipt.feePaid;
@@ -2695,7 +2735,8 @@ var ClientRunner = class {
       }
     };
     const senderSecretKey = generateSecretKey();
-    const swapClient = req.senderConditions ? this.withSenderConditions(apex.client) : apex.client;
+    const preimages = new InMemoryPreimageRetentionStore();
+    const swapClient = req.senderConditions ? this.withSenderConditions(apex.client, preimages) : apex.client;
     const result = await streamSwap({
       client: swapClient,
       swapPubkey: req.swapPubkey,
@@ -2714,15 +2755,19 @@ var ClientRunner = class {
     const firstReject = result.rejections[0];
     const expectedChain = req.pair.to.chain;
     const minaSignerClient = expectedChain.startsWith("mina") ? await loadMinaSignerClient() : void 0;
-    const ingest = ingestReceivedClaims({
+    const reveal = () => ({ decision: "revealed" });
+    const ingest = await ingestAndReveal({
       claims: result.claims,
       expectedChain,
       chainRecipient: req.chainRecipient,
       ...req.swapSignerAddress ? { expectedSignerAddress: req.swapSignerAddress } : {},
       store: this.receivedClaimStore,
-      ...minaSignerClient ? { minaSignerClient } : {}
+      ...minaSignerClient ? { minaSignerClient } : {},
+      preimages,
+      reveal
     });
-    const verifiedSet = new Set(ingest.verified.map((v) => v.claim));
+    preimages.clear();
+    const verifiedSet = new Set(ingest.revealed.map((v) => v.claim));
     const rejectionByClaim = new Map(
       ingest.rejected.map((r) => [r.claim, r])
     );
@@ -2776,12 +2821,13 @@ var ClientRunner = class {
         `${ingest.rejected.length} received claim(s) FAILED verification and were NOT counted as value received (first: ${firstRejected.code} \u2014 ${firstRejected.message}). See per-claim verificationError.`
       );
     }
-    const hadIngestibleClaims = ingest.verified.length + ingest.rejected.length > 0;
+    const hadIngestibleClaims = ingest.revealed.length + ingest.rejected.length > 0;
     return {
-      // A swap only counts as accepted when it yielded a VERIFIED claim (or a
-      // legacy no-metadata claim, whose path is unchanged). FULFILLed packets
-      // whose claims all failed verification are a failed swap, loudly.
-      accepted: ingest.verified.length + ingest.legacy.length > 0,
+      // A swap only counts as accepted when it yielded a VERIFIED+REVEALED
+      // claim (or a legacy no-metadata claim, whose path is unchanged).
+      // FULFILLed packets whose claims all failed verification are a failed
+      // swap, loudly.
+      accepted: ingest.revealed.length + ingest.legacy.length > 0,
       packetsAccepted: result.claims.length,
       claims,
       cumulativeSource: result.cumulativeSource.toString(),
@@ -2803,9 +2849,9 @@ var ClientRunner = class {
       ...firstReject ? { code: firstReject.code, message: firstReject.message } : {},
       ...warnings.length > 0 ? { warning: warnings.join("\n") } : {},
       ...hadIngestibleClaims ? {
-        claimsVerified: ingest.verified.length,
+        claimsVerified: ingest.revealed.length,
         claimsRejected: ingest.rejected.length,
-        valueReceived: ingest.valueReceived.toString()
+        valueReceived: ingest.valueRevealed.toString()
       } : {}
     };
   }
@@ -2883,16 +2929,56 @@ var ClientRunner = class {
         results.push(base);
         continue;
       }
-      if (bundle.chainKind !== "evm") {
+      if (bundle.chainKind === "solana") {
         results.push({
           ...base,
           error: {
             code: "SUBMISSION_UNSUPPORTED",
-            message: bundle.chainKind === "mina" ? "Mina receive-side redemption needs a co-signed claimFromChannel (signatureA AND signatureB) plus o1js proof generation \u2014 no client co-sign path exists yet. Out of scope for #352; follow-up: toon-client#357." : "Solana settlement submission is not wired yet (bundle carries a serialized Message; follow-up under toon-meta#145)."
+            message: "Solana settlement submission is not wired yet (bundle carries a serialized Message; follow-up under toon-meta#145)."
           }
         });
         continue;
       }
+      if (bundle.chainKind === "mina") {
+        if (!this.identityClient.settleSwapBundle) {
+          results.push({
+            ...base,
+            error: {
+              code: "SUBMISSION_UNAVAILABLE",
+              message: "The active client does not implement settleSwapBundle."
+            }
+          });
+          continue;
+        }
+        try {
+          const submitted = await this.identityClient.settleSwapBundle(bundle);
+          const latest = this.receivedClaimStore.load(entry.chain, entry.channelId) ?? entry;
+          this.receivedClaimStore.save({
+            ...latest,
+            settledAt: Date.now(),
+            settledNonce: BigInt(bundle.nonce),
+            settleTxHash: submitted.txHash
+          });
+          this.log(
+            `[runner] swap settle: submitted ${bundle.chain}/${bundle.channelId} nonce ${bundle.nonce} cumulative ${bundle.cumulativeAmount} \u2192 ${submitted.txHash}`
+          );
+          results.push({
+            ...base,
+            submitted: true,
+            txHash: submitted.txHash,
+            ...submitted.status ? { txStatus: submitted.status } : {}
+          });
+        } catch (err) {
+          results.push({
+            ...base,
+            error: {
+              code: "SUBMISSION_FAILED",
+              message: err instanceof Error ? err.message : String(err)
+            }
+          });
+        }
+        continue;
+      }
       const rpcUrl = this.config.toonClientConfig.chainRpcUrls?.[bundle.chain];
       if (!rpcUrl) {
         results.push({
@@ -2948,20 +3034,30 @@ var ClientRunner = class {
    * Wrap an apex client so each `sendSwapPacket` call carries a freshly
    * minted sender-chosen execution condition (one preimage per packet, spec
    * R1 — reuse would let an observer of packet *i* fulfill packet *i+1*).
-   * `streamSwap` calls `sendSwapPacket` once per packet, so minting here
-   * yields exactly one condition per packet. The transports verify each
-   * FULFILL's preimage against the condition and fail the packet on mismatch.
+   * `streamSwap` calls `sendSwapPacket` once per packet, in strictly
+   * increasing `packetIndex` order, so minting here yields exactly one
+   * condition per packet and the local counter tracks `packetIndex`. The
+   * transports verify each FULFILL's preimage against the condition and fail
+   * the packet on mismatch.
    *
-   * NOTE: the minted preimage is intentionally NOT retained yet — leg-B
-   * receive-side ingestion (where the sender reveals `P_i`) is a separate
-   * rolling-swap workstream (toon-meta docs/rolling-swap.md §3.2). Until a
-   * maker implements the connector#309 contract end-to-end, packets sent with
-   * conditions will fail closed rather than settle unverified.
+   * Preimage retention (toon-client#360, spec §3.2 leg-B reveal): every minted
+   * `P_i` is retained in `preimages`, keyed by `packetIndex` — the identifier
+   * shared with `AccumulatedClaim.packetIndex` — so the receive-side reveal
+   * step (`ingestAndReveal`) can correlate and consume the preimage for the
+   * claim it commits. Retention is session-scoped (one store per `swap()`
+   * call); a fresh stream mints fresh preimages.
    */
-  withSenderConditions(client) {
+  withSenderConditions(client, preimages) {
     const wrapped = Object.create(client);
+    let packetIndex = 0;
     wrapped.sendSwapPacket = (params) => {
-      const { condition } = mintExecutionCondition();
+      const { preimage, condition } = mintExecutionCondition();
+      preimages.retain({
+        packetIndex: packetIndex++,
+        preimage,
+        condition,
+        retainedAt: Date.now()
+      });
       return client.sendSwapPacket({
         ...params,
         executionCondition: condition
@@ -3932,4 +4028,4 @@ export {
   PublishRejectedError,
   registerRoutes
 };
-//# sourceMappingURL=chunk-FXPDLGDN.js.map
+//# sourceMappingURL=chunk-ITONR5ML.js.map