@blockrun/clawrouter 0.6.9 → 0.8.0

package/dist/index.js

@@ -2324,6 +2324,8 @@ var DEFAULT_PORT = 8402;
 var MAX_FALLBACK_ATTEMPTS = 3;
 var HEALTH_CHECK_TIMEOUT_MS = 2e3;
 var RATE_LIMIT_COOLDOWN_MS = 6e4;
+var PORT_RETRY_ATTEMPTS = 5;
+var PORT_RETRY_DELAY_MS = 1e3;
 var rateLimitedModels = /* @__PURE__ */ new Map();
 function isRateLimited(modelId) {
   const hitTime = rateLimitedModels.get(modelId);
@@ -2613,7 +2615,7 @@ async function startProxy(options) {
   if (existingWallet) {
     const account2 = privateKeyToAccount2(options.walletKey);
     const balanceMonitor2 = new BalanceMonitor(account2.address);
-    const baseUrl = `http://127.0.0.1:${listenPort}`;
+    const baseUrl2 = `http://127.0.0.1:${listenPort}`;
     if (existingWallet !== account2.address) {
       console.warn(
         `[ClawRouter] Existing proxy on port ${listenPort} uses wallet ${existingWallet}, but current config uses ${account2.address}. Reusing existing proxy.`
@@ -2622,7 +2624,7 @@ async function startProxy(options) {
     options.onReady?.(listenPort);
     return {
       port: listenPort,
-      baseUrl,
+      baseUrl: baseUrl2,
       walletAddress: existingWallet,
       balanceMonitor: balanceMonitor2,
       close: async () => {
@@ -2748,80 +2750,123 @@ async function startProxy(options) {
       }
     }
   });
-  return new Promise((resolve, reject) => {
-    server.on("error", (err) => {
-      if (err.code === "EADDRINUSE") {
-        const baseUrl = `http://127.0.0.1:${listenPort}`;
+  const tryListen = (attempt) => {
+    return new Promise((resolveAttempt, rejectAttempt) => {
+      const onError = async (err) => {
+        server.removeListener("error", onError);
+        if (err.code === "EADDRINUSE") {
+          const existingWallet2 = await checkExistingProxy(listenPort);
+          if (existingWallet2) {
+            console.log(`[ClawRouter] Existing proxy detected on port ${listenPort}, reusing`);
+            rejectAttempt({ code: "REUSE_EXISTING", wallet: existingWallet2 });
+            return;
+          }
+          if (attempt < PORT_RETRY_ATTEMPTS) {
+            console.log(
+              `[ClawRouter] Port ${listenPort} in TIME_WAIT, retrying in ${PORT_RETRY_DELAY_MS}ms (attempt ${attempt}/${PORT_RETRY_ATTEMPTS})`
+            );
+            rejectAttempt({ code: "RETRY", attempt });
+            return;
+          }
+          console.error(
+            `[ClawRouter] Port ${listenPort} still in use after ${PORT_RETRY_ATTEMPTS} attempts`
+          );
+          rejectAttempt(err);
+          return;
+        }
+        rejectAttempt(err);
+      };
+      server.once("error", onError);
+      server.listen(listenPort, "127.0.0.1", () => {
+        server.removeListener("error", onError);
+        resolveAttempt();
+      });
+    });
+  };
+  let lastError;
+  for (let attempt = 1; attempt <= PORT_RETRY_ATTEMPTS; attempt++) {
+    try {
+      await tryListen(attempt);
+      break;
+    } catch (err) {
+      const error = err;
+      if (error.code === "REUSE_EXISTING" && error.wallet) {
+        const baseUrl2 = `http://127.0.0.1:${listenPort}`;
         options.onReady?.(listenPort);
-        resolve({
+        return {
           port: listenPort,
-          baseUrl,
-          walletAddress: account.address,
+          baseUrl: baseUrl2,
+          walletAddress: error.wallet,
           balanceMonitor,
           close: async () => {
           }
-        });
-        return;
+        };
       }
-      reject(err);
+      if (error.code === "RETRY") {
+        await new Promise((r) => setTimeout(r, PORT_RETRY_DELAY_MS));
+        continue;
+      }
+      lastError = err;
+      break;
+    }
+  }
+  if (lastError) {
+    throw lastError;
+  }
+  const addr = server.address();
+  const port = addr.port;
+  const baseUrl = `http://127.0.0.1:${port}`;
+  options.onReady?.(port);
+  server.on("error", (err) => {
+    console.error(`[ClawRouter] Server runtime error: ${err.message}`);
+    options.onError?.(err);
+  });
+  server.on("clientError", (err, socket) => {
+    console.error(`[ClawRouter] Client error: ${err.message}`);
+    if (socket.writable && !socket.destroyed) {
+      socket.end("HTTP/1.1 400 Bad Request\r\n\r\n");
+    }
+  });
+  server.on("connection", (socket) => {
+    connections.add(socket);
+    socket.setTimeout(3e5);
+    socket.on("timeout", () => {
+      console.error(`[ClawRouter] Socket timeout, destroying connection`);
+      socket.destroy();
     });
-    server.listen(listenPort, "127.0.0.1", () => {
-      const addr = server.address();
-      const port = addr.port;
-      const baseUrl = `http://127.0.0.1:${port}`;
-      options.onReady?.(port);
-      server.on("error", (err) => {
-        console.error(`[ClawRouter] Server runtime error: ${err.message}`);
-        options.onError?.(err);
-      });
-      server.on("clientError", (err, socket) => {
-        console.error(`[ClawRouter] Client error: ${err.message}`);
-        if (socket.writable && !socket.destroyed) {
-          socket.end("HTTP/1.1 400 Bad Request\r\n\r\n");
-        }
-      });
-      server.on("connection", (socket) => {
-        connections.add(socket);
-        socket.setTimeout(3e5);
-        socket.on("timeout", () => {
-          console.error(`[ClawRouter] Socket timeout, destroying connection`);
-          socket.destroy();
-        });
-        socket.on("end", () => {
-        });
-        socket.on("error", (err) => {
-          console.error(`[ClawRouter] Socket error: ${err.message}`);
-        });
-        socket.on("close", () => {
-          connections.delete(socket);
-        });
-      });
-      resolve({
-        port,
-        baseUrl,
-        walletAddress: account.address,
-        balanceMonitor,
-        close: () => new Promise((res, rej) => {
-          const timeout = setTimeout(() => {
-            rej(new Error("[ClawRouter] Close timeout after 4s"));
-          }, 4e3);
-          sessionStore.close();
-          for (const socket of connections) {
-            socket.destroy();
-          }
-          connections.clear();
-          server.close((err) => {
-            clearTimeout(timeout);
-            if (err) {
-              rej(err);
-            } else {
-              res();
-            }
-          });
-        })
-      });
+    socket.on("end", () => {
+    });
+    socket.on("error", (err) => {
+      console.error(`[ClawRouter] Socket error: ${err.message}`);
+    });
+    socket.on("close", () => {
+      connections.delete(socket);
     });
   });
+  return {
+    port,
+    baseUrl,
+    walletAddress: account.address,
+    balanceMonitor,
+    close: () => new Promise((res, rej) => {
+      const timeout = setTimeout(() => {
+        rej(new Error("[ClawRouter] Close timeout after 4s"));
+      }, 4e3);
+      sessionStore.close();
+      for (const socket of connections) {
+        socket.destroy();
+      }
+      connections.clear();
+      server.close((err) => {
+        clearTimeout(timeout);
+        if (err) {
+          rej(err);
+        } else {
+          res();
+        }
+      });
+    })
+  };
 }
 async function tryModelRequest(upstreamUrl, method, headers, body, modelId, maxTokens, payFetch, balanceMonitor, signal) {
   let requestBody = body;
@@ -3457,80 +3502,137 @@ function isCompletionMode() {
   return args.some((arg, i) => arg === "completion" && i >= 1 && i <= 3);
 }
 function injectModelsConfig(logger) {
-  const configPath = join5(homedir4(), ".openclaw", "openclaw.json");
-  if (!existsSync(configPath)) {
-    logger.info("OpenClaw config not found, skipping models injection");
-    return;
+  const configDir = join5(homedir4(), ".openclaw");
+  const configPath = join5(configDir, "openclaw.json");
+  let config = {};
+  let needsWrite = false;
+  if (!existsSync(configDir)) {
+    try {
+      mkdirSync(configDir, { recursive: true });
+      logger.info("Created OpenClaw config directory");
+    } catch (err) {
+      logger.info(`Failed to create config dir: ${err instanceof Error ? err.message : String(err)}`);
+      return;
+    }
   }
-  try {
-    const config = JSON.parse(readFileSync(configPath, "utf-8"));
-    let needsWrite = false;
-    if (!config.models) config.models = {};
-    if (!config.models.providers) config.models.providers = {};
-    const proxyPort = getProxyPort();
-    const expectedBaseUrl = `http://127.0.0.1:${proxyPort}/v1`;
-    if (!config.models.providers.blockrun) {
-      config.models.providers.blockrun = {
-        baseUrl: expectedBaseUrl,
-        api: "openai-completions",
-        // apiKey is required by pi-coding-agent's ModelRegistry for providers with models.
-        // We use a placeholder since the proxy handles real x402 auth internally.
-        apiKey: "x402-proxy-handles-auth",
-        models: OPENCLAW_MODELS
-      };
-      needsWrite = true;
-    } else {
-      if (config.models.providers.blockrun.baseUrl !== expectedBaseUrl) {
-        config.models.providers.blockrun.baseUrl = expectedBaseUrl;
-        needsWrite = true;
-      }
-      if (!config.models.providers.blockrun.apiKey) {
-        config.models.providers.blockrun.apiKey = "x402-proxy-handles-auth";
-        needsWrite = true;
-      }
-      const currentModels = config.models.providers.blockrun.models;
-      if (!currentModels || currentModels.length !== OPENCLAW_MODELS.length) {
-        config.models.providers.blockrun.models = OPENCLAW_MODELS;
+  if (existsSync(configPath)) {
+    try {
+      const content = readFileSync(configPath, "utf-8").trim();
+      if (content) {
+        config = JSON.parse(content);
+      } else {
+        logger.info("OpenClaw config is empty, initializing");
         needsWrite = true;
       }
+    } catch (err) {
+      logger.info(`Failed to parse config (will recreate): ${err instanceof Error ? err.message : String(err)}`);
+      config = {};
+      needsWrite = true;
     }
-    if (!config.agents) config.agents = {};
-    if (!config.agents.defaults) config.agents.defaults = {};
-    if (!config.agents.defaults.model) config.agents.defaults.model = {};
-    if (config.agents.defaults.model.primary !== "blockrun/auto") {
-      config.agents.defaults.model.primary = "blockrun/auto";
+  } else {
+    logger.info("OpenClaw config not found, creating");
+    needsWrite = true;
+  }
+  if (!config.models) {
+    config.models = {};
+    needsWrite = true;
+  }
+  const models = config.models;
+  if (!models.providers) {
+    models.providers = {};
+    needsWrite = true;
+  }
+  const proxyPort = getProxyPort();
+  const expectedBaseUrl = `http://127.0.0.1:${proxyPort}/v1`;
+  const providers = models.providers;
+  if (!providers.blockrun) {
+    providers.blockrun = {
+      baseUrl: expectedBaseUrl,
+      api: "openai-completions",
+      // apiKey is required by pi-coding-agent's ModelRegistry for providers with models.
+      // We use a placeholder since the proxy handles real x402 auth internally.
+      apiKey: "x402-proxy-handles-auth",
+      models: OPENCLAW_MODELS
+    };
+    logger.info("Injected BlockRun provider config");
+    needsWrite = true;
+  } else {
+    const blockrun = providers.blockrun;
+    let fixed = false;
+    if (!blockrun.baseUrl || blockrun.baseUrl !== expectedBaseUrl) {
+      blockrun.baseUrl = expectedBaseUrl;
+      fixed = true;
+    }
+    if (!blockrun.api) {
+      blockrun.api = "openai-completions";
+      fixed = true;
+    }
+    if (!blockrun.apiKey) {
+      blockrun.apiKey = "x402-proxy-handles-auth";
+      fixed = true;
+    }
+    const currentModels = blockrun.models;
+    if (!currentModels || !Array.isArray(currentModels) || currentModels.length !== OPENCLAW_MODELS.length) {
+      blockrun.models = OPENCLAW_MODELS;
+      fixed = true;
+    }
+    if (fixed) {
+      logger.info("Fixed incomplete BlockRun provider config");
       needsWrite = true;
     }
-    const KEY_MODEL_ALIASES = [
-      { id: "auto", alias: "auto" },
-      { id: "free", alias: "free" },
-      { id: "sonnet", alias: "sonnet" },
-      { id: "opus", alias: "opus" },
-      { id: "haiku", alias: "haiku" },
-      { id: "grok", alias: "grok" },
-      { id: "deepseek", alias: "deepseek" },
-      { id: "kimi", alias: "kimi" },
-      { id: "gemini", alias: "gemini" },
-      { id: "flash", alias: "flash" },
-      { id: "gpt", alias: "gpt" },
-      { id: "reasoner", alias: "reasoner" }
-    ];
-    if (!config.agents) config.agents = {};
-    if (!config.agents.defaults) config.agents.defaults = {};
-    if (!config.agents.defaults.models) config.agents.defaults.models = {};
-    const allowlist = config.agents.defaults.models;
-    for (const m of KEY_MODEL_ALIASES) {
-      const fullId = `blockrun/${m.id}`;
-      if (!allowlist[fullId]) {
-        allowlist[fullId] = { alias: m.alias };
-        needsWrite = true;
-      }
+  }
+  if (!config.agents) {
+    config.agents = {};
+    needsWrite = true;
+  }
+  const agents = config.agents;
+  if (!agents.defaults) {
+    agents.defaults = {};
+    needsWrite = true;
+  }
+  const defaults = agents.defaults;
+  if (!defaults.model) {
+    defaults.model = {};
+    needsWrite = true;
+  }
+  const model = defaults.model;
+  if (model.primary !== "blockrun/auto") {
+    model.primary = "blockrun/auto";
+    needsWrite = true;
+  }
+  const KEY_MODEL_ALIASES = [
+    { id: "auto", alias: "auto" },
+    { id: "free", alias: "free" },
+    { id: "sonnet", alias: "sonnet" },
+    { id: "opus", alias: "opus" },
+    { id: "haiku", alias: "haiku" },
+    { id: "grok", alias: "grok" },
+    { id: "deepseek", alias: "deepseek" },
+    { id: "kimi", alias: "kimi" },
+    { id: "gemini", alias: "gemini" },
+    { id: "flash", alias: "flash" },
+    { id: "gpt", alias: "gpt" },
+    { id: "reasoner", alias: "reasoner" }
+  ];
+  if (!defaults.models) {
+    defaults.models = {};
+    needsWrite = true;
+  }
+  const allowlist = defaults.models;
+  for (const m of KEY_MODEL_ALIASES) {
+    const fullId = `blockrun/${m.id}`;
+    if (!allowlist[fullId]) {
+      allowlist[fullId] = { alias: m.alias };
+      needsWrite = true;
     }
-    if (needsWrite) {
+  }
+  if (needsWrite) {
+    try {
       writeFileSync(configPath, JSON.stringify(config, null, 2));
       logger.info("Smart routing enabled (blockrun/auto)");
+    } catch (err) {
+      logger.info(`Failed to write config: ${err instanceof Error ? err.message : String(err)}`);
     }
-  } catch {
   }
 }
 function injectAuthProfile(logger) {