@clawcash/forge 0.1.8 → 0.2.0

package/dist/index.js

@@ -36,136 +36,8 @@ function defineAgentService(config) {
   };
 }
 
-// src/mount.ts
-import { Router as createRouter } from "express";
-import { paymentMiddleware, x402ResourceServer } from "@x402/express";
-import { HTTPFacilitatorClient } from "@x402/core/server";
-import { ExactEvmScheme } from "@x402/evm/exact/server";
-
-// src/base-url.ts
-import { randomBytes } from "crypto";
-function resolveBaseUrlFromEnv(explicit) {
-  const fromExplicit = explicit?.trim();
-  if (fromExplicit) return stripSlash(fromExplicit);
-  const fromEnv = process.env.PUBLIC_BASE_URL?.trim();
-  if (fromEnv) return stripSlash(fromEnv);
-  const railway = process.env.RAILWAY_PUBLIC_DOMAIN?.trim();
-  if (railway) return `https://${stripSlash(railway)}`;
-  const render = process.env.RENDER_EXTERNAL_URL?.trim();
-  if (render) return stripSlash(render);
-  const vercel = process.env.VERCEL_PROJECT_PRODUCTION_URL?.trim() || process.env.VERCEL_URL?.trim();
-  if (vercel) return `https://${stripSlash(vercel)}`;
-  const fly = process.env.FLY_APP_NAME?.trim();
-  if (fly) return `https://${fly}.fly.dev`;
-  const heroku = process.env.HEROKU_APP_NAME?.trim();
-  if (heroku) return `https://${heroku}.herokuapp.com`;
-  return null;
-}
-function stripSlash(url) {
-  return url.replace(/\/$/, "");
-}
-var MAX_VERIFY_ATTEMPTS = 5;
-var VERIFY_TIMEOUT_MS = 3e3;
-var PublicBaseUrlResolver = class {
-  /** Per-boot nonce, echoed by /forge/health for self-verification. */
-  instanceNonce;
-  resolved;
-  verifying = false;
-  rejected = /* @__PURE__ */ new Set();
-  attempts = 0;
-  onResolved;
-  constructor(opts) {
-    this.instanceNonce = randomBytes(16).toString("hex");
-    this.resolved = opts.initial;
-    this.onResolved = opts.onResolved ?? null;
-  }
-  get() {
-    return this.resolved;
-  }
-  /**
-   * Feed an inbound Forge-surface request. No-op once resolved. Kicks off
-   * async self-verification of the candidate URL derived from the request.
-   */
-  considerRequest(req) {
-    if (this.resolved || this.verifying) return;
-    if (this.attempts >= MAX_VERIFY_ATTEMPTS) return;
-    const candidate = candidateFromRequest(req);
-    if (!candidate || this.rejected.has(candidate)) return;
-    this.verifying = true;
-    this.attempts += 1;
-    void this.verify(candidate).then((ok) => {
-      if (ok) {
-        this.resolved = candidate;
-        console.log(`[forge] public base URL inferred and verified: ${candidate}`);
-        this.onResolved?.(candidate);
-      } else {
-        this.rejected.add(candidate);
-        console.warn(
-          `[forge] candidate base URL failed self-verification, ignoring: ${candidate}`
-        );
-      }
-    }).finally(() => {
-      this.verifying = false;
-    });
-  }
-  /** Fetch our own /forge/health at the candidate and match the boot nonce. */
-  async verify(candidate) {
-    try {
-      const controller = new AbortController();
-      const timer = setTimeout(() => controller.abort(), VERIFY_TIMEOUT_MS);
-      const res = await fetch(`${candidate}/forge/health`, {
-        signal: controller.signal,
-        headers: { accept: "application/json" },
-        redirect: "manual"
-      });
-      clearTimeout(timer);
-      if (!res.ok) return false;
-      const json = await res.json();
-      return json.instance === this.instanceNonce;
-    } catch {
-      return false;
-    }
-  }
-};
-function candidateFromRequest(req) {
-  const host = firstHeaderValue(req.headers["x-forwarded-host"]) ?? req.headers.host;
-  if (!host || !isValidHost(host)) return null;
-  const proto = firstHeaderValue(req.headers["x-forwarded-proto"]) ?? (req.protocol || "http");
-  if (proto !== "https" && proto !== "http") return null;
-  const isLocal = /^(localhost|127\.0\.0\.1|\[::1\])(:\d+)?$/i.test(host);
-  if (proto === "http" && !isLocal) return null;
-  return `${proto}://${host}`;
-}
-function firstHeaderValue(value) {
-  const raw = Array.isArray(value) ? value[0] : value;
-  const first = raw?.split(",")[0]?.trim();
-  return first || null;
-}
-function isValidHost(host) {
-  return /^[a-z0-9.-]+(:\d{1,5})?$/i.test(host) || /^\[[0-9a-f:]+\](:\d{1,5})?$/i.test(host);
-}
-
-// src/gateway.ts
-async function heartbeatGateway(opts) {
-  const gateway = opts.gatewayUrl.replace(/\/$/, "");
-  const res = await fetch(`${gateway}/register/heartbeat`, {
-    method: "POST",
-    headers: {
-      "content-type": "application/json",
-      authorization: `Bearer ${opts.registerSecret}`
-    },
-    body: JSON.stringify({
-      handle: opts.handle.trim().toLowerCase(),
-      baseUrl: opts.baseUrl.replace(/\/$/, "")
-    })
-  });
-  if (!res.ok) {
-    const text = await res.text();
-    throw new Error(
-      `gateway heartbeat failed (${res.status}): ${text.slice(0, 240)}`
-    );
-  }
-}
+// src/worker.ts
+import os from "os";
 
 // src/gateway-auth.ts
 function getForgeApiKey(explicit) {
@@ -173,29 +45,7 @@ function getForgeApiKey(explicit) {
   if (!value || value.length < 16) return null;
   return value;
 }
-function getForgeGatewaySecret(explicit) {
-  return getForgeApiKey(explicit);
-}
-function isForgeGatewayRequest(req, secret) {
-  const expected = getForgeApiKey(secret);
-  if (!expected) return false;
-  const header = req.header("authorization") ?? "";
-  const bearer = header.toLowerCase().startsWith("bearer ") ? header.slice(7).trim() : "";
-  const alt = req.header("x-forge-api-key")?.trim() || req.header("x-clawcash-gateway")?.trim() || "";
-  return bearer === expected || alt === expected;
-}
 var FORGE_GATEWAY_USER_ID = "forge_gateway_agent";
-function requireForgeGateway(secret) {
-  return (req, res, next) => {
-    if (!isForgeGatewayRequest(req, secret)) {
-      res.status(401).json({
-        error: "Unauthorized \u2014 Forge API key required (FORGE_API_KEY from Forge dashboard)"
-      });
-      return;
-    }
-    next();
-  };
-}
 function forgeGatewayLoopbackHeaders(secret) {
   const expected = getForgeApiKey(secret);
   if (!expected) return {};
@@ -205,139 +55,7 @@ function forgeGatewayLoopbackHeaders(secret) {
   };
 }
 
-// src/payto.ts
-var ZERO = /^0x0{40}$/i;
-function isZeroAddress(address) {
-  if (!address) return true;
-  return ZERO.test(address.trim());
-}
-function normalizeBaseUrl(url) {
-  return url.replace(/\/$/, "");
-}
-function pickForgeBaseUrl(source) {
-  const fromEnv = process.env.FORGE_URL?.trim();
-  if (fromEnv) return normalizeBaseUrl(fromEnv);
-  const fromOpts = source?.baseUrl?.trim();
-  if (!fromOpts) return null;
-  const normalized = normalizeBaseUrl(fromOpts);
-  if (/localhost|127\.0\.0\.1/i.test(normalized) && process.env.NODE_ENV === "production") {
-    return null;
-  }
-  return normalized;
-}
-async function resolvePayTo(opts) {
-  const envOverride = process.env.PAY_TO?.trim();
-  if (envOverride && !isZeroAddress(envOverride)) {
-    return envOverride;
-  }
-  const explicit = opts.payTo?.trim();
-  if (explicit && !isZeroAddress(explicit) && !opts.forge) {
-    return explicit;
-  }
-  const baseUrl = pickForgeBaseUrl(opts.forge);
-  if (baseUrl && opts.forge) {
-    const url = `${baseUrl}/api/public/pay-to/${encodeURIComponent(opts.forge.owner)}/${encodeURIComponent(opts.forge.repo)}`;
-    try {
-      const controller = new AbortController();
-      const timer = setTimeout(
-        () => controller.abort(),
-        opts.timeoutMs ?? 2500
-      );
-      const res = await fetch(url, {
-        signal: controller.signal,
-        headers: { accept: "application/json" }
-      });
-      clearTimeout(timer);
-      if (res.ok) {
-        const json = await res.json();
-        if (json.address && !isZeroAddress(json.address)) {
-          return json.address.trim();
-        }
-      }
-    } catch (err) {
-      console.warn("[forge] live payTo fetch failed, using fallback:", err);
-    }
-  }
-  if (explicit && !isZeroAddress(explicit)) return explicit;
-  if (opts.fallback && !isZeroAddress(opts.fallback)) return opts.fallback;
-  throw new Error(
-    "resolvePayTo: no usable address (set Forge wallet / PAY_TO, or re-run Forge PR)"
-  );
-}
-
-// src/status.ts
-var PACKAGE_VERSION = "0.1.8";
-var lastHeartbeat = {
-  attempted: false,
-  ok: null,
-  at: null,
-  error: null
-};
-function recordHeartbeatResult(result) {
-  lastHeartbeat = {
-    attempted: true,
-    ok: result.ok,
-    at: (/* @__PURE__ */ new Date()).toISOString(),
-    error: result.ok ? null : result.error
-  };
-}
-function getLastHeartbeat() {
-  return { ...lastHeartbeat };
-}
-function buildForgeSurfaceStatus(opts) {
-  const fulfillPath = opts.fulfillPath.replace(/\/$/, "") || "/forge/fulfill";
-  const agentBasePath = opts.agentBasePath.replace(/\/$/, "") || "/agent";
-  const ready = opts.fulfillMounted && Boolean(opts.publicBaseUrl) && opts.actions.length > 0;
-  return {
-    ok: true,
-    forge: true,
-    version: PACKAGE_VERSION,
-    handle: opts.handle,
-    publicBaseUrl: opts.publicBaseUrl,
-    gatewayUrl: opts.gatewayUrl,
-    fulfillMounted: opts.fulfillMounted,
-    fulfillPath,
-    agentBasePath,
-    skipPayment: opts.skipPayment,
-    actions: opts.actions,
-    ready,
-    heartbeat: getLastHeartbeat(),
-    endpoints: {
-      health: "/forge/health",
-      status: "/forge/status",
-      wellKnown: "/.well-known/clawcash.json",
-      fulfill: fulfillPath,
-      agent: agentBasePath
-    }
-  };
-}
-function buildWellKnownDocument(status) {
-  return {
-    forge: true,
-    version: status.version,
-    health: status.endpoints.health,
-    status: status.endpoints.status,
-    handle: status.handle,
-    ready: status.ready
-  };
-}
-function forgeSdkVersion() {
-  return PACKAGE_VERSION;
-}
-
-// src/mount.ts
-var DEFAULT_NETWORK = "eip155:8453";
-var DEFAULT_FACILITATOR_URL = "https://facilitator.xpay.sh";
-var DEFAULT_GATEWAY_URL = "https://gateway.clawca.sh";
-function asNetwork(value) {
-  return value ?? DEFAULT_NETWORK;
-}
-function createFacilitatorClient(options) {
-  return new HTTPFacilitatorClient({
-    url: options.facilitatorUrl ?? DEFAULT_FACILITATOR_URL,
-    createAuthHeaders: options.createAuthHeaders
-  });
-}
+// src/validate.ts
 function validateInput(body, schema) {
   if (!body || typeof body !== "object" || Array.isArray(body)) {
     return { ok: false, error: "Request body must be a JSON object" };
@@ -383,305 +101,343 @@ function checkType(key, value, type) {
       return null;
   }
 }
-function formatPrice(amount) {
-  const normalized = amount.startsWith("$") ? amount.slice(1) : amount;
-  return `$${normalized}`;
+
+// src/worker.ts
+var DEFAULT_GATEWAY_URL = "https://gateway.clawca.sh";
+var DEFAULT_WAIT_MS = 2e4;
+var BACKOFF_STEPS_MS = [1e3, 2e3, 5e3, 1e4, 3e4];
+function findService(services, action) {
+  const key = toKebabCase(action.trim());
+  return services.find((s) => s.path === key || toKebabCase(s.name) === key) ?? null;
+}
+async function postJson(url, apiKey, body, signal) {
+  const res = await fetch(url, {
+    method: "POST",
+    headers: {
+      "content-type": "application/json",
+      accept: "application/json",
+      authorization: `Bearer ${apiKey}`
+    },
+    body: JSON.stringify(body),
+    signal
+  });
+  const text = await res.text();
+  let json2 = {};
+  try {
+    json2 = text ? JSON.parse(text) : {};
+  } catch {
+    json2 = { raw: text };
+  }
+  return { status: res.status, json: json2 };
 }
-function mountFulfillmentRouter(app, services, options) {
-  const secret = getForgeApiKey(options.gateway?.registerSecret);
-  if (!secret) {
-    console.warn(
-      "[forge] /forge/fulfill not mounted \u2014 set FORGE_API_KEY (from Forge dashboard, min 16 chars) so the gateway can fulfill after payment"
+function forgeWorker(options) {
+  const handle = (options.handle ?? process.env.FORGE_HANDLE ?? "").trim().toLowerCase();
+  if (!handle) {
+    throw new Error(
+      "forgeWorker: handle is required (option or FORGE_HANDLE env)"
     );
-    return;
   }
-  const fulfillPath = (options.fulfillPath ?? "/forge/fulfill").replace(/\/$/, "") || "/forge/fulfill";
-  const router = createRouter();
-  const context = createContext();
-  const gate = requireForgeGateway(secret);
-  for (const service of services) {
-    router.post(
-      `/${service.path}`,
-      gate,
-      async (req, res) => {
-        try {
-          const validated = validateInput(req.body, service.input);
-          if (!validated.ok) {
-            res.status(400).json({ error: validated.error });
-            return;
-          }
-          const output = await service.execute(validated.value, context);
-          res.json(output);
-        } catch (err) {
-          const message = err instanceof Error ? err.message : "Internal error";
-          console.error(`[forge] fulfill ${service.name} failed:`, err);
-          res.status(500).json({ error: message });
-        }
+  const apiKey = getForgeApiKey(options.apiKey);
+  if (!apiKey) {
+    throw new Error(
+      "forgeWorker: FORGE_API_KEY is required (per-project key from the Forge dashboard, min 16 chars)"
+    );
+  }
+  if (!options.services?.length) {
+    throw new Error("forgeWorker: services must be a non-empty array");
+  }
+  const gatewayUrl = (options.gatewayUrl?.trim() || process.env.GATEWAY_URL?.trim() || DEFAULT_GATEWAY_URL).replace(/\/$/, "");
+  const workerId = options.workerId?.trim() || `${os.hostname()}-${process.pid}`;
+  const waitMs = options.waitMs ?? DEFAULT_WAIT_MS;
+  let running = true;
+  const controller = new AbortController();
+  let wakeSleeper = null;
+  const reportError = (err) => {
+    if (options.onError) options.onError(err);
+    else console.warn(`[forge-worker] ${err.message}`);
+  };
+  const sleep = (ms) => new Promise((resolve) => {
+    const timer = setTimeout(() => {
+      wakeSleeper = null;
+      resolve();
+    }, ms);
+    wakeSleeper = () => {
+      clearTimeout(timer);
+      wakeSleeper = null;
+      resolve();
+    };
+  });
+  async function runJob(job) {
+    const resultUrl = `${gatewayUrl}/jobs/${encodeURIComponent(job.id)}/result`;
+    const service = findService(options.services, job.action);
+    if (!service) {
+      await postJson(
+        resultUrl,
+        apiKey,
+        { ok: false, error: `no service registered for action ${job.action}` },
+        controller.signal
+      );
+      reportError(new Error(`job ${job.id}: unknown action ${job.action}`));
+      return;
+    }
+    try {
+      const validated = validateInput(job.input, service.input);
+      if (!validated.ok) {
+        await postJson(
+          resultUrl,
+          apiKey,
+          { ok: false, error: validated.error },
+          controller.signal
+        );
+        return;
+      }
+      const output = await service.execute(validated.value, createContext());
+      const res = await postJson(
+        resultUrl,
+        apiKey,
+        { ok: true, output },
+        controller.signal
+      );
+      if (res.status >= 400) {
+        reportError(
+          new Error(
+            `job ${job.id}: result rejected (${res.status}): ${JSON.stringify(res.json).slice(0, 300)}`
+          )
+        );
+      } else {
+        console.log(`[forge-worker] completed job ${job.id} (${job.action})`);
       }
+    } catch (err) {
+      const message = err instanceof Error ? err.message : "execute failed";
+      try {
+        await postJson(
+          resultUrl,
+          apiKey,
+          { ok: false, error: message },
+          controller.signal
+        );
+      } catch {
+      }
+      reportError(new Error(`job ${job.id} failed: ${message}`));
+    }
+  }
+  async function loop() {
+    console.log(
+      `[forge-worker] ${handle} polling ${gatewayUrl}/jobs/claim as ${workerId} (${options.services.length} action(s))`
     );
+    let backoffIndex = 0;
+    while (running) {
+      try {
+        const { status, json: json2 } = await postJson(
+          `${gatewayUrl}/jobs/claim`,
+          apiKey,
+          { handle, workerId, waitMs },
+          controller.signal
+        );
+        if (status === 401 || status === 404 || status === 409) {
+          throw new Error(
+            `claim rejected (${status}): ${JSON.stringify(json2).slice(0, 300)} \u2014 check FORGE_API_KEY, handle, and that the project is registered with fulfillment.mode=worker`
+          );
+        }
+        if (status >= 400) {
+          throw Object.assign(
+            new Error(`claim failed (${status})`),
+            { transient: true }
+          );
+        }
+        backoffIndex = 0;
+        const job = json2.job;
+        if (job) {
+          await runJob(job);
+        }
+      } catch (err) {
+        if (!running) break;
+        const error = err instanceof Error ? err : new Error(String(err));
+        if (error.name === "AbortError") break;
+        reportError(error);
+        const transient = error.transient || !/claim rejected/.test(error.message);
+        if (!transient) {
+          console.error(
+            "[forge-worker] fatal configuration error \u2014 stopping worker"
+          );
+          running = false;
+          break;
+        }
+        const delay = BACKOFF_STEPS_MS[Math.min(backoffIndex, BACKOFF_STEPS_MS.length - 1)];
+        backoffIndex += 1;
+        await sleep(delay);
+      }
+    }
+    console.log("[forge-worker] stopped");
   }
-  app.use(fulfillPath, router);
-  console.log(
-    `[forge] fulfillment mounted at POST ${fulfillPath}/{action} (gateway secret)`
-  );
+  void loop();
+  return {
+    stop() {
+      running = false;
+      controller.abort();
+      wakeSleeper?.();
+    },
+    get running() {
+      return running;
+    }
+  };
 }
-function mountForgeStatusRoutes(app, services, options, opts) {
-  const getStatus = () => buildForgeSurfaceStatus({
+
+// src/status.ts
+var PACKAGE_VERSION = "0.2.0";
+function buildForgeSurfaceStatus(opts) {
+  const fulfillPath = opts.fulfillPath.replace(/\/$/, "") || "/forge/fulfill";
+  const ready = opts.fulfillMounted && opts.actions.length > 0;
+  return {
+    ok: true,
+    forge: true,
+    version: PACKAGE_VERSION,
     handle: opts.handle,
-    publicBaseUrl: opts.resolver.get(),
+    publicBaseUrl: opts.publicBaseUrl,
     gatewayUrl: opts.gatewayUrl,
     fulfillMounted: opts.fulfillMounted,
-    fulfillPath: opts.fulfillPath,
-    agentBasePath: opts.agentBasePath,
-    skipPayment: Boolean(options.skipPayment),
-    actions: services.map((s) => ({
-      name: s.name,
-      path: s.path,
-      price: s.payment.amount
-    }))
-  });
-  app.get("/forge/health", (req, res) => {
-    opts.resolver.considerRequest(req);
-    const status = getStatus();
-    res.json({
-      ok: true,
-      forge: true,
-      ready: status.ready,
-      handle: status.handle,
-      version: status.version,
-      // Per-boot nonce so this instance can self-verify an inferred base URL.
-      instance: opts.resolver.instanceNonce,
-      actions: status.actions.map((a) => a.name)
-    });
-  });
-  app.get("/forge/status", (req, res) => {
-    opts.resolver.considerRequest(req);
-    const status = getStatus();
-    res.status(status.ready ? 200 : 503).json(status);
-  });
-  app.get("/.well-known/clawcash.json", (req, res) => {
-    opts.resolver.considerRequest(req);
-    res.json(buildWellKnownDocument(getStatus()));
+    fulfillPath,
+    actions: opts.actions,
+    ready,
+    endpoints: {
+      health: "/forge/health",
+      status: "/forge/status",
+      wellKnown: "/.well-known/clawcash.json",
+      fulfill: fulfillPath
+    }
+  };
+}
+function buildWellKnownDocument(status) {
+  return {
+    forge: true,
+    version: status.version,
+    health: status.endpoints.health,
+    status: status.endpoints.status,
+    handle: status.handle,
+    ready: status.ready
+  };
+}
+function forgeSdkVersion() {
+  return PACKAGE_VERSION;
+}
+
+// src/handler.ts
+function json(body, status = 200) {
+  return new Response(JSON.stringify(body), {
+    status,
+    headers: { "content-type": "application/json" }
   });
-  console.log(
-    "[forge] liveliness: GET /forge/health, GET /forge/status, GET /.well-known/clawcash.json"
-  );
 }
-async function mountAgentServices(app, services, options) {
-  let payTo = "";
-  if (!options.skipPayment) {
-    const fallback = options.payToFallback?.trim() || options.payTo?.trim() || "";
-    payTo = await resolvePayTo({
-      fallback,
-      payTo: options.payTo,
-      forge: options.forge
-    });
-    if (isZeroAddress(payTo)) {
-      throw new Error(
-        "mountAgentServices: resolved payTo is the zero address. Re-run Forge to provision a wallet."
-      );
-    }
+function isAuthorized(request, apiKey) {
+  if (!apiKey) return false;
+  const header = request.headers.get("authorization") ?? "";
+  const bearer = header.toLowerCase().startsWith("bearer ") ? header.slice(7).trim() : "";
+  const alt = request.headers.get("x-forge-api-key")?.trim() || request.headers.get("x-clawcash-gateway")?.trim() || "";
+  return bearer === apiKey || alt === apiKey;
+}
+function createForgeRequestMatcher(services, options = {}) {
+  if (!services?.length) {
+    throw new Error("createForgeHandler: services must be a non-empty array");
   }
-  const basePath = (options.basePath ?? "/agent").replace(/\/$/, "") || "/agent";
   const fulfillPath = (options.fulfillPath ?? "/forge/fulfill").replace(/\/$/, "") || "/forge/fulfill";
-  const router = createRouter();
+  const handle = options.handle?.trim().toLowerCase() || process.env.FORGE_HANDLE?.trim().toLowerCase() || null;
+  const gatewayUrl = options.gatewayUrl?.trim() || process.env.GATEWAY_URL?.trim() || "https://gateway.clawca.sh";
   const context = createContext();
-  const routes = {};
-  for (const service of services) {
-    const routePath = `/${service.path}`;
-    const fullPath = `${basePath}${routePath}`;
-    const network = asNetwork(service.payment.network);
-    if (!options.skipPayment) {
-      routes[`POST ${fullPath}`] = {
-        accepts: {
-          scheme: "exact",
-          price: formatPrice(service.payment.amount),
-          network,
-          payTo
-        },
-        description: service.description,
-        mimeType: "application/json"
-      };
+  const getStatus = () => {
+    const apiKey = getForgeApiKey(options.apiKey);
+    return buildForgeSurfaceStatus({
+      handle,
+      publicBaseUrl: options.publicBaseUrl ?? null,
+      gatewayUrl,
+      fulfillMounted: Boolean(apiKey),
+      fulfillPath,
+      actions: services.map((s) => ({
+        name: s.name,
+        path: s.path,
+        price: s.payment.amount
+      }))
+    });
+  };
+  return async (request) => {
+    const url = new URL(request.url);
+    const pathname = url.pathname.replace(/\/$/, "") || "/";
+    if (request.method === "GET") {
+      if (pathname === "/forge/health") {
+        const status = getStatus();
+        return json({
+          ok: true,
+          forge: true,
+          ready: status.ready,
+          handle: status.handle,
+          version: status.version,
+          actions: status.actions.map((a) => a.name)
+        });
+      }
+      if (pathname === "/forge/status") {
+        const status = getStatus();
+        return json(status, status.ready ? 200 : 503);
+      }
+      if (pathname === "/.well-known/clawcash.json") {
+        return json(buildWellKnownDocument(getStatus()));
+      }
+      return null;
     }
-    router.post(routePath, async (req, res) => {
+    if (request.method === "POST" && pathname.startsWith(`${fulfillPath}/`)) {
+      const actionPath = pathname.slice(fulfillPath.length + 1);
+      const service = services.find((s) => s.path === actionPath) ?? null;
+      if (!service) {
+        return json({ error: `Unknown action ${actionPath}` }, 404);
+      }
+      const apiKey = getForgeApiKey(options.apiKey);
+      if (!isAuthorized(request, apiKey)) {
+        return json(
+          {
+            error: "Unauthorized \u2014 Forge API key required (FORGE_API_KEY from Forge dashboard)"
+          },
+          401
+        );
+      }
+      let body;
+      try {
+        body = await request.json();
+      } catch {
+        return json({ error: "Request body must be JSON" }, 400);
+      }
+      const validated = validateInput(body, service.input);
+      if (!validated.ok) {
+        return json({ error: validated.error }, 400);
+      }
       try {
-        const validated = validateInput(req.body, service.input);
-        if (!validated.ok) {
-          res.status(400).json({ error: validated.error });
-          return;
-        }
         const output = await service.execute(validated.value, context);
-        res.json(output);
+        return json(output);
       } catch (err) {
         const message = err instanceof Error ? err.message : "Internal error";
-        console.error(`[forge] ${service.name} failed:`, err);
-        res.status(500).json({ error: message });
+        console.error(`[forge] fulfill ${service.name} failed:`, err);
+        return json({ error: message }, 500);
       }
-    });
-  }
-  if (!options.skipPayment && Object.keys(routes).length > 0) {
-    const facilitator = createFacilitatorClient(options);
-    const networks = new Set(
-      services.map((s) => asNetwork(s.payment.network))
-    );
-    const resourceServer = new x402ResourceServer(facilitator);
-    for (const network of networks) {
-      resourceServer.register(network, new ExactEvmScheme());
     }
-    app.use(paymentMiddleware(routes, resourceServer, void 0, void 0, true));
-  }
-  app.use(basePath, router);
-  const fulfillMounted = Boolean(
-    getForgeApiKey(options.gateway?.registerSecret)
-  );
-  mountFulfillmentRouter(app, services, options);
-  const gatewayUrl = options.gateway?.url?.trim() || process.env.GATEWAY_URL?.trim() || DEFAULT_GATEWAY_URL;
-  const handle = options.gateway?.handle?.trim() || process.env.FORGE_HANDLE?.trim() || null;
-  const registerSecret = options.gateway?.registerSecret?.trim() || process.env.FORGE_API_KEY?.trim() || process.env.GATEWAY_REGISTER_SECRET?.trim();
-  const sendHeartbeat = (baseUrl) => {
-    if (!handle || !registerSecret) return;
-    void heartbeatGateway({
-      gatewayUrl,
-      handle,
-      baseUrl,
-      registerSecret
-    }).then(() => {
-      recordHeartbeatResult({ ok: true });
-    }).catch((err) => {
-      const message = err instanceof Error ? err.message : String(err);
-      recordHeartbeatResult({ ok: false, error: message });
-      console.warn("[forge] gateway heartbeat skipped:", err);
-    });
+    return null;
   };
-  const resolver = new PublicBaseUrlResolver({
-    initial: resolveBaseUrlFromEnv(options.gateway?.publicBaseUrl),
-    // Base URL learned late (inferred from the first probe): heartbeat now.
-    onResolved: sendHeartbeat
-  });
-  mountForgeStatusRoutes(app, services, options, {
-    fulfillMounted,
-    fulfillPath,
-    agentBasePath: basePath,
-    handle,
-    resolver,
-    gatewayUrl
-  });
-  const bootBaseUrl = resolver.get();
-  if (bootBaseUrl) {
-    sendHeartbeat(bootBaseUrl);
-  }
-  return router;
-}
-function createForgeRouter(services, options) {
-  return (app) => mountAgentServices(app, services, options);
 }
-
-// src/skill.ts
-function generateSkillMarkdown(services, meta) {
-  const base = meta.baseUrl.replace(/\/$/, "");
-  const lines = [
-    `---`,
-    `name: ${meta.name}`,
-    `description: ${meta.description}`,
-    `---`,
-    ``,
-    `# ${meta.name}`,
-    ``,
-    meta.description,
-    ``
-  ];
-  if (meta.homepage) {
-    lines.push(`Homepage: ${meta.homepage}`, ``);
-  }
-  lines.push(
-    `## How to use`,
-    ``,
-    `1. Read this skill.`,
-    `2. Call the agent endpoint with a JSON body matching the input schema.`,
-    `3. If you receive HTTP 402, pay via x402 (USDC) and retry with the payment header.`,
-    `4. Use the returned output fields.`,
-    ``,
-    `## Services`,
-    ``
-  );
-  for (const service of services) {
-    const path = `${base}/agent/${service.path}`;
-    const price = service.payment.amount.startsWith("$") ? service.payment.amount : `$${service.payment.amount}`;
-    lines.push(
-      `### \`${service.name}\``,
-      ``,
-      service.description,
-      ``,
-      `- **Method:** \`POST\``,
-      `- **URL:** \`${path}\``,
-      `- **Price:** ${price} ${service.payment.currency} via ${service.payment.protocols.join(", ")}`,
-      ``,
-      `**Input**`,
-      ``,
-      "```json",
-      JSON.stringify(
-        Object.fromEntries(
-          Object.entries(service.input).map(([k, t]) => [k, `<${t}>`])
-        ),
-        null,
-        2
-      ),
-      "```",
-      ``,
-      `**Output**`,
-      ``,
-      "```json",
-      JSON.stringify(
-        Object.fromEntries(
-          Object.entries(service.output).map(([k, t]) => [k, `<${t}>`])
-        ),
-        null,
-        2
-      ),
-      "```",
-      ``,
-      `**Example**`,
-      ``,
-      "```bash",
-      `curl -X POST ${path} \\`,
-      `  -H "Content-Type: application/json" \\`,
-      `  -d '${JSON.stringify(
-        Object.fromEntries(
-          Object.entries(service.input).map(([k, t]) => [
-            k,
-            t === "url" ? "https://example.com/image.png" : `example-${k}`
-          ])
-        )
-      )}'`,
-      "```",
-      ``
-    );
-  }
-  return lines.join("\n");
+function createForgeHandler(services, options = {}) {
+  const match = createForgeRequestMatcher(services, options);
+  return async (request) => await match(request) ?? json({ error: "Not found" }, 404);
 }
 export {
   FORGE_GATEWAY_USER_ID,
-  PublicBaseUrlResolver,
   buildForgeSurfaceStatus,
   buildWellKnownDocument,
+  checkType,
   createContext,
-  createForgeRouter,
+  createForgeHandler,
+  createForgeRequestMatcher,
   defineAgentService,
   forgeGatewayLoopbackHeaders,
   forgeSdkVersion,
-  generateSkillMarkdown,
+  forgeWorker,
   getForgeApiKey,
-  getForgeGatewaySecret,
-  getLastHeartbeat,
-  heartbeatGateway,
-  isForgeGatewayRequest,
-  isZeroAddress,
-  mountAgentServices,
-  recordHeartbeatResult,
-  requireForgeGateway,
-  resolveBaseUrlFromEnv,
-  resolvePayTo,
   toKebabCase,
+  validateInput,
   waitUntil
 };
 //# sourceMappingURL=index.js.map