@blockrun/clawrouter 0.6.9 → 0.7.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;