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

package/dist/cli/index.js

@@ -0,0 +1,2396 @@
+#!/usr/bin/env node
+import { ZodError, z } from 'zod';
+import { existsSync, mkdirSync, accessSync, constants, readFileSync, chmodSync, promises } from 'fs';
+import * as path from 'path';
+import { resolve, dirname, join } from 'path';
+import { stringify, parse, YAMLError } from 'yaml';
+import { CommanderError, Command } from 'commander';
+import picocolors from 'picocolors';
+import { randomUUID } from 'crypto';
+import Database from 'better-sqlite3';
+import { createRequire } from 'module';
+import { writeFile } from 'fs/promises';
+import * as clack from '@clack/prompts';
+
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/config/filename.ts
+var DEFAULT_CONFIG_FILENAME;
+var init_filename = __esm({
+  "src/config/filename.ts"() {
+    DEFAULT_CONFIG_FILENAME = "config.yaml";
+  }
+});
+
+// src/core/domain/resource.ts
+var init_resource = __esm({
+  "src/core/domain/resource.ts"() {
+  }
+});
+
+// src/core/errors/codes.ts
+var COMMERCE_ERROR_HTTP_STATUS, RETRYABLE_ERROR_CODES;
+var init_codes = __esm({
+  "src/core/errors/codes.ts"() {
+    COMMERCE_ERROR_HTTP_STATUS = {
+      CONFIG_INVALID: 500,
+      RESOURCE_NOT_FOUND: 404,
+      INPUT_INVALID: 400,
+      PAYMENT_REQUIRED: 402,
+      PAYMENT_INVALID: 402,
+      PAYMENT_REPLAYED: 409,
+      PAYMENT_PROVIDER_UNAVAILABLE: 503,
+      PAYMENT_SETTLEMENT_FAILED: 502,
+      BACKEND_TIMEOUT: 504,
+      BACKEND_ERROR: 502,
+      PROTOCOL_UNSUPPORTED: 501,
+      GATEWAY_BUSY: 503,
+      STORAGE_ERROR: 500,
+      INTERNAL_ERROR: 500
+    };
+    RETRYABLE_ERROR_CODES = /* @__PURE__ */ new Set([
+      "PAYMENT_PROVIDER_UNAVAILABLE",
+      "BACKEND_TIMEOUT",
+      // Load shedding is transient by definition: the caller should back off and
+      // try again. Before this code existed the MCP adapter's queue-full path threw
+      // PROTOCOL_UNSUPPORTED — HTTP 501, retryable:false — so an agent framework
+      // keyed on the machine-readable flag (which exists precisely so clients need
+      // not parse prose) would read a momentary throttle as a permanent capability
+      // gap and stop calling the tool.
+      "GATEWAY_BUSY"
+    ]);
+  }
+});
+
+// src/core/errors/commerce-error.ts
+function isCommerceError(value) {
+  return value instanceof CommerceError;
+}
+function toCommerceError(value, fallbackCode = "INTERNAL_ERROR", fallbackMessage = "Unexpected internal error") {
+  if (isCommerceError(value)) return value;
+  return new CommerceError(fallbackCode, fallbackMessage, { cause: value });
+}
+var CommerceError;
+var init_commerce_error = __esm({
+  "src/core/errors/commerce-error.ts"() {
+    init_codes();
+    CommerceError = class _CommerceError extends Error {
+      code;
+      httpStatus;
+      retryable;
+      details;
+      requestId;
+      resourceId;
+      constructor(code, message, options = {}) {
+        super(message, options.cause !== void 0 ? { cause: options.cause } : void 0);
+        this.name = "CommerceError";
+        this.code = code;
+        this.httpStatus = options.httpStatus ?? COMMERCE_ERROR_HTTP_STATUS[code];
+        this.retryable = RETRYABLE_ERROR_CODES.has(code);
+        if (options.details !== void 0) this.details = options.details;
+        if (options.requestId !== void 0) this.requestId = options.requestId;
+        if (options.resourceId !== void 0) this.resourceId = options.resourceId;
+        Error.captureStackTrace?.(this, _CommerceError);
+      }
+      /** Non-secret, client-safe representation. */
+      toInfo() {
+        return {
+          code: this.code,
+          message: this.message,
+          httpStatus: this.httpStatus,
+          retryable: this.retryable,
+          ...this.requestId !== void 0 ? { requestId: this.requestId } : {},
+          ...this.resourceId !== void 0 ? { resourceId: this.resourceId } : {},
+          ...this.details !== void 0 ? { details: this.details } : {}
+        };
+      }
+    };
+  }
+});
+
+// src/core/errors/index.ts
+var init_errors = __esm({
+  "src/core/errors/index.ts"() {
+    init_codes();
+    init_commerce_error();
+  }
+});
+
+// src/core/interfaces/logger.ts
+var NOOP_LOGGER;
+var init_logger = __esm({
+  "src/core/interfaces/logger.ts"() {
+    NOOP_LOGGER = {
+      debug: () => {
+      },
+      info: () => {
+      },
+      warn: () => {
+      },
+      error: () => {
+      },
+      child: () => NOOP_LOGGER
+    };
+  }
+});
+
+// src/core/execution/backend-http.ts
+function extractPathParameterNames(url) {
+  return [...url.matchAll(PATH_PARAM_PATTERN)].map((match) => match[1]);
+}
+function findUnparsedBraceToken(url) {
+  const residue = url.replace(PATH_PARAM_PATTERN, "");
+  const index = residue.search(/[{}]/);
+  if (index === -1) return void 0;
+  const token = /\{[^{}]*\}?|\}/.exec(residue.slice(index));
+  return token?.[0] ?? residue[index];
+}
+var PATH_PARAM_PATTERN;
+var init_backend_http = __esm({
+  "src/core/execution/backend-http.ts"() {
+    init_resource();
+    init_errors();
+    init_logger();
+    PATH_PARAM_PATTERN = /\{([a-zA-Z0-9_.-]+)\}/g;
+  }
+});
+
+// src/core/execution/event-bus.ts
+var init_event_bus = __esm({
+  "src/core/execution/event-bus.ts"() {
+  }
+});
+
+// src/core/domain/wire.ts
+var PAYMENT_INPUT_FIELD;
+var init_wire = __esm({
+  "src/core/domain/wire.ts"() {
+    PAYMENT_INPUT_FIELD = "_payment";
+  }
+});
+
+// src/core/execution/validation.ts
+function typeList(raw) {
+  if (typeof raw === "string") return [raw];
+  if (Array.isArray(raw) && raw.every((entry) => typeof entry === "string")) {
+    return raw;
+  }
+  return void 0;
+}
+function isObjectSchemaNode(schema) {
+  const types = typeList(schema["type"]);
+  if (types !== void 0) return types.includes("object");
+  return Object.hasOwn(schema, "properties") || Object.hasOwn(schema, "required");
+}
+var init_validation = __esm({
+  "src/core/execution/validation.ts"() {
+  }
+});
+
+// src/core/execution/pipeline.ts
+var init_pipeline = __esm({
+  "src/core/execution/pipeline.ts"() {
+    init_wire();
+    init_errors();
+    init_backend_http();
+    init_validation();
+  }
+});
+
+// src/core/execution/registry.ts
+var init_registry = __esm({
+  "src/core/execution/registry.ts"() {
+    init_errors();
+  }
+});
+
+// src/core/execution/index.ts
+var init_execution = __esm({
+  "src/core/execution/index.ts"() {
+    init_backend_http();
+    init_event_bus();
+    init_pipeline();
+    init_registry();
+    init_validation();
+  }
+});
+
+// src/core/domain/event.ts
+var init_event = __esm({
+  "src/core/domain/event.ts"() {
+  }
+});
+
+// src/core/interfaces/protocol-adapter.ts
+var init_protocol_adapter = __esm({
+  "src/core/interfaces/protocol-adapter.ts"() {
+  }
+});
+
+// src/core/interfaces/runtime.ts
+var systemClock;
+var init_runtime = __esm({
+  "src/core/interfaces/runtime.ts"() {
+    systemClock = {
+      now: () => /* @__PURE__ */ new Date(),
+      nowIso: () => (/* @__PURE__ */ new Date()).toISOString(),
+      monotonicMs: () => performance.now()
+    };
+  }
+});
+
+// src/core/public-types.ts
+var init_public_types = __esm({
+  "src/core/public-types.ts"() {
+    init_event();
+    init_resource();
+    init_wire();
+    init_errors();
+    init_logger();
+    init_protocol_adapter();
+    init_runtime();
+  }
+});
+
+// src/core/index.ts
+var init_core = __esm({
+  "src/core/index.ts"() {
+    init_public_types();
+  }
+});
+
+// src/config/env.ts
+function substituteEnv(value, env, path2 = "$") {
+  if (typeof value === "string") {
+    return substituteString(value, env, path2);
+  }
+  if (Array.isArray(value)) {
+    return value.map((entry, index) => substituteEnv(entry, env, `${path2}[${index}]`));
+  }
+  if (isPlainObject(value)) {
+    const result = {};
+    for (const [key, entry] of Object.entries(value)) {
+      result[key] = substituteEnv(entry, env, `${path2}.${key}`);
+    }
+    return result;
+  }
+  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;
+    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 } }
+    );
+  }
+  return substituted;
+}
+function substituteOnce(value, env, path2) {
+  return value.replace(
+    PLACEHOLDER_PATTERN,
+    (_match, name, hasDefault, def) => {
+      const envValue = env[name];
+      if (hasDefault !== void 0) {
+        if (envValue === void 0 || envValue === "") return def ?? "";
+        return envValue;
+      }
+      if (envValue === void 0) {
+        throw new CommerceError(
+          "CONFIG_INVALID",
+          `Unresolved environment variable "\${${name}}" referenced at config path "${path2}"`,
+          { details: { variable: name, path: path2 } }
+        );
+      }
+      return envValue;
+    }
+  );
+}
+function isPlainObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+var PLACEHOLDER_PATTERN;
+var init_env = __esm({
+  "src/config/env.ts"() {
+    init_core();
+    PLACEHOLDER_PATTERN = /\$\{([A-Za-z_][A-Za-z0-9_]*)(:-([^}]*))?\}/g;
+  }
+});
+function parseConfig(raw, env) {
+  if (typeof raw !== "object" || raw === null || Array.isArray(raw)) {
+    throw new CommerceError(
+      "CONFIG_INVALID",
+      'Configuration root must be a mapping (object) at "$"',
+      {
+        details: { path: "$" }
+      }
+    );
+  }
+  checkVersion(raw);
+  const substituted = substituteEnv(raw, env);
+  const parsed = parseWithZod(RawConfigSchema, substituted);
+  return normalise(parsed);
+}
+function checkVersion(raw) {
+  if (!("version" in raw)) {
+    throw new CommerceError("CONFIG_INVALID", 'Configuration is missing required field "version"', {
+      details: { path: "version" }
+    });
+  }
+  const rawVersion = raw["version"];
+  const version = typeof rawVersion === "string" ? Number(rawVersion) : rawVersion;
+  if (version !== SUPPORTED_CONFIG_VERSION) {
+    throw new CommerceError(
+      "CONFIG_INVALID",
+      `Unsupported config version "${String(rawVersion)}": this gateway only supports version ${SUPPORTED_CONFIG_VERSION}`,
+      { details: { path: "version", supported: SUPPORTED_CONFIG_VERSION } }
+    );
+  }
+}
+function parseWithZod(schema, value) {
+  const result = schema.safeParse(value);
+  if (!result.success) {
+    throw zodErrorToConfigError(result.error);
+  }
+  return result.data;
+}
+function zodErrorToConfigError(error) {
+  const issues = error.issues.map(describeIssue);
+  const first = issues[0];
+  const message = first ? `Configuration invalid at "${first.path}": ${first.message}` : "Configuration invalid";
+  return new CommerceError("CONFIG_INVALID", message, { details: { issues } });
+}
+function describeIssue(issue) {
+  const path2 = issue.path.length > 0 ? issue.path.join(".") : "$";
+  return { path: path2, message: issue.message, code: issue.code };
+}
+function toNumber(value, path2, bounds = {}) {
+  if (typeof value === "string" && !/^\s*\d+\s*$/.test(value)) {
+    throw new CommerceError(
+      "CONFIG_INVALID",
+      `Configuration value at "${path2}" must be an integer written in decimal digits (got ${value === "" ? "an empty string" : `"${value}"`})`,
+      { details: { path: path2 } }
+    );
+  }
+  const n = typeof value === "number" ? value : Number(value);
+  if (!Number.isFinite(n) || !Number.isInteger(n)) {
+    throw new CommerceError(
+      "CONFIG_INVALID",
+      `Configuration value at "${path2}" must be an integer`,
+      {
+        details: { path: path2 }
+      }
+    );
+  }
+  if (bounds.min !== void 0 && n < bounds.min) {
+    throw new CommerceError(
+      "CONFIG_INVALID",
+      `Configuration value at "${path2}" must be >= ${bounds.min}`,
+      {
+        details: { path: path2 }
+      }
+    );
+  }
+  if (bounds.max !== void 0 && n > bounds.max) {
+    throw new CommerceError(
+      "CONFIG_INVALID",
+      `Configuration value at "${path2}" must be <= ${bounds.max}`,
+      {
+        details: { path: path2 }
+      }
+    );
+  }
+  return n;
+}
+function toBoolean(value, path2) {
+  if (typeof value === "boolean") return value;
+  const normalized = value.trim().toLowerCase();
+  if (normalized === "true") return true;
+  if (normalized === "false") return false;
+  throw new CommerceError(
+    "CONFIG_INVALID",
+    `Configuration value at "${path2}" must be a boolean ("true" or "false")`,
+    { details: { path: path2 } }
+  );
+}
+function normalise(raw) {
+  const protocols = {
+    http: { enabled: toBoolean(raw.protocols.http.enabled, "protocols.http.enabled") },
+    mcp: {
+      enabled: toBoolean(raw.protocols.mcp.enabled, "protocols.mcp.enabled"),
+      mountPath: raw.protocols.mcp.mountPath
+    }
+  };
+  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 ? {
+    enabled: toBoolean(x402Raw.enabled, "payments.x402.enabled"),
+    network: x402Raw.network,
+    rpcUrl: x402Raw.rpcUrl,
+    asset: x402Raw.asset,
+    assetName: x402Raw.assetName,
+    assetVersion: x402Raw.assetVersion,
+    assetDecimals: toNumber(x402Raw.assetDecimals, "payments.x402.assetDecimals", {
+      min: 0,
+      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
+    }
+  } : void 0;
+  if (x402) {
+    validateAddress("payments.x402.payTo", x402.payTo);
+    validateAddress("payments.x402.asset", x402.asset);
+  }
+  const resources = Object.entries(raw.resources).map(
+    ([id, entry]) => normaliseResource(id, entry, protocols, x402)
+  );
+  return {
+    version: SUPPORTED_CONFIG_VERSION,
+    merchant: {
+      id: raw.merchant.id,
+      name: raw.merchant.name,
+      publicBaseUrl: raw.merchant.publicBaseUrl
+    },
+    // min 0, not 1: port 0 is the standard "let the OS pick a free port"
+    // convention, useful for tests and ephemeral dev/demo instances.
+    server: {
+      port: toNumber(raw.server.port, "server.port", { min: 0, max: 65535 }),
+      host: raw.server.host,
+      ...raw.server.adminToken !== void 0 ? { adminToken: raw.server.adminToken } : {},
+      allowedOrigins: raw.server.allowedOrigins ?? []
+    },
+    storage: { receipts: { driver: "sqlite", path: raw.storage.receipts.path } },
+    protocols,
+    resources,
+    payments: {
+      ...x402 !== void 0 ? { x402 } : {}
+    }
+  };
+}
+function normaliseResource(id, entry, protocols, x402) {
+  if (entry.input !== void 0) validateResourceSchemaKeywords(id, "input", entry.input);
+  const inputProperties = entry.input?.["properties"];
+  if (inputProperties && typeof inputProperties === "object" && PAYMENT_INPUT_FIELD in inputProperties) {
+    throw new CommerceError(
+      "CONFIG_INVALID",
+      `Resource "${id}" declares an input property "${PAYMENT_INPUT_FIELD}", which is reserved for payment proofs`,
+      {
+        details: {
+          path: `resources.${id}.input.properties.${PAYMENT_INPUT_FIELD}`,
+          resourceId: id
+        }
+      }
+    );
+  }
+  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)" : "";
+      throw new CommerceError(
+        "CONFIG_INVALID",
+        `Resource "${id}" exposes unsupported protocol "${protocol}"${hint}. Supported: http, mcp.`,
+        { details: { path: `resources.${id}.expose`, resourceId: id, protocol } }
+      );
+    }
+  }
+  if (entry.expose.includes("mcp")) {
+    if (!protocols.mcp.enabled) {
+      throw new CommerceError(
+        "CONFIG_INVALID",
+        `Resource "${id}" is exposed via "mcp" but protocols.mcp.enabled is false`,
+        { details: { path: `resources.${id}.expose`, resourceId: id } }
+      );
+    }
+    if (!MCP_TOOL_NAME_PATTERN.test(id)) {
+      throw new CommerceError(
+        "CONFIG_INVALID",
+        `Resource "${id}" is exposed via "mcp" but its id is not a legal MCP tool name (allowed: A-Z, a-z, 0-9, "_", "-", ".", 1-128 chars)`,
+        { details: { path: `resources.${id}`, resourceId: id } }
+      );
+    }
+  }
+  if (entry.expose.includes("http") && !protocols.http.enabled) {
+    throw new CommerceError(
+      "CONFIG_INVALID",
+      `Resource "${id}" is exposed via "http" but protocols.http.enabled is false`,
+      { details: { path: `resources.${id}.expose`, resourceId: id } }
+    );
+  }
+  validateBackendUrl(id, entry.backend.url);
+  validatePathParametersDeclared(id, entry.backend.url, entry.input);
+  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`,
+      { details: { path: `resources.${id}.pricing.type`, resourceId: id } }
+    );
+  }
+  if (entry.pricing.type === "fixed") {
+    validatePricingAmount(id, entry.pricing.amount, x402);
+  }
+  const paymentMethods = entry.payments ?? [];
+  if (entry.pricing.type === "fixed") {
+    if (paymentMethods.length === 0) {
+      throw new CommerceError(
+        "CONFIG_INVALID",
+        `Resource "${id}" has fixed pricing but declares no "payments" (a paid resource must name at least one payment method)`,
+        { details: { path: `resources.${id}.payments`, resourceId: id } }
+      );
+    }
+    for (const method of paymentMethods) {
+      if (!SUPPORTED_PAYMENT_METHODS.has(method)) {
+        throw new CommerceError(
+          "CONFIG_INVALID",
+          `Resource "${id}" names unsupported payment method "${method}". Supported: x402.`,
+          { details: { path: `resources.${id}.payments`, resourceId: id, method } }
+        );
+      }
+      if (method === "x402" && (!x402 || !x402.enabled)) {
+        throw new CommerceError(
+          "CONFIG_INVALID",
+          `Resource "${id}" names payment method "x402" which is not configured or not enabled under payments.x402`,
+          { details: { path: `resources.${id}.payments`, resourceId: id, method } }
+        );
+      }
+    }
+  }
+  const pricing = entry.pricing.type === "free" ? { type: "free" } : { type: "fixed", amount: entry.pricing.amount, currency: entry.pricing.currency };
+  return {
+    id,
+    name: entry.name,
+    ...entry.description !== void 0 ? { description: entry.description } : {},
+    inputSchema: entry.input !== void 0 ? defaultClosedObjectSchema(entry.input) : EMPTY_CLOSED_OBJECT_SCHEMA,
+    ...entry.output !== void 0 ? { outputSchema: entry.output } : {},
+    handler: {
+      type: "http",
+      method: entry.backend.method,
+      url: entry.backend.url,
+      ...entry.backend.headers !== void 0 ? { headers: entry.backend.headers } : {},
+      ...entry.backend.timeoutMs !== void 0 ? {
+        timeoutMs: toNumber(entry.backend.timeoutMs, `resources.${id}.backend.timeoutMs`, {
+          min: 1
+        })
+      } : {}
+    },
+    pricing,
+    exposedVia: entry.expose,
+    paymentMethods
+  };
+}
+function defaultClosedObjectSchema(schema) {
+  const isObjectSchema = isObjectSchemaNode(schema);
+  const result = { ...schema };
+  if (isObjectSchema) {
+    const properties = schema["properties"];
+    if (isPlainObject2(properties)) {
+      result["properties"] = Object.fromEntries(
+        Object.entries(properties).map(([key, sub]) => [
+          key,
+          isPlainObject2(sub) ? defaultClosedObjectSchema(sub) : sub
+        ])
+      );
+    }
+    if (!Object.hasOwn(schema, "additionalProperties")) {
+      result["additionalProperties"] = false;
+    }
+  }
+  const items = schema["items"];
+  if (isPlainObject2(items)) {
+    result["items"] = defaultClosedObjectSchema(items);
+  }
+  return result;
+}
+function isPlainObject2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function excludesObjectType(schema) {
+  const type = schema["type"];
+  if (type === void 0 || type === "object") return false;
+  if (Array.isArray(type)) return !type.includes("object");
+  return true;
+}
+function validateResourceSchemaKeywords(id, path2, schema) {
+  for (const keyword of UNSUPPORTED_SCHEMA_KEYWORDS) {
+    if (Object.hasOwn(schema, keyword)) {
+      console.warn(
+        `[agent-commerce] resource "${id}" ${path2} uses JSON Schema keyword "${keyword}", which this gateway does not enforce (see src/core/execution/validation.ts for the supported subset). Remove it or treat it as documentation only.`
+      );
+    }
+  }
+  if ((Object.hasOwn(schema, "properties") || Object.hasOwn(schema, "required")) && excludesObjectType(schema)) {
+    throw new CommerceError(
+      "CONFIG_INVALID",
+      `Resource "${id}" ${path2} declares "properties" and/or "required" but its "type" (${JSON.stringify(schema["type"])}) does not include "object" \u2014 the validator will never route a value through either check under that type, so this schema claims to constrain input it does not actually enforce. Remove "properties"/"required", or include "object" in "type".`,
+      { details: { path: `resources.${id}.${path2}`, resourceId: id } }
+    );
+  }
+  const requiredRaw = schema["required"];
+  const closed = !Object.hasOwn(schema, "additionalProperties") ? true : schema["additionalProperties"] === false;
+  if (Array.isArray(requiredRaw) && closed && isObjectSchemaNode(schema)) {
+    const declared = isPlainObject2(schema["properties"]) ? schema["properties"] : {};
+    const undeclared = requiredRaw.filter(
+      (name) => typeof name === "string" && !Object.hasOwn(declared, name)
+    );
+    if (undeclared.length > 0) {
+      throw new CommerceError(
+        "CONFIG_INVALID",
+        `Resource "${id}" ${path2} lists ${undeclared.map((n) => `"${n}"`).join(", ")} in "required" but does not declare ${undeclared.length === 1 ? "it" : "them"} in "properties". The schema is closed (additionalProperties: false), so ${undeclared.length === 1 ? "that name is" : "those names are"} rejected as an unknown key and no input can ever satisfy this schema. Declare ${undeclared.length === 1 ? "it" : "them"} in "properties".`,
+        { details: { path: `resources.${id}.${path2}`, resourceId: id, undeclared } }
+      );
+    }
+  }
+  const properties = schema["properties"];
+  if (isPlainObject2(properties)) {
+    for (const [key, sub] of Object.entries(properties)) {
+      if (isPlainObject2(sub)) validateResourceSchemaKeywords(id, `${path2}.properties.${key}`, sub);
+    }
+  }
+  const items = schema["items"];
+  if (isPlainObject2(items)) {
+    validateResourceSchemaKeywords(id, `${path2}.items`, items);
+  } else if (Array.isArray(items)) {
+    console.warn(
+      `[agent-commerce] resource "${id}" ${path2}.items is a tuple (an array of schemas), which this gateway does not enforce \u2014 only a single schema applied to every array element is supported (see src/core/execution/validation.ts). Each position's schema is unenforced; treat it as documentation only.`
+    );
+  }
+}
+function validatePricingAmount(id, amount, x402) {
+  const path2 = `resources.${id}.pricing.amount`;
+  if (!PRICING_AMOUNT_PATTERN.test(amount)) {
+    throw new CommerceError(
+      "CONFIG_INVALID",
+      `Resource "${id}" has pricing.amount "${amount}", which is not a plain positive decimal (no currency symbol, no thousands separator, no exponent \u2014 e.g. "0.01")`,
+      { details: { path: path2, resourceId: id } }
+    );
+  }
+  if (ZERO_AMOUNT_PATTERN.test(amount)) {
+    throw new CommerceError(
+      "CONFIG_INVALID",
+      `Resource "${id}" has pricing.amount "0" \u2014 a paid resource cannot cost zero; use "pricing: { type: free }" instead`,
+      { details: { path: path2, resourceId: id } }
+    );
+  }
+  if (x402 !== void 0) {
+    const fractionalDigits = amount.includes(".") ? amount.split(".")[1]?.length ?? 0 : 0;
+    if (fractionalDigits > x402.assetDecimals) {
+      throw new CommerceError(
+        "CONFIG_INVALID",
+        `Resource "${id}" has pricing.amount "${amount}" with more precision (${fractionalDigits} fractional digits) than the configured asset supports (${x402.assetDecimals} decimals)`,
+        { details: { path: path2, resourceId: id } }
+      );
+    }
+  }
+}
+function validatePathParametersDeclared(id, url, input) {
+  const stray = findUnparsedBraceToken(url);
+  if (stray !== void 0) {
+    throw new CommerceError(
+      "CONFIG_INVALID",
+      `Resource "${id}" has backend.url containing "${stray}", which is not a valid path parameter (allowed characters: A-Z a-z 0-9 _ . -). It would be sent to the backend literally, so a paid resource would settle payment and then never reach the backend`,
+      { details: { path: `resources.${id}.backend.url`, resourceId: id, token: stray } }
+    );
+  }
+  const params = extractPathParameterNames(url);
+  if (params.length === 0) return;
+  const propertiesRaw = input?.["properties"];
+  const properties = isPlainObject2(propertiesRaw) ? propertiesRaw : {};
+  const requiredRaw = input?.["required"];
+  const required = new Set(
+    Array.isArray(requiredRaw) ? requiredRaw.filter((entry) => typeof entry === "string") : []
+  );
+  for (const param of params) {
+    const path2 = `resources.${id}.backend.url`;
+    if (!Object.hasOwn(properties, param)) {
+      throw new CommerceError(
+        "CONFIG_INVALID",
+        `Resource "${id}" has backend.url path parameter "{${param}}" which is not declared in its input schema \u2014 the caller has no way to supply it, so every call would settle payment (if priced) and then fail to reach the backend`,
+        { details: { path: path2, resourceId: id, param } }
+      );
+    }
+    if (!required.has(param)) {
+      throw new CommerceError(
+        "CONFIG_INVALID",
+        `Resource "${id}" has backend.url path parameter "{${param}}" declared in its input schema but not listed in "required" \u2014 a caller that omits it hits the same unservable-request problem as an undeclared parameter`,
+        { details: { path: path2, resourceId: id, param } }
+      );
+    }
+  }
+}
+function validateBackendUrl(id, url) {
+  let parsed;
+  try {
+    parsed = new URL(url);
+  } catch {
+    throw new CommerceError(
+      "CONFIG_INVALID",
+      `Resource "${id}" has an invalid backend.url "${url}": must be an absolute http:// or https:// URL`,
+      { details: { path: `resources.${id}.backend.url`, resourceId: id } }
+    );
+  }
+  if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+    throw new CommerceError(
+      "CONFIG_INVALID",
+      `Resource "${id}" has a backend.url with scheme "${parsed.protocol}": must be http:// or https://`,
+      { details: { path: `resources.${id}.backend.url`, resourceId: id } }
+    );
+  }
+}
+function validateAddress(path2, value) {
+  if (!ADDRESS_PATTERN.test(value)) {
+    throw new CommerceError(
+      "CONFIG_INVALID",
+      `Configuration value at "${path2}" is not a plausible address (expected "0x" followed by 40 hex characters)`,
+      { details: { path: path2 } }
+    );
+  }
+  if (ZERO_ADDRESS_PATTERN.test(value)) {
+    throw new CommerceError(
+      "CONFIG_INVALID",
+      `Configuration value at "${path2}" must not be the zero address`,
+      {
+        details: { path: path2 }
+      }
+    );
+  }
+}
+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 init_schema = __esm({
+  "src/config/schema.ts"() {
+    init_execution();
+    init_core();
+    init_env();
+    SUPPORTED_CONFIG_VERSION = 1;
+    ADDRESS_PATTERN = /^0x[0-9a-fA-F]{40}$/;
+    ZERO_ADDRESS_PATTERN = /^0x0{40}$/i;
+    MCP_TOOL_NAME_PATTERN = /^[A-Za-z0-9._-]{1,128}$/;
+    NumberOrString = z.union([z.number(), z.string()]);
+    BooleanOrString = z.union([z.boolean(), z.string()]);
+    MerchantSchema = z.object({
+      id: z.string().min(1),
+      name: z.string().min(1),
+      publicBaseUrl: z.string().min(1)
+    }).strict();
+    ServerSchema = z.object({
+      port: NumberOrString,
+      host: z.string().min(1),
+      /** Shared secret gating /api/receipts, /api/events, /api/events/stream. No token -> those routes 404. */
+      adminToken: z.string().min(1).optional(),
+      /** Browser origins allowed to read the dashboard-facing routes. Empty by default: closed. */
+      // Entries are matched literally against the browser's
+      // `Origin` header, so `"*"` and a trailing slash match nothing at all —
+      // fail-closed (a lockout, not a bypass), but silently, and a lockout with
+      // no explanation is the kind of thing an operator "fixes" by disabling the
+      // check. Reject those two shapes with a pointer instead.
+      allowedOrigins: z.array(
+        z.string().min(1).refine((origin) => origin !== "*", {
+          message: `wildcard "*" is not supported \u2014 allowedOrigins entries are matched literally against the browser's Origin header, so "*" would match nothing. List each scheme://host[:port] explicitly.`
+        }).refine((origin) => !origin.endsWith("/"), {
+          message: 'must not end with "/" \u2014 a browser Origin header never has a trailing slash, so this entry would match nothing. Use e.g. "http://localhost:5173".'
+        })
+      ).optional()
+    }).strict();
+    StorageSchema = z.object({
+      receipts: z.object({
+        driver: z.literal("sqlite"),
+        path: z.string().min(1)
+      }).strict()
+    }).strict();
+    ProtocolsSchema = z.object({
+      http: z.object({ enabled: BooleanOrString }).strict(),
+      mcp: z.object({
+        enabled: BooleanOrString,
+        mountPath: z.string().min(1)
+      }).strict()
+    }).strict();
+    BackendMethodSchema = z.enum(["GET", "POST", "PUT", "PATCH", "DELETE"]);
+    BackendHandlerSchema = z.object({
+      type: z.literal("http"),
+      method: BackendMethodSchema,
+      url: z.string().min(1),
+      headers: z.record(z.string(), z.string()).optional(),
+      timeoutMs: NumberOrString.optional()
+    }).strict();
+    PricingSchema = z.discriminatedUnion("type", [
+      z.object({ type: z.literal("free") }).strict(),
+      z.object({
+        type: z.literal("fixed"),
+        amount: z.string().min(1),
+        currency: z.string().min(1)
+      }).strict(),
+      z.object({
+        type: z.literal("dynamic"),
+        resolver: z.string().min(1)
+      }).strict()
+    ]);
+    JsonSchemaValueSchema = z.record(z.string(), z.unknown());
+    ResourceEntrySchema = z.object({
+      name: z.string().min(1),
+      description: z.string().optional(),
+      input: JsonSchemaValueSchema.optional(),
+      output: JsonSchemaValueSchema.optional(),
+      backend: BackendHandlerSchema,
+      pricing: PricingSchema,
+      expose: z.array(z.string().min(1)).min(1),
+      payments: z.array(z.string().min(1)).optional()
+    }).strict();
+    ResourcesMapSchema = z.record(z.string().min(1), ResourceEntrySchema);
+    FacilitatorSchema = z.discriminatedUnion("mode", [
+      z.object({
+        mode: z.literal("local"),
+        signerPrivateKey: z.string().min(1)
+      }).strict(),
+      z.object({
+        mode: z.literal("remote"),
+        url: z.string().min(1)
+      }).strict()
+    ]);
+    X402Schema = z.object({
+      enabled: BooleanOrString,
+      network: z.string().min(1),
+      rpcUrl: z.string().min(1),
+      asset: z.string().min(1),
+      assetName: z.string().min(1),
+      assetVersion: z.string().min(1),
+      assetDecimals: NumberOrString,
+      payTo: z.string().min(1),
+      maxTimeoutSeconds: NumberOrString,
+      facilitator: FacilitatorSchema
+    }).strict();
+    PaymentsSchema = z.object({
+      x402: X402Schema.optional()
+    }).strict();
+    RawConfigSchema = z.object({
+      version: z.literal(SUPPORTED_CONFIG_VERSION),
+      merchant: MerchantSchema,
+      server: ServerSchema,
+      storage: StorageSchema,
+      protocols: ProtocolsSchema,
+      resources: ResourcesMapSchema,
+      payments: PaymentsSchema
+    }).strict();
+    SUPPORTED_PROTOCOLS = /* @__PURE__ */ new Set(["http", "mcp"]);
+    SUPPORTED_PAYMENT_METHODS = /* @__PURE__ */ new Set(["x402"]);
+    EMPTY_CLOSED_OBJECT_SCHEMA = {
+      type: "object",
+      properties: {},
+      additionalProperties: false
+    };
+    UNSUPPORTED_SCHEMA_KEYWORDS = [
+      "pattern",
+      "minLength",
+      "maxLength",
+      "format",
+      "minimum",
+      "maximum",
+      "exclusiveMinimum",
+      "exclusiveMaximum",
+      "multipleOf",
+      "oneOf",
+      "anyOf",
+      "allOf",
+      "not",
+      "$ref",
+      "const",
+      "patternProperties",
+      "minItems",
+      "maxItems",
+      "uniqueItems"
+    ];
+    PRICING_AMOUNT_PATTERN = /^\d+(?:\.\d+)?$/;
+    ZERO_AMOUNT_PATTERN = /^0(?:\.0+)?$/;
+  }
+});
+async function loadConfig(options = {}) {
+  const env = options.env ?? process.env;
+  const cwd = options.cwd ?? process.cwd();
+  const configPath = resolveConfigPath(options.path, env, cwd);
+  let text2;
+  try {
+    text2 = await promises.readFile(configPath, "utf8");
+  } catch (error) {
+    throw new CommerceError("CONFIG_INVALID", `Could not read configuration file "${configPath}"`, {
+      details: { path: configPath },
+      cause: error
+    });
+  }
+  let raw;
+  try {
+    raw = parse(text2);
+  } catch (error) {
+    const { reason, details } = describeYamlError(error);
+    throw new CommerceError(
+      "CONFIG_INVALID",
+      `Configuration file "${configPath}" is not valid YAML: ${reason}`,
+      {
+        details: { path: configPath, ...details },
+        // Retained for programmatic callers. Nothing in the CLI prints a
+        // `cause`, and nothing should start: this is the object whose
+        // `.message` carries the source excerpt (see below).
+        cause: error
+      }
+    );
+  }
+  return parseConfig(raw, env);
+}
+function describeYamlError(error) {
+  if (!(error instanceof YAMLError)) {
+    return { reason: "unknown YAML parse error", details: {} };
+  }
+  const start = error.linePos?.[0];
+  const where = start === void 0 ? "" : ` at line ${String(start.line)}, column ${String(start.col)}`;
+  const explanation = YAML_ERROR_EXPLANATIONS[error.code];
+  const what = explanation === void 0 ? error.code : `${error.code} (${explanation})`;
+  return {
+    reason: `${what}${where}`,
+    details: {
+      yamlErrorCode: error.code,
+      ...start === void 0 ? {} : { line: start.line, column: start.col }
+    }
+  };
+}
+function resolveConfigPath(explicitPath, env, cwd) {
+  if (explicitPath) return path.resolve(cwd, explicitPath);
+  const fromEnv = env[CONFIG_PATH_ENV_VAR];
+  if (fromEnv) return path.resolve(cwd, fromEnv);
+  return path.resolve(cwd, DEFAULT_CONFIG_FILENAME);
+}
+var CONFIG_PATH_ENV_VAR, YAML_ERROR_EXPLANATIONS;
+var init_load = __esm({
+  "src/config/load.ts"() {
+    init_core();
+    init_filename();
+    init_schema();
+    CONFIG_PATH_ENV_VAR = "AGENT_COMMERCE_CONFIG";
+    YAML_ERROR_EXPLANATIONS = {
+      DUPLICATE_KEY: "map keys must be unique",
+      BAD_INDENT: "bad indentation",
+      TAB_AS_INDENT: "tabs cannot be used for indentation",
+      MISSING_CHAR: "a required character is missing",
+      BLOCK_AS_IMPLICIT_KEY: "a block value cannot be used as a key (missing quotes, or a stray colon)",
+      MULTILINE_IMPLICIT_KEY: "a key spans multiple lines (missing quotes, or a stray colon)",
+      UNEXPECTED_TOKEN: "unexpected token"
+    };
+  }
+});
+
+// src/config/index.ts
+var config_exports = {};
+__export(config_exports, {
+  loadConfig: () => loadConfig,
+  parseConfig: () => parseConfig,
+  substituteEnv: () => substituteEnv
+});
+var init_config = __esm({
+  "src/config/index.ts"() {
+    init_env();
+    init_load();
+    init_schema();
+  }
+});
+
+// src/cli/program.ts
+init_filename();
+
+// src/cli/commands/demo.ts
+function defaultDemoSteps() {
+  return [
+    {
+      name: "Start local chain + gateway + merchant (docker compose)",
+      command: "docker",
+      args: ["compose", "up", "--build", "-d"]
+    },
+    { name: "Run the deterministic buyer agent", command: "npm", args: ["run", "demo:agent"] }
+  ];
+}
+async function runDemo(io, deps = {}) {
+  const steps = deps.steps ?? defaultDemoSteps();
+  const run = deps.run ?? execCommand;
+  io.stdout("agent-commerce demo \u2014 running the documented quickstart steps:");
+  for (const step of steps) {
+    io.stdout("");
+    io.stdout(`==> ${step.name}`);
+    io.stdout(`    $ ${step.command} ${step.args.join(" ")}`);
+    const result = await run(step.command, step.args);
+    if (result.code !== 0) {
+      io.stderr(`FAIL  "${step.name}" exited with code ${result.code}.`);
+      if (result.stderrTail !== void 0 && result.stderrTail.length > 0) {
+        io.stderr(result.stderrTail);
+      }
+      io.stderr("");
+      io.stderr("Nothing further was run. To retry manually:");
+      io.stderr(`  ${step.command} ${step.args.join(" ")}`);
+      return 1;
+    }
+    if (step.healthCheck !== void 0) {
+      const healthy = await step.healthCheck();
+      if (!healthy) {
+        io.stderr(`FAIL  "${step.name}" completed but its health check did not pass.`);
+        return 1;
+      }
+    }
+    io.stdout(`OK    ${step.name}`);
+  }
+  io.stdout("");
+  io.stdout("PASS  Demo is up. Try: agent-commerce doctor --config config-demo.yaml");
+  return 0;
+}
+async function execCommand(command, args) {
+  const { spawn } = await import('child_process');
+  return new Promise((resolvePromise) => {
+    let stderr = "";
+    const child = spawn(command, args, { stdio: ["ignore", "inherit", "pipe"] });
+    child.stderr?.on("data", (chunk) => {
+      stderr += chunk.toString("utf8");
+    });
+    child.on("error", (err) => {
+      resolvePromise({ code: 1, stderrTail: err.message });
+    });
+    child.on("close", (code) => {
+      const tail = stderr.trim().split("\n").slice(-10).join("\n");
+      resolvePromise({ code: code ?? 1, ...tail.length > 0 ? { stderrTail: tail } : {} });
+    });
+  });
+}
+
+// src/cli/commands/doctor.ts
+init_execution();
+init_core();
+
+// src/storage/receipts/store.ts
+init_core();
+var PACKAGE_VERSION = "0.1.0-alpha.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;
+var REDACTED = "[REDACTED]";
+function isSecretKey(key) {
+  return SECRET_KEY_PATTERN.test(key);
+}
+function redact(value) {
+  return redactValue(value);
+}
+function redactValue(value) {
+  if (Array.isArray(value)) {
+    return value.map(redactValue);
+  }
+  if (value !== null && typeof value === "object") {
+    const out = {};
+    for (const [key, inner] of Object.entries(value)) {
+      out[key] = isSecretKey(key) ? REDACTED : redactValue(inner);
+    }
+    return out;
+  }
+  return value;
+}
+
+// src/storage/receipts/rows.ts
+function receiptToRow(receipt) {
+  return {
+    id: receipt.id,
+    request_id: receipt.requestId,
+    resource_id: receipt.resourceId,
+    payment_json: receipt.payment !== void 0 ? JSON.stringify(redact(receipt.payment)) : null,
+    delivered_at: receipt.deliveredAt,
+    backend_status: receipt.backendStatus,
+    duration_ms: receipt.durationMs !== void 0 ? receipt.durationMs : null,
+    protocol: receipt.protocol !== void 0 ? receipt.protocol : null,
+    metadata_json: receipt.metadata !== void 0 ? JSON.stringify(redact(receipt.metadata)) : null
+  };
+}
+function rowToReceipt(row) {
+  const payment = row.payment_json !== null ? JSON.parse(row.payment_json) : void 0;
+  const metadata = row.metadata_json !== null ? JSON.parse(row.metadata_json) : void 0;
+  return {
+    id: row.id,
+    requestId: row.request_id,
+    resourceId: row.resource_id,
+    deliveredAt: row.delivered_at,
+    backendStatus: row.backend_status,
+    ...payment !== void 0 ? { payment } : {},
+    ...row.duration_ms !== null ? { durationMs: row.duration_ms } : {},
+    ...row.protocol !== null ? { protocol: row.protocol } : {},
+    ...metadata !== void 0 ? { metadata } : {}
+  };
+}
+function eventToRow(event) {
+  return {
+    id: event.id,
+    type: event.type,
+    request_id: event.requestId,
+    resource_id: event.resourceId !== void 0 ? event.resourceId : null,
+    at: event.at,
+    adapter: event.adapter !== void 0 ? event.adapter : null,
+    payment_provider: event.paymentProvider !== void 0 ? event.paymentProvider : null,
+    duration_ms: event.durationMs !== void 0 ? event.durationMs : null,
+    status: event.status !== void 0 ? event.status : null,
+    data_json: event.data !== void 0 ? JSON.stringify(redact(event.data)) : null
+  };
+}
+function rowToEvent(row) {
+  const data = row.data_json !== null ? JSON.parse(row.data_json) : void 0;
+  return {
+    id: row.id,
+    type: row.type,
+    requestId: row.request_id,
+    at: row.at,
+    ...row.resource_id !== null ? { resourceId: row.resource_id } : {},
+    ...row.adapter !== null ? { adapter: row.adapter } : {},
+    ...row.payment_provider !== null ? { paymentProvider: row.payment_provider } : {},
+    ...row.duration_ms !== null ? { durationMs: row.duration_ms } : {},
+    ...row.status !== null ? { status: row.status } : {},
+    ...data !== void 0 ? { data } : {}
+  };
+}
+function rowToPaymentAttempt(row) {
+  return {
+    id: row.id,
+    requestId: row.request_id,
+    resourceId: row.resource_id,
+    provider: row.provider,
+    replayKey: row.replay_key,
+    status: row.status,
+    amount: row.amount,
+    currency: row.currency,
+    ...row.payer !== null ? { payer: row.payer } : {},
+    ...row.payee !== null ? { payee: row.payee } : {},
+    ...row.external_reference !== null ? { externalReference: row.external_reference } : {},
+    ...row.rejection_reason !== null ? { rejectionReason: row.rejection_reason } : {},
+    createdAt: row.created_at,
+    updatedAt: row.updated_at
+  };
+}
+
+// src/storage/receipts/schema.ts
+var MIGRATIONS = [
+  {
+    version: 1,
+    up(db) {
+      db.exec(`
+        CREATE TABLE IF NOT EXISTS receipts (
+          seq             INTEGER PRIMARY KEY AUTOINCREMENT,
+          id              TEXT NOT NULL UNIQUE,
+          request_id      TEXT NOT NULL,
+          resource_id     TEXT NOT NULL,
+          payment_json    TEXT,
+          delivered_at    TEXT NOT NULL,
+          backend_status  INTEGER NOT NULL,
+          duration_ms     INTEGER,
+          protocol        TEXT,
+          metadata_json   TEXT
+        );
+        CREATE INDEX IF NOT EXISTS idx_receipts_request_id ON receipts(request_id);
+        CREATE INDEX IF NOT EXISTS idx_receipts_delivered_at ON receipts(delivered_at);
+
+        CREATE TABLE IF NOT EXISTS events (
+          seq               INTEGER PRIMARY KEY AUTOINCREMENT,
+          id                TEXT NOT NULL UNIQUE,
+          type              TEXT NOT NULL,
+          request_id        TEXT NOT NULL,
+          resource_id       TEXT,
+          at                TEXT NOT NULL,
+          adapter           TEXT,
+          payment_provider  TEXT,
+          duration_ms       INTEGER,
+          status            TEXT,
+          data_json         TEXT
+        );
+        CREATE INDEX IF NOT EXISTS idx_events_request_id ON events(request_id);
+        CREATE INDEX IF NOT EXISTS idx_events_at ON events(at);
+
+        CREATE TABLE IF NOT EXISTS payment_attempts (
+          seq                 INTEGER PRIMARY KEY AUTOINCREMENT,
+          id                  TEXT NOT NULL UNIQUE,
+          request_id          TEXT NOT NULL,
+          resource_id         TEXT NOT NULL,
+          provider             TEXT NOT NULL,
+          replay_key          TEXT NOT NULL UNIQUE,
+          status              TEXT NOT NULL,
+          amount              TEXT NOT NULL,
+          currency            TEXT NOT NULL,
+          payer               TEXT,
+          payee               TEXT,
+          external_reference  TEXT,
+          rejection_reason    TEXT,
+          created_at          TEXT NOT NULL,
+          updated_at          TEXT NOT NULL
+        );
+        CREATE INDEX IF NOT EXISTS idx_payment_attempts_request_id ON payment_attempts(request_id);
+        CREATE INDEX IF NOT EXISTS idx_payment_attempts_created_at ON payment_attempts(created_at);
+      `);
+    }
+  }
+];
+var SCHEMA_VERSION = MIGRATIONS[MIGRATIONS.length - 1]?.version ?? 0;
+function migrate(db) {
+  const current = db.pragma("user_version", { simple: true });
+  for (const migration of MIGRATIONS) {
+    if (migration.version <= current) continue;
+    const apply = db.transaction(() => {
+      migration.up(db);
+      db.pragma(`user_version = ${migration.version}`);
+    });
+    apply();
+  }
+}
+
+// src/storage/receipts/store.ts
+var DEFAULT_LIST_LIMIT = 50;
+var MAX_LIST_LIMIT = 500;
+function clampListLimit(limit) {
+  const base = limit !== void 0 && Number.isFinite(limit) ? limit : DEFAULT_LIST_LIMIT;
+  return Math.min(Math.max(Math.trunc(base), 1), MAX_LIST_LIMIT);
+}
+var defaultIds = {
+  next: (prefix) => prefix !== void 0 ? `${prefix}_${randomUUID()}` : randomUUID()
+};
+function isUniqueConstraintOn(err, column) {
+  return err instanceof Error && "code" in err && err.code === "SQLITE_CONSTRAINT_UNIQUE" && err.message.includes(column);
+}
+function restrictDatabasePermissions(path2, logger) {
+  for (const file of [path2, `${path2}-wal`, `${path2}-shm`]) {
+    try {
+      chmodSync(file, 384);
+    } catch (error) {
+      const code = error.code;
+      if (code === "ENOENT") continue;
+      logger.warn(
+        { file, error: code ?? "unknown" },
+        "could not restrict receipt database permissions to owner-only"
+      );
+    }
+  }
+}
+function createSqliteReceiptStore(options) {
+  const logger = options.logger ?? NOOP_LOGGER;
+  const clock = options.clock ?? systemClock;
+  const ids = options.ids ?? defaultIds;
+  const path2 = options.path;
+  const isFileBacked = path2 !== ":memory:";
+  if (isFileBacked) {
+    const dir = dirname(path2);
+    if (dir !== "" && dir !== "." && !existsSync(dir)) {
+      mkdirSync(dir, { recursive: true, mode: 448 });
+    }
+  }
+  if (isFileBacked && existsSync(path2)) {
+    try {
+      accessSync(path2, constants.W_OK);
+    } catch {
+      throw new CommerceError(
+        "STORAGE_ERROR",
+        `Receipt database "${path2}" exists but is not writable by this process (uid ${typeof process.getuid === "function" ? process.getuid() : "unknown"}). If this is a container that recently changed user, an existing volume may still be owned by the previous one \u2014 recreate it (docker compose down -v) or fix its ownership.`,
+        { details: { path: path2 } }
+      );
+    }
+  }
+  const db = new Database(path2);
+  db.pragma("journal_mode = WAL");
+  db.pragma("foreign_keys = ON");
+  migrate(db);
+  if (isFileBacked) restrictDatabasePermissions(path2, logger);
+  const insertReceiptStmt = db.prepare(
+    `INSERT INTO receipts (id, request_id, resource_id, payment_json, delivered_at, backend_status, duration_ms, protocol, metadata_json)
+     VALUES (@id, @request_id, @resource_id, @payment_json, @delivered_at, @backend_status, @duration_ms, @protocol, @metadata_json)`
+  );
+  const getReceiptStmt = db.prepare("SELECT * FROM receipts WHERE id = ?");
+  const listReceiptsStmt = db.prepare(
+    "SELECT * FROM receipts ORDER BY delivered_at DESC, seq DESC LIMIT ?"
+  );
+  const listReceiptsByRequestStmt = db.prepare(
+    "SELECT * FROM receipts WHERE request_id = ? ORDER BY delivered_at DESC, seq DESC LIMIT ?"
+  );
+  const countReceiptsStmt = db.prepare(
+    "SELECT COUNT(*) AS count FROM receipts"
+  );
+  const countUndeliveredReceiptsStmt = db.prepare(
+    "SELECT COUNT(*) AS count FROM receipts WHERE backend_status NOT BETWEEN 200 AND 299"
+  );
+  const insertEventStmt = db.prepare(
+    `INSERT INTO events (id, type, request_id, resource_id, at, adapter, payment_provider, duration_ms, status, data_json)
+     VALUES (@id, @type, @request_id, @resource_id, @at, @adapter, @payment_provider, @duration_ms, @status, @data_json)`
+  );
+  const listEventsStmt = db.prepare(
+    "SELECT * FROM events ORDER BY at DESC, seq DESC LIMIT ?"
+  );
+  const listEventsByRequestStmt = db.prepare(
+    "SELECT * FROM events WHERE request_id = ? ORDER BY at DESC, seq DESC LIMIT ?"
+  );
+  const insertPaymentAttemptStmt = db.prepare(
+    `INSERT INTO payment_attempts (id, request_id, resource_id, provider, replay_key, status, amount, currency, payer, payee, external_reference, rejection_reason, created_at, updated_at)
+     VALUES (@id, @request_id, @resource_id, @provider, @replay_key, @status, @amount, @currency, @payer, @payee, @external_reference, @rejection_reason, @created_at, @updated_at)`
+  );
+  const getPaymentAttemptByIdStmt = db.prepare(
+    "SELECT * FROM payment_attempts WHERE id = ?"
+  );
+  const updatePaymentAttemptStmt = db.prepare(
+    `UPDATE payment_attempts SET status = @status,
+       external_reference = COALESCE(@external_reference, external_reference),
+       rejection_reason = COALESCE(@rejection_reason, rejection_reason),
+       updated_at = @updated_at
+     WHERE replay_key = @replay_key`
+  );
+  const listPaymentAttemptsStmt = db.prepare(
+    "SELECT * FROM payment_attempts ORDER BY created_at DESC, seq DESC LIMIT ?"
+  );
+  const listPaymentAttemptsByRequestStmt = db.prepare(
+    "SELECT * FROM payment_attempts WHERE request_id = ? ORDER BY created_at DESC, seq DESC LIMIT ?"
+  );
+  let closed = false;
+  const descriptor = {
+    name: "sqlite-receipt-store",
+    kind: "storage",
+    implementationVersion: PACKAGE_VERSION,
+    supportedSpec: `sqlite-schema-v${SCHEMA_VERSION}`,
+    capabilities: ["receipts", "events", "payment-attempts"],
+    status: "stable"
+  };
+  const store = {
+    async init() {
+      const version = db.pragma("user_version", { simple: true });
+      if (version !== SCHEMA_VERSION) {
+        throw new CommerceError(
+          "STORAGE_ERROR",
+          `Receipt store schema version mismatch (found ${version}, expected ${SCHEMA_VERSION})`
+        );
+      }
+    },
+    async appendEvent(event) {
+      try {
+        insertEventStmt.run(eventToRow(event));
+      } catch (err) {
+        logger.warn(
+          {
+            err: err instanceof Error ? err.message : String(err),
+            eventId: event.id,
+            requestId: event.requestId
+          },
+          "receipt-store: failed to persist commerce event"
+        );
+      }
+    },
+    async reservePaymentAttempt(reservation) {
+      const now = clock.nowIso();
+      const id = ids.next("attempt");
+      try {
+        insertPaymentAttemptStmt.run({
+          id,
+          request_id: reservation.requestId,
+          resource_id: reservation.resourceId,
+          provider: reservation.provider,
+          replay_key: reservation.replayKey,
+          status: "reserved",
+          amount: reservation.amount,
+          currency: reservation.currency,
+          payer: reservation.payer ?? null,
+          payee: reservation.payee ?? null,
+          external_reference: null,
+          rejection_reason: null,
+          created_at: now,
+          updated_at: now
+        });
+      } catch (err) {
+        if (isUniqueConstraintOn(err, "payment_attempts.replay_key")) {
+          throw new CommerceError(
+            "PAYMENT_REPLAYED",
+            `Payment authorisation has already been used (replayKey=${reservation.replayKey})`,
+            { requestId: reservation.requestId, resourceId: reservation.resourceId }
+          );
+        }
+        throw toCommerceError(err, "STORAGE_ERROR", "Failed to reserve payment attempt");
+      }
+      const row = getPaymentAttemptByIdStmt.get(id);
+      if (row === void 0) {
+        throw new CommerceError(
+          "STORAGE_ERROR",
+          "Payment attempt vanished immediately after insert"
+        );
+      }
+      return rowToPaymentAttempt(row);
+    },
+    async updatePaymentAttempt(update) {
+      try {
+        const result = updatePaymentAttemptStmt.run({
+          replay_key: update.replayKey,
+          status: update.status,
+          external_reference: update.externalReference ?? null,
+          rejection_reason: update.rejectionReason ?? null,
+          updated_at: clock.nowIso()
+        });
+        if (result.changes === 0) {
+          throw new CommerceError(
+            "STORAGE_ERROR",
+            `No payment attempt found for replayKey=${update.replayKey}`
+          );
+        }
+      } catch (err) {
+        throw toCommerceError(err, "STORAGE_ERROR", "Failed to update payment attempt");
+      }
+    },
+    async saveReceipt(receipt) {
+      try {
+        insertReceiptStmt.run(receiptToRow(receipt));
+      } catch (err) {
+        throw toCommerceError(err, "STORAGE_ERROR", "Failed to save receipt");
+      }
+    },
+    async getReceipt(id) {
+      const row = getReceiptStmt.get(id);
+      return row !== void 0 ? rowToReceipt(row) : void 0;
+    },
+    async listReceipts(listOptions = {}) {
+      const limit = clampListLimit(listOptions.limit);
+      const rows = listOptions.requestId !== void 0 ? listReceiptsByRequestStmt.all(listOptions.requestId, limit) : listReceiptsStmt.all(limit);
+      return rows.map(rowToReceipt);
+    },
+    /** Exact total, ignoring the listReceipts clamp — see the interface doc for why this exists. */
+    async countReceipts() {
+      return countReceiptsStmt.get()?.count ?? 0;
+    },
+    /** Exact count of non-2xx receipts — see the interface doc for why this exists. */
+    async countUndeliveredReceipts() {
+      return countUndeliveredReceiptsStmt.get()?.count ?? 0;
+    },
+    async listEvents(listOptions = {}) {
+      const limit = clampListLimit(listOptions.limit);
+      const rows = listOptions.requestId !== void 0 ? listEventsByRequestStmt.all(listOptions.requestId, limit) : listEventsStmt.all(limit);
+      return rows.map(rowToEvent);
+    },
+    async listPaymentAttempts(listOptions = {}) {
+      const limit = clampListLimit(listOptions.limit);
+      const rows = listOptions.requestId !== void 0 ? listPaymentAttemptsByRequestStmt.all(listOptions.requestId, limit) : listPaymentAttemptsStmt.all(limit);
+      return rows.map(rowToPaymentAttempt);
+    },
+    descriptor,
+    async health() {
+      const startedAt = clock.monotonicMs();
+      if (closed) {
+        return { status: "fail", detail: "store-unavailable", checkedAt: clock.nowIso() };
+      }
+      if (isFileBacked) {
+        try {
+          accessSync(path2, constants.W_OK);
+        } catch (err) {
+          logger.warn(
+            { err: err instanceof Error ? err.message : String(err) },
+            "receipt-store: health check failed (store not writable)"
+          );
+          return {
+            status: "fail",
+            detail: "store-unwritable",
+            checkedAt: clock.nowIso(),
+            durationMs: clock.monotonicMs() - startedAt
+          };
+        }
+      }
+      try {
+        const version = db.pragma("user_version", { simple: true });
+        if (version !== SCHEMA_VERSION) {
+          logger.warn(
+            { found: version, expected: SCHEMA_VERSION },
+            "receipt-store: health check failed (schema version mismatch)"
+          );
+          return {
+            status: "fail",
+            detail: "store-schema-mismatch",
+            checkedAt: clock.nowIso(),
+            durationMs: clock.monotonicMs() - startedAt
+          };
+        }
+        return {
+          status: "pass",
+          detail: `sqlite schema v${SCHEMA_VERSION} writable`,
+          checkedAt: clock.nowIso(),
+          durationMs: clock.monotonicMs() - startedAt
+        };
+      } catch (err) {
+        logger.warn(
+          { err: err instanceof Error ? err.message : String(err) },
+          "receipt-store: health check failed (store unavailable)"
+        );
+        return {
+          status: "fail",
+          detail: "store-unavailable",
+          checkedAt: clock.nowIso(),
+          durationMs: clock.monotonicMs() - startedAt
+        };
+      }
+    },
+    async close() {
+      if (!closed) {
+        closed = true;
+        db.close();
+      }
+    }
+  };
+  return store;
+}
+
+// src/cli/lib/config-client.ts
+async function loadConfigDynamic(options = {}) {
+  let mod;
+  try {
+    mod = await Promise.resolve().then(() => (init_config(), config_exports));
+  } catch (err) {
+    throw new Error(
+      `the configuration module could not be loaded: ${err instanceof Error ? err.message : String(err)}`
+    );
+  }
+  return mod.loadConfig(options);
+}
+async function parseConfigDynamic(raw, env = process.env) {
+  let mod;
+  try {
+    mod = await Promise.resolve().then(() => (init_config(), config_exports));
+  } catch (err) {
+    throw new Error(
+      `the configuration module could not be loaded: ${err instanceof Error ? err.message : String(err)}`
+    );
+  }
+  return mod.parseConfig(raw, env);
+}
+
+// src/cli/lib/http.ts
+async function fetchJson(fetchImpl, url, timeoutMs = 1500) {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    const res = await fetchImpl(url, { signal: controller.signal });
+    let body;
+    try {
+      body = await res.json();
+    } catch {
+      body = void 0;
+    }
+    return { ok: res.ok, status: res.status, ...body !== void 0 ? { body } : {} };
+  } catch (err) {
+    return {
+      ok: false,
+      status: 0,
+      error: err instanceof Error ? err.message : "unknown fetch error"
+    };
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+// 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
+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";
+function defaultInitAnswers() {
+  return {
+    backendBaseUrl: "http://localhost:3000",
+    resources: ["weather", "report"],
+    protocols: ["http", "mcp"],
+    x402Enabled: true,
+    merchantPayTo: LOCAL_DEV_MERCHANT_ADDRESS
+  };
+}
+function buildResourcesMap(answers) {
+  const resources = {};
+  const expose = [...answers.protocols];
+  if (answers.resources.includes("weather")) {
+    resources.weather = {
+      name: "Get weather",
+      description: "Deterministic demo weather lookup (free resource).",
+      input: {
+        type: "object",
+        properties: { city: { type: "string" } },
+        required: ["city"],
+        additionalProperties: false
+      },
+      backend: {
+        type: "http",
+        method: "GET",
+        url: `${answers.backendBaseUrl}/api/weather/{city}`
+      },
+      pricing: { type: "free" },
+      expose
+    };
+  }
+  if (answers.resources.includes("report")) {
+    const paid = answers.x402Enabled;
+    resources.report = {
+      name: "Get market report",
+      description: "Deterministic demo premium market report.",
+      // No caller-supplied fields for this resource: an explicit empty,
+      // closed schema (rather than omitting `input`) so a missing schema can
+      // never be read as "anything goes".
+      input: {
+        type: "object",
+        properties: {},
+        additionalProperties: false
+      },
+      backend: {
+        type: "http",
+        method: "GET",
+        url: `${answers.backendBaseUrl}/api/report`
+      },
+      pricing: paid ? { type: "fixed", amount: "0.01", currency: "USDC" } : { type: "free" },
+      expose,
+      ...paid ? { payments: ["x402"] } : {}
+    };
+  }
+  return resources;
+}
+function buildInitConfigObject(answers) {
+  return {
+    version: 1,
+    merchant: {
+      id: "demo-merchant",
+      name: "Demo Merchant",
+      publicBaseUrl: "http://localhost:8080"
+    },
+    server: { port: 8080, host: "127.0.0.1" },
+    storage: { receipts: { driver: "sqlite", path: "./data/receipts.db" } },
+    protocols: {
+      http: { enabled: answers.protocols.includes("http") },
+      mcp: { enabled: answers.protocols.includes("mcp"), mountPath: "/mcp" }
+    },
+    resources: buildResourcesMap(answers),
+    payments: answers.x402Enabled ? {
+      x402: {
+        enabled: true,
+        network: "base-sepolia",
+        rpcUrl: "http://127.0.0.1:8545",
+        asset: PLACEHOLDER_ASSET_ADDRESS,
+        assetName: "MockUSDC",
+        assetVersion: "2",
+        assetDecimals: 6,
+        payTo: answers.merchantPayTo,
+        maxTimeoutSeconds: 60,
+        facilitator: { mode: "local", signerPrivateKey: LOCAL_DEV_FACILITATOR_PRIVATE_KEY }
+      }
+    } : {}
+  };
+}
+var HEADER = `# Generated by \`agent-commerce init\`.
+#
+# Any address/key below labelled "LOCAL DEVELOPMENT ONLY" or "placeholder" is
+# either one of Anvil's well-known, public dev accounts (never fund them,
+# never use them outside a local chain) or a
+# not-yet-real address. Before running against the local chain, run
+# \`npm run chain:deploy\` and replace \`payments.x402.asset\` with the deployed
+# MockUSDC address from \`.deploy/local.json\`. Replace \`payments.x402.payTo\`
+# with your real merchant-controlled settlement address before ever pointing
+# this at a funded network.
+#
+# server.host is loopback (127.0.0.1) on purpose: binding every interface
+# should be a deliberate edit, not something you inherit from a generator.
+#
+# server.adminToken / server.allowedOrigins are left unset here \u2014 a generated
+# secret in a file you might commit is its own problem, so this is left as a
+# placeholder for you to fill in rather than a real token. Without a token,
+# the operator routes (/api/receipts, /api/events, /api/events/stream) \u2014
+# the merchant's commerce ledger: payer addresses, amounts, settlement
+# hashes \u2014 return 404 rather than serving openly. To enable them, uncomment
+# and set:
+#   server:
+#     adminToken: \${ADMIN_TOKEN}
+#     allowedOrigins:
+#       - http://localhost:5173
+# See SECURITY.md before exposing this gateway beyond localhost.
+`;
+function renderInitConfigYaml(answers) {
+  const body = stringify(buildInitConfigObject(answers), { indent: 2 });
+  return `${HEADER}
+${body}`;
+}
+var LOCAL_CHAIN_MANIFEST_PATH = ".deploy/local.json";
+var REQUIRED_TOP_LEVEL_STRING_FIELDS = [
+  "rpcUrl",
+  "asset",
+  "assetName",
+  "assetVersion",
+  "buyerInitialBalance"
+];
+function readLocalChainManifest(cwd = process.cwd()) {
+  const path2 = join(cwd, LOCAL_CHAIN_MANIFEST_PATH);
+  if (!existsSync(path2)) {
+    throw new Error(
+      `Local chain manifest not found at "${path2}". Run "npm run chain:start" then "npm run chain:deploy" first.`
+    );
+  }
+  let raw;
+  try {
+    raw = readFileSync(path2, "utf8");
+  } catch (cause) {
+    throw new Error(`Could not read local chain manifest at "${path2}".`, { cause });
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (cause) {
+    throw new Error(
+      `Local chain manifest at "${path2}" is not valid JSON. Re-run "npm run chain:deploy" to regenerate it.`,
+      { cause }
+    );
+  }
+  return validateManifestShape(parsed, path2);
+}
+function validateManifestShape(value, path2) {
+  const fail = (detail) => {
+    throw new Error(
+      `Local chain manifest at "${path2}" is invalid: ${detail}. Re-run "npm run chain:deploy".`
+    );
+  };
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    return fail("expected a JSON object");
+  }
+  const record = value;
+  if (typeof record.chainId !== "number") {
+    return fail('"chainId" must be a number');
+  }
+  if (typeof record.assetDecimals !== "number") {
+    return fail('"assetDecimals" must be a number');
+  }
+  for (const field of REQUIRED_TOP_LEVEL_STRING_FIELDS) {
+    if (typeof record[field] !== "string" || record[field] === "") {
+      return fail(`"${field}" must be a non-empty string`);
+    }
+  }
+  if ("hostRpcUrl" in record && record.hostRpcUrl !== void 0) {
+    if (typeof record.hostRpcUrl !== "string" || record.hostRpcUrl === "") {
+      return fail('"hostRpcUrl" must be a non-empty string when present');
+    }
+  }
+  const merchant = record.merchant;
+  if (typeof merchant !== "object" || merchant === null || typeof merchant.address !== "string" || typeof merchant.privateKeyLabel !== "string") {
+    return fail('"merchant" must be { address: string, privateKeyLabel: string }');
+  }
+  for (const key of ["buyer", "facilitator"]) {
+    const account = record[key];
+    if (typeof account !== "object" || account === null || typeof account.address !== "string" || typeof account.privateKey !== "string" || typeof account.note !== "string") {
+      return fail(`"${key}" must be { address: string, privateKey: string, note: string }`);
+    }
+  }
+  return record;
+}
+
+// src/cli/lib/manifest-env.ts
+var MANIFEST_ENV_VARS = [
+  ["X402_ASSET", (m) => m.asset],
+  ["X402_ASSET_NAME", (m) => m.assetName],
+  ["X402_ASSET_VERSION", (m) => m.assetVersion],
+  ["X402_ASSET_DECIMALS", (m) => String(m.assetDecimals)],
+  ["MERCHANT_WALLET", (m) => m.merchant.address],
+  ["X402_FACILITATOR_PRIVATE_KEY", (m) => m.facilitator.privateKey]
+];
+var MANIFEST_FILLABLE_ENV_VAR_NAMES = new Set(
+  MANIFEST_ENV_VARS.map(([name]) => name)
+);
+function fillEnvFromLocalChainManifest(baseEnv, cwd = process.cwd()) {
+  let manifest;
+  try {
+    manifest = readLocalChainManifest(cwd);
+  } catch {
+    return { env: baseEnv, filled: [], manifestFound: false };
+  }
+  const filled = [];
+  const env = { ...baseEnv };
+  for (const [name, read] of MANIFEST_ENV_VARS) {
+    if (env[name] === void 0) {
+      env[name] = read(manifest);
+      filled.push(name);
+    }
+  }
+  return { env, filled, manifestFound: true };
+}
+
+// src/cli/lib/mask.ts
+function maskMiddle(value, keep = 6) {
+  if (value.length <= keep * 2) return value.length === 0 ? value : "\u2026";
+  return `${value.slice(0, keep)}\u2026${value.slice(-4)}`;
+}
+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"}]}' ;
+  {
+    return JSON.parse(injected);
+  }
+}
+
+// src/cli/commands/doctor.ts
+var CHECK_TIMEOUT_MS = 1500;
+function deriveGatewayUrl(explicit, config) {
+  if (explicit !== void 0) return explicit.replace(/\/$/, "");
+  if (config !== void 0) {
+    const raw = config.server.host;
+    const host = raw === "0.0.0.0" ? "127.0.0.1" : raw === "::" ? "::1" : raw;
+    const authority = host.includes(":") ? `[${host}]` : host;
+    return `http://${authority}:${config.server.port}`;
+  }
+  return "http://localhost:8080";
+}
+function substitutePathParams(url) {
+  let filled = url;
+  for (const name of extractPathParameterNames(url)) {
+    filled = filled.split(`{${name}}`).join("demo-check");
+  }
+  return filled;
+}
+function extractWellKnownX402(body) {
+  const payments = body?.["payments"];
+  if (typeof payments !== "object" || payments === null) return void 0;
+  const x402 = payments["x402"];
+  if (typeof x402 !== "object" || x402 === null) return void 0;
+  const rec = x402;
+  if (rec["enabled"] === false) return "disabled";
+  if (rec["enabled"] !== true) return void 0;
+  const { asset, network, payTo } = rec;
+  if (typeof asset !== "string" || typeof network !== "string" || typeof payTo !== "string") {
+    return void 0;
+  }
+  return { asset, network, payTo };
+}
+function sameAddress(a, b) {
+  return a.toLowerCase() === b.toLowerCase();
+}
+function findX402Mismatch(configured, live) {
+  const diffs = [];
+  if (!sameAddress(configured.asset, live.asset)) {
+    diffs.push(
+      `asset: gateway is using ${live.asset} but local config resolves to ${configured.asset}`
+    );
+  }
+  if (configured.network !== live.network) {
+    diffs.push(
+      `network: gateway is using "${live.network}" but local config resolves to "${configured.network}"`
+    );
+  }
+  if (!sameAddress(configured.payTo, live.payTo)) {
+    diffs.push(
+      `payTo: gateway is using ${live.payTo} but local config resolves to ${configured.payTo}`
+    );
+  }
+  if (diffs.length === 0) return void 0;
+  return `${diffs.join("; ")} \u2014 the gateway may be running against an older deployment; restart it or re-run chain:deploy`;
+}
+async function runDoctor(options, deps = {}) {
+  const fetchImpl = deps.fetchImpl ?? globalThis.fetch;
+  const loadConfig2 = deps.loadConfig ?? loadConfigDynamic;
+  const createStore = deps.createStore ?? ((path2) => createSqliteReceiptStore({ path: path2 }));
+  const fillEnvFromManifest = deps.fillEnvFromManifest ?? fillEnvFromLocalChainManifest;
+  const checks = [];
+  let config;
+  const { env, filled, manifestFound } = fillEnvFromManifest(process.env);
+  const filledSuffix = filled.length > 0 ? ` (using local chain manifest ${LOCAL_CHAIN_MANIFEST_PATH} for ${filled.join(", ")})` : "";
+  try {
+    config = await loadConfig2({
+      ...options.configPath !== void 0 ? { path: options.configPath } : {},
+      env
+    });
+    checks.push({
+      name: "Config",
+      status: "PASS",
+      detail: `valid \u2014 ${config.resources.length} resource(s), merchant "${config.merchant.name}"${filledSuffix}`
+    });
+  } catch (err) {
+    const variable = isCommerceError(err) ? err.details?.["variable"] : void 0;
+    const hint = !manifestFound && typeof variable === "string" && MANIFEST_FILLABLE_ENV_VAR_NAMES.has(variable) ? ` \u2014 run "npm run chain:deploy" (writes ${LOCAL_CHAIN_MANIFEST_PATH}, read automatically for local X402_*/MERCHANT_WALLET placeholders)` : "";
+    checks.push({
+      name: "Config",
+      status: "FAIL",
+      detail: `${err instanceof Error ? err.message : String(err)}${hint}`
+    });
+  }
+  const gatewayUrl = deriveGatewayUrl(options.gatewayUrl, config);
+  const health = await fetchJson(fetchImpl, `${gatewayUrl}/health`, CHECK_TIMEOUT_MS);
+  let gatewayUp = false;
+  if (!health.ok) {
+    checks.push({
+      name: "Gateway",
+      status: "FAIL",
+      detail: `unreachable at ${gatewayUrl} (${health.error ?? `HTTP ${health.status}`})`
+    });
+  } else {
+    gatewayUp = true;
+    const ready = await fetchJson(fetchImpl, `${gatewayUrl}/ready`, CHECK_TIMEOUT_MS);
+    checks.push(
+      ready.ok ? { name: "Gateway", status: "PASS", detail: `healthy and ready at ${gatewayUrl}` } : {
+        name: "Gateway",
+        status: "WARN",
+        detail: `healthy but not ready at ${gatewayUrl} (${ready.error ?? `HTTP ${ready.status}`})`
+      }
+    );
+  }
+  if (config === void 0) {
+    checks.push({ name: "Backend", status: "WARN", detail: "skipped \u2014 config invalid" });
+  } else if (config.resources.length === 0) {
+    checks.push({ name: "Backend", status: "INFO", detail: "no resources configured" });
+  } else {
+    const resources = config.resources;
+    const urls = [...new Set(resources.map((r) => substitutePathParams(r.handler.url)))];
+    const results = await Promise.all(
+      urls.map((url) => fetchJson(fetchImpl, url, CHECK_TIMEOUT_MS))
+    );
+    const reachable = results.filter((r) => r.status !== 0).length;
+    const status = reachable === urls.length ? "PASS" : reachable === 0 ? "FAIL" : "WARN";
+    checks.push({
+      name: "Backend",
+      status,
+      detail: `${reachable}/${urls.length} backend host(s) reachable`
+    });
+  }
+  const wellKnown = gatewayUp ? await fetchJson(
+    fetchImpl,
+    `${gatewayUrl}/.well-known/agent-commerce`,
+    CHECK_TIMEOUT_MS
+  ) : void 0;
+  if (config === void 0) {
+    checks.push({ name: "Protocols", status: "WARN", detail: "skipped \u2014 config invalid" });
+  } else if (wellKnown === void 0 || !wellKnown.ok) {
+    checks.push({ name: "Protocols", status: "FAIL", detail: "well-known document unreachable" });
+  } else {
+    const mcpMountPath = config.protocols.mcp.enabled ? config.protocols.mcp.mountPath : void 0;
+    checks.push({
+      name: "Protocols",
+      status: "PASS",
+      detail: `http=${config.protocols.http.enabled ? "on" : "off"} mcp=${config.protocols.mcp.enabled ? `on (${mcpMountPath})` : "off"}`
+    });
+  }
+  const x402 = config?.payments.x402;
+  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 live = wellKnown?.ok ? extractWellKnownX402(wellKnown.body) : void 0;
+    if (sameAddress(x402.asset, PLACEHOLDER_ASSET_ADDRESS)) {
+      checks.push({
+        name: "Payments",
+        status: "WARN",
+        detail: `${summary}, but the asset is still the init placeholder ${maskMiddle(PLACEHOLDER_ASSET_ADDRESS)} \u2014 no token contract exists there, so every paid call will fail. Set payments.x402.asset (\${X402_ASSET} is filled from .deploy/local.json by "npm run chain:deploy")`
+      });
+    } else if (live === "disabled") {
+      checks.push({
+        name: "Payments",
+        status: "FAIL",
+        detail: `${summary}, but the gateway at ${gatewayUrl} reports x402 disabled \u2014 it is running a different configuration`
+      });
+    } else if (live === void 0) {
+      checks.push({
+        name: "Payments",
+        status: "INFO",
+        detail: `${summary} (gateway's live settlement config could not be verified)`
+      });
+    } else {
+      const mismatch = findX402Mismatch(x402, live);
+      checks.push(
+        mismatch === void 0 ? { name: "Payments", status: "PASS", detail: summary } : { name: "Payments", status: "FAIL", detail: mismatch }
+      );
+    }
+  }
+  checks.push({
+    name: "Payments (MPP)",
+    status: "INFO",
+    detail: "planned \u2014 not implemented in v0.1"
+  });
+  if (config === void 0) {
+    checks.push({ name: "Storage", status: "WARN", detail: "skipped \u2014 config invalid" });
+  } else if (
+    // Diagnose without creating: createSqliteReceiptStore mkdir+creates the
+    // file, so calling it on a wrong path (a typo, or a container path read
+    // 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.
+    config.storage.receipts.path !== ":memory:" && !existsSync(config.storage.receipts.path)
+  ) {
+    checks.push({
+      name: "Storage",
+      status: "WARN",
+      detail: `no store exists yet at "${config.storage.receipts.path}" \u2014 it is created automatically the first time the gateway starts. If the gateway is already running, this path does not match the one it actually uses.`
+    });
+  } else {
+    let store;
+    try {
+      store = createStore(config.storage.receipts.path);
+      await store.init();
+      const storeHealth = await store.health();
+      let receiptCount;
+      try {
+        receiptCount = await store.countReceipts();
+      } catch {
+        receiptCount = void 0;
+      }
+      let undeliveredCount;
+      try {
+        undeliveredCount = await store.countUndeliveredReceipts();
+      } catch {
+        undeliveredCount = void 0;
+      }
+      const status = storeHealth.status === "pass" ? "PASS" : storeHealth.status === "warn" ? "WARN" : "FAIL";
+      const receiptsSuffix = receiptCount !== void 0 ? `; receipts=${receiptCount}${undeliveredCount !== void 0 && undeliveredCount > 0 ? ` (${undeliveredCount} undelivered)` : ""}` : "";
+      checks.push({
+        name: "Storage",
+        status,
+        detail: `${storeHealth.detail ?? "sqlite"}${receiptsSuffix}`
+      });
+    } catch (err) {
+      checks.push({
+        name: "Storage",
+        status: "FAIL",
+        detail: err instanceof Error ? err.message : String(err)
+      });
+    } finally {
+      await store?.close();
+    }
+  }
+  if (wellKnown !== void 0 && wellKnown.ok) {
+    checks.push({
+      name: "Protocol versions",
+      status: "PASS",
+      detail: "reported by gateway /.well-known/agent-commerce"
+    });
+  } else {
+    const local = readVersionReport();
+    checks.push({
+      name: "Protocol versions",
+      status: "INFO",
+      detail: `gateway unreachable \u2014 local pins: ${local.pinned.map((p) => `${p.name}@${p.version}`).join(", ")}`
+    });
+  }
+  const scored = checks.filter((c) => c.status !== "INFO");
+  const passed = scored.filter((c) => c.status === "PASS").length;
+  const exitCode = checks.some((c) => c.status === "FAIL") ? 1 : 0;
+  return { checks, score: { passed, total: scored.length }, exitCode };
+}
+function statusColor(status, text2) {
+  switch (status) {
+    case "PASS":
+      return picocolors.green(text2);
+    case "WARN":
+      return picocolors.yellow(text2);
+    case "FAIL":
+      return picocolors.red(text2);
+    case "INFO":
+      return picocolors.cyan(text2);
+  }
+}
+function printDoctorReport(report, io, json) {
+  if (json) {
+    io.stdout(JSON.stringify(report, null, 2));
+    return;
+  }
+  for (const check of report.checks) {
+    const label = statusColor(check.status, check.status.padEnd(5));
+    io.stdout(`${label} ${check.name.padEnd(20)} ${check.detail}`);
+  }
+  io.stdout("");
+  io.stdout(`Score: ${report.score.passed}/${report.score.total} checks passed`);
+}
+
+// src/cli/commands/init.ts
+init_filename();
+
+// src/cli/commands/validate.ts
+init_core();
+function formatConfigError(err, manifestFound = false) {
+  if (isCommerceError(err)) {
+    const lines = [`FAIL  ${err.code}: ${err.message}`];
+    if (err.details !== void 0) {
+      lines.push(`      details: ${JSON.stringify(err.details)}`);
+    }
+    const variable = err.details?.["variable"];
+    if (!manifestFound && typeof variable === "string" && MANIFEST_FILLABLE_ENV_VAR_NAMES.has(variable)) {
+      lines.push(
+        `      hint: "npm run chain:deploy" writes ${LOCAL_CHAIN_MANIFEST_PATH}, which validate/doctor read automatically to fill local X402_*/MERCHANT_WALLET placeholders.`
+      );
+    }
+    return lines.join("\n");
+  }
+  if (err instanceof ZodError) {
+    const lines = ["FAIL  Configuration schema errors:"];
+    for (const issue of err.issues) {
+      const path2 = issue.path.length > 0 ? issue.path.join(".") : "(root)";
+      lines.push(`      - ${path2}: ${issue.message}`);
+    }
+    return lines.join("\n");
+  }
+  if (err instanceof Error) {
+    return `FAIL  ${err.message}`;
+  }
+  return `FAIL  ${String(err)}`;
+}
+async function runValidate(options, io, deps = {}) {
+  const loadConfig2 = deps.loadConfig ?? loadConfigDynamic;
+  const fillEnvFromManifest = deps.fillEnvFromManifest ?? fillEnvFromLocalChainManifest;
+  const { env, filled, manifestFound } = fillEnvFromManifest(process.env);
+  if (filled.length > 0) {
+    io.stdout(`using local chain manifest ${LOCAL_CHAIN_MANIFEST_PATH} for ${filled.join(", ")}`);
+  }
+  try {
+    const config = await loadConfig2({
+      ...options.configPath !== void 0 ? { path: options.configPath } : {},
+      env
+    });
+    io.stdout("PASS  Configuration is valid");
+    io.stdout(`      merchant: ${config.merchant.name} (${config.merchant.id})`);
+    io.stdout(`      resources: ${config.resources.length}`);
+    io.stdout(
+      `      protocols: http=${config.protocols.http.enabled ? "on" : "off"} mcp=${config.protocols.mcp.enabled ? "on" : "off"}`
+    );
+    io.stdout(`      payments: x402=${config.payments.x402?.enabled === true ? "on" : "off"}`);
+    return 0;
+  } catch (err) {
+    io.stderr(formatConfigError(err, manifestFound));
+    return 1;
+  }
+}
+
+// src/cli/commands/init.ts
+async function collectAnswersInteractive() {
+  clack.intro("agent-commerce init");
+  const backendBaseUrl = await clack.text({
+    message: "Backend base URL (your existing merchant API)",
+    initialValue: "http://localhost:3000",
+    // shape-checked here, where the user can retype it,
+    // rather than surfacing as a config error after the fact.
+    validate: (value) => {
+      const trimmed = (value ?? "").trim();
+      if (trimmed.length === 0) return "Required";
+      let parsed;
+      try {
+        parsed = new URL(trimmed);
+      } catch {
+        return "Must be an absolute URL, e.g. http://localhost:3000";
+      }
+      return parsed.protocol === "http:" || parsed.protocol === "https:" ? void 0 : "Must use http:// or https://";
+    }
+  });
+  if (clack.isCancel(backendBaseUrl)) {
+    clack.cancel("Aborted.");
+    return void 0;
+  }
+  const resources = await clack.multiselect({
+    message: "Which example resource(s) do you want to expose?",
+    options: [
+      { value: "weather", label: "Weather (free)" },
+      { value: "report", label: "Market report (paid)" }
+    ],
+    initialValues: ["weather", "report"],
+    required: false
+  });
+  if (clack.isCancel(resources)) {
+    clack.cancel("Aborted.");
+    return void 0;
+  }
+  const protocols = await clack.multiselect({
+    message: "Which protocols should be enabled?",
+    options: [
+      { value: "http", label: "HTTP" },
+      { value: "mcp", label: "MCP" }
+    ],
+    initialValues: ["http", "mcp"],
+    // `required: false` permits an empty selection, which renders
+    // `expose: []` on every resource and fails the schema's min(1). clack's
+    // multiselect has no `validate` hook, so this is caught by the in-memory
+    // validation in `runInit` — which now reports the real schema error and
+    // writes nothing, instead of leaving an invalid file behind.
+    required: false
+  });
+  if (clack.isCancel(protocols)) {
+    clack.cancel("Aborted.");
+    return void 0;
+  }
+  const x402Enabled = await clack.confirm({ message: "Enable x402 payments?", initialValue: true });
+  if (clack.isCancel(x402Enabled)) {
+    clack.cancel("Aborted.");
+    return void 0;
+  }
+  let merchantPayTo = defaultInitAnswers().merchantPayTo;
+  if (x402Enabled) {
+    const answer = await clack.text({
+      message: "Merchant settlement destination address (merchant-controlled \u2014 never a gateway-owned wallet)",
+      initialValue: merchantPayTo,
+      validate: (value) => {
+        const trimmed = (value ?? "").trim();
+        if (trimmed.length === 0) return "Required";
+        return /^0x[0-9a-fA-F]{40}$/.test(trimmed) ? void 0 : "Must be a 0x-prefixed 20-byte EVM address (42 characters)";
+      }
+    });
+    if (clack.isCancel(answer)) {
+      clack.cancel("Aborted.");
+      return void 0;
+    }
+    merchantPayTo = answer;
+  }
+  clack.outro("Configuration answers collected.");
+  return { backendBaseUrl, resources, protocols, x402Enabled, merchantPayTo };
+}
+async function runInit(options, io, deps = {}) {
+  const outputPath = options.outputPath ?? DEFAULT_CONFIG_FILENAME;
+  const loadConfig2 = deps.loadConfig ?? loadConfigDynamic;
+  const parseConfigInMemory = deps.parseConfig ?? parseConfigDynamic;
+  const fileExists = deps.fileExists ?? existsSync;
+  const writeFileImpl = deps.writeFile ?? (async (path2, content) => {
+    await writeFile(path2, content, "utf8");
+  });
+  if (fileExists(outputPath) && options.force !== true) {
+    io.stderr(`FAIL  ${outputPath} already exists. Re-run with --force to overwrite.`);
+    return 1;
+  }
+  const answers = options.yes === true ? defaultInitAnswers() : await (deps.collectAnswers ?? collectAnswersInteractive)();
+  if (answers === void 0) {
+    io.stderr("FAIL  init aborted, nothing was written.");
+    return 1;
+  }
+  let config;
+  try {
+    config = await parseConfigInMemory(buildInitConfigObject(answers));
+  } catch (err) {
+    io.stderr(formatConfigError(err));
+    io.stderr(`FAIL  Nothing was written to ${outputPath}.`);
+    return 1;
+  }
+  const yamlContent = renderInitConfigYaml(answers);
+  const resolvedPath = resolve(outputPath);
+  const dir = dirname(resolvedPath);
+  if (dir !== "" && !existsSync(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+  await writeFileImpl(outputPath, yamlContent);
+  io.stdout(`PASS  Wrote ${outputPath}`);
+  io.stdout(`PASS  ${outputPath} is valid \u2014 ${config.resources.length} resource(s)`);
+  try {
+    await loadConfig2({ path: outputPath });
+  } catch (err) {
+    io.stderr(formatConfigError(err));
+    io.stderr(
+      `FAIL  ${outputPath} was written but does not parse, although the same answers validated in memory \u2014 this is a bug in the config renderer, please report it.`
+    );
+    return 1;
+  }
+  io.stdout("");
+  io.stdout("Next steps:");
+  io.stdout(`  agent-commerce validate --config ${outputPath}`);
+  io.stdout("  docker compose up     # start the local demo stack (from a repo clone)");
+  io.stdout(`  agent-commerce doctor --config ${outputPath}`);
+  return 0;
+}
+
+// src/cli/commands/version.ts
+function runVersion(io, deps = {}) {
+  const report = (deps.readVersionReport ?? readVersionReport)();
+  io.stdout(`agent-commerce v${report.cliVersion}`);
+  if (report.pinned.length > 0) {
+    io.stdout("");
+    io.stdout("Pinned protocol / SDK versions:");
+    for (const pin of report.pinned) {
+      io.stdout(`  ${pin.name.padEnd(24)} ${pin.version.padEnd(12)} (via ${pin.via})`);
+    }
+  }
+  return 0;
+}
+
+// src/cli/lib/io.ts
+var processIo = {
+  stdout: (line) => {
+    process.stdout.write(`${line}
+`);
+  },
+  stderr: (line) => {
+    process.stderr.write(`${line}
+`);
+  }
+};
+
+// src/cli/program.ts
+function buildProgram(io = processIo) {
+  const program = new Command();
+  program.name("agent-commerce").description("CLI for the Agent Commerce Gateway: init, validate, doctor, demo.").version(readVersionReport().cliVersion, "-v, --version", "Print the CLI version.").exitOverride().configureOutput({
+    writeOut: (str) => io.stdout(str.replace(/\n+$/, "")),
+    writeErr: (str) => io.stderr(str.replace(/\n+$/, ""))
+  });
+  program.command("version").description("Print the CLI version and pinned protocol/SDK versions.").action(() => {
+    process.exitCode = runVersion(io);
+  });
+  program.command("validate").description(`Validate ${DEFAULT_CONFIG_FILENAME} and exit non-zero if it is invalid.`).option("--config <path>", `path to ${DEFAULT_CONFIG_FILENAME}`).action(async (opts) => {
+    const code = await runValidate(
+      opts.config !== void 0 ? { configPath: opts.config } : {},
+      io
+    );
+    process.exitCode = code;
+  });
+  program.command("doctor").description("Diagnose config, gateway, backend, protocol and payment health.").option("--config <path>", `path to ${DEFAULT_CONFIG_FILENAME}`).option(
+    "--gateway <url>",
+    "gateway base URL (default: derived from config, else http://localhost:8080)"
+  ).option("--json", "emit machine-readable JSON instead of a formatted report", false).action(async (opts) => {
+    const report = await runDoctor({
+      ...opts.config !== void 0 ? { configPath: opts.config } : {},
+      ...opts.gateway !== void 0 ? { gatewayUrl: opts.gateway } : {}
+    });
+    printDoctorReport(report, io, opts.json === true);
+    process.exitCode = report.exitCode;
+  });
+  program.command("init").description(`Interactively generate ${DEFAULT_CONFIG_FILENAME}.`).option("--output <path>", "output path", DEFAULT_CONFIG_FILENAME).option("--force", "overwrite an existing file", false).option("--yes", "use non-interactive defaults (required for scripting/tests)", false).action(async (opts) => {
+    const code = await runInit({ outputPath: opts.output, force: opts.force, yes: opts.yes }, io);
+    process.exitCode = code;
+  });
+  program.command("demo").description(
+    "Run the documented docker compose + demo agent quickstart, verifying health between steps."
+  ).action(async () => {
+    process.exitCode = await runDemo(io);
+  });
+  return program;
+}
+
+// src/cli/index.ts
+async function main() {
+  const program = buildProgram();
+  try {
+    await program.parseAsync(process.argv);
+  } catch (err) {
+    if (err instanceof CommanderError) {
+      process.exitCode = err.exitCode;
+      return;
+    }
+    throw err;
+  }
+}
+void main();
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map