@zeroxyz/cli 1.1.0 → 1.3.0

package/dist/index.js

@@ -76582,7 +76582,7 @@ init_esm_shims();
 
 // package.json
 var package_default = {
-  version: "1.1.0"};
+  version: "1.3.0"};
 
 // src/app.ts
 init_esm_shims();
@@ -77578,7 +77578,7 @@ init_esm_shims();
 // ../sdk/dist/index.js
 init_esm_shims();
 
-// ../sdk/dist/chunk-SE2M66VR.js
+// ../sdk/dist/chunk-RPL7VC32.js
 init_esm_shims();
 
 // ../../node_modules/.pnpm/viem@2.52.2_bufferutil@4.1.0_typescript@5.9.3_utf-8-validate@6.0.6_zod@4.3.6/node_modules/viem/_esm/index.js
@@ -143021,6 +143021,16 @@ var ZeroPaymentError = class extends ZeroError {
     this.name = "ZeroPaymentError";
   }
 };
+var ZeroInsufficientFundsError = class extends ZeroError {
+  have;
+  need;
+  constructor(message2, init) {
+    super("insufficient_funds", message2, { cause: init.cause });
+    this.name = "ZeroInsufficientFundsError";
+    this.have = init.have;
+    this.need = init.need;
+  }
+};
 var ZeroSessionCloseFailedError = class extends ZeroError {
   session;
   response;
@@ -143361,7 +143371,12 @@ var FETCH_SKIP_REASONS = Object.freeze({
   bodyReadFailed: "body_read_failed",
   mppSessionCloseFailedNotRecorded: "mpp_session_close_failed_not_recorded",
   paidButStill402NotRecorded: FETCH_WARNINGS.paidButStill402NotRecorded,
-  paymentSettlementUnconfirmed: FETCH_WARNINGS.paymentSettlementUnconfirmed
+  paymentSettlementUnconfirmed: FETCH_WARNINGS.paymentSettlementUnconfirmed,
+  // Pre-sign abort: deliberately NOT recorded as a run — the wallet was
+  // empty before we reached the capability, so charging it as a 402 would
+  // corrupt cap reliability. The wallet funnel is tracked via the
+  // fetch_executed.outcome analytics event instead.
+  insufficientFunds: "insufficient_funds_not_recorded"
 });
 var MAX_RECEIPT_HEADER_BYTES = 8 * 1024;
 var decodeSessionReceiptHeader = (header) => {
@@ -143503,6 +143518,7 @@ var Payments = class {
     );
     let capturedAmount = null;
     let capturedNetwork;
+    let preflightError = null;
     const x402 = registerExactEvmScheme(new x402Client(), { signer: account });
     x402.onBeforePaymentCreation(async (context) => {
       const selected = context.selectedRequirements;
@@ -143536,6 +143552,29 @@ var Payments = class {
           reason: `Payment of ${capturedAmount} USDC exceeds maxPay ${input.maxPay}`
         };
       }
+      const detected = networkToChain(capturedNetwork);
+      const balanceChain = detected === "base-sepolia" ? "base-sepolia" : "base";
+      let balance = null;
+      try {
+        balance = await this.readUsdcBalance(account.address, balanceChain);
+      } catch (readErr) {
+        this.client.logger?.({
+          level: "warn",
+          message: "Pre-flight balance read failed; proceeding to attempt payment",
+          meta: {
+            chain: balanceChain,
+            error: readErr instanceof Error ? readErr.message : String(readErr)
+          }
+        });
+      }
+      if (balance !== null && balance < rawAmountUnits) {
+        const have = formatUnits(balance, 6);
+        preflightError = new ZeroInsufficientFundsError(
+          `wallet has ${have} USDC on Base, needs ${capturedAmount}.`,
+          { have, need: capturedAmount }
+        );
+        return { abort: true, reason: preflightError.message };
+      }
     });
     const configuredFetch = buildConfiguredFetch(this.client, {
       timeoutMs: input.timeoutMs
@@ -143556,6 +143595,7 @@ var Payments = class {
         signal: input.signal
       });
     } catch (err) {
+      if (preflightError) throw preflightError;
       if (err instanceof ZeroError) throw err;
       throw new ZeroPaymentError(
         `x402 payment failed: ${err instanceof Error ? err.message : String(err)}`,
@@ -143800,23 +143840,29 @@ var Payments = class {
     );
     if (tempoBalance < requiredRaw) {
       if (coerced.chain === "tempo-testnet") {
-        throw new ZeroPaymentError(
-          `Insufficient pathUSD on Tempo testnet: have ${formatUnits(tempoBalance, 6)}, need ${capturedAmount}. Fund via the Tempo testnet faucet: https://docs.tempo.xyz/quickstart/faucet`
+        const have = formatUnits(tempoBalance, 6);
+        throw new ZeroInsufficientFundsError(
+          `Insufficient pathUSD on Tempo testnet: have ${have}, need ${capturedAmount}. Fund via the Tempo testnet faucet: https://docs.tempo.xyz/quickstart/faucet`,
+          { have, need: capturedAmount }
         );
       }
-      await this.bridgeBaseToTempo(account, requiredRaw - tempoBalance);
+      await this.bridgeBaseToTempo(account, requiredRaw - tempoBalance, {
+        isSessionDeposit: challenge2.intent === "session",
+        depositTotal: capturedAmount
+      });
     }
     return capturedAmount;
   };
-  bridgeBaseToTempo = async (account, requiredAmount) => {
+  bridgeBaseToTempo = async (account, requiredAmount, depositContext) => {
     this.ensureRelayClient();
     const baseBalance = await this.readUsdcBalance(account.address, "base");
     const buffer3 = calculateBuffer(baseBalance);
     const bridgeAmount = requiredAmount + buffer3;
     if (baseBalance < bridgeAmount) {
-      throw new ZeroPaymentError(
-        `Insufficient Base USDC to bridge: have ${formatUnits(baseBalance, 6)}, need ${formatUnits(bridgeAmount, 6)} (${formatUnits(requiredAmount, 6)} + ${formatUnits(buffer3, 6)} buffer). This capability uses an MPP payment channel, which is pre-funded up front. Either fund your wallet on Base, or pass \`maxPay\` to size a smaller channel (e.g. \`maxPay: '0.05'\` for a ~5-cent channel sized for a single cheap call).`
-      );
+      const have = formatUnits(baseBalance, 6);
+      const need = formatUnits(bridgeAmount, 6);
+      const message2 = depositContext?.isSessionDeposit ? `wallet has ${have} USDC on Base, but this capability pre-funds a ${depositContext.depositTotal} USDC MPP payment channel up front (the channel is deposited before the call, so it asks for more than a single charge). Needs ${need} on Base to open it \u2014 fund the wallet, or pass a smaller \`maxPay\` (e.g. '0.05') to size the channel down to one cheap call.` : `wallet has ${have} USDC on Base, needs ${need} to fund this capability's MPP payment channel (${formatUnits(requiredAmount, 6)} + ${formatUnits(buffer3, 6)} buffer). Tip: pass a smaller \`maxPay\` (e.g. '0.05') to size a cheaper channel.`;
+      throw new ZeroInsufficientFundsError(message2, { have, need });
     }
     this.client.logger?.({
       level: "info",
@@ -144034,7 +144080,7 @@ var Payments = class {
   };
 };
 var package_default2 = {
-  version: "0.1.0"
+  version: "0.4.0"
 };
 var SDK_VERSION2 = package_default2.version;
 var userWalletDtoSchema = external_exports3.object({
@@ -144999,7 +145045,7 @@ var Wallet = class {
   };
 };
 var DEFAULT_BASE_URL = "https://api.zero.xyz";
-var DEFAULT_TIMEOUT_MS = 6e4;
+var DEFAULT_TIMEOUT_MS = 18e4;
 var DEFAULT_MAX_RETRIES = 2;
 var noopRefresh = async () => {
 };
@@ -145283,11 +145329,44 @@ var recordErrorFetchRun = async (client, opts, result) => {
   } catch {
   }
 };
+var recordTimeoutRun = async (client, opts, err, startedAt, capabilityIdRequested) => {
+  const result = errorFetchResult(
+    startedAt,
+    err.message,
+    "timeout",
+    capabilityIdRequested,
+    "network_error"
+  );
+  await recordErrorFetchRun(client, opts, result);
+};
+var sniffJsonShapeBytes = (buf) => {
+  let i = 0;
+  if (buf.length >= 3 && buf[0] === 239 && buf[1] === 187 && buf[2] === 191) {
+    i = 3;
+  }
+  while (i < buf.length && (buf[i] === 32 || buf[i] === 9 || buf[i] === 10 || buf[i] === 13)) {
+    i++;
+  }
+  if (i >= buf.length) return false;
+  return buf[i] === 123 || buf[i] === 91;
+};
+var withDefaultContentType = (headers, body) => {
+  if (!headers && body === void 0) return void 0;
+  const next = headers ? { ...headers } : {};
+  if (body === void 0) return next;
+  const hasContentType = Object.keys(next).some(
+    (k3) => k3.toLowerCase() === "content-type"
+  );
+  if (!hasContentType) {
+    next["content-type"] = typeof body === "string" || sniffJsonShapeBytes(body) ? "application/json" : "application/octet-stream";
+  }
+  return next;
+};
 var clientFetch = async (client, url4, opts = {}) => {
   const startedAt = Date.now();
   const capabilityIdRequested = opts.capabilityId !== void 0;
   const method = opts.method ?? (opts.body !== void 0 ? "POST" : "GET");
-  const probeHeaders = opts.headers ? { ...opts.headers } : void 0;
+  const probeHeaders = withDefaultContentType(opts.headers, opts.body);
   const requestInit = {
     method,
     headers: probeHeaders,
@@ -145304,6 +145383,16 @@ var clientFetch = async (client, url4, opts = {}) => {
   try {
     response = await configuredFetch(url4, requestInit);
   } catch (err) {
+    if (err instanceof ZeroTimeoutError) {
+      await recordTimeoutRun(
+        client,
+        opts,
+        err,
+        startedAt,
+        capabilityIdRequested
+      );
+      throw err;
+    }
     if (err instanceof ZeroError) throw err;
     const errMessage = err instanceof Error ? err.message : String(err);
     const result2 = errorFetchResult(
@@ -145325,8 +145414,9 @@ var clientFetch = async (client, url4, opts = {}) => {
           url: url4,
           method,
           // Fresh clone for the paid retry — same rationale as
-          // the probe-side clone above.
-          headers: opts.headers ? { ...opts.headers } : void 0,
+          // the probe-side clone above. Re-derives the default
+          // Content-Type so the paid leg matches the probe.
+          headers: withDefaultContentType(opts.headers, opts.body),
           body: opts.body,
           maxPay: opts.maxPay,
           account: opts.account,
@@ -145351,6 +145441,15 @@ var clientFetch = async (client, url4, opts = {}) => {
             session: err.session
           };
           warnings.push(FETCH_WARNINGS.mppSessionCloseFailed);
+        } else if (err instanceof ZeroInsufficientFundsError) {
+          return errorFetchResult(
+            startedAt,
+            err.message,
+            FETCH_SKIP_REASONS.insufficientFunds,
+            capabilityIdRequested,
+            "insufficient_funds",
+            null
+          );
         } else if (err instanceof ZeroPaymentError || err instanceof ZeroAuthError) {
           const result2 = errorFetchResult(
             startedAt,
@@ -145362,6 +145461,15 @@ var clientFetch = async (client, url4, opts = {}) => {
           );
           await recordErrorFetchRun(client, opts, result2);
           return result2;
+        } else if (err instanceof ZeroTimeoutError) {
+          await recordTimeoutRun(
+            client,
+            opts,
+            err,
+            startedAt,
+            capabilityIdRequested
+          );
+          throw err;
         } else {
           throw err;
         }
@@ -145539,8 +145647,15 @@ var searchResultSchema = external_exports3.object({
   slug: external_exports3.string(),
   name: external_exports3.string(),
   canonicalName: external_exports3.string().nullable().optional(),
+  brandName: external_exports3.string().nullable().optional(),
   description: external_exports3.string(),
   whatItDoes: external_exports3.string().nullable().optional(),
+  // HTTP verb the capability expects. Surfaced on the search row so a caller
+  // can tell GET from POST without a `capabilities.get()` round-trip — enough
+  // to `fetch()` a no-body GET directly. POST bodies still need `get()` for
+  // the `bodySchema`. Optional (not required) so a response that omits it —
+  // an older API deploy — still parses rather than failing the whole search.
+  method: external_exports3.string().optional(),
   url: external_exports3.string(),
   urlTemplate: external_exports3.string().nullable().optional(),
   cost: external_exports3.object({ amount: external_exports3.string(), asset: external_exports3.string() }),
@@ -146288,6 +146403,14 @@ var OUTCOMES = {
     errorClass: "payment_rejected",
     reviewable: false
   },
+  // Wallet can't cover the call (pre-sign abort). A funding condition, not
+  // a cap failure — the SDK records no run, so this is the only surviving
+  // signal. Not reviewable (we never reached the capability).
+  insufficient_funds: {
+    exitCode: 1,
+    errorClass: "insufficient_funds",
+    reviewable: false
+  },
   server_error: { exitCode: 0, errorClass: "upstream_4xx", reviewable: true }
 };
 var cliErrorClassFor = (outcome, status, walletAddress) => {
@@ -146367,7 +146490,7 @@ var fetchCommand = (appContext) => new Command("fetch").description(
   "Read the request body from stdin (equivalent to `-d @-`)."
 ).option("-H, --header <header...>", "Headers in Key:Value format").option("--max-pay <amount>", "Maximum per-call spend limit (USDC)").option(
   "--timeout <seconds>",
-  "Per-request timeout in seconds, overriding the default (60). Applies to each HTTP leg of the call (probe and paid retry), not as a wall-clock deadline."
+  "Per-request timeout in seconds, overriding the default (180). Applies to each HTTP leg of the call (probe and paid retry), not as a wall-clock deadline."
 ).option(
   "--capability <id>",
   "Bind this fetch to a capability (uid or slug) so a reviewable run is recorded even without a prior `zero search`"
@@ -146704,6 +146827,16 @@ var fetchCommand = (appContext) => new Command("fetch").description(
             `  Payment failed: ${resultError ?? "could not complete payment"}`
           );
           if (legacyMigrateHint) console.error(`  ${legacyMigrateHint}`);
+        } else if (outcome === "insufficient_funds") {
+          console.error(
+            `  Insufficient funds: ${resultError ?? "wallet can't cover this call"}`
+          );
+          if (!resultError?.includes("faucet")) {
+            console.error(
+              "  Top off your wallet with `zero wallet fund`, then retry."
+            );
+          }
+          if (legacyMigrateHint) console.error(`  ${legacyMigrateHint}`);
         } else if (outcome === "payment_rejected") {
           console.error(
             `  Upstream returned 402 after payment was sent \u2014 the seller's facilitator rejected the credential${messageSuffix}`
@@ -146858,29 +146991,140 @@ var formatRating = (rating) => {
   return `${successPct} success, ${reviews} reviews`;
 };
 var asNode = (v) => v && typeof v === "object" && !Array.isArray(v) ? v : null;
-var placeholderFor = (fieldName, propSchema) => {
+var schemaType = (node) => {
+  const t = node?.type;
+  if (typeof t === "string") return t;
+  if (Array.isArray(t)) {
+    const first = t.find((x2) => typeof x2 === "string" && x2 !== "null");
+    return typeof first === "string" ? first : void 0;
+  }
+  return void 0;
+};
+var coerceToType = (value, type2) => {
+  if (typeof value !== "string") return value;
+  if (type2 === "number" || type2 === "integer") {
+    const n = Number(value);
+    return value.trim() !== "" && Number.isFinite(n) ? n : value;
+  }
+  if (type2 === "boolean") {
+    if (value === "true") return true;
+    if (value === "false") return false;
+  }
+  return value;
+};
+var sampleValueFor = (fieldName, propSchema) => {
   const node = asNode(propSchema);
+  const type2 = schemaType(node);
   const example = node?.example ?? node?.default;
-  if (typeof example === "string") return example;
-  if (typeof example === "number" || typeof example === "boolean") {
-    return String(example);
+  if (example !== void 0 && example !== null) {
+    return coerceToType(example, type2);
+  }
+  switch (type2) {
+    case "number":
+    case "integer":
+      return 0;
+    case "boolean":
+      return false;
+    case "array":
+      return [];
+    case "object":
+      return {};
+    default:
+      return `<${fieldName.toUpperCase()}>`;
   }
-  return `<${fieldName.toUpperCase()}>`;
 };
+var placeholderFor = (fieldName, propSchema) => String(sampleValueFor(fieldName, propSchema));
 var extractInputEnvelope = (bodySchema, method) => {
-  if (!bodySchema) return {};
-  const props = asNode(bodySchema.properties);
+  const root = asNode(bodySchema);
+  if (!root) return {};
+  const props = asNode(root.properties);
   if (!props) return {};
   const inputProps = asNode(asNode(props.input)?.properties);
   if (inputProps) {
     return {
-      queryParams: asNode(asNode(inputProps.queryParams)?.properties) ?? void 0,
-      body: asNode(asNode(inputProps.body)?.properties) ?? void 0
+      queryParams: asNode(inputProps.queryParams) ?? void 0,
+      body: asNode(inputProps.body) ?? void 0
     };
   }
   const upperMethod = method.toUpperCase();
   const isGetLike = upperMethod === "GET" || upperMethod === "DELETE";
-  return isGetLike ? { queryParams: props } : { body: props };
+  return isGetLike ? { queryParams: root } : { body: root };
+};
+var schemaTypeLabel = (node) => {
+  const t = node.type;
+  if (typeof t === "string") return t;
+  if (Array.isArray(t)) {
+    const parts = t.filter((x2) => typeof x2 === "string");
+    return parts.length > 0 ? parts.join(" | ") : "any";
+  }
+  return "any";
+};
+var constraintHint = (node) => {
+  const num2 = (k3) => typeof node[k3] === "number" ? node[k3] : void 0;
+  const min = num2("minimum");
+  const max = num2("maximum");
+  if (min !== void 0 && max !== void 0) return `range: ${min}..${max}`;
+  if (min !== void 0) return `min: ${min}`;
+  if (max !== void 0) return `max: ${max}`;
+  const minLen = num2("minLength");
+  const maxLen = num2("maxLength");
+  if (minLen !== void 0 && maxLen !== void 0)
+    return `length: ${minLen}..${maxLen}`;
+  if (maxLen !== void 0) return `maxLength: ${maxLen}`;
+  if (minLen !== void 0) return `minLength: ${minLen}`;
+  return null;
+};
+var renderParam = (name, propSchema, required3) => {
+  const node = asNode(propSchema) ?? {};
+  const attrs = [schemaTypeLabel(node)];
+  if (required3) attrs.push("required");
+  if (node.default !== void 0)
+    attrs.push(`default: ${JSON.stringify(node.default)}`);
+  if (Array.isArray(node.enum))
+    attrs.push(`one of: ${node.enum.map((v) => String(v)).join(" | ")}`);
+  const hint = constraintHint(node);
+  if (hint) attrs.push(hint);
+  const lines = [`    ${name} (${attrs.join(", ")})`];
+  const desc = typeof node.description === "string" ? node.description.trim() : "";
+  if (desc) lines.push(`      ${desc}`);
+  return lines;
+};
+var renderProps = (node) => {
+  const props = node ? asNode(node.properties) : null;
+  if (!props) return [];
+  const entries = Object.entries(props);
+  if (entries.length === 0) return [];
+  const requiredSet = new Set(
+    Array.isArray(node?.required) ? node.required.filter((x2) => typeof x2 === "string") : []
+  );
+  return entries.flatMap(
+    ([name, schema]) => renderParam(name, schema, requiredSet.has(name))
+  );
+};
+var buildSchemaSection = (capability) => {
+  const { queryParams, body } = extractInputEnvelope(
+    capability.bodySchema,
+    capability.method
+  );
+  return [...renderProps(queryParams), ...renderProps(body)];
+};
+var buildResponseSection = (capability) => {
+  const rs = asNode(capability.responseSchema);
+  if (!rs) return [];
+  if (rs.example !== void 0) {
+    const example = JSON.stringify(rs.example);
+    const truncated = example.length > 300 ? `${example.slice(0, 300)}\u2026` : example;
+    return ["  Returns (example):", `    ${truncated}`];
+  }
+  const props = asNode(rs.properties);
+  if (props) {
+    const fields = Object.entries(props).map(
+      ([k3, v]) => `${k3}: ${schemaTypeLabel(asNode(v) ?? {})}`
+    );
+    if (fields.length > 0)
+      return ["  Returns:", `    { ${fields.join(", ")} }`];
+  }
+  return [];
 };
 var buildTryItExample = (capability) => {
   const method = capability.method.toUpperCase();
@@ -146894,7 +147138,8 @@ var buildTryItExample = (capability) => {
     ([k3, v]) => `-H "${k3}: ${v}"  # [caller-provided]`
   );
   if (method === "GET" || queryParams && !body) {
-    const qs = queryParams ? Object.entries(queryParams).map(
+    const qpProps = queryParams ? asNode(queryParams.properties) : null;
+    const qs = qpProps ? Object.entries(qpProps).map(
       ([k3, schema]) => `${encodeURIComponent(k3)}=${encodeURIComponent(placeholderFor(k3, schema))}`
     ).join("&") : "";
     const url4 = qs ? `${capability.url}?${qs}` : capability.url;
@@ -146908,15 +147153,16 @@ var buildTryItExample = (capability) => {
     }
     if (!queryParams && method === "GET") {
       lines.push(
-        "  # bodySchema did not expose queryParams \u2014 call the URL as-is or inspect the raw schema above."
+        "  # bodySchema did not expose queryParams \u2014 call the URL as-is."
       );
     }
     return lines;
   }
-  const samplePayload = body ? Object.fromEntries(
-    Object.entries(body).map(([k3, schema]) => [
+  const bodyProps = body ? asNode(body.properties) : null;
+  const samplePayload = bodyProps ? Object.fromEntries(
+    Object.entries(bodyProps).map(([k3, schema]) => [
       k3,
-      placeholderFor(k3, schema)
+      sampleValueFor(k3, schema)
     ])
   ) : null;
   const bodyJson = samplePayload ? JSON.stringify(samplePayload) : "<BODY_JSON>";
@@ -146924,9 +147170,9 @@ var buildTryItExample = (capability) => {
   if (method !== "POST") lines.push(`    -X ${method} \\`);
   for (const h2 of headerFlags) lines.push(`    ${h2} \\`);
   lines.push(`    -d '${bodyJson}'`);
-  if (!body) {
+  if (!bodyProps) {
     lines.push(
-      "  # bodySchema did not expose input.body \u2014 replace <BODY_JSON> with the exact shape shown above."
+      "  # bodySchema did not expose input.body \u2014 replace <BODY_JSON> with the documented request shape."
     );
   }
   return lines;
@@ -146948,6 +147194,12 @@ var formatCapability = (capability) => {
       lines.push(`    ${promptLine}`);
     }
   }
+  const schemaLines = buildSchemaSection(capability);
+  if (schemaLines.length > 0) {
+    lines.push("", "Parameters:");
+    lines.push(...schemaLines);
+  }
+  lines.push(...buildResponseSection(capability));
   lines.push(...buildTryItExample(capability));
   return lines.join("\n");
 };

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@zeroxyz/cli",
-	"version": "1.1.0",
+	"version": "1.3.0",
 	"type": "module",
 	"bin": {
 		"zero": "dist/index.js",