@cmdoss/suipay-mcp 0.2.2-dev.5 → 0.2.2-dev.6

package/README.md

@@ -51,7 +51,7 @@ missing, expired, or revoked.
 | Tool | Purpose |
 | --- | --- |
 | `discover` | Search live gateway resources. After login: `name`, `path`, `url`, `targetHash`, catalog price, and `affordable` (can this session cover one call — not authorization). `pay({ url })` still settles |
-| `pay` | Fetch resource, prepare `spend_account` settlement, settle when this process holds the grant key |
+| `pay` | Fetch resource, prepare `spend_account` settlement, settle when this process holds the grant key. POST `json` is the paid body. Optional stdio `file` + `fileField` fill one JSON key from a local file as canonical base64 (Walrus `contentBase64`); requires `SUIPAY_MCP_FILE_ROOT`; hosted `/mcp` refuses `file` |
 | `receipts` | List settlement receipts, optionally by challenge ID |
 | `access_context` | Report current session / delegate / policy state (no secret material) |
 | `suipay_login` | Mint or reuse the local delegate key and return a clickable console URL (does not wait for the wallet). Default target is Railway suipay-dev; pass `target: "local"` for the laptop stack |
@@ -76,6 +76,22 @@ json: {"prompt":"a cat"}
 maxAmount: 50000
 ```
 
+To store local bytes (Walrus), do not paste base64. Name the file and field.
+Set `SUIPAY_MCP_FILE_ROOT` to an absolute directory; `file` must resolve inside
+it (unset disables attach). Paths under `~/.suipay` are refused even if that
+directory falls inside the root.
+
+```
+Pay this SuiPay resource with the suipay MCP `pay` tool. Do not write SDK code.
+
+url: https://gateway.example/v1/walrus/store
+method: POST
+json: {"contentType":"text/plain"}
+file: /absolute/path/to/note.txt
+fileField: contentBase64
+maxAmount: 50000
+```
+
 `pay` uses SDK `createPayer` internally. When this process settles, a binary
 body is written once under `~/.suipay/deliveries/` and named first in the
 JSON as `savedTo` (absolute path) and `savedToUrl` (`file://`). Hosted `/mcp`

package/dist/bin/suipay.js

@@ -1,8 +1,8 @@
 #!/usr/bin/env node
 import {
   main
-} from "../chunk-P54ZYBPN.js";
-import "../chunk-THLDEMGS.js";
+} from "../chunk-AEV6Q6JC.js";
+import "../chunk-UTKVBAEZ.js";
 
 // src/bin/suipay.ts
 main().catch((err) => {

package/dist/{chunk-P54ZYBPN.js → chunk-AEV6Q6JC.js}

@@ -4,7 +4,7 @@ import {
   loadLocalSigningKeyRecord,
   loadMcpConfig,
   loadPaymentProfile
-} from "./chunk-THLDEMGS.js";
+} from "./chunk-UTKVBAEZ.js";
 
 // src/index.ts
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
@@ -19,7 +19,7 @@ async function main() {
   const argv = process.argv.slice(2);
   const cfg = loadMcpConfig(process.env, argv);
   const target = cfg.target ?? "dev";
-  const server = createServer(cfg);
+  const server = createServer(cfg, void 0, void 0, { transport: "stdio" });
   await server.connect(new StdioServerTransport());
   try {
     const boundGateway = loadLocalSigningKeyRecord()?.gatewayUrl ?? cfg.gatewayUrl;

package/dist/{chunk-THLDEMGS.js → chunk-UTKVBAEZ.js}

@@ -7002,6 +7002,205 @@ function settlePayResult(result) {
   return error(result);
 }
 
+// src/pay-file.ts
+import { isAbsolute, dirname as dirname3, sep } from "path";
+import {
+  openSync as openSync2,
+  closeSync as closeSync2,
+  fstatSync,
+  readFileSync as readFileSync2,
+  realpathSync,
+  constants
+} from "fs";
+var JSON_WRAP_SLACK_BYTES = 256;
+var MCP_MAX_FILE_FIELD_BYTES = Math.floor(
+  (MAX_PAID_BODY_BYTES - JSON_WRAP_SLACK_BYTES) * 3 / 4
+);
+var FIELD = /^[A-Za-z][A-Za-z0-9_]{0,63}$/;
+var FORBIDDEN = /* @__PURE__ */ new Set(["constructor", "prototype"]);
+function fail2(code, detail) {
+  return { code, detail };
+}
+function hasLocalFileArgs(input) {
+  return input.file !== void 0 && input.file !== null || input.fileField !== void 0 && input.fileField !== null;
+}
+function parseField(value) {
+  if (typeof value !== "string" || !FIELD.test(value) || FORBIDDEN.has(value)) {
+    return fail2("INVALID_FILE_FIELD", "fileField must be a simple JSON key");
+  }
+  return value;
+}
+function parsePath(value) {
+  if (typeof value !== "string" || value.length === 0 || value.includes("\0")) {
+    return fail2("INVALID_FILE", "file must be a non-empty absolute path");
+  }
+  if (!isAbsolute(value) || value.includes("://")) {
+    return fail2("INVALID_FILE", "file must be an absolute filesystem path, not a URL");
+  }
+  return value;
+}
+function parseMethod(value) {
+  if (value === void 0 || value === null) return "GET";
+  if (typeof value !== "string") {
+    return fail2("MALFORMED_REQUEST", "method must be GET or POST");
+  }
+  const upper = value.trim().toUpperCase();
+  if (upper === "GET" || upper === "POST") return upper;
+  return fail2("MALFORMED_REQUEST", "method must be GET or POST");
+}
+function inside(root, candidate) {
+  const prefix = root.endsWith(sep) ? root : root + sep;
+  return candidate === root || candidate.startsWith(prefix);
+}
+function resolveContainedPath(raw) {
+  const rootRaw = process.env.SUIPAY_MCP_FILE_ROOT;
+  if (typeof rootRaw !== "string" || rootRaw.trim() === "") {
+    return fail2(
+      "FILE_ROOT_UNSET",
+      "file attach requires SUIPAY_MCP_FILE_ROOT to be an absolute directory"
+    );
+  }
+  if (!isAbsolute(rootRaw) || rootRaw.includes("://")) {
+    return fail2(
+      "FILE_ROOT_UNSET",
+      "SUIPAY_MCP_FILE_ROOT must be an absolute filesystem path"
+    );
+  }
+  let rootReal;
+  let fileReal;
+  try {
+    rootReal = realpathSync(rootRaw);
+  } catch {
+    return fail2("FILE_ROOT_UNSET", "SUIPAY_MCP_FILE_ROOT is not a readable directory");
+  }
+  try {
+    fileReal = realpathSync(raw);
+  } catch (err) {
+    const code = err.code;
+    if (code === "ENOENT" || code === "ENOTDIR") {
+      return fail2("FILE_NOT_FOUND", "file does not exist");
+    }
+    if (code === "EACCES") {
+      return fail2("FILE_EACCES", "file is not readable");
+    }
+    return fail2(
+      "INVALID_FILE",
+      `file could not be read (${code ?? "unknown error"})`
+    );
+  }
+  if (!inside(rootReal, fileReal)) {
+    return fail2("FILE_OUTSIDE_ROOT", "file must be under SUIPAY_MCP_FILE_ROOT");
+  }
+  const credsDir2 = dirname3(mcpCredentialsPath());
+  let credsReal = credsDir2;
+  try {
+    credsReal = realpathSync(credsDir2);
+  } catch {
+  }
+  if (inside(credsReal, fileReal)) {
+    return fail2("FILE_FORBIDDEN", "file must not be under ~/.suipay");
+  }
+  return fileReal;
+}
+function readRegularFile(path) {
+  if (constants.O_NOFOLLOW === void 0 || constants.O_NONBLOCK === void 0) {
+    return fail2("INVALID_FILE", "symlink-safe nonblocking open is unavailable on this platform");
+  }
+  let fd;
+  try {
+    const flags = constants.O_RDONLY | constants.O_NOFOLLOW | constants.O_NONBLOCK;
+    fd = openSync2(path, flags);
+    const st = fstatSync(fd);
+    if (!st.isFile()) {
+      return fail2("INVALID_FILE", "file must be a regular file");
+    }
+    if (st.size > MCP_MAX_FILE_FIELD_BYTES) {
+      return fail2(
+        "FILE_TOO_LARGE",
+        `file is ${st.size} bytes; exceeds ${MCP_MAX_FILE_FIELD_BYTES} decoded bytes`
+      );
+    }
+    const bytes = readFileSync2(fd);
+    if (bytes.byteLength === 0) {
+      return fail2("EMPTY_FILE", "file is empty");
+    }
+    if (bytes.byteLength > MCP_MAX_FILE_FIELD_BYTES) {
+      return fail2(
+        "FILE_TOO_LARGE",
+        `file is ${bytes.byteLength} bytes; exceeds ${MCP_MAX_FILE_FIELD_BYTES} decoded bytes`
+      );
+    }
+    return bytes;
+  } catch (err) {
+    const code = err.code;
+    if (code === "ENOENT" || code === "ENOTDIR") {
+      return fail2("FILE_NOT_FOUND", "file does not exist");
+    }
+    if (code === "ELOOP" || code === "EMLINK" || code === "ENXIO") {
+      return fail2("INVALID_FILE", "file must be a regular file");
+    }
+    if (code === "EACCES") return fail2("FILE_EACCES", "file is not readable");
+    return fail2(
+      "INVALID_FILE",
+      `file could not be read (${code ?? "unknown error"})`
+    );
+  } finally {
+    if (fd !== void 0) {
+      try {
+        closeSync2(fd);
+      } catch {
+      }
+    }
+  }
+}
+function toCanonicalBase64(bytes) {
+  return Buffer.from(bytes).toString("base64");
+}
+function jsonWithLocalFile(input) {
+  const hasFile = input.file !== void 0 && input.file !== null;
+  const hasField = input.fileField !== void 0 && input.fileField !== null;
+  if (!hasFile && !hasField) return { json: input.json };
+  if (hasFile !== hasField) {
+    return {
+      error: fail2(
+        "INVALID_FILE_ARGS",
+        "file and fileField are required together"
+      )
+    };
+  }
+  const method = parseMethod(input.method);
+  if (typeof method !== "string") return { error: method };
+  if (method !== "POST") {
+    return { error: fail2("INVALID_FILE_ARGS", "file is only valid on POST") };
+  }
+  const field = parseField(input.fileField);
+  if (typeof field !== "string") return { error: field };
+  const path = parsePath(input.file);
+  if (typeof path !== "string") return { error: path };
+  let json;
+  if (input.json === void 0) {
+    json = {};
+  } else if (typeof input.json === "object" && input.json !== null && !Array.isArray(input.json)) {
+    json = { ...input.json };
+  } else {
+    return { error: fail2("MALFORMED_REQUEST", "POST requires json object") };
+  }
+  if (Object.prototype.hasOwnProperty.call(json, field)) {
+    return {
+      error: fail2(
+        "FILE_FIELD_EXISTS",
+        "json already has fileField; refuse to overwrite"
+      )
+    };
+  }
+  const contained = resolveContainedPath(path);
+  if (typeof contained !== "string") return { error: contained };
+  const bytes = readRegularFile(contained);
+  if (!(bytes instanceof Uint8Array)) return { error: bytes };
+  json[field] = toCanonicalBase64(bytes);
+  return { json };
+}
+
 // src/tools.ts
 function payerTrace(deps) {
   const hooks = deps.trace;
@@ -7080,18 +7279,34 @@ function intentViolation(intent, prepared) {
 }
 async function pay(args, cfg, deps = {}) {
   if (!args.url) return error("url is required");
+  if (hasLocalFileArgs(args) && deps.transport === "http") {
+    return closedPayError(
+      "FILE_STDIO_ONLY",
+      "file is stdio only; hosted /mcp does not read the buyer disk"
+    );
+  }
   let intent;
   try {
     intent = normalizePayIntent(args);
   } catch {
     return closedPayError("INVALID_INTENT", "payment intent is invalid");
   }
+  let attached;
+  try {
+    attached = jsonWithLocalFile(args);
+  } catch {
+    return closedPayError("INVALID_FILE", "file could not be read");
+  }
+  if ("error" in attached) {
+    return closedPayError(attached.error.code, attached.error.detail);
+  }
+  const paidArgs = { ...args, json: attached.json };
   let request;
   try {
-    request = normalizeMcpPaidHttpRequest(args);
+    request = normalizeMcpPaidHttpRequest(paidArgs);
   } catch (err) {
     const raw = err instanceof Error ? err.message : "";
-    const detail = /method/i.test(raw) ? "method must be GET or POST" : /json/i.test(raw) ? "POST requires json" : "request could not be normalized";
+    const detail = /too large/i.test(raw) ? `paid request body exceeds ${MAX_PAID_BODY_BYTES} bytes` : /method/i.test(raw) ? "method must be GET or POST" : /json/i.test(raw) ? "POST requires json" : "request could not be normalized";
     return closedPayError("MALFORMED_REQUEST", detail);
   }
   if (deps.auth?.spendAccountPay) {
@@ -7624,6 +7839,14 @@ var TOOLS = [
           type: "object",
           description: "JSON request body for a POST. Sent as application/json and bound to the payment."
         },
+        file: {
+          type: "string",
+          description: "Absolute path under SUIPAY_MCP_FILE_ROOT (unset disables attach). Stdio POST only; requires fileField. Regular non-empty file whose decoded size fits the paid-body ceiling. Not a URL, FIFO, device, or path under ~/.suipay. Bytes fill json[fileField] as canonical base64."
+        },
+        fileField: {
+          type: "string",
+          description: "JSON key to set from file (e.g. contentBase64). Required with file. Pattern [A-Za-z][A-Za-z0-9_]{0,63}. Must not already be present on json."
+        },
         recipient: {
           type: "string",
           description: "Sui address you expect to be paid. The payment is refused, unsigned, if the prepared transaction pays anyone else."
@@ -7731,6 +7954,7 @@ function toolError(value) {
 }
 function createServer2(cfg, auth, trace, options = {}) {
   const resolveAgentHeld = options.resolveAgentHeld ?? resolveAgentHeldSettlement;
+  const transport = options.transport ?? "stdio";
   const server = new Server(
     { name: "suipay", version: "1.0.0" },
     {
@@ -7757,17 +7981,29 @@ function createServer2(cfg, auth, trace, options = {}) {
           return await accessContext({ auth }, cfg);
         case "pay": {
           const agentHeld = auth?.spendAccountPay ? resolveAgentHeld(cfg, auth.spendAccountPay) : null;
+          const fileArgs = {
+            ...args.file !== void 0 ? { file: args.file } : {},
+            ...args.fileField !== void 0 ? { fileField: args.fileField } : {}
+          };
+          if (transport === "http" && hasLocalFileArgs(fileArgs)) {
+            return closedPayError(
+              "FILE_STDIO_ONLY",
+              "file is stdio only; hosted /mcp does not read the buyer disk"
+            );
+          }
           return await pay(
             {
               url: String(args.url ?? ""),
               ...args.method !== void 0 ? { method: args.method } : {},
               ...args.json !== void 0 ? { json: args.json } : {},
+              ...transport === "stdio" ? fileArgs : {},
               ...args.recipient !== void 0 ? { recipient: args.recipient } : {},
               ...args.maxAmount !== void 0 ? { maxAmount: args.maxAmount } : {}
             },
             cfg,
             {
               auth,
+              transport,
               ...trace ? { trace } : {},
               ...agentHeld ? { agentHeld } : {}
             }
@@ -7856,6 +8092,11 @@ function canonicalMcpRequestId(id) {
 function asRecord(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value) ? value : null;
 }
+function redactPayFileArg(args) {
+  const record = asRecord(args);
+  if (!record || !("file" in record)) return args;
+  return { ...record, file: "[redacted]" };
+}
 function readEntry(message) {
   const record = asRecord(message);
   if (!record) return null;
@@ -7867,7 +8108,7 @@ function readEntry(message) {
     jsonRpcId: typeof rawId === "string" || typeof rawId === "number" ? rawId : null,
     requestId: canonicalMcpRequestId(rawId),
     toolName: params && typeof params.name === "string" ? params.name : null,
-    toolArguments: params ? params.arguments : void 0,
+    toolArguments: params ? redactPayFileArg(params.arguments) : void 0,
     clientName: clientInfo && typeof clientInfo.name === "string" ? clientInfo.name : null,
     clientVersion: clientInfo && typeof clientInfo.version === "string" ? clientInfo.version : null,
     protocolVersion: params && typeof params.protocolVersion === "string" ? params.protocolVersion : null
@@ -8297,7 +8538,10 @@ async function handleSuipayMcpHttpRequest(req, cfg, auth, trace, options) {
         sessionIdGenerator: void 0,
         enableJsonResponse: true
       });
-      const server = createServer2(cfg, auth, hooks, options);
+      const server = createServer2(cfg, auth, hooks, {
+        ...options,
+        transport: "http"
+      });
       await server.connect(transport);
       return transport.handleRequest(request);
     }

package/dist/{http-B4YTVw0k.d.ts → http-DBP9qgVw.d.ts}

@@ -282,6 +282,14 @@ declare const TOOLS: readonly [{
                 readonly type: "object";
                 readonly description: "JSON request body for a POST. Sent as application/json and bound to the payment.";
             };
+            readonly file: {
+                readonly type: "string";
+                readonly description: "Absolute path under SUIPAY_MCP_FILE_ROOT (unset disables attach). Stdio POST only; requires fileField. Regular non-empty file whose decoded size fits the paid-body ceiling. Not a URL, FIFO, device, or path under ~/.suipay. Bytes fill json[fileField] as canonical base64.";
+            };
+            readonly fileField: {
+                readonly type: "string";
+                readonly description: "JSON key to set from file (e.g. contentBase64). Required with file. Pattern [A-Za-z][A-Za-z0-9_]{0,63}. Must not already be present on json.";
+            };
             readonly recipient: {
                 readonly type: "string";
                 readonly description: "Sui address you expect to be paid. The payment is refused, unsigned, if the prepared transaction pays anyone else.";
@@ -370,6 +378,11 @@ interface McpServerOptions {
      * does not already authorize.
      */
     resolveAgentHeld?: AgentHeldResolver;
+    /**
+     * Wire that created this server. Hosted HTTP never forwards `file` into `pay`.
+     * Stdio is the default so existing tests stay local.
+     */
+    transport?: 'stdio' | 'http';
 }
 declare function createServer(cfg: McpConfig, auth?: McpAuthContext, trace?: McpTraceHooks, options?: McpServerOptions): Server;
 

package/dist/http.d.ts

@@ -1,4 +1,4 @@
-export { m as handleSuipayMcpHttpRequest } from './http-B4YTVw0k.js';
+export { m as handleSuipayMcpHttpRequest } from './http-DBP9qgVw.js';
 import '@cmdoss/suipay-core/policy/grant-target';
 import '@cmdoss/suipay-sdk/mcp/access-context';
 import '@cmdoss/suipay-sdk/buyer/settlement-dto';

package/dist/http.js

@@ -1,6 +1,6 @@
 import {
   handleSuipayMcpHttpRequest
-} from "./chunk-THLDEMGS.js";
+} from "./chunk-UTKVBAEZ.js";
 export {
   handleSuipayMcpHttpRequest
 };

package/dist/index.d.ts

@@ -1,6 +1,6 @@
 import { Wallet } from '@cmdoss/suipay-core/chain/types';
-import { M as McpConfig, a as McpAuthContext, b as McpTraceHooks } from './http-B4YTVw0k.js';
-export { A as AgentHeldResolver, c as AgentHeldSettlement, d as MCP_TARGET_PRESETS, e as McpEnvelope, f as McpEnvelopeEntry, g as McpServerOptions, h as McpTarget, i as McpTraceContext, j as McpTraceRuntime, P as PACKAGE_NAME, T as TOOLS, k as canonicalMcpRequestId, l as createServer, m as handleSuipayMcpHttpRequest, n as inspectMcpEnvelope, o as loadMcpConfig, p as parseMcpTargetFlag, r as resetAgentHeldProcessLedger, q as resolveAgentHeldSettlement, s as resolveMcpTarget, t as sameMcpGateway, u as traceMcpHttpRequest } from './http-B4YTVw0k.js';
+import { M as McpConfig, a as McpAuthContext, b as McpTraceHooks } from './http-DBP9qgVw.js';
+export { A as AgentHeldResolver, c as AgentHeldSettlement, d as MCP_TARGET_PRESETS, e as McpEnvelope, f as McpEnvelopeEntry, g as McpServerOptions, h as McpTarget, i as McpTraceContext, j as McpTraceRuntime, P as PACKAGE_NAME, T as TOOLS, k as canonicalMcpRequestId, l as createServer, m as handleSuipayMcpHttpRequest, n as inspectMcpEnvelope, o as loadMcpConfig, p as parseMcpTargetFlag, r as resetAgentHeldProcessLedger, q as resolveAgentHeldSettlement, s as resolveMcpTarget, t as sameMcpGateway, u as traceMcpHttpRequest } from './http-DBP9qgVw.js';
 import { GrantSnapshot } from '@cmdoss/suipay-core/policy/grant-target';
 export { resolveGrantTarget } from '@cmdoss/suipay-core/policy/grant-target';
 import { PaidHttpRequest } from '@cmdoss/suipay-sdk/protocol/paid-http-request';
@@ -347,6 +347,8 @@ interface ToolDeps {
     profileLoader?: () => PaymentProfile | null;
     /** Remote HTTP auth (grant + scope + optional shared-pool pay session). */
     auth?: McpAuthContext;
+    /** Wire transport. Hosted HTTP never reads a buyer path. */
+    transport?: 'stdio' | 'http';
     /**
      * Proxy-resolved live trace for this MCP request. Observation only: it never
      * changes which rail runs, what is paid, or whether a payment is allowed.
@@ -377,6 +379,8 @@ declare function pay(args: {
     url: string;
     method?: unknown;
     json?: unknown;
+    file?: unknown;
+    fileField?: unknown;
     recipient?: unknown;
     maxAmount?: unknown;
 }, cfg: McpConfig, deps?: ToolDeps): Promise<ToolResult>;

package/dist/index.js

@@ -1,7 +1,7 @@
 import {
   loadBootProfile,
   main
-} from "./chunk-P54ZYBPN.js";
+} from "./chunk-AEV6Q6JC.js";
 import {
   MCP_TARGET_PRESETS,
   PACKAGE_NAME,
@@ -26,7 +26,7 @@ import {
   settlePreparedMcpPayment,
   traceMcpHttpRequest,
   verifySpendAccountPayReconstructs
-} from "./chunk-THLDEMGS.js";
+} from "./chunk-UTKVBAEZ.js";
 export {
   MCP_TARGET_PRESETS,
   PACKAGE_NAME,

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "@cmdoss/suipay-mcp",
-  "version": "0.2.2-dev.5",
+  "version": "0.2.2-dev.6",
   "type": "module",
-  "description": "SuiPay MCP — pay MPP-gated APIs from a spend-account grant with an agent-held delegate key.",
+  "description": "SuiPay MCP \u2014 pay MPP-gated APIs from a spend-account grant with an agent-held delegate key.",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "exports": {