unbrowse 3.0.4 → 3.1.0

package/dist/cli.js

@@ -17,12 +17,21 @@ var __toESM = (mod, isNodeMode, target) => {
       });
   return to;
 };
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
 var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
 var __promiseAll = (args) => Promise.all(args);
 var __require = /* @__PURE__ */ createRequire(import.meta.url);
 
 // ../../src/build-info.generated.ts
-var BUILD_RELEASE_VERSION = "3.0.4", BUILD_GIT_SHA = "44d2baa5a0e0", BUILD_CODE_HASH = "1488fc1d92b7", BUILD_RELEASE_MANIFEST_BASE64 = "eyJzY2hlbWFfdmVyc2lvbiI6MSwicmVsZWFzZV92ZXJzaW9uIjoiMy4wLjQiLCJnaXRfc2hhIjoiNDRkMmJhYTVhMGUwIiwiY29kZV9oYXNoIjoiMTQ4OGZjMWQ5MmI3IiwidHJhY2VfdmVyc2lvbiI6IjE0ODhmYzFkOTJiN0A0NGQyYmFhNWEwZTAiLCJpc3N1ZWRfYXQiOiIyMDI2LTA0LTA1VDA0OjIyOjE2LjM2M1oifQ", BUILD_RELEASE_MANIFEST_SIGNATURE = "zLW181YNH-1BLhH-HL-OvhuGJAzfy-HrZnIo7xm0aVo", BUILD_DEFAULT_BACKEND_URL = "https://beta-api.unbrowse.ai";
+var BUILD_RELEASE_VERSION = "3.1.0", BUILD_GIT_SHA = "c9f9ce0e5cb1", BUILD_CODE_HASH = "1488fc1d92b7", BUILD_RELEASE_MANIFEST_BASE64 = "eyJzY2hlbWFfdmVyc2lvbiI6MSwicmVsZWFzZV92ZXJzaW9uIjoiMy4xLjAiLCJnaXRfc2hhIjoiYzlmOWNlMGU1Y2IxIiwiY29kZV9oYXNoIjoiMTQ4OGZjMWQ5MmI3IiwidHJhY2VfdmVyc2lvbiI6IjE0ODhmYzFkOTJiN0BjOWY5Y2UwZTVjYjEiLCJpc3N1ZWRfYXQiOiIyMDI2LTA0LTA1VDA2OjUwOjA4LjQzNVoifQ", BUILD_RELEASE_MANIFEST_SIGNATURE = "_2pdxyoIEYkKUHO0nXaXTubP5SrZCa-8CqStcPBsXxw", BUILD_DEFAULT_BACKEND_URL = "https://beta-api.unbrowse.ai";
 
 // ../../src/version.ts
 import { createHash } from "crypto";
@@ -284,8 +293,114 @@ var init_telemetry_attribution = __esm(() => {
   ];
 });
 
+// ../../src/payments/lobster-pay.ts
+var exports_lobster_pay = {};
+__export(exports_lobster_pay, {
+  payAndRetry: () => payAndRetry,
+  lobsterX402Fetch: () => lobsterX402Fetch,
+  isLobsterAvailable: () => isLobsterAvailable
+});
+import { execFile, execFileSync } from "node:child_process";
+import { existsSync as existsSync3 } from "node:fs";
+import { homedir as homedir2 } from "node:os";
+import { join as join3 } from "node:path";
+function getLobsterCommand() {
+  try {
+    execFileSync("lobstercash", ["--version"], { stdio: "ignore", timeout: 3000 });
+    return { cmd: "lobstercash", prefix: [] };
+  } catch (_e) {}
+  try {
+    const npmPrefix = execFileSync("npm", ["config", "get", "prefix"], { encoding: "utf8", timeout: 5000 }).trim();
+    const lobsterPath = join3(npmPrefix, "bin", "lobstercash");
+    if (existsSync3(lobsterPath)) {
+      execFileSync(lobsterPath, ["--version"], { stdio: "ignore", timeout: 3000 });
+      return { cmd: lobsterPath, prefix: [] };
+    }
+  } catch (_e) {}
+  return null;
+}
+function lobsterCmd() {
+  if (cachedCommand === undefined)
+    cachedCommand = getLobsterCommand();
+  return cachedCommand;
+}
+function isLobsterAvailable() {
+  const agentsPath = join3(process.env.HOME || homedir2(), ".lobster", "agents.json");
+  return existsSync3(agentsPath);
+}
+function lobsterX402Fetch(url, options) {
+  return new Promise((resolve) => {
+    const resolved = lobsterCmd();
+    if (!resolved) {
+      resolve({ success: false, body: "", error: "lobstercash CLI not in PATH" });
+      return;
+    }
+    const { cmd, prefix } = resolved;
+    const args = [...prefix, "x402", "fetch", url, "--debug"];
+    if (options?.jsonBody) {
+      args.push("--json", options.jsonBody);
+    }
+    if (options?.headers) {
+      for (const [key, value] of Object.entries(options.headers)) {
+        args.push("--header", `${key}:${value}`);
+      }
+    }
+    const timeout = options?.timeoutMs ?? LOBSTER_PAY_TIMEOUT_MS;
+    args.push("--timeout", String(timeout));
+    execFile(cmd, args, { timeout: timeout + 5000, maxBuffer: 1024 * 1024 }, (err, stdout, stderr) => {
+      if (err) {
+        const msg = stderr?.trim() || err.message;
+        console.warn(`[lobster-pay] x402 fetch failed: ${msg}`);
+        resolve({ success: false, body: "", error: msg });
+        return;
+      }
+      if (stderr) {
+        for (const line of stderr.split(`
+`).filter(Boolean)) {
+          console.log(`[lobster-pay] ${line}`);
+        }
+      }
+      const statusMatch = stdout.match(/^Status:\s*(\d+)/m);
+      const statusCode = statusMatch ? parseInt(statusMatch[1], 10) : undefined;
+      if (statusCode && statusCode >= 400) {
+        resolve({ success: false, body: stdout, statusCode, error: `HTTP ${statusCode}` });
+        return;
+      }
+      resolve({ success: true, body: stdout, statusCode });
+    });
+  });
+}
+async function payAndRetry(fullUrl, options) {
+  if (!isLobsterAvailable()) {
+    console.log("[lobster-pay] lobster.cash not configured — skipping payment");
+    return null;
+  }
+  console.log(`[lobster-pay] attempting x402 payment for ${fullUrl}`);
+  const result = await lobsterX402Fetch(fullUrl, {
+    jsonBody: options?.body ? JSON.stringify(options.body) : undefined,
+    headers: options?.headers
+  });
+  if (!result.success) {
+    console.warn(`[lobster-pay] payment failed: ${result.error}`);
+    return null;
+  }
+  try {
+    const raw = result.body;
+    const jsonStart = Math.min(...[raw.indexOf("{"), raw.indexOf("[")].filter((i) => i >= 0));
+    const jsonStr = jsonStart >= 0 ? raw.slice(jsonStart) : raw;
+    const data = JSON.parse(jsonStr);
+    console.log("[lobster-pay] payment successful — got paid response");
+    return { data, paid: true };
+  } catch (_e) {
+    console.warn("[lobster-pay] paid response was not valid JSON");
+    return null;
+  }
+}
+var LOBSTER_PAY_TIMEOUT_MS = 30000, cachedCommand = undefined;
+var init_lobster_pay = () => {};
+
 // ../../src/runtime/paths.ts
-import { existsSync as existsSync4, mkdirSync as mkdirSync2, realpathSync } from "node:fs";
+import { existsSync as existsSync5, mkdirSync as mkdirSync2, realpathSync } from "node:fs";
 import os from "node:os";
 import path from "node:path";
 import { createRequire as createRequire2 } from "node:module";
@@ -299,7 +414,7 @@ function getPackageRoot(metaUrl) {
   let dir = getModuleDir(metaUrl);
   const root = path.parse(dir).root;
   while (dir !== root) {
-    if (existsSync4(path.join(dir, "package.json")))
+    if (existsSync5(path.join(dir, "package.json")))
       return dir;
     dir = path.dirname(dir);
   }
@@ -318,7 +433,7 @@ function runtimeArgsForEntrypoint(metaUrl, entrypoint) {
     const req = createRequire2(metaUrl);
     const tsxPkg = req.resolve("tsx/package.json");
     const tsxLoader = path.join(path.dirname(tsxPkg), "dist", "loader.mjs");
-    if (existsSync4(tsxLoader))
+    if (existsSync5(tsxLoader))
       return ["--import", pathToFileURL(tsxLoader).href, entrypoint];
   } catch {}
   return ["--import", "tsx", entrypoint];
@@ -327,7 +442,7 @@ function getUnbrowseHome() {
   return path.join(os.homedir(), ".unbrowse");
 }
 function ensureDir(dir) {
-  if (!existsSync4(dir))
+  if (!existsSync5(dir))
     mkdirSync2(dir, { recursive: true });
   return dir;
 }
@@ -470,8 +585,8 @@ var init_logger = __esm(() => {
 });
 
 // ../../src/kuri/client.ts
-import { execFileSync, spawn as spawn2 } from "node:child_process";
-import { existsSync as existsSync6 } from "node:fs";
+import { execFileSync as execFileSync2, spawn as spawn2 } from "node:child_process";
+import { existsSync as existsSync7 } from "node:fs";
 import path5 from "node:path";
 function createBrokerState(port = KURI_DEFAULT_PORT) {
   return {
@@ -496,12 +611,14 @@ function currentBundledKuriTarget() {
     return "linux-arm64";
   if (process.platform === "linux" && process.arch === "x64")
     return "linux-x64";
+  if (process.platform === "win32" && process.arch === "x64")
+    return "win-x64";
   return null;
 }
 function resolveBinaryOnPath(name) {
   const checker = process.platform === "win32" ? "where" : "which";
   try {
-    const output = execFileSync(checker, [name], { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] });
+    const output = execFileSync2(checker, [name], { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] });
     const match = output.split(/\r?\n/).map((line) => line.trim()).find(Boolean);
     return match || null;
   } catch {
@@ -544,7 +661,7 @@ function findKuriBinary() {
   if (process.env.KURI_BIN)
     return process.env.KURI_BIN;
   const candidates = getKuriBinaryCandidates();
-  return candidates.find((candidate) => existsSync6(candidate)) ?? candidates[0] ?? kuriBinaryName();
+  return candidates.find((candidate) => existsSync7(candidate)) ?? candidates[0] ?? kuriBinaryName();
 }
 var KURI_DEFAULT_PORT = 7700, defaultBrokerState, brokerClients;
 var init_client2 = __esm(() => {
@@ -584,11 +701,11 @@ var init_transform = __esm(() => {
 });
 
 // ../../src/debug-trace.ts
-import { join as join4 } from "node:path";
+import { join as join5 } from "node:path";
 import { nanoid as nanoid3 } from "nanoid";
 var TRACE_DIR;
 var init_debug_trace = __esm(() => {
-  TRACE_DIR = process.env.TRACES_DIR ?? join4(process.cwd(), "traces");
+  TRACE_DIR = process.env.TRACES_DIR ?? join5(process.cwd(), "traces");
 });
 
 // ../../src/publish/sanitize.ts
@@ -678,8 +795,8 @@ var init_bundle_scanner = __esm(() => {
 });
 
 // ../../src/vault/index.ts
-import { join as join5 } from "path";
-import { homedir as homedir3 } from "os";
+import { join as join6 } from "path";
+import { homedir as homedir4 } from "os";
 function normalizeKeytarModule(mod) {
   let candidate = mod;
   for (let depth = 0;depth < 3; depth++) {
@@ -701,9 +818,9 @@ var init_vault = __esm(async () => {
   try {
     keytar = normalizeKeytarModule(await import("keytar"));
   } catch {}
-  VAULT_DIR = join5(homedir3(), ".unbrowse", "vault");
-  VAULT_FILE = join5(VAULT_DIR, "credentials.enc");
-  KEY_FILE = join5(VAULT_DIR, ".key");
+  VAULT_DIR = join6(homedir4(), ".unbrowse", "vault");
+  VAULT_FILE = join6(VAULT_DIR, "credentials.enc");
+  KEY_FILE = join6(VAULT_DIR, ".key");
   vaultLock = Promise.resolve();
 });
 
@@ -854,7 +971,7 @@ var init_schema_review = __esm(() => {
 });
 
 // ../../src/indexer/index.ts
-import { join as join6 } from "node:path";
+import { join as join7 } from "node:path";
 var SKILL_SNAPSHOT_DIR, indexInFlight, pendingIndexJobs;
 var init_indexer = __esm(async () => {
   init_graph();
@@ -869,7 +986,7 @@ var init_indexer = __esm(async () => {
   init_graph();
   init_schema_review();
   await init_orchestrator();
-  SKILL_SNAPSHOT_DIR = process.env.UNBROWSE_SKILL_SNAPSHOT_DIR ?? join6(process.env.HOME ?? "/tmp", ".unbrowse", "skill-snapshots");
+  SKILL_SNAPSHOT_DIR = process.env.UNBROWSE_SKILL_SNAPSHOT_DIR ?? join7(process.env.HOME ?? "/tmp", ".unbrowse", "skill-snapshots");
   indexInFlight = new Map;
   pendingIndexJobs = new Map;
 });
@@ -1046,8 +1163,8 @@ var init_routing_telemetry = __esm(() => {
 });
 // ../../src/orchestrator/index.ts
 import { nanoid as nanoid9 } from "nanoid";
-import { existsSync as existsSync7, writeFileSync as writeFileSync3, readFileSync as readFileSync5, mkdirSync as mkdirSync4, readdirSync as readdirSync3 } from "node:fs";
-import { dirname as dirname2, join as join7 } from "node:path";
+import { existsSync as existsSync8, writeFileSync as writeFileSync3, readFileSync as readFileSync5, mkdirSync as mkdirSync4, readdirSync as readdirSync3 } from "node:fs";
+import { dirname as dirname2, join as join8 } from "node:path";
 var LIVE_CAPTURE_TIMEOUT_MS, capturedDomainCache, captureInFlight, captureDomainLocks, skillRouteCache, ROUTE_CACHE_FILE, SKILL_SNAPSHOT_DIR2, domainSkillCache, DOMAIN_CACHE_FILE, _routeCacheDirty = false, routeCacheFlushTimer, routeResultCache, ROUTE_CACHE_TTL, MARKETPLACE_HYDRATE_LIMIT, MARKETPLACE_GET_SKILL_TIMEOUT_MS, MARKETPLACE_DOMAIN_SEARCH_K, MARKETPLACE_GLOBAL_SEARCH_K, SEARCH_INTENT_STOPWORDS;
 var init_orchestrator = __esm(async () => {
   init_client();
@@ -1077,12 +1194,12 @@ var init_orchestrator = __esm(async () => {
   captureInFlight = new Map;
   captureDomainLocks = new Map;
   skillRouteCache = new Map;
-  ROUTE_CACHE_FILE = join7(process.env.HOME ?? "/tmp", ".unbrowse", "route-cache.json");
-  SKILL_SNAPSHOT_DIR2 = process.env.UNBROWSE_SKILL_SNAPSHOT_DIR ?? join7(process.env.HOME ?? "/tmp", ".unbrowse", "skill-snapshots");
+  ROUTE_CACHE_FILE = join8(process.env.HOME ?? "/tmp", ".unbrowse", "route-cache.json");
+  SKILL_SNAPSHOT_DIR2 = process.env.UNBROWSE_SKILL_SNAPSHOT_DIR ?? join8(process.env.HOME ?? "/tmp", ".unbrowse", "skill-snapshots");
   domainSkillCache = new Map;
-  DOMAIN_CACHE_FILE = join7(process.env.HOME ?? "/tmp", ".unbrowse", "domain-skill-cache.json");
+  DOMAIN_CACHE_FILE = join8(process.env.HOME ?? "/tmp", ".unbrowse", "domain-skill-cache.json");
   try {
-    if (existsSync7(DOMAIN_CACHE_FILE)) {
+    if (existsSync8(DOMAIN_CACHE_FILE)) {
       const data = JSON.parse(readFileSync5(DOMAIN_CACHE_FILE, "utf-8"));
       for (const [k, v] of Object.entries(data)) {
         const entry = v;
@@ -1099,7 +1216,7 @@ var init_orchestrator = __esm(async () => {
     _routeCacheDirty = false;
     try {
       const dir = dirname2(ROUTE_CACHE_FILE);
-      if (!existsSync7(dir))
+      if (!existsSync8(dir))
         mkdirSync4(dir, { recursive: true });
       const entries = Object.fromEntries(skillRouteCache);
       writeFileSync3(ROUTE_CACHE_FILE, JSON.stringify(entries), "utf-8");
@@ -1107,7 +1224,7 @@ var init_orchestrator = __esm(async () => {
   }, 5000);
   routeCacheFlushTimer.unref?.();
   try {
-    if (existsSync7(ROUTE_CACHE_FILE)) {
+    if (existsSync8(ROUTE_CACHE_FILE)) {
       const data = JSON.parse(readFileSync5(ROUTE_CACHE_FILE, "utf-8"));
       for (const [k, v] of Object.entries(data)) {
         const entry = v;
@@ -1198,6 +1315,60 @@ var init_orchestrator = __esm(async () => {
   ]);
 });
 
+// ../../src/payments/wallet.ts
+var exports_wallet = {};
+__export(exports_wallet, {
+  getWalletContext: () => getWalletContext2,
+  checkWalletConfigured: () => checkWalletConfigured2
+});
+import { existsSync as existsSync12, readFileSync as readFileSync8 } from "node:fs";
+import { homedir as homedir5 } from "node:os";
+import { join as join10 } from "node:path";
+function asNonEmptyString2(value) {
+  return typeof value === "string" && value.trim() ? value.trim() : undefined;
+}
+function getLobsterWalletFromLocalConfig2() {
+  const agentsPath = join10(process.env.HOME || homedir5(), ".lobster", "agents.json");
+  if (!existsSync12(agentsPath))
+    return;
+  try {
+    const raw = JSON.parse(readFileSync8(agentsPath, "utf8"));
+    const activeAgentId = asNonEmptyString2(raw.activeAgentId);
+    const activeAgent = Array.isArray(raw.agents) ? raw.agents.find((agent) => asNonEmptyString2(agent.id) === activeAgentId) : activeAgentId ? raw.agents?.[activeAgentId] : undefined;
+    return asNonEmptyString2(activeAgent?.authorizedWallets?.solana) ?? asNonEmptyString2(activeAgent?.walletAddress) ?? asNonEmptyString2(activeAgent?.wallet_address);
+  } catch {
+    return;
+  }
+}
+function getWalletContext2() {
+  const lobsterWallet = asNonEmptyString2(process.env.LOBSTER_WALLET_ADDRESS);
+  if (lobsterWallet) {
+    return { wallet_address: lobsterWallet, wallet_provider: "lobster.cash" };
+  }
+  const genericWallet = asNonEmptyString2(process.env.AGENT_WALLET_ADDRESS);
+  if (genericWallet) {
+    return {
+      wallet_address: genericWallet,
+      wallet_provider: asNonEmptyString2(process.env.AGENT_WALLET_PROVIDER)
+    };
+  }
+  const localLobsterWallet = getLobsterWalletFromLocalConfig2();
+  if (localLobsterWallet) {
+    return { wallet_address: localLobsterWallet, wallet_provider: "lobster.cash" };
+  }
+  return {};
+}
+function checkWalletConfigured2() {
+  const wallet = getWalletContext2();
+  if (!wallet.wallet_address)
+    return { configured: false };
+  return {
+    configured: true,
+    provider: wallet.wallet_provider ?? "unknown"
+  };
+}
+var init_wallet2 = () => {};
+
 // ../../src/cli.ts
 import { config as loadEnv } from "dotenv";
 import { spawn as spawn3 } from "child_process";
@@ -1207,9 +1378,9 @@ init_version();
 init_cascade();
 init_wallet();
 init_telemetry_attribution();
-import { readFileSync as readFileSync3, writeFileSync, existsSync as existsSync3, mkdirSync, readdirSync as readdirSync2 } from "fs";
-import { join as join3 } from "path";
-import { homedir as homedir2, hostname } from "os";
+import { readFileSync as readFileSync3, writeFileSync, existsSync as existsSync4, mkdirSync, readdirSync as readdirSync2 } from "fs";
+import { join as join4 } from "path";
+import { homedir as homedir3, hostname } from "os";
 import { randomBytes, createHash as createHash2 } from "crypto";
 import { createInterface } from "readline";
 var API_URL = process.env.UNBROWSE_BACKEND_URL || DEFAULT_BACKEND_URL;
@@ -1244,13 +1415,13 @@ function decodeBase64Json(value) {
 function getConfigDir() {
   if (process.env.UNBROWSE_CONFIG_DIR)
     return process.env.UNBROWSE_CONFIG_DIR;
-  return PROFILE_NAME ? join3(homedir2(), ".unbrowse", "profiles", PROFILE_NAME) : join3(homedir2(), ".unbrowse");
+  return PROFILE_NAME ? join4(homedir3(), ".unbrowse", "profiles", PROFILE_NAME) : join4(homedir3(), ".unbrowse");
 }
 function getConfigPath() {
-  return join3(getConfigDir(), "config.json");
+  return join4(getConfigDir(), "config.json");
 }
 function getInstallTelemetryPath() {
-  return join3(getConfigDir(), "install-state.json");
+  return join4(getConfigDir(), "install-state.json");
 }
 function getLandingToken() {
   const token = process.env.UNBROWSE_LANDING_TOKEN?.trim();
@@ -1265,7 +1436,7 @@ function getActiveProfile() {
 function loadConfig() {
   try {
     const configPath = getConfigPath();
-    if (existsSync3(configPath)) {
+    if (existsSync4(configPath)) {
       return JSON.parse(readFileSync3(configPath, "utf-8"));
     }
   } catch {}
@@ -1274,14 +1445,14 @@ function loadConfig() {
 function saveConfig(config) {
   const configDir = getConfigDir();
   const configPath = getConfigPath();
-  if (!existsSync3(configDir))
+  if (!existsSync4(configDir))
     mkdirSync(configDir, { recursive: true });
   writeFileSync(configPath, JSON.stringify(config, null, 2), { mode: 384 });
 }
 function loadInstallTelemetryState() {
   try {
     const statePath = getInstallTelemetryPath();
-    if (existsSync3(statePath)) {
+    if (existsSync4(statePath)) {
       return JSON.parse(readFileSync3(statePath, "utf-8"));
     }
   } catch {}
@@ -1290,7 +1461,7 @@ function loadInstallTelemetryState() {
 function saveInstallTelemetryState(state) {
   const configDir = getConfigDir();
   const statePath = getInstallTelemetryPath();
-  if (!existsSync3(configDir))
+  if (!existsSync4(configDir))
     mkdirSync(configDir, { recursive: true });
   writeFileSync(statePath, JSON.stringify(state, null, 2), { mode: 384 });
 }
@@ -1547,6 +1718,26 @@ async function apiRequest(method, path, body, opts) {
     const paymentRequired = res.headers.get("PAYMENT-REQUIRED");
     const legacyPaymentTerms = res.headers.get("X-Payment-Required");
     const terms = paymentRequired ? decodeBase64Json(paymentRequired) : legacyPaymentTerms ? JSON.parse(legacyPaymentTerms) : data.terms;
+    try {
+      const { isLobsterAvailable: isLobsterAvailable2, payAndRetry: payAndRetry2 } = await Promise.resolve().then(() => (init_lobster_pay(), exports_lobster_pay));
+      if (isLobsterAvailable2()) {
+        const fullUrl = `${API_URL}${path}`;
+        const paidResult = await payAndRetry2(fullUrl, {
+          body,
+          headers: {
+            "Content-Type": "application/json",
+            "Accept-Encoding": "gzip, deflate",
+            ...releaseAttestationHeaders,
+            ...key ? { Authorization: `Bearer ${key}` } : {}
+          }
+        });
+        if (paidResult) {
+          return { data: paidResult.data, headers: new Headers };
+        }
+      }
+    } catch (payErr) {
+      console.warn(`[x402] lobster pay-and-retry failed: ${payErr.message}`);
+    }
     const err = new Error(`Payment required: ${data.error ?? "This skill requires payment"}`);
     err.x402 = true;
     err.terms = terms;
@@ -2150,7 +2341,7 @@ async function restartServer(baseUrl, metaUrl) {
 }
 
 // ../../src/runtime/paths.ts
-import { existsSync as existsSync5, mkdirSync as mkdirSync3, realpathSync as realpathSync2 } from "node:fs";
+import { existsSync as existsSync6, mkdirSync as mkdirSync3, realpathSync as realpathSync2 } from "node:fs";
 import path3 from "node:path";
 import { createRequire as createRequire3 } from "node:module";
 import { fileURLToPath as fileURLToPath3, pathToFileURL as pathToFileURL2 } from "node:url";
@@ -2170,7 +2361,7 @@ function runtimeArgsForEntrypoint2(metaUrl, entrypoint) {
     const req = createRequire3(metaUrl);
     const tsxPkg = req.resolve("tsx/package.json");
     const tsxLoader = path3.join(path3.dirname(tsxPkg), "dist", "loader.mjs");
-    if (existsSync5(tsxLoader))
+    if (existsSync6(tsxLoader))
       return ["--import", pathToFileURL2(tsxLoader).href, entrypoint];
   } catch {}
   return ["--import", "tsx", entrypoint];
@@ -2200,8 +2391,8 @@ init_publish();
 init_settings();
 init_graph();
 init_schema_review();
-import { join as join8 } from "node:path";
-var SKILL_SNAPSHOT_DIR3 = process.env.UNBROWSE_SKILL_SNAPSHOT_DIR ?? join8(process.env.HOME ?? "/tmp", ".unbrowse", "skill-snapshots");
+import { join as join9 } from "node:path";
+var SKILL_SNAPSHOT_DIR3 = process.env.UNBROWSE_SKILL_SNAPSHOT_DIR ?? join9(process.env.HOME ?? "/tmp", ".unbrowse", "skill-snapshots");
 var indexInFlight2 = new Map;
 var pendingIndexJobs2 = new Map;
 async function drainPendingIndexJobs() {
@@ -2238,14 +2429,14 @@ init_paths();
 init_client2();
 init_logger();
 init_wallet();
-import { execFileSync as execFileSync2 } from "node:child_process";
-import { existsSync as existsSync9, mkdirSync as mkdirSync6, writeFileSync as writeFileSync5 } from "node:fs";
+import { execFileSync as execFileSync3 } from "node:child_process";
+import { existsSync as existsSync10, mkdirSync as mkdirSync6, writeFileSync as writeFileSync5 } from "node:fs";
 import os4 from "node:os";
 import path7 from "node:path";
 
 // ../../src/runtime/update-hints.ts
 init_paths();
-import { existsSync as existsSync8, mkdirSync as mkdirSync5, readFileSync as readFileSync6, writeFileSync as writeFileSync4 } from "node:fs";
+import { existsSync as existsSync9, mkdirSync as mkdirSync5, readFileSync as readFileSync6, writeFileSync as writeFileSync4 } from "node:fs";
 import os3 from "node:os";
 import path6 from "node:path";
 var DEFAULT_INTERVAL_MS = 12 * 60 * 60 * 1000;
@@ -2259,7 +2450,7 @@ function getConfigDir2() {
   return path6.join(getHomeDir(), ".unbrowse");
 }
 function ensureDir2(dir) {
-  if (!existsSync8(dir))
+  if (!existsSync9(dir))
     mkdirSync5(dir, { recursive: true });
   return dir;
 }
@@ -2282,7 +2473,7 @@ function detectRepoRoot(start2) {
   let dir = path6.resolve(start2);
   const root = path6.parse(dir).root;
   while (dir !== root) {
-    if (existsSync8(path6.join(dir, ".git")))
+    if (existsSync9(path6.join(dir, ".git")))
       return dir;
     dir = path6.dirname(dir);
   }
@@ -2361,12 +2552,12 @@ codex_hooks = true
 }
 function writeCodexHook(metaUrl) {
   const configPath = getCodexConfigPath();
-  if (!existsSync8(path6.dirname(configPath))) {
+  if (!existsSync9(path6.dirname(configPath))) {
     return { host: "codex", action: "not-detected", config_file: configPath };
   }
   try {
     const hookScript = getHookScriptPath(metaUrl).replace(/\\/g, "/");
-    const fileExistsBefore = existsSync8(configPath);
+    const fileExistsBefore = existsSync9(configPath);
     let content = fileExistsBefore ? readFileSync6(configPath, "utf8") : "";
     const previous = content;
     content = ensureCodexHooksFeature(content);
@@ -2401,13 +2592,13 @@ command = ${JSON.stringify(command)}
 }
 function writeClaudeHook(metaUrl) {
   const settingsPath = getClaudeSettingsPath();
-  if (!existsSync8(path6.dirname(settingsPath))) {
+  if (!existsSync9(path6.dirname(settingsPath))) {
     return { host: "claude", action: "not-detected", config_file: settingsPath };
   }
   try {
     const hookScript = getHookScriptPath(metaUrl).replace(/\\/g, "/");
     const command = `node "${hookScript}"`;
-    const fileExistsBefore = existsSync8(settingsPath);
+    const fileExistsBefore = existsSync9(settingsPath);
     const settings = readJsonFile(settingsPath) ?? {};
     settings.hooks ??= {};
     settings.hooks.SessionStart ??= [];
@@ -2445,7 +2636,7 @@ function configureUpdateHintHooks(metaUrl, install) {
 function hasBinary(name) {
   const checker = process.platform === "win32" ? "where" : "which";
   try {
-    execFileSync2(checker, [name], { stdio: "ignore" });
+    execFileSync3(checker, [name], { stdio: "ignore" });
     return true;
   } catch {
     return false;
@@ -2472,7 +2663,7 @@ function getOpenCodeProjectCommandsDir(cwd) {
   return path7.join(cwd, ".opencode", "commands");
 }
 function detectOpenCode(cwd) {
-  return hasBinary("opencode") || existsSync9(path7.join(resolveConfigHome(), "opencode")) || existsSync9(path7.join(cwd, ".opencode"));
+  return hasBinary("opencode") || existsSync10(path7.join(resolveConfigHome(), "opencode")) || existsSync10(path7.join(cwd, ".opencode"));
 }
 function renderOpenCodeCommand() {
   return `---
@@ -2500,11 +2691,11 @@ function writeOpenCodeCommand(scope, cwd) {
   if (scope === "auto" && !detected) {
     return { detected: false, action: "not-detected", scope: "off" };
   }
-  const resolvedScope = scope === "project" ? "project" : scope === "global" ? "global" : existsSync9(path7.join(cwd, ".opencode")) ? "project" : "global";
+  const resolvedScope = scope === "project" ? "project" : scope === "global" ? "global" : existsSync10(path7.join(cwd, ".opencode")) ? "project" : "global";
   const commandsDir = resolvedScope === "project" ? getOpenCodeProjectCommandsDir(cwd) : getOpenCodeGlobalCommandsDir();
   const commandFile = path7.join(ensureDir(commandsDir), "unbrowse.md");
   const content = renderOpenCodeCommand();
-  const action2 = existsSync9(commandFile) ? "updated" : "installed";
+  const action2 = existsSync10(commandFile) ? "updated" : "installed";
   mkdirSync6(path7.dirname(commandFile), { recursive: true });
   writeFileSync5(commandFile, content);
   return {
@@ -2516,10 +2707,10 @@ function writeOpenCodeCommand(scope, cwd) {
 }
 async function ensureBrowserEngineInstalled() {
   const binary = findKuriBinary();
-  if (existsSync9(binary)) {
+  if (existsSync10(binary)) {
     return { installed: true, action: "already-installed" };
   }
-  const sourceDir = getKuriSourceCandidates().find((candidate) => existsSync9(path7.join(candidate, "build.zig")));
+  const sourceDir = getKuriSourceCandidates().find((candidate) => existsSync10(path7.join(candidate, "build.zig")));
   if (!sourceDir) {
     return {
       installed: false,
@@ -2535,13 +2726,13 @@ async function ensureBrowserEngineInstalled() {
     };
   }
   try {
-    execFileSync2("zig", ["build", "-Doptimize=ReleaseFast"], {
+    execFileSync3("zig", ["build", "-Doptimize=ReleaseFast"], {
       cwd: sourceDir,
       stdio: "inherit",
       timeout: 300000
     });
     const builtBinary = findKuriBinary();
-    if (existsSync9(builtBinary)) {
+    if (existsSync10(builtBinary)) {
       return {
         installed: true,
         action: "installed",
@@ -2566,11 +2757,11 @@ async function runSetup(options) {
   const browser = options?.installBrowser === false ? { installed: false, action: "skipped" } : await ensureBrowserEngineInstalled();
   const walletCheck = checkWalletConfigured();
   const skipWalletSetup = process.env.UNBROWSE_SKIP_WALLET_SETUP === "1";
-  const lobsterInstalled = hasBinary("lobstercash") || existsSync9(path7.join(os4.homedir(), ".agents", "skills", "lobstercash", "SKILL.md"));
+  const lobsterInstalled = hasBinary("lobstercash") || existsSync10(path7.join(os4.homedir(), ".agents", "skills", "lobstercash", "SKILL.md"));
   if (!skipWalletSetup && !walletCheck.configured && lobsterInstalled) {
     console.log("[unbrowse] Crossmint lobster.cash detected but wallet not configured — running wallet setup...");
     try {
-      execFileSync2("npx", ["@crossmint/lobster-cli", "setup"], {
+      execFileSync3("npx", ["@crossmint/lobster-cli", "setup"], {
         stdio: "inherit",
         timeout: 60000
       });
@@ -2606,7 +2797,7 @@ async function runSetup(options) {
 
 // ../../src/runtime/update-hints.ts
 init_paths();
-import { existsSync as existsSync10, mkdirSync as mkdirSync7, readFileSync as readFileSync7, writeFileSync as writeFileSync6 } from "node:fs";
+import { existsSync as existsSync11, mkdirSync as mkdirSync7, readFileSync as readFileSync7, writeFileSync as writeFileSync6 } from "node:fs";
 import os5 from "node:os";
 import path8 from "node:path";
 var INSTALL_SCRIPT_URL = "https://unbrowse.ai/install.sh";
@@ -2620,7 +2811,7 @@ function getConfigDir3() {
   return path8.join(getHomeDir2(), ".unbrowse");
 }
 function ensureDir3(dir) {
-  if (!existsSync10(dir))
+  if (!existsSync11(dir))
     mkdirSync7(dir, { recursive: true });
   return dir;
 }
@@ -2646,7 +2837,7 @@ function detectRepoRoot2(start2) {
   let dir = path8.resolve(start2);
   const root = path8.parse(dir).root;
   while (dir !== root) {
-    if (existsSync10(path8.join(dir, ".git")))
+    if (existsSync11(path8.join(dir, ".git")))
       return dir;
     dir = path8.dirname(dir);
   }
@@ -2780,6 +2971,7 @@ loadEnv({ quiet: true });
 loadEnv({ path: ".env.runtime", quiet: true });
 var BASE_URL = process.env.UNBROWSE_URL || "http://localhost:6969";
 var CLI_CLIENT_ID = process.env.UNBROWSE_CLIENT_ID || `cli-${process.ppid || process.pid}`;
+var walletNudgeShown = false;
 function parseArgs(argv) {
   const raw = argv.slice(2);
   const command = raw[0] && !raw[0].startsWith("--") ? raw[0] : "help";
@@ -3089,6 +3281,16 @@ async function cmdResolve(flags) {
     emitNextActionSummary(result);
     const skill = result.skill;
     const trace = result.trace;
+    if (trace?.success && !walletNudgeShown) {
+      try {
+        const { checkWalletConfigured: checkWalletConfigured3 } = await Promise.resolve().then(() => (init_wallet2(), exports_wallet));
+        const wallet = checkWalletConfigured3();
+        if (!wallet.configured) {
+          info("You're indexing routes but have no payout wallet. Run: npx @crossmint/lobster-cli setup");
+          walletNudgeShown = true;
+        }
+      } catch (_e) {}
+    }
     if (skill?.skill_id && trace) {
       result._feedback = `unbrowse feedback --skill ${skill.skill_id} --endpoint ${trace.endpoint_id || "?"} --rating <1-5>`;
     }
@@ -3472,6 +3674,16 @@ async function cmdSetup(flags) {
       info(`${hook.host} update hint hook ${hook.action} at ${hook.config_file}`);
     }
   }
+  if (report.wallet.configured) {
+    info(`Wallet configured (${report.wallet.provider}): ${report.wallet.wallet_address ?? "linked"}`);
+  } else if (report.wallet.lobster_installed) {
+    info("Wallet not paired \u2014 your indexed routes won't earn payouts.");
+    info("Run: npx @crossmint/lobster-cli setup");
+  } else {
+    info("No wallet configured \u2014 you're indexing routes for free.");
+    info("Set up a wallet so you earn when agents use your routes:");
+    info("  npx @crossmint/lobster-cli setup");
+  }
   await recordInstallTelemetryEvent("setup", {
     hostType,
     status: report.browser_engine.action === "failed" ? "failed" : "installed",

package/dist/mcp.js

@@ -108,11 +108,11 @@ import { dirname, join, parse } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 
 // ../../src/build-info.generated.ts
-var BUILD_RELEASE_VERSION = "3.0.4";
-var BUILD_GIT_SHA = "44d2baa5a0e0";
+var BUILD_RELEASE_VERSION = "3.1.0";
+var BUILD_GIT_SHA = "c9f9ce0e5cb1";
 var BUILD_CODE_HASH = "1488fc1d92b7";
-var BUILD_RELEASE_MANIFEST_BASE64 = "eyJzY2hlbWFfdmVyc2lvbiI6MSwicmVsZWFzZV92ZXJzaW9uIjoiMy4wLjQiLCJnaXRfc2hhIjoiNDRkMmJhYTVhMGUwIiwiY29kZV9oYXNoIjoiMTQ4OGZjMWQ5MmI3IiwidHJhY2VfdmVyc2lvbiI6IjE0ODhmYzFkOTJiN0A0NGQyYmFhNWEwZTAiLCJpc3N1ZWRfYXQiOiIyMDI2LTA0LTA1VDA0OjIyOjE2LjM2M1oifQ";
-var BUILD_RELEASE_MANIFEST_SIGNATURE = "zLW181YNH-1BLhH-HL-OvhuGJAzfy-HrZnIo7xm0aVo";
+var BUILD_RELEASE_MANIFEST_BASE64 = "eyJzY2hlbWFfdmVyc2lvbiI6MSwicmVsZWFzZV92ZXJzaW9uIjoiMy4xLjAiLCJnaXRfc2hhIjoiYzlmOWNlMGU1Y2IxIiwiY29kZV9oYXNoIjoiMTQ4OGZjMWQ5MmI3IiwidHJhY2VfdmVyc2lvbiI6IjE0ODhmYzFkOTJiN0BjOWY5Y2UwZTVjYjEiLCJpc3N1ZWRfYXQiOiIyMDI2LTA0LTA1VDA2OjUwOjA4LjQzNVoifQ";
+var BUILD_RELEASE_MANIFEST_SIGNATURE = "_2pdxyoIEYkKUHO0nXaXTubP5SrZCa-8CqStcPBsXxw";
 var BUILD_DEFAULT_BACKEND_URL = "https://beta-api.unbrowse.ai";
 
 // ../../src/version.ts

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "unbrowse",
-  "version": "3.0.4",
+  "version": "3.1.0",
   "description": "Reverse-engineer any website into reusable API skills. Zero-dep single binary with embedded browser engine.",
   "type": "module",
   "bin": {

package/runtime-src/build-info.generated.ts

@@ -1,6 +1,6 @@
-export const BUILD_RELEASE_VERSION = "3.0.4";
-export const BUILD_GIT_SHA = "44d2baa5a0e0";
+export const BUILD_RELEASE_VERSION = "3.1.0";
+export const BUILD_GIT_SHA = "c9f9ce0e5cb1";
 export const BUILD_CODE_HASH = "1488fc1d92b7";
-export const BUILD_RELEASE_MANIFEST_BASE64 = "eyJzY2hlbWFfdmVyc2lvbiI6MSwicmVsZWFzZV92ZXJzaW9uIjoiMy4wLjQiLCJnaXRfc2hhIjoiNDRkMmJhYTVhMGUwIiwiY29kZV9oYXNoIjoiMTQ4OGZjMWQ5MmI3IiwidHJhY2VfdmVyc2lvbiI6IjE0ODhmYzFkOTJiN0A0NGQyYmFhNWEwZTAiLCJpc3N1ZWRfYXQiOiIyMDI2LTA0LTA1VDA0OjIyOjE2LjM2M1oifQ";
-export const BUILD_RELEASE_MANIFEST_SIGNATURE = "zLW181YNH-1BLhH-HL-OvhuGJAzfy-HrZnIo7xm0aVo";
+export const BUILD_RELEASE_MANIFEST_BASE64 = "eyJzY2hlbWFfdmVyc2lvbiI6MSwicmVsZWFzZV92ZXJzaW9uIjoiMy4xLjAiLCJnaXRfc2hhIjoiYzlmOWNlMGU1Y2IxIiwiY29kZV9oYXNoIjoiMTQ4OGZjMWQ5MmI3IiwidHJhY2VfdmVyc2lvbiI6IjE0ODhmYzFkOTJiN0BjOWY5Y2UwZTVjYjEiLCJpc3N1ZWRfYXQiOiIyMDI2LTA0LTA1VDA2OjUwOjA4LjQzNVoifQ";
+export const BUILD_RELEASE_MANIFEST_SIGNATURE = "_2pdxyoIEYkKUHO0nXaXTubP5SrZCa-8CqStcPBsXxw";
 export const BUILD_DEFAULT_BACKEND_URL = "https://beta-api.unbrowse.ai";

package/runtime-src/cli.ts

@@ -30,6 +30,7 @@ loadEnv({ path: ".env.runtime", quiet: true });
 
 const BASE_URL = process.env.UNBROWSE_URL || "http://localhost:6969";
 const CLI_CLIENT_ID = process.env.UNBROWSE_CLIENT_ID || `cli-${process.ppid || process.pid}`;
+let walletNudgeShown = false;
 
 // ---------------------------------------------------------------------------
 // Arg parser
@@ -374,6 +375,19 @@ async function cmdResolve(flags: Record<string, string | boolean>): Promise<void
 
     const skill = result.skill as Record<string, unknown> | undefined;
     const trace = result.trace as Record<string, unknown> | undefined;
+
+    // Nudge wallet setup after successful resolve that indexed routes
+    if (trace?.success && !walletNudgeShown) {
+      try {
+        const { checkWalletConfigured } = await import("./payments/wallet.js");
+        const wallet = checkWalletConfigured();
+        if (!wallet.configured) {
+          info("You're indexing routes but have no payout wallet. Run: npx @crossmint/lobster-cli setup");
+          walletNudgeShown = true;
+        }
+      } catch (_e) { /* non-fatal */ }
+    }
+
     if (skill?.skill_id && trace) {
       (result as Record<string, unknown>)._feedback = `unbrowse feedback --skill ${skill.skill_id} --endpoint ${trace.endpoint_id || "?"} --rating <1-5>`;
     }
@@ -812,6 +826,18 @@ async function cmdSetup(flags: Record<string, string | boolean>): Promise<void>
     }
   }
 
+  // Wallet status — tell the user if they're missing payout config
+  if (report.wallet.configured) {
+    info(`Wallet configured (${report.wallet.provider}): ${(report.wallet as Record<string, unknown>).wallet_address ?? "linked"}`);
+  } else if ((report.wallet as Record<string, unknown>).lobster_installed) {
+    info("Wallet not paired — your indexed routes won't earn payouts.");
+    info("Run: npx @crossmint/lobster-cli setup");
+  } else {
+    info("No wallet configured — you're indexing routes for free.");
+    info("Set up a wallet so you earn when agents use your routes:");
+    info("  npx @crossmint/lobster-cli setup");
+  }
+
   await recordInstallTelemetryEvent("setup", {
     hostType,
     status: report.browser_engine.action === "failed" ? "failed" : "installed",

package/runtime-src/client/index.ts

@@ -497,7 +497,8 @@ async function apiRequest<T = unknown>(
     throw new Error("ToS update required. Restart unbrowse to accept new terms.");
   }
 
-  // Handle x402 payment required — surface payment terms to the caller
+
+  // Handle x402 payment required — attempt lobster pay-and-retry before surfacing
   if (res.status === 402) {
     const paymentRequired = res.headers.get("PAYMENT-REQUIRED");
     const legacyPaymentTerms = res.headers.get("X-Payment-Required");
@@ -506,6 +507,29 @@ async function apiRequest<T = unknown>(
       : legacyPaymentTerms
         ? JSON.parse(legacyPaymentTerms)
         : (data as Record<string, unknown>).terms;
+
+    // Try lobster.cash automatic payment before throwing
+    try {
+      const { isLobsterAvailable, payAndRetry } = await import("../payments/lobster-pay.js");
+      if (isLobsterAvailable()) {
+        const fullUrl = `${API_URL}${path}`;
+        const paidResult = await payAndRetry<T>(fullUrl, {
+          body,
+          headers: {
+            "Content-Type": "application/json",
+            "Accept-Encoding": "gzip, deflate",
+            ...releaseAttestationHeaders,
+            ...(key ? { Authorization: `Bearer ${key}` } : {}),
+          },
+        });
+        if (paidResult) {
+          return { data: paidResult.data, headers: new Headers() };
+        }
+      }
+    } catch (payErr) {
+      console.warn(`[x402] lobster pay-and-retry failed: ${(payErr as Error).message}`);
+    }
+
     const err = new Error(`Payment required: ${(data as Record<string, unknown>).error ?? "This skill requires payment"}`);
     (err as Error & { x402: boolean; terms: unknown; status: number }).x402 = true;
     (err as Error & { terms: unknown }).terms = terms;

package/runtime-src/execution/index.ts

@@ -1882,28 +1882,40 @@ export async function executeEndpoint(
       wallet_configured: !!wallet.wallet_address,
     });
     if (gate.status === "payment_required" || gate.status === "wallet_not_configured" || gate.status === "insufficient_balance") {
-      const trace: ExecutionTrace = stampTrace({
-        trace_id: nanoid(),
-        skill_id: skill.skill_id,
-        endpoint_id: endpoint.endpoint_id,
-        started_at: new Date().toISOString(),
-        completed_at: new Date().toISOString(),
-        success: false,
-        status_code: 402,
-        error: "payment_required",
-      });
-      return {
-        trace,
-        result: {
+      // If lobster wallet is available, let execution proceed —
+      // the client-level apiRequest will handle 402 pay-and-retry automatically.
+      let lobsterAvailable = false;
+      try {
+        const { isLobsterAvailable } = await import("../payments/lobster-pay.js");
+        lobsterAvailable = isLobsterAvailable();
+      } catch {}
+
+      if (lobsterAvailable && gate.status === "payment_required") {
+        console.log(`[payment] ${skill.skill_id}: lobster available — proceeding with auto-pay`);
+      } else {
+        const trace: ExecutionTrace = stampTrace({
+          trace_id: nanoid(),
+          skill_id: skill.skill_id,
+          endpoint_id: endpoint.endpoint_id,
+          started_at: new Date().toISOString(),
+          completed_at: new Date().toISOString(),
+          success: false,
+          status_code: 402,
           error: "payment_required",
-          price_usd: gate.requirement?.amount,
-          payment_status: gate.status,
-          message: gate.message,
-          wallet_provider: wallet.wallet_provider ?? "lobster.cash",
-          wallet_address: wallet.wallet_address,
-          indexing_fallback_available: true,
-        },
-      };
+        });
+        return {
+          trace,
+          result: {
+            error: "payment_required",
+            price_usd: gate.requirement?.amount,
+            payment_status: gate.status,
+            message: gate.message,
+            wallet_provider: wallet.wallet_provider ?? "lobster.cash",
+            wallet_address: wallet.wallet_address,
+            indexing_fallback_available: true,
+          },
+        };
+      }
     }
   }
 

package/runtime-src/kuri/client.ts

@@ -216,7 +216,10 @@ function falseyEnv(value: string | undefined): boolean {
 }
 
 export function resolveKuriLaunchConfig(env: NodeJS.ProcessEnv = process.env): KuriLaunchConfig {
-  const headless = envFlag(env.KURI_HEADLESS ?? env.HEADLESS);
+  const explicitHeadless = env.KURI_HEADLESS ?? env.HEADLESS;
+  const headless = explicitHeadless !== undefined
+    ? envFlag(explicitHeadless)
+    : (process.platform === "linux" && !env.DISPLAY); // auto-headless when no display on Linux
   const cleanRoom = envFlag(env.UNBROWSE_LOCAL_ONLY) || envFlag(env.KURI_CLEAN_ROOM);
   const browserCookieOptOut = falseyEnv(env.UNBROWSE_IMPORT_BROWSER_COOKIES);
   const explicitAttach = envFlag(env.KURI_ATTACH_EXISTING_CHROME ?? env.UNBROWSE_ATTACH_EXISTING_CHROME);
@@ -240,6 +243,7 @@ function currentBundledKuriTarget(): string | null {
   if (process.platform === "darwin" && process.arch === "x64") return "darwin-x64";
   if (process.platform === "linux" && process.arch === "arm64") return "linux-arm64";
   if (process.platform === "linux" && process.arch === "x64") return "linux-x64";
+  if (process.platform === "win32" && process.arch === "x64") return "win-x64";
   return null;
 }
 

package/runtime-src/orchestrator/index.ts

@@ -3015,7 +3015,11 @@ export async function resolveAndExecute(
             console.log(`[prefetch] error: ${(prefetchErr as Error).message}`);
           }
           // --- Payment gate: only for marketplace-sourced paid skills ---
-          if (source === "marketplace" && skill.base_price_usd && skill.base_price_usd > 0) {
+          const dynamicPrice = source === "marketplace"
+            ? (skill.base_price_usd ?? await (await import("../payments/index.js")).fetchDynamicPrice(skill.skill_id))
+            : null;
+          const effectivePrice = typeof dynamicPrice === "string" ? parseFloat(dynamicPrice) : (dynamicPrice ?? 0);
+          if (source === "marketplace" && effectivePrice > 0) {
             try {
               const walletCheck = checkWalletConfigured();
               const wallet = getLocalWalletContext();
@@ -3023,7 +3027,7 @@ export async function resolveAndExecute(
                 skill.skill_id,
                 candidate.endpoint.endpoint_id,
                 {
-                  price_usd: String(skill.base_price_usd),
+                  price_usd: String(effectivePrice),
                   wallet_configured: walletCheck.configured,
                 },
               );
@@ -3038,7 +3042,7 @@ export async function resolveAndExecute(
                   return {
                     result: {
                       error: "payment_required",
-                      price_usd: skill.base_price_usd,
+                      price_usd: effectivePrice,
                       payment_status: paymentResult.status,
                       message: paymentResult.message,
                       next_step: paymentResult.next_step,

package/runtime-src/payments/lobster-pay.ts

@@ -0,0 +1,182 @@
+/**
+ * Lobster.cash x402 payment bridge.
+ *
+ * Handles the pay-and-retry cycle:
+ *   1. Receives x402 payment terms from a 402 response
+ *   2. Calls `lobstercash x402 fetch <url>` to pay + retry
+ *   3. Returns the paid response body
+ *
+ * Delegation boundary:
+ * - Unbrowse owns: detecting 402, passing the URL, using the result
+ * - Lobster owns: wallet signing, transaction broadcast, proof construction
+ */
+
+import { execFile, execFileSync } from "node:child_process";
+import { existsSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+
+const LOBSTER_PAY_TIMEOUT_MS = 30_000;
+
+/**
+ * Resolve the lobster CLI command. Prefers the direct binary if
+ * installed globally, otherwise falls back to npx.
+ */
+function getLobsterCommand(): { cmd: string; prefix: string[] } | null {
+  // 1. Direct binary in PATH
+  try {
+    execFileSync("lobstercash", ["--version"], { stdio: "ignore", timeout: 3_000 });
+    return { cmd: "lobstercash", prefix: [] };
+  } catch (_e) { /* not in PATH */ }
+
+  // 2. Check npm global bin (often not in agent PATH)
+  try {
+    const npmPrefix = execFileSync("npm", ["config", "get", "prefix"], { encoding: "utf8", timeout: 5_000 }).trim();
+    const lobsterPath = join(npmPrefix, "bin", "lobstercash");
+    if (existsSync(lobsterPath)) {
+      execFileSync(lobsterPath, ["--version"], { stdio: "ignore", timeout: 3_000 });
+      return { cmd: lobsterPath, prefix: [] };
+    }
+  } catch (_e) { /* npm not available */ }
+
+  return null;
+}
+
+let cachedCommand: { cmd: string; prefix: string[] } | null | undefined = undefined;
+function lobsterCmd(): { cmd: string; prefix: string[] } | null {
+  if (cachedCommand === undefined) cachedCommand = getLobsterCommand();
+  return cachedCommand;
+}
+
+export interface LobsterPayResult {
+  success: boolean;
+  body: string;
+  statusCode?: number;
+  error?: string;
+}
+
+/**
+ * Check if the lobster CLI is available and wallet is configured.
+ */
+export function isLobsterAvailable(): boolean {
+  const agentsPath = join(process.env.HOME || homedir(), ".lobster", "agents.json");
+  return existsSync(agentsPath);
+}
+
+/**
+ * Pay for an x402-gated URL via lobster.cash and return the response.
+ *
+ * Shells out to `lobstercash x402 fetch <url>` which handles:
+ * - Reading 402 + payment terms
+ * - Signing + broadcasting the USDC transfer
+ * - Retrying with PAYMENT-SIGNATURE header
+ * - Returning the paid response
+ */
+export function lobsterX402Fetch(
+  url: string,
+  options?: {
+    jsonBody?: string;
+    headers?: Record<string, string>;
+    timeoutMs?: number;
+  },
+): Promise<LobsterPayResult> {
+  return new Promise((resolve) => {
+    const resolved = lobsterCmd();
+    if (!resolved) {
+      resolve({ success: false, body: "", error: "lobstercash CLI not in PATH" });
+      return;
+    }
+    const { cmd, prefix } = resolved;
+    const args = [...prefix, "x402", "fetch", url, "--debug"];
+
+    if (options?.jsonBody) {
+      args.push("--json", options.jsonBody);
+    }
+
+    if (options?.headers) {
+      for (const [key, value] of Object.entries(options.headers)) {
+        args.push("--header", `${key}:${value}`);
+      }
+    }
+
+    const timeout = options?.timeoutMs ?? LOBSTER_PAY_TIMEOUT_MS;
+    args.push("--timeout", String(timeout));
+
+    execFile(cmd, args, { timeout: timeout + 5_000, maxBuffer: 1024 * 1024 }, (err, stdout, stderr) => {
+      if (err) {
+        const msg = stderr?.trim() || err.message;
+        console.warn(`[lobster-pay] x402 fetch failed: ${msg}`);
+        resolve({ success: false, body: "", error: msg });
+        return;
+      }
+
+      if (stderr) {
+        for (const line of stderr.split("\n").filter(Boolean)) {
+          console.log(`[lobster-pay] ${line}`);
+        }
+      }
+
+      // Parse status from stdout header line: "Status: 200"
+      const statusMatch = stdout.match(/^Status:\s*(\d+)/m);
+      const statusCode = statusMatch ? parseInt(statusMatch[1], 10) : undefined;
+
+      if (statusCode && statusCode >= 400) {
+        resolve({ success: false, body: stdout, statusCode, error: `HTTP ${statusCode}` });
+        return;
+      }
+
+      resolve({ success: true, body: stdout, statusCode });
+    });
+  });
+}
+
+/**
+ * Pay for an x402-gated API request and return the parsed JSON response.
+ *
+ * This is the high-level entry point for the pay-and-retry loop.
+ * Returns null if payment fails or lobster is unavailable.
+ */
+export async function payAndRetry<T = unknown>(
+  fullUrl: string,
+  options?: {
+    body?: unknown;
+    headers?: Record<string, string>;
+  },
+): Promise<{ data: T; paid: true } | null> {
+  if (!isLobsterAvailable()) {
+    console.log("[lobster-pay] lobster.cash not configured — skipping payment");
+    return null;
+  }
+
+  console.log(`[lobster-pay] attempting x402 payment for ${fullUrl}`);
+
+  const result = await lobsterX402Fetch(fullUrl, {
+    jsonBody: options?.body ? JSON.stringify(options.body) : undefined,
+    headers: options?.headers,
+  });
+
+  if (!result.success) {
+    console.warn(`[lobster-pay] payment failed: ${result.error}`);
+    return null;
+  }
+  try {
+    // lobstercash x402 fetch outputs header lines before the JSON body:
+    //   x402 FETCH <url>
+    //   Status: 200
+    //   Content-Type: application/json
+    //   <blank line>
+    //   {"actual":"json",...}
+    // Extract the JSON portion by finding the first '{' or '['
+    const raw = result.body;
+    const jsonStart = Math.min(
+      ...[raw.indexOf("{"), raw.indexOf("[")].filter((i) => i >= 0),
+    );
+    const jsonStr = jsonStart >= 0 ? raw.slice(jsonStart) : raw;
+    const data = JSON.parse(jsonStr) as T;
+    console.log("[lobster-pay] payment successful — got paid response");
+    return { data, paid: true };
+  } catch (_e) {
+    console.warn("[lobster-pay] paid response was not valid JSON");
+    return null;
+  }
+}

package/vendor/kuri/manifest.json

@@ -1,24 +1,28 @@
 {
   "repo_url": "https://github.com/justrach/kuri.git",
   "branch": "adding-extensions",
-  "source_sha": "005ce5cdf41347b683df99d307868a11439be972",
-  "built_at": "2026-04-04T11:57:45.378Z",
+  "source_sha": "08eecbe3740f046a46f656eed7ebfc66c1bad9bb",
+  "built_at": "2026-04-05T06:43:57.212Z",
   "binaries": {
     "darwin-arm64": {
       "zig_target": "aarch64-macos",
-      "sha256": "44d5e985e075ba57c7cc8e3ab51a39186b4bf62ece4d0c2e57797cbd4d0408d2"
+      "sha256": "1553633e722d18059dedffa8a52d55ed6c052e4961fd2753ee0b62be60b241bf"
     },
     "darwin-x64": {
       "zig_target": "x86_64-macos",
-      "sha256": "09dc2104449506f2ba8a73edc884bb7399c349c12fc6ec6b3d5f7f652918742f"
+      "sha256": "b5eb07e631c6ddad64019c8d0c86c32cb76a74ff0791ac5611a3aa3550767ec8"
     },
     "linux-arm64": {
       "zig_target": "aarch64-linux",
-      "sha256": "98c18cec5a588f44746cd465b0c8fd17cec311ca03e1292dab173841db8bfcf1"
+      "sha256": "ea88a26f7b335d5842b0c1d83bfa4066bed0a119284560f6bd3833f1d240cce2"
     },
     "linux-x64": {
       "zig_target": "x86_64-linux",
-      "sha256": "6d081f758ee76e44bbf1bb9c633057212f9c1641d97060e391dadf35015fbbe2"
+      "sha256": "175a7c59e458e952a26974f0fb5c2ce374e56f2c4c352903b481b5aa5a16978f"
+    },
+    "win-x64": {
+      "zig_target": "x86_64-windows",
+      "sha256": "176291ad9827a183ba7322ddb56cc1fa5edc7c214a264ecdf8a1d5d18366d686"
     }
   }
 }