@bankofai/x402-cli 1.0.1-beta.0 → 1.0.1-beta.10

package/dist/gateway/server.js

@@ -1,14 +1,17 @@
 import http from "node:http";
+import { timingSafeEqual } from "node:crypto";
 import { URL } from "node:url";
 import { endpointFor, paymentRequirements, priceUsd } from "./config.js";
 import { decodeSignature, encodeRequired, encodeResponse, headers, matchRequirement } from "./x402.js";
 class HttpError extends Error {
     status;
     publicMessage;
-    constructor(status, publicMessage, message = publicMessage) {
+    responseHeaders;
+    constructor(status, publicMessage, message = publicMessage, responseHeaders = {}) {
         super(message);
         this.status = status;
         this.publicMessage = publicMessage;
+        this.responseHeaders = responseHeaders;
     }
 }
 class RequestTooLargeError extends HttpError {
@@ -16,9 +19,23 @@ class RequestTooLargeError extends HttpError {
         super(413, "request body too large");
     }
 }
-const MAX_BODY_BYTES = Number(process.env.X402_GATEWAY_MAX_BODY_BYTES ?? 1_000_000);
-const FACILITATOR_TIMEOUT_MS = Number(process.env.X402_GATEWAY_FACILITATOR_TIMEOUT_MS ?? 10_000);
-const UPSTREAM_TIMEOUT_MS = Number(process.env.X402_GATEWAY_UPSTREAM_TIMEOUT_MS ?? 30_000);
+function positiveIntegerEnv(name, fallback) {
+    const raw = process.env[name];
+    if (raw === undefined || raw === "")
+        return fallback;
+    if (!/^\d+$/.test(raw))
+        throw new Error(`${name} must be a positive integer`);
+    const value = Number(raw);
+    if (!Number.isSafeInteger(value) || value <= 0 || value > 2_147_483_647)
+        throw new Error(`${name} must be an integer between 1 and 2147483647`);
+    return value;
+}
+const MAX_BODY_BYTES = positiveIntegerEnv("X402_GATEWAY_MAX_BODY_BYTES", 1_000_000);
+const FACILITATOR_TIMEOUT_MS = positiveIntegerEnv("X402_GATEWAY_FACILITATOR_TIMEOUT_MS", 10_000);
+const UPSTREAM_TIMEOUT_MS = positiveIntegerEnv("X402_GATEWAY_UPSTREAM_TIMEOUT_MS", 30_000);
+const MAX_RESPONSE_BYTES = positiveIntegerEnv("X402_GATEWAY_MAX_RESPONSE_BYTES", 10_000_000);
+const MAX_CONCURRENT_REQUESTS = positiveIntegerEnv("X402_GATEWAY_MAX_CONCURRENT_REQUESTS", 100);
+const RATE_LIMIT_PER_MINUTE = positiveIntegerEnv("X402_GATEWAY_RATE_LIMIT_PER_MINUTE", 300);
 const STRIP_REQUEST_HEADERS = new Set([
     "host",
     "connection",
@@ -36,6 +53,8 @@ const STRIP_REQUEST_HEADERS = new Set([
     "payment-signature",
     "payment-required",
     "x-payment-required",
+    "payment-response",
+    "x-payment-response",
     "accept-encoding",
 ]);
 const STRIP_RESPONSE_HEADERS = new Set([
@@ -46,15 +65,23 @@ const STRIP_RESPONSE_HEADERS = new Set([
     "authorization",
     "proxy-authorization",
     "set-cookie",
+    "payment-required",
+    "x-payment-required",
+    "payment-signature",
+    "x-payment",
+    "payment-response",
+    "x-payment-response",
 ]);
-const metrics = {
-    requests: 0,
-    paidRequests: 0,
-    verifyFailures: 0,
-    settleFailures: 0,
-    feeQuoteFailures: 0,
-    upstreamFailures: 0,
-};
+function createMetrics() {
+    return {
+        requests: 0,
+        paidRequests: 0,
+        verifyFailures: 0,
+        settleFailures: 0,
+        upstreamFailures: 0,
+        rejectedRequests: 0,
+    };
+}
 async function readBody(request) {
     const chunks = [];
     let total = 0;
@@ -68,17 +95,20 @@ async function readBody(request) {
     return Buffer.concat(chunks);
 }
 function json(response, status, body, extraHeaders = {}) {
-    response.writeHead(status, { "content-type": "application/json", ...extraHeaders });
+    response.writeHead(status, { "content-type": "application/json", "cache-control": "no-store", "x-content-type-options": "nosniff", ...extraHeaders });
     response.end(JSON.stringify(body));
 }
 async function fetchWithTimeout(url, init, timeoutMs, label = "upstream") {
     const controller = new AbortController();
     const timer = setTimeout(() => controller.abort(), timeoutMs);
     try {
-        return await fetch(url, { ...init, signal: controller.signal });
+        const response = await fetch(url, { ...init, redirect: "manual", signal: controller.signal });
+        if (response.status >= 300 && response.status < 400)
+            throw new HttpError(502, `${label} redirect refused`);
+        return response;
     }
     catch (error) {
-        if (error?.name === "AbortError")
+        if (error instanceof Error && error.name === "AbortError")
             throw new HttpError(504, `${label} request timed out`);
         throw error;
     }
@@ -86,59 +116,103 @@ async function fetchWithTimeout(url, init, timeoutMs, label = "upstream") {
         clearTimeout(timer);
     }
 }
+async function readResponseBytes(response, limit = MAX_RESPONSE_BYTES) {
+    const declared = Number(response.headers.get("content-length"));
+    if (Number.isFinite(declared) && declared > limit)
+        throw new HttpError(502, "upstream response too large");
+    if (!response.body)
+        return Buffer.alloc(0);
+    const chunks = [];
+    let total = 0;
+    for await (const chunk of response.body) {
+        const buffer = Buffer.from(chunk);
+        total += buffer.length;
+        if (total > limit)
+            throw new HttpError(502, "upstream response too large");
+        chunks.push(buffer);
+    }
+    return Buffer.concat(chunks);
+}
 async function facilitatorPost(entry, path, body) {
     const headers = { "content-type": "application/json" };
     if (entry.facilitatorApiKey) {
-        headers.authorization = `Bearer ${entry.facilitatorApiKey}`;
+        headers["x-api-key"] = entry.facilitatorApiKey;
     }
-    const response = await fetchWithTimeout(new URL(path, entry.facilitatorUrl), { method: "POST", headers, body: JSON.stringify(body) }, FACILITATOR_TIMEOUT_MS, "facilitator");
-    const text = await response.text();
+    const response = await fetchWithTimeout(new URL(path.replace(/^\/+/, ""), `${entry.facilitatorUrl.replace(/\/+$/, "")}/`), { method: "POST", headers, body: JSON.stringify(body) }, FACILITATOR_TIMEOUT_MS, "facilitator");
+    const text = (await readResponseBytes(response, Math.min(MAX_RESPONSE_BYTES, 1_000_000))).toString("utf8");
     let data = {};
     try {
         data = text ? JSON.parse(text) : {};
     }
     catch {
+        logFacilitatorFailure(entry, path, response, body, { code: "invalid_json" });
         throw new HttpError(502, "facilitator returned invalid response");
     }
-    if (!response.ok)
-        throw new HttpError(502, "facilitator request failed", `facilitator ${path} failed: ${response.status} ${text}`);
+    if (!response.ok) {
+        logFacilitatorFailure(entry, path, response, body, data);
+        if (response.status === 429) {
+            const retryAfter = response.headers.get("retry-after");
+            throw new HttpError(429, "facilitator rate limited", `facilitator ${path} rate limited`, retryAfter ? { "retry-after": retryAfter } : {});
+        }
+        throw new HttpError(502, "facilitator request failed", `facilitator ${path} failed: ${response.status}`);
+    }
     return data;
 }
-async function attachFeeQuotes(entry, requirements, context) {
+function configuredPublicBaseUrl() {
+    const value = process.env.X402_GATEWAY_PUBLIC_BASE_URL?.trim();
+    if (!value)
+        return undefined;
     try {
-        const quotes = await facilitatorPost(entry, "/fee_quote", {
-            paymentRequirements: requirements,
-            context,
-        });
-        const list = Array.isArray(quotes) ? quotes : quotes.quotes ?? quotes.fees ?? [];
-        return requirements.map(requirement => {
-            const quote = list.find((item) => item.scheme === requirement.scheme &&
-                item.network === requirement.network &&
-                String(item.asset).toLowerCase() === requirement.asset.toLowerCase());
-            return quote?.fee ? { ...requirement, extra: { ...requirement.extra, fee: quote.fee } } : requirement;
-        });
+        const url = new URL(value);
+        if (!["http:", "https:"].includes(url.protocol))
+            throw new Error("unsupported protocol");
+        return `${value.replace(/\/+$/, "")}/`;
     }
-    catch (error) {
-        metrics.feeQuoteFailures += 1;
-        console.warn("fee quote failed", error);
-        return requirements;
+    catch {
+        throw new Error("X402_GATEWAY_PUBLIC_BASE_URL must be a valid http(s) URL");
     }
 }
+function resourceUrl(url, publicBaseUrl) {
+    const path = `${url.pathname}${url.search}`;
+    if (!publicBaseUrl)
+        return path;
+    return new URL(path, publicBaseUrl).toString();
+}
+function logFacilitatorFailure(entry, path, response, body, data) {
+    const requirement = body?.paymentRequirements;
+    const nestedError = data?.error && typeof data.error === "object" ? data.error : undefined;
+    const message = nestedError?.message ?? data?.message ?? data?.detail ??
+        (typeof data?.error === "string" ? data.error : undefined);
+    console.error(JSON.stringify({
+        event: "facilitator_request_failed",
+        provider: entry.config.name,
+        endpoint: path,
+        status: response.status,
+        scheme: requirement?.scheme,
+        network: requirement?.network,
+        errorCode: nestedError?.code ?? data?.code,
+        errorMessage: typeof message === "string" ? message.slice(0, 200) : undefined,
+        retryAfter: response.headers.get("retry-after") ?? undefined,
+        cfRay: response.headers.get("cf-ray") ?? undefined,
+    }));
+}
 function isVerifySuccess(verify) {
     return verify?.valid === true || verify?.isValid === true;
 }
 function isSettleSuccess(settle) {
-    return (settle?.success === true ||
-        settle?.settled === true ||
-        (typeof settle?.transaction === "string" && settle.transaction.length > 0) ||
-        (typeof settle?.txHash === "string" && settle.txHash.length > 0));
+    return settle?.success === true && typeof settle?.transaction === "string" && settle.transaction.length > 0 && typeof settle?.network === "string" && settle.network.length > 0;
 }
 function isAdminAllowed(request) {
     const token = process.env.X402_GATEWAY_ADMIN_TOKEN;
     if (!token)
         return process.env.X402_GATEWAY_ADMIN_ALLOW_PUBLIC === "true";
     const auth = request.headers.authorization ?? "";
-    return auth === `Bearer ${token}`;
+    const expected = Buffer.from(`Bearer ${token}`);
+    const actual = Buffer.from(auth);
+    return actual.length === expected.length && timingSafeEqual(actual, expected);
+}
+function clientAddress(request) {
+    return request.socket.remoteAddress ?? "unknown";
 }
 function requestParams(url, body, request) {
     const params = {};
@@ -165,11 +239,12 @@ function requestParams(url, body, request) {
 }
 function upstreamHeaders(request, entry) {
     const headersOut = new Headers();
+    const connectionHeaders = new Set(String(request.headers.connection ?? "").split(",").map(value => value.trim().toLowerCase()).filter(Boolean));
     for (const [key, value] of Object.entries(request.headers)) {
         if (!value)
             continue;
         const lower = key.toLowerCase();
-        if (STRIP_REQUEST_HEADERS.has(lower))
+        if (STRIP_REQUEST_HEADERS.has(lower) || connectionHeaders.has(lower))
             continue;
         headersOut.set(key, Array.isArray(value) ? value.join(",") : value);
     }
@@ -184,7 +259,14 @@ function upstreamHeaders(request, entry) {
 }
 function upstreamUrl(entry, request, routePath) {
     const sourceUrl = new URL(request.url ?? "/", "http://local");
-    const upstream = new URL(routePath + (sourceUrl.search || ""), entry.config.forward_url);
+    if (!routePath.startsWith("/") || routePath.startsWith("//") || routePath.includes("\\") || routePath.includes("\0") || /%(?:2f|5c)/i.test(routePath))
+        throw new HttpError(400, "invalid provider path");
+    const base = new URL(entry.config.forward_url);
+    const upstream = new URL(base);
+    upstream.pathname = routePath;
+    upstream.search = sourceUrl.search;
+    if (upstream.origin !== base.origin)
+        throw new HttpError(400, "invalid provider path");
     const auth = entry.config.routing?.auth;
     const value = auth?.value ?? (auth?.value_from_env ? process.env[auth.value_from_env] : undefined);
     if (auth?.method === "query_param" && value) {
@@ -192,7 +274,7 @@ function upstreamUrl(entry, request, routePath) {
     }
     return upstream;
 }
-async function forward(entry, request, response, routePath, body, paymentResponse) {
+async function forward(metrics, entry, request, response, routePath, body, paymentResponse) {
     const upstream = upstreamUrl(entry, request, routePath);
     let upstreamResponse;
     try {
@@ -216,11 +298,24 @@ async function forward(entry, request, response, routePath, body, paymentRespons
     });
     if (paymentResponse)
         responseHeaders[headers.response] = encodeResponse(paymentResponse);
+    let responseBody;
+    try {
+        responseBody = await readResponseBytes(upstreamResponse);
+    }
+    catch (error) {
+        metrics.upstreamFailures += 1;
+        throw error;
+    }
     response.writeHead(upstreamResponse.status, responseHeaders);
-    response.end(Buffer.from(await upstreamResponse.arrayBuffer()));
+    response.end(responseBody);
 }
 export function createGatewayServer(providers) {
-    return http.createServer(async (request, response) => {
+    const publicBaseUrl = configuredPublicBaseUrl();
+    const metrics = createMetrics();
+    const rateLimits = new Map();
+    let activeRequests = 0;
+    const server = http.createServer(async (request, response) => {
+        let countedActive = false;
         try {
             metrics.requests += 1;
             const url = new URL(request.url ?? "/", "http://local");
@@ -265,8 +360,8 @@ export function createGatewayServer(providers) {
                     `x402_gateway_paid_requests_total ${metrics.paidRequests}`,
                     `x402_gateway_verify_failures_total ${metrics.verifyFailures}`,
                     `x402_gateway_settle_failures_total ${metrics.settleFailures}`,
-                    `x402_gateway_fee_quote_failures_total ${metrics.feeQuoteFailures}`,
                     `x402_gateway_upstream_failures_total ${metrics.upstreamFailures}`,
+                    `x402_gateway_rejected_requests_total ${metrics.rejectedRequests}`,
                     "",
                 ].join("\n"));
                 return;
@@ -287,19 +382,41 @@ export function createGatewayServer(providers) {
                 json(response, 404, { error: "endpoint not found" });
                 return;
             }
+            const now = Date.now();
+            const address = clientAddress(request);
+            let rate = rateLimits.get(address);
+            if (!rate || rate.resetAt <= now) {
+                rate = { count: 0, resetAt: now + 60_000 };
+                rateLimits.set(address, rate);
+            }
+            rate.count += 1;
+            if (rate.count > RATE_LIMIT_PER_MINUTE) {
+                metrics.rejectedRequests += 1;
+                const retryAfter = Math.max(1, Math.ceil((rate.resetAt - now) / 1000));
+                throw new HttpError(429, "gateway rate limited", undefined, { "retry-after": String(retryAfter) });
+            }
+            if (activeRequests >= MAX_CONCURRENT_REQUESTS) {
+                metrics.rejectedRequests += 1;
+                throw new HttpError(503, "gateway is busy", undefined, { "retry-after": "1" });
+            }
+            activeRequests += 1;
+            countedActive = true;
             const body = await readBody(request);
-            const requirements = paymentRequirements(entry.config, priceUsd(endpoint, requestParams(url, body, request)));
+            const price = priceUsd(endpoint, requestParams(url, body, request));
+            const requirements = paymentRequirements(entry.config, price);
+            if (price > 0 && !requirements.length)
+                throw new HttpError(500, "paid endpoint has no payment requirements");
             if (!requirements.length) {
-                await forward(entry, request, response, routePath, body);
+                await forward(metrics, entry, request, response, routePath, body);
                 return;
             }
             const paymentHeader = request.headers[headers.signature.toLowerCase()];
             if (!paymentHeader || Array.isArray(paymentHeader)) {
-                const accepts = await attachFeeQuotes(entry, requirements);
+                const accepts = requirements;
                 const challenge = {
                     x402Version: 2,
                     error: "Payment required",
-                    resource: { url: url.pathname },
+                    resource: { url: resourceUrl(url, publicBaseUrl) },
                     accepts,
                 };
                 json(response, 402, challenge, { [headers.required]: encodeRequired(challenge) });
@@ -344,15 +461,37 @@ export function createGatewayServer(providers) {
                 return;
             }
             metrics.paidRequests += 1;
-            await forward(entry, request, response, routePath, body, settle);
+            try {
+                await forward(metrics, entry, request, response, routePath, body, settle);
+            }
+            catch (error) {
+                const status = error instanceof HttpError ? error.status : 502;
+                const extraHeaders = error instanceof HttpError ? error.responseHeaders : {};
+                json(response, status, {
+                    error: "upstream failed after payment settlement",
+                    settled: true,
+                }, {
+                    ...extraHeaders,
+                    [headers.response]: encodeResponse(settle),
+                });
+            }
         }
         catch (error) {
             if (error instanceof HttpError) {
-                json(response, error.status, { error: error.publicMessage });
+                json(response, error.status, { error: error.publicMessage }, error.responseHeaders);
                 return;
             }
             console.error(error);
             json(response, 500, { error: "internal server error" });
         }
+        finally {
+            if (countedActive)
+                activeRequests -= 1;
+        }
     });
+    server.requestTimeout = UPSTREAM_TIMEOUT_MS + FACILITATOR_TIMEOUT_MS * 2 + 5_000;
+    server.headersTimeout = Math.min(server.requestTimeout, 60_000);
+    server.keepAliveTimeout = 5_000;
+    server.maxConnections = MAX_CONCURRENT_REQUESTS * 2;
+    return server;
 }

package/dist/gateway/tokens.js

@@ -1,9 +1,9 @@
 export const TOKENS = {
-    "tron:mainnet": {
+    "tron:0x2b6653dc": {
         USDT: { address: "TR7NHqjeKQxGTCi8q8ZY4pL8otSzgjLj6t", decimals: 6, name: "Tether USD", symbol: "USDT", assetTransferMethod: "permit2" },
         USDD: { address: "TXDk8mbtRbXeYuMNS83CfKPaYYT8XWv9Hz", decimals: 18, name: "Decentralized USD", symbol: "USDD", assetTransferMethod: "permit2" },
     },
-    "tron:nile": {
+    "tron:0xcd8690dc": {
         USDT: { address: "TXYZopYRdj2D9XRtbG411XZZ3kM5VkAeBf", decimals: 6, name: "Tether USD", symbol: "USDT", assetTransferMethod: "permit2" },
         USDD: { address: "TGjgvdTWWrybVLaVeFqSyVqJQWjxqRYbaK", decimals: 18, name: "Decentralized USD", symbol: "USDD", assetTransferMethod: "permit2" },
     },
@@ -16,13 +16,25 @@ export const TOKENS = {
     },
 };
 export function normalizeNetwork(network) {
-    return ({
-        "tron-mainnet": "tron:mainnet",
-        "tron-shasta": "tron:shasta",
-        "tron-nile": "tron:nile",
+    const legacyTronIds = {
+        "tron-mainnet": "tron:0x2b6653dc",
+        "tron:mainnet": "tron:0x2b6653dc",
+        mainnet: "tron:0x2b6653dc",
+        "tron-shasta": "tron:0x94a9059e",
+        "tron:shasta": "tron:0x94a9059e",
+        shasta: "tron:0x94a9059e",
+        "tron-nile": "tron:0xcd8690dc",
+        "tron:nile": "tron:0xcd8690dc",
+        nile: "tron:0xcd8690dc",
+    };
+    const canonical = legacyTronIds[network];
+    if (canonical) {
+        throw new Error(`legacy TRON network identifier ${network} is not supported; use ${canonical}`);
+    }
+    return {
         "bsc-mainnet": "eip155:56",
         "bsc-testnet": "eip155:97",
-    }[network] ?? network);
+    }[network] ?? network;
 }
 export function getToken(network, symbol) {
     const normalized = normalizeNetwork(network);

package/dist/gateway-commands.js

@@ -0,0 +1,145 @@
+import fs from "node:fs";
+import path from "node:path";
+import { spawn } from "node:child_process";
+import { createRequire } from "node:module";
+import { fileURLToPath } from "node:url";
+import { opt, outputMode } from "./args.js";
+import { emit, printJson } from "./output.js";
+import { buildGatewayCatalog, loadProviders, providerPaymentAssets } from "@bankofai/x402-gateway";
+const require = createRequire(import.meta.url);
+function executableInPath(name) {
+    for (const dir of (process.env.PATH ?? "").split(path.delimiter)) {
+        if (!dir)
+            continue;
+        const candidate = path.join(dir, name);
+        try {
+            fs.accessSync(candidate, fs.constants.X_OK);
+            return candidate;
+        }
+        catch {
+            // Try the next PATH entry.
+        }
+    }
+    return undefined;
+}
+function resolveGatewayPackageRuntime() {
+    try {
+        return path.join(path.dirname(require.resolve("@bankofai/x402-gateway/package.json")), "dist", "cli.js");
+    }
+    catch {
+        return undefined;
+    }
+}
+function gatewayCommand(options) {
+    const explicit = opt(options, "gateway-bin");
+    const gatewayPackageRuntime = resolveGatewayPackageRuntime();
+    const candidates = [
+        explicit ? { file: explicit, source: "--gateway-bin" } : undefined,
+        gatewayPackageRuntime ? { file: gatewayPackageRuntime, source: "@bankofai/x402-gateway dependency" } : undefined,
+        { file: path.resolve(path.dirname(fileURLToPath(import.meta.url)), "gateway", "cli.js"), source: "bundled gateway runtime" },
+        executableInPath("x402-gateway") ? { file: executableInPath("x402-gateway"), source: "PATH x402-gateway" } : undefined,
+        { file: path.resolve(process.cwd(), "../x402-gateway/dist/cli.js"), source: "sibling ../x402-gateway" },
+    ].filter(Boolean);
+    for (const candidate of candidates) {
+        try {
+            fs.accessSync(candidate.file, fs.constants.R_OK);
+            if (candidate.file.endsWith(".js")) {
+                return { command: process.execPath, argsPrefix: [candidate.file], source: candidate.source };
+            }
+            return { command: candidate.file, argsPrefix: [], source: candidate.source };
+        }
+        catch {
+            // Try the next candidate.
+        }
+    }
+    throw new Error("x402-gateway runtime not found. Install @bankofai/x402-gateway, run from a checkout with ../x402-gateway/dist/cli.js, or pass --gateway-bin <path>.");
+}
+export async function gatewayStart(args, options) {
+    const gateway = gatewayCommand(options);
+    const child = spawn(gateway.command, [...gateway.argsPrefix, ...args], {
+        stdio: "inherit",
+        env: process.env,
+    });
+    await new Promise((resolve, reject) => {
+        child.on("exit", code => code === 0 ? resolve() : reject(new Error(`gateway exited with ${code}`)));
+        child.on("error", reject);
+    });
+}
+export function gatewayCheck(target, options) {
+    const providers = loadProviders(target);
+    emit({
+        command: "gateway check",
+        mode: outputMode(options),
+        result: { providers: [...providers.keys()], count: providers.size },
+    });
+}
+export function gatewayScaffold(name, options) {
+    const outputDir = opt(options, "output-dir", path.join("providers", name));
+    const forwardUrl = opt(options, "forward-url", "https://api.example.com");
+    fs.mkdirSync(outputDir, { recursive: true });
+    const body = `name: ${name}
+title: "${name}"
+description: "x402 provider"
+category: data
+version: v1
+
+forward_url: ${forwardUrl}
+
+routing:
+  type: proxy
+
+operator:
+  network: tron:0xcd8690dc
+  currencies:
+    usd: ["USDT"]
+  recipient: <provider-recipient-address>
+  scheme: exact
+  protocol: exact
+  asset_transfer_method: permit2
+  facilitator_url: https://facilitator.bankofai.io
+  facilitator_api_key: <facilitator-api-key>
+  valid_for_seconds: 300
+
+endpoints:
+  - method: GET
+    path: /v1/ping
+    metering:
+      dimensions:
+        - tiers:
+            - price_usd: 0.0001
+  `;
+    fs.writeFileSync(path.join(outputDir, "provider.yml"), body);
+    emit({
+        command: "gateway scaffold",
+        mode: outputMode(options),
+        result: { file: path.join(outputDir, "provider.yml") },
+    });
+}
+export function catalogBuild(target, options) {
+    const providers = loadProviders(target);
+    const catalog = buildGatewayCatalog(providers);
+    const output = opt(options, "output", opt(options, "dist-dir") ? path.join(opt(options, "dist-dir"), "catalog.json") : undefined);
+    if (output) {
+        fs.mkdirSync(path.dirname(output), { recursive: true });
+        fs.writeFileSync(output, JSON.stringify(catalog, null, 2));
+        emit({
+            command: "catalog build",
+            mode: outputMode(options),
+            result: { output, count: providers.size },
+        });
+    }
+    else if (outputMode(options) === "json") {
+        emit({ command: "catalog build", mode: "json", result: catalog });
+    }
+    else {
+        printJson(catalog);
+    }
+}
+export function catalogPayAssets(target, options) {
+    const rows = providerPaymentAssets(loadProviders(target));
+    emit({
+        command: "gateway catalog pay-assets",
+        mode: outputMode(options),
+        result: { count: rows.length, assets: rows },
+    });
+}