@devlab.group/agent-commerce 0.1.0-alpha.0 → 1.0.0

package/dist/cli/index.js

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 import { ZodError, z } from 'zod';
-import { existsSync, mkdirSync, accessSync, constants, readFileSync, chmodSync, promises } from 'fs';
+import { existsSync, mkdirSync, accessSync, constants, closeSync, openSync, readFileSync, chmodSync, promises } from 'fs';
 import * as path from 'path';
 import { resolve, dirname, join } from 'path';
 import { stringify, parse, YAMLError } from 'yaml';
@@ -267,6 +267,64 @@ var init_core = __esm({
   }
 });
 
+// src/payments/x402/networks.ts
+function findNetworkProfile(id) {
+  return BY_ID.get(id);
+}
+function requireNetworkProfile(id, path2) {
+  const profile = BY_ID.get(id);
+  if (!profile) {
+    throw new CommerceError(
+      "CONFIG_INVALID",
+      `${path2}: "${id}" is not a supported network. Supported CAIP-2 identifiers: ${SUPPORTED_NETWORK_IDS.join(", ")}`,
+      { details: { path: path2, network: id } }
+    );
+  }
+  return profile;
+}
+function resolveDeploymentMode(profile, facilitatorMode) {
+  if (facilitatorMode === "local") return "local";
+  return profile.kind;
+}
+function describeDeploymentMode(mode) {
+  return mode === "mainnet" ? LIVE_MAINNET_BANNER : mode.toUpperCase();
+}
+var PROFILES, BY_ID, SUPPORTED_NETWORK_IDS, LIVE_MAINNET_BANNER;
+var init_networks = __esm({
+  "src/payments/x402/networks.ts"() {
+    init_core();
+    PROFILES = [
+      {
+        id: "eip155:84532",
+        chainId: 84532,
+        displayName: "Base Sepolia",
+        kind: "testnet",
+        canonicalAsset: {
+          symbol: "USDC",
+          address: "0x036CbD53842c5426634e7929541eC2318f3dCF7e",
+          name: "USDC",
+          version: "2"
+        }
+      },
+      {
+        id: "eip155:8453",
+        chainId: 8453,
+        displayName: "Base",
+        kind: "mainnet",
+        canonicalAsset: {
+          symbol: "USDC",
+          address: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
+          name: "USD Coin",
+          version: "2"
+        }
+      }
+    ];
+    BY_ID = new Map(PROFILES.map((profile) => [profile.id, profile]));
+    SUPPORTED_NETWORK_IDS = PROFILES.map((p) => p.id);
+    LIVE_MAINNET_BANNER = "LIVE MAINNET MODE \u2014 REAL FUNDS";
+  }
+});
+
 // src/config/env.ts
 function substituteEnv(value, env, path2 = "$") {
   if (typeof value === "string") {
@@ -285,19 +343,26 @@ function substituteEnv(value, env, path2 = "$") {
   return value;
 }
 function substituteString(value, env, path2) {
-  const substituted = substituteOnce(value, env, path2);
-  PLACEHOLDER_PATTERN.lastIndex = 0;
-  if (PLACEHOLDER_PATTERN.test(substituted)) {
-    PLACEHOLDER_PATTERN.lastIndex = 0;
-    const residual = PLACEHOLDER_PATTERN.exec(substituted)?.[0] ?? "${\u2026}";
-    PLACEHOLDER_PATTERN.lastIndex = 0;
+  assertTemplateIsSupported(value, path2);
+  return substituteOnce(value, env, path2);
+}
+function assertTemplateIsSupported(value, path2) {
+  if (NESTED_PLACEHOLDER.test(value)) {
     throw new CommerceError(
       "CONFIG_INVALID",
-      `Configuration value at "${path2}" still contains the unresolved placeholder "${residual}" after substitution \u2014 nested placeholders (e.g. "\${A:-\${B}}") are not supported. Use a plain default, or set the variable.`,
-      { details: { path: path2, residual } }
+      `Configuration value at "${path2}" nests placeholders (e.g. "\${A:-\${B}}"), which is not supported \u2014 the inner one is not resolved and its closing brace ends up in the value. Use a plain default, or set the variable.`,
+      { details: { path: path2 } }
+    );
+  }
+  BRACE_TOKEN.lastIndex = 0;
+  for (const [token] of value.matchAll(BRACE_TOKEN)) {
+    if (SUPPORTED_TOKEN.test(token)) continue;
+    throw new CommerceError(
+      "CONFIG_INVALID",
+      `Configuration value at "${path2}" contains "${token}", which is not a supported placeholder. Only "\${VAR}" and "\${VAR:-default}" are recognised; shell forms such as "\${VAR-default}", "\${VAR:=default}" and "\${VAR:?message}" would load as literal text.`,
+      { details: { path: path2, token } }
     );
   }
-  return substituted;
 }
 function substituteOnce(value, env, path2) {
   return value.replace(
@@ -322,11 +387,191 @@ function substituteOnce(value, env, path2) {
 function isPlainObject(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-var PLACEHOLDER_PATTERN;
+var PLACEHOLDER_PATTERN, BRACE_TOKEN, SUPPORTED_TOKEN, NESTED_PLACEHOLDER;
 var init_env = __esm({
   "src/config/env.ts"() {
     init_core();
     PLACEHOLDER_PATTERN = /\$\{([A-Za-z_][A-Za-z0-9_]*)(:-([^}]*))?\}/g;
+    BRACE_TOKEN = /\$\{[^{}]*\}/g;
+    SUPPORTED_TOKEN = /^\$\{[A-Za-z_][A-Za-z0-9_]*(:-[^}]*)?\}$/;
+    NESTED_PLACEHOLDER = /\$\{[^{}]*\$\{/;
+  }
+});
+
+// src/payments/x402/local-chain/accounts.ts
+var ANVIL_WELL_KNOWN_ACCOUNTS;
+var init_accounts = __esm({
+  "src/payments/x402/local-chain/accounts.ts"() {
+    ANVIL_WELL_KNOWN_ACCOUNTS = [
+      {
+        address: "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266",
+        privateKey: "0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80"
+      },
+      {
+        address: "0x70997970C51812dc3A010C7d01b50e0d17dc79C8",
+        privateKey: "0x59c6995e998f97a5a0044966f0945389dc9e86dae88c7a8412f4603b6b78690d"
+      },
+      {
+        address: "0x3C44CdDdB6a900fa2b585dd299e03d12FA4293BC",
+        privateKey: "0x5de4111afa1a4b94908f83103eb1f1706367c2e68ca870fc3fb9a804cdab365a"
+      }
+    ];
+    ANVIL_WELL_KNOWN_ACCOUNTS[0];
+    ANVIL_WELL_KNOWN_ACCOUNTS[1];
+    ANVIL_WELL_KNOWN_ACCOUNTS[2];
+  }
+});
+
+// src/payments/x402/dev-key-guard.ts
+function isWellKnownDevAddress(address) {
+  return WELL_KNOWN_DEV_ADDRESSES.has(address.toLowerCase());
+}
+function isLikelyLocalOrPrivateHost(hostname) {
+  const h = hostname.toLowerCase().replace(/^\[|\]$/g, "");
+  if (h === "localhost" || h === "127.0.0.1" || h === "::1") return true;
+  if (/^127\.\d{1,3}\.\d{1,3}\.\d{1,3}$/.test(h)) return true;
+  if (/^10\.\d{1,3}\.\d{1,3}\.\d{1,3}$/.test(h)) return true;
+  if (/^192\.168\.\d{1,3}\.\d{1,3}$/.test(h)) return true;
+  if (/^172\.(1[6-9]|2\d|3[01])\.\d{1,3}\.\d{1,3}$/.test(h)) return true;
+  if (!h.includes(".") && !h.includes(":")) return true;
+  return false;
+}
+var WELL_KNOWN_DEV_ADDRESSES;
+var init_dev_key_guard = __esm({
+  "src/payments/x402/dev-key-guard.ts"() {
+    init_core();
+    init_accounts();
+    new Set(
+      ANVIL_WELL_KNOWN_ACCOUNTS.map((a) => a.privateKey.toLowerCase())
+    );
+    WELL_KNOWN_DEV_ADDRESSES = new Set(
+      ANVIL_WELL_KNOWN_ACCOUNTS.map((a) => a.address.toLowerCase())
+    );
+  }
+});
+
+// src/payments/x402/guardrails.ts
+function invalid(message, path2) {
+  return new CommerceError("CONFIG_INVALID", message, { details: { path: path2 } });
+}
+function resolveX402Deployment(input) {
+  const profile = requireNetworkProfile(input.network, "payments.x402.network");
+  const mode = resolveDeploymentMode(profile, input.facilitator.mode);
+  if (profile.kind === "mainnet" && input.facilitator.mode === "local") {
+    throw invalid(
+      `payments.x402: network "${profile.id}" (${profile.displayName}) is a mainnet and cannot be served by facilitator.mode "local". A mainnet deployment must settle through a remote facilitator.`,
+      "payments.x402.facilitator.mode"
+    );
+  }
+  if (mode === "mainnet" && input.allowMainnet !== true) {
+    throw invalid(
+      `payments.x402: network "${profile.id}" (${profile.displayName}) settles real funds. Set payments.x402.allowMainnet: true to acknowledge this explicitly \u2014 it is never the default.`,
+      "payments.x402.allowMainnet"
+    );
+  }
+  if (input.facilitator.mode === "remote") {
+    assertFacilitatorUrlIsSafe(input.facilitator.url, mode);
+    if (mode === "mainnet" && input.facilitator.auth.type === "none" && input.allowUnauthenticatedFacilitator !== true) {
+      throw invalid(
+        `payments.x402: facilitator ${describeOrigin(input.facilitator.url)} takes no credential, and this is a mainnet deployment. It will see every payment authorisation you handle, with no account, terms or support behind it. Set payments.x402.allowUnauthenticatedFacilitator: true to accept that, or configure facilitator.auth.`,
+        "payments.x402.allowUnauthenticatedFacilitator"
+      );
+    }
+    for (const [field, value] of credentialFields(input.facilitator.auth)) {
+      if (value.trim() === "") {
+        throw invalid(
+          `payments.x402: facilitator.auth.type is "${input.facilitator.auth.type}" but ${field} is empty. An empty credential is refused rather than sent.`,
+          `payments.x402.facilitator.auth.${field}`
+        );
+      }
+    }
+  }
+  if (/^0x0{40}$/i.test(input.payTo)) {
+    throw invalid(
+      'payments.x402: "payTo" is the zero address. Every payment settled there is destroyed.',
+      "payments.x402.payTo"
+    );
+  }
+  if (mode !== "local" && isWellKnownDevAddress(input.payTo)) {
+    throw invalid(
+      `payments.x402: "payTo" (${input.payTo}) is a well-known Anvil development address and this is a ${mode} deployment. Anyone can spend what settles there. Set payTo to your own merchant wallet.`,
+      "payments.x402.payTo"
+    );
+  }
+  const canonical = profile.canonicalAsset;
+  if (mode === "mainnet" && canonical) {
+    if (!sameAddress(input.asset, canonical.address)) {
+      throw invalid(
+        `payments.x402: asset ${input.asset} is not ${canonical.symbol} on ${profile.displayName} (expected ${canonical.address}). Settling a mainnet payment in an unintended token is refused.`,
+        "payments.x402.asset"
+      );
+    }
+    if (input.assetName !== void 0 && input.assetName !== canonical.name) {
+      throw invalid(
+        `payments.x402: assetName "${input.assetName}" is not the EIP-712 domain name ${canonical.symbol} reports on ${profile.displayName} (expected "${canonical.name}"). Every payment would be refused after the buyer signed.`,
+        "payments.x402.assetName"
+      );
+    }
+    if (input.assetVersion !== void 0 && input.assetVersion !== canonical.version) {
+      throw invalid(
+        `payments.x402: assetVersion "${input.assetVersion}" is not the EIP-712 domain version ${canonical.symbol} reports on ${profile.displayName} (expected "${canonical.version}").`,
+        "payments.x402.assetVersion"
+      );
+    }
+  }
+  return { profile, mode };
+}
+function assertFacilitatorUrlIsSafe(url, mode) {
+  let parsed;
+  try {
+    parsed = new URL(url);
+  } catch (cause) {
+    throw new CommerceError("CONFIG_INVALID", `payments.x402: facilitator.url is not a valid URL`, {
+      cause,
+      details: { path: "payments.x402.facilitator.url" }
+    });
+  }
+  if (parsed.protocol === "https:") return;
+  if (parsed.protocol !== "http:") {
+    throw invalid(
+      `payments.x402: facilitator ${describeOrigin(url)} must be reached over https (or http on a local/private host); got "${parsed.protocol}//"`,
+      "payments.x402.facilitator.url"
+    );
+  }
+  if (mode !== "mainnet" && isLikelyLocalOrPrivateHost(parsed.hostname)) return;
+  throw invalid(
+    `payments.x402: facilitator ${describeOrigin(url)} is reached over plain HTTP. Payment authorisations and settlement results would travel unencrypted. Use https, or point at a local/private host on a non-mainnet deployment.`,
+    "payments.x402.facilitator.url"
+  );
+}
+function describeOrigin(url) {
+  try {
+    return new URL(url).origin;
+  } catch {
+    return "[unparseable facilitator.url]";
+  }
+}
+function credentialFields(auth) {
+  switch (auth.type) {
+    case "bearer":
+      return [["token", auth.token]];
+    case "cdp":
+      return [
+        ["apiKeyId", auth.apiKeyId],
+        ["apiKeySecret", auth.apiKeySecret]
+      ];
+    default:
+      return [];
+  }
+}
+function sameAddress(a, b) {
+  return a.toLowerCase() === b.toLowerCase();
+}
+var init_guardrails = __esm({
+  "src/payments/x402/guardrails.ts"() {
+    init_core();
+    init_dev_key_guard();
+    init_networks();
   }
 });
 function parseConfig(raw, env) {
@@ -435,14 +680,12 @@ function normalise(raw) {
     }
   };
   const x402Raw = raw.payments.x402;
-  if (x402Raw?.facilitator.mode === "remote") {
-    throw new CommerceError(
-      "CONFIG_INVALID",
-      'payments.x402.facilitator.mode "remote" is not supported in v0.1.0-alpha; use "local" (the deterministic dev-chain facilitator)',
-      { details: { path: "payments.x402.facilitator.mode" } }
-    );
-  }
-  const x402 = x402Raw ? {
+  const facilitator = x402Raw === void 0 ? void 0 : x402Raw.facilitator.mode === "local" ? { mode: "local", signerPrivateKey: x402Raw.facilitator.signerPrivateKey } : {
+    mode: "remote",
+    url: x402Raw.facilitator.url,
+    auth: x402Raw.facilitator.auth ?? { type: "none" }
+  };
+  const x402 = x402Raw && facilitator ? {
     enabled: toBoolean(x402Raw.enabled, "payments.x402.enabled"),
     network: x402Raw.network,
     rpcUrl: x402Raw.rpcUrl,
@@ -454,18 +697,35 @@ function normalise(raw) {
       max: 36
     }),
     payTo: x402Raw.payTo,
-    maxTimeoutSeconds: toNumber(x402Raw.maxTimeoutSeconds, "payments.x402.maxTimeoutSeconds", {
-      min: 1
-    }),
-    // Only "local" can reach here — "remote" was rejected above.
-    facilitator: {
-      mode: "local",
-      signerPrivateKey: x402Raw.facilitator.signerPrivateKey
-    }
+    maxTimeoutSeconds: toNumber(
+      x402Raw.maxTimeoutSeconds,
+      "payments.x402.maxTimeoutSeconds",
+      {
+        min: 1
+      }
+    ),
+    facilitator,
+    ...x402Raw.allowMainnet !== void 0 ? { allowMainnet: toBoolean(x402Raw.allowMainnet, "payments.x402.allowMainnet") } : {},
+    ...x402Raw.allowUnauthenticatedFacilitator !== void 0 ? {
+      allowUnauthenticatedFacilitator: toBoolean(
+        x402Raw.allowUnauthenticatedFacilitator,
+        "payments.x402.allowUnauthenticatedFacilitator"
+      )
+    } : {}
   } : void 0;
   if (x402) {
     validateAddress("payments.x402.payTo", x402.payTo);
     validateAddress("payments.x402.asset", x402.asset);
+    resolveX402Deployment({
+      network: x402.network,
+      payTo: x402.payTo,
+      asset: x402.asset,
+      assetName: x402.assetName,
+      assetVersion: x402.assetVersion,
+      facilitator: x402.facilitator,
+      ...x402.allowMainnet !== void 0 ? { allowMainnet: x402.allowMainnet } : {},
+      ...x402.allowUnauthenticatedFacilitator !== void 0 ? { allowUnauthenticatedFacilitator: x402.allowUnauthenticatedFacilitator } : {}
+    });
   }
   const resources = Object.entries(raw.resources).map(
     ([id, entry]) => normaliseResource(id, entry, protocols, x402)
@@ -510,7 +770,7 @@ function normaliseResource(id, entry, protocols, x402) {
   }
   for (const protocol of entry.expose) {
     if (!SUPPORTED_PROTOCOLS.has(protocol)) {
-      const hint = protocol === "ucp" ? " (UCP is planned, not supported in v0.1.0-alpha)" : "";
+      const hint = protocol === "ucp" ? " (UCP is planned, not supported in this release)" : "";
       throw new CommerceError(
         "CONFIG_INVALID",
         `Resource "${id}" exposes unsupported protocol "${protocol}"${hint}. Supported: http, mcp.`,
@@ -546,7 +806,7 @@ function normaliseResource(id, entry, protocols, x402) {
   if (entry.pricing.type === "dynamic") {
     throw new CommerceError(
       "CONFIG_INVALID",
-      `Resource "${id}" uses pricing.type "dynamic", which is not supported in v0.1.0-alpha`,
+      `Resource "${id}" uses pricing.type "dynamic", which is not supported in this release`,
       { details: { path: `resources.${id}.pricing.type`, resourceId: id } }
     );
   }
@@ -623,6 +883,10 @@ function defaultClosedObjectSchema(schema) {
   if (isPlainObject2(items)) {
     result["items"] = defaultClosedObjectSchema(items);
   }
+  const additional = schema["additionalProperties"];
+  if (isPlainObject2(additional)) {
+    result["additionalProperties"] = defaultClosedObjectSchema(additional);
+  }
   return result;
 }
 function isPlainObject2(value) {
@@ -670,6 +934,10 @@ function validateResourceSchemaKeywords(id, path2, schema) {
       if (isPlainObject2(sub)) validateResourceSchemaKeywords(id, `${path2}.properties.${key}`, sub);
     }
   }
+  const additional = schema["additionalProperties"];
+  if (isPlainObject2(additional)) {
+    validateResourceSchemaKeywords(id, `${path2}.additionalProperties`, additional);
+  }
   const items = schema["items"];
   if (isPlainObject2(items)) {
     validateResourceSchemaKeywords(id, `${path2}.items`, items);
@@ -717,6 +985,23 @@ function validatePathParametersDeclared(id, url, input) {
   }
   const params = extractPathParameterNames(url);
   if (params.length === 0) return;
+  const firstBrace = url.indexOf("{");
+  if (firstBrace !== -1) {
+    const prefix = url.slice(0, firstBrace);
+    let origin;
+    try {
+      const parsedPrefix = new URL(prefix);
+      origin = parsedPrefix.hostname === "" ? void 0 : parsedPrefix.origin;
+    } catch {
+    }
+    if (origin === void 0 || !prefix.startsWith(`${origin}/`)) {
+      throw new CommerceError(
+        "CONFIG_INVALID",
+        `Resource "${id}" has a backend.url parameter before the end of the host ("${url}"). A caller-supplied value would choose which host the gateway calls, which is request forgery with the gateway's own network position. Parameters are supported inside the path and query only`,
+        { details: { path: `resources.${id}.backend.url`, resourceId: id } }
+      );
+    }
+  }
   const propertiesRaw = input?.["properties"];
   const properties = isPlainObject2(propertiesRaw) ? propertiesRaw : {};
   const requiredRaw = input?.["required"];
@@ -778,11 +1063,12 @@ function validateAddress(path2, value) {
     );
   }
 }
-var SUPPORTED_CONFIG_VERSION, ADDRESS_PATTERN, ZERO_ADDRESS_PATTERN, MCP_TOOL_NAME_PATTERN, NumberOrString, BooleanOrString, MerchantSchema, ServerSchema, StorageSchema, ProtocolsSchema, BackendMethodSchema, BackendHandlerSchema, PricingSchema, JsonSchemaValueSchema, ResourceEntrySchema, ResourcesMapSchema, FacilitatorSchema, X402Schema, PaymentsSchema, RawConfigSchema, SUPPORTED_PROTOCOLS, SUPPORTED_PAYMENT_METHODS, EMPTY_CLOSED_OBJECT_SCHEMA, UNSUPPORTED_SCHEMA_KEYWORDS, PRICING_AMOUNT_PATTERN, ZERO_AMOUNT_PATTERN;
+var SUPPORTED_CONFIG_VERSION, ADDRESS_PATTERN, ZERO_ADDRESS_PATTERN, MCP_TOOL_NAME_PATTERN, NumberOrString, BooleanOrString, MerchantSchema, ServerSchema, StorageSchema, RESERVED_GATEWAY_PATHS, McpMountPathSchema, ProtocolsSchema, BackendMethodSchema, BackendHandlerSchema, PricingSchema, JsonSchemaValueSchema, ResourceEntrySchema, ResourcesMapSchema, FacilitatorAuthSchema, FacilitatorSchema, X402Schema, PaymentsSchema, RawConfigSchema, SUPPORTED_PROTOCOLS, SUPPORTED_PAYMENT_METHODS, EMPTY_CLOSED_OBJECT_SCHEMA, UNSUPPORTED_SCHEMA_KEYWORDS, PRICING_AMOUNT_PATTERN, ZERO_AMOUNT_PATTERN;
 var init_schema = __esm({
   "src/config/schema.ts"() {
     init_execution();
     init_core();
+    init_guardrails();
     init_env();
     SUPPORTED_CONFIG_VERSION = 1;
     ADDRESS_PATTERN = /^0x[0-9a-fA-F]{40}$/;
@@ -820,11 +1106,36 @@ var init_schema = __esm({
         path: z.string().min(1)
       }).strict()
     }).strict();
+    RESERVED_GATEWAY_PATHS = [
+      "/health",
+      "/ready",
+      "/.well-known/agent-commerce",
+      "/api/resources",
+      "/api/resources/:id/invoke",
+      "/api/receipts",
+      "/api/events",
+      "/api/events/stream"
+    ];
+    McpMountPathSchema = z.string().min(1).refine((value) => value.startsWith("/"), {
+      message: 'must start with "/" \u2014 it is an absolute gateway path, e.g. "/mcp".'
+    }).refine((value) => !/[:*?\s]/.test(value), {
+      message: 'must not contain ":", "*", "?" or whitespace \u2014 the mount is a literal path prefix, not a Fastify route pattern, and registers its own wildcard.'
+    }).refine(
+      (value) => {
+        const base = value.replace(/\/+$/, "");
+        return !RESERVED_GATEWAY_PATHS.some(
+          (reserved) => reserved === base || reserved.startsWith(`${base}/`)
+        );
+      },
+      {
+        message: `must not collide with a route the gateway already serves (${RESERVED_GATEWAY_PATHS.join(", ")}); pick a dedicated prefix such as "/mcp".`
+      }
+    );
     ProtocolsSchema = z.object({
       http: z.object({ enabled: BooleanOrString }).strict(),
       mcp: z.object({
         enabled: BooleanOrString,
-        mountPath: z.string().min(1)
+        mountPath: McpMountPathSchema
       }).strict()
     }).strict();
     BackendMethodSchema = z.enum(["GET", "POST", "PUT", "PATCH", "DELETE"]);
@@ -859,6 +1170,17 @@ var init_schema = __esm({
       payments: z.array(z.string().min(1)).optional()
     }).strict();
     ResourcesMapSchema = z.record(z.string().min(1), ResourceEntrySchema);
+    FacilitatorAuthSchema = z.discriminatedUnion("type", [
+      z.object({ type: z.literal("none") }).strict(),
+      z.object({ type: z.literal("bearer"), token: z.string().min(1) }).strict(),
+      // Coinbase Developer Platform. Needs the optional peer `@coinbase/x402`,
+      // which signs a fresh JWT per request; a static header cannot express it.
+      z.object({
+        type: z.literal("cdp"),
+        apiKeyId: z.string().min(1),
+        apiKeySecret: z.string().min(1)
+      }).strict()
+    ]);
     FacilitatorSchema = z.discriminatedUnion("mode", [
       z.object({
         mode: z.literal("local"),
@@ -866,7 +1188,12 @@ var init_schema = __esm({
       }).strict(),
       z.object({
         mode: z.literal("remote"),
-        url: z.string().min(1)
+        url: z.string().min(1),
+        // Absent means "this facilitator takes no credential" — an explicit
+        // statement, normalised to `{ type: 'none' }` below. On a mainnet that
+        // combination is refused outright, so the default can never quietly
+        // become an unauthenticated production facilitator.
+        auth: FacilitatorAuthSchema.optional()
       }).strict()
     ]);
     X402Schema = z.object({
@@ -879,7 +1206,11 @@ var init_schema = __esm({
       assetDecimals: NumberOrString,
       payTo: z.string().min(1),
       maxTimeoutSeconds: NumberOrString,
-      facilitator: FacilitatorSchema
+      facilitator: FacilitatorSchema,
+      /** Real funds. Never defaulted — see src/payments/x402/guardrails.ts. */
+      allowMainnet: BooleanOrString.optional(),
+      /** Accepts a mainnet facilitator that takes no credential. Never defaulted. */
+      allowUnauthenticatedFacilitator: BooleanOrString.optional()
     }).strict();
     PaymentsSchema = z.object({
       x402: X402Schema.optional()
@@ -1080,10 +1411,11 @@ async function execCommand(command, args) {
 // src/cli/commands/doctor.ts
 init_execution();
 init_core();
+init_networks();
 
 // src/storage/receipts/store.ts
 init_core();
-var PACKAGE_VERSION = "0.1.0-alpha.0" ;
+var PACKAGE_VERSION = "1.0.0" ;
 
 // src/storage/receipts/redact.ts
 var SECRET_KEY_PATTERN = /private[-_ ]?key|secret|password|mnemonic|seed[-_ ]?phrase|api[-_ ]?key|authoriz(e|ation)|^auth$|auth[-_]?header|payment[-_ ]?proof|^proof$|x-payment|signature|signed[-_ ]?message|token|bearer|credential|cookie|session|jwt/i;
@@ -1308,6 +1640,12 @@ function createSqliteReceiptStore(options) {
       );
     }
   }
+  if (isFileBacked) {
+    try {
+      closeSync(openSync(path2, "a", 384));
+    } catch {
+    }
+  }
   const db = new Database(path2);
   db.pragma("journal_mode = WAL");
   db.pragma("foreign_keys = ON");
@@ -1598,23 +1936,8 @@ async function fetchJson(fetchImpl, url, timeoutMs = 1500) {
   }
 }
 
-// src/payments/x402/local-chain/accounts.ts
-var ANVIL_WELL_KNOWN_ACCOUNTS = [
-  {
-    address: "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266",
-    privateKey: "0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80"
-  },
-  {
-    address: "0x70997970C51812dc3A010C7d01b50e0d17dc79C8",
-    privateKey: "0x59c6995e998f97a5a0044966f0945389dc9e86dae88c7a8412f4603b6b78690d"
-  },
-  {
-    address: "0x3C44CdDdB6a900fa2b585dd299e03d12FA4293BC",
-    privateKey: "0x5de4111afa1a4b94908f83103eb1f1706367c2e68ca870fc3fb9a804cdab365a"
-  }
-];
-
 // src/cli/lib/init-config.ts
+init_accounts();
 var LOCAL_DEV_MERCHANT_ADDRESS = ANVIL_WELL_KNOWN_ACCOUNTS[1].address;
 var LOCAL_DEV_FACILITATOR_PRIVATE_KEY = ANVIL_WELL_KNOWN_ACCOUNTS[0].privateKey;
 var PLACEHOLDER_ASSET_ADDRESS = "0x000000000000000000000000000000000000dEaD";
@@ -1692,7 +2015,7 @@ function buildInitConfigObject(answers) {
     payments: answers.x402Enabled ? {
       x402: {
         enabled: true,
-        network: "base-sepolia",
+        network: "eip155:84532",
         rpcUrl: "http://127.0.0.1:8545",
         asset: PLACEHOLDER_ASSET_ADDRESS,
         assetName: "MockUSDC",
@@ -1845,7 +2168,7 @@ function maskMiddle(value, keep = 6) {
 }
 createRequire(import.meta.url);
 function readVersionReport() {
-  const injected = '{"cliVersion":"0.1.0-alpha.0","pinned":[{"name":"@modelcontextprotocol/sdk","version":"1.30.0","via":"@devlab.group/agent-commerce"},{"name":"x402","version":"1.2.0","via":"@devlab.group/agent-commerce"},{"name":"viem","version":"2.55.18","via":"@devlab.group/agent-commerce"},{"name":"better-sqlite3","version":"13.0.3","via":"@devlab.group/agent-commerce"},{"name":"fastify","version":"5.12.0","via":"@devlab.group/agent-commerce"},{"name":"pino","version":"10.3.1","via":"@devlab.group/agent-commerce"},{"name":"zod","version":"3.25.76","via":"@devlab.group/agent-commerce"}]}' ;
+  const injected = '{"cliVersion":"1.0.0","pinned":[{"name":"@coinbase/x402","version":"2.1.0","via":"@devlab.group/agent-commerce"},{"name":"@modelcontextprotocol/sdk","version":"1.30.0","via":"@devlab.group/agent-commerce"},{"name":"@x402/core","version":"2.23.0","via":"@devlab.group/agent-commerce"},{"name":"@x402/evm","version":"2.23.0","via":"@devlab.group/agent-commerce"},{"name":"viem","version":"2.55.18","via":"@devlab.group/agent-commerce"},{"name":"better-sqlite3","version":"13.0.3","via":"@devlab.group/agent-commerce"},{"name":"fastify","version":"5.12.0","via":"@devlab.group/agent-commerce"},{"name":"pino","version":"10.3.1","via":"@devlab.group/agent-commerce"},{"name":"zod","version":"3.25.76","via":"@devlab.group/agent-commerce"}]}' ;
   {
     return JSON.parse(injected);
   }
@@ -1884,12 +2207,12 @@ function extractWellKnownX402(body) {
   }
   return { asset, network, payTo };
 }
-function sameAddress(a, b) {
+function sameAddress2(a, b) {
   return a.toLowerCase() === b.toLowerCase();
 }
 function findX402Mismatch(configured, live) {
   const diffs = [];
-  if (!sameAddress(configured.asset, live.asset)) {
+  if (!sameAddress2(configured.asset, live.asset)) {
     diffs.push(
       `asset: gateway is using ${live.asset} but local config resolves to ${configured.asset}`
     );
@@ -1899,7 +2222,7 @@ function findX402Mismatch(configured, live) {
       `network: gateway is using "${live.network}" but local config resolves to "${configured.network}"`
     );
   }
-  if (!sameAddress(configured.payTo, live.payTo)) {
+  if (!sameAddress2(configured.payTo, live.payTo)) {
     diffs.push(
       `payTo: gateway is using ${live.payTo} but local config resolves to ${configured.payTo}`
     );
@@ -1994,9 +2317,13 @@ async function runDoctor(options, deps = {}) {
   if (x402 === void 0 || !x402.enabled) {
     checks.push({ name: "Payments", status: "INFO", detail: "x402 not configured" });
   } else {
-    const summary = `x402 enabled \u2014 network=${x402.network}, destination=${maskMiddle(x402.payTo)}, facilitator=${x402.facilitator.mode}`;
+    const profile = findNetworkProfile(x402.network);
+    const mode = profile ? resolveDeploymentMode(profile, x402.facilitator.mode) : void 0;
+    const where = profile === void 0 || mode === void 0 ? `unknown network ${x402.network}` : mode === "local" ? `LOCAL dev chain (${x402.network}, chain id shared with ${profile.displayName})` : `${describeDeploymentMode(mode)} on ${profile.displayName} (${x402.network})`;
+    const facilitatorDetail = x402.facilitator.mode === "local" ? "local" : `remote (auth=${x402.facilitator.auth.type})`;
+    const summary = `x402 v2 (scheme=exact) enabled \u2014 ${where}, destination=${maskMiddle(x402.payTo)}, facilitator=${facilitatorDetail}`;
     const live = wellKnown?.ok ? extractWellKnownX402(wellKnown.body) : void 0;
-    if (sameAddress(x402.asset, PLACEHOLDER_ASSET_ADDRESS)) {
+    if (sameAddress2(x402.asset, PLACEHOLDER_ASSET_ADDRESS)) {
       checks.push({
         name: "Payments",
         status: "WARN",
@@ -2020,11 +2347,19 @@ async function runDoctor(options, deps = {}) {
         mismatch === void 0 ? { name: "Payments", status: "PASS", detail: summary } : { name: "Payments", status: "FAIL", detail: mismatch }
       );
     }
+    if (mode === "mainnet") {
+      const unauthenticated = x402.facilitator.mode === "remote" && x402.facilitator.auth.type === "none";
+      checks.push({
+        name: "Mainnet safety",
+        status: unauthenticated ? "WARN" : "INFO",
+        detail: unauthenticated ? `${describeDeploymentMode("mainnet")} \u2014 settling through a facilitator that takes no credential, accepted via allowUnauthenticatedFacilitator. It sees every payment authorisation you handle, with no account or terms behind it. Everything else is enforced at config load: explicit allowMainnet opt-in, HTTPS, non-development payTo, canonical asset. Payments are fail-closed.` : `${describeDeploymentMode("mainnet")} \u2014 enforced at config load: explicit allowMainnet opt-in, remote facilitator over HTTPS with a credential, non-development payTo, and the canonical asset for this network. Payments are fail-closed.`
+      });
+    }
   }
   checks.push({
     name: "Payments (MPP)",
     status: "INFO",
-    detail: "planned \u2014 not implemented in v0.1"
+    detail: "planned \u2014 not implemented in this release"
   });
   if (config === void 0) {
     checks.push({ name: "Storage", status: "WARN", detail: "skipped \u2014 config invalid" });
@@ -2034,9 +2369,8 @@ async function runDoctor(options, deps = {}) {
     // from the host) silently produces a fresh empty database and a false
     // "healthy, receipts=0" PASS — a read-only command must not have this
     // side effect, and it shadows the real store's real receipts entirely.
-    //. `:memory:` never exists on disk by
-    // definition, so it always falls through to the real open/health/count
-    // branch below, same as today.
+    // `:memory:` never exists on disk by definition, so it always falls
+    // through to the real open/health/count branch below, same as today.
     config.storage.receipts.path !== ":memory:" && !existsSync(config.storage.receipts.path)
   ) {
     checks.push({
@@ -2379,6 +2713,12 @@ function buildProgram(io = processIo) {
 }
 
 // src/cli/index.ts
+for (const stream of [process.stdout, process.stderr]) {
+  stream.on("error", (err) => {
+    if (err.code === "EPIPE") process.exit(0);
+    throw err;
+  });
+}
 async function main() {
   const program = buildProgram();
   try {