@mindstudio-ai/local-model-tunnel 0.5.61 → 0.5.63

package/dist/{chunk-45DC6K4V.js → chunk-7CY3GAYS.js}

@@ -2206,6 +2206,12 @@ var ClientRegistry = class {
   hasConnected() {
     return this.clients.size > 0;
   }
+  hasHeadless() {
+    for (const client of this.clients.values()) {
+      if (client.mode === "headless") return true;
+    }
+    return false;
+  }
   count() {
     return this.clients.size;
   }
@@ -2245,6 +2251,96 @@ var ClientRegistry = class {
   }
 };
 
+// src/dev/proxy/telemetry-mock.ts
+var MAX_BODY_BYTES = 1048576;
+var SSE_KEEPALIVE_MS = 25e3;
+function tryHandleTelemetry(req, res, sseConnections) {
+  const url = req.url ?? "";
+  if (!url.startsWith("/_/telemetry/")) return false;
+  if (!req.headers.authorization) {
+    res.writeHead(401, { "Content-Type": "application/json" });
+    res.end(
+      JSON.stringify({
+        error: "missing_authorization",
+        code: "missing_authorization"
+      })
+    );
+    return true;
+  }
+  if (url === "/_/telemetry/errors" && req.method === "POST") {
+    handleBatchPost(req, res);
+    return true;
+  }
+  if (url === "/_/telemetry/events" && req.method === "POST") {
+    handleBatchPost(req, res);
+    return true;
+  }
+  if (url === "/_/telemetry/presence" && req.method === "GET") {
+    handlePresence(req, res, sseConnections);
+    return true;
+  }
+  return false;
+}
+function handleBatchPost(req, res) {
+  let total = 0;
+  const chunks = [];
+  let aborted = false;
+  req.on("data", (chunk) => {
+    total += chunk.length;
+    if (total > MAX_BODY_BYTES) {
+      aborted = true;
+      req.destroy();
+      return;
+    }
+    chunks.push(chunk);
+  });
+  req.on("end", () => {
+    if (aborted) {
+      res.writeHead(413, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ accepted: 0, rejected: 0 }));
+      return;
+    }
+    let accepted = 0;
+    try {
+      const body = JSON.parse(Buffer.concat(chunks).toString("utf-8"));
+      if (Array.isArray(body?.events)) accepted = body.events.length;
+    } catch {
+    }
+    res.writeHead(200, { "Content-Type": "application/json" });
+    res.end(JSON.stringify({ accepted, rejected: 0 }));
+  });
+  req.on("error", () => {
+  });
+}
+function handlePresence(req, res, sseConnections) {
+  res.writeHead(200, {
+    "Content-Type": "text/event-stream",
+    "Cache-Control": "no-cache",
+    Connection: "keep-alive",
+    "X-Accel-Buffering": "no"
+  });
+  res.flushHeaders?.();
+  sseConnections.add(res);
+  const keepalive = setInterval(() => {
+    try {
+      res.write(": keepalive\n\n");
+    } catch {
+    }
+  }, SSE_KEEPALIVE_MS);
+  let cleaned = false;
+  const cleanup = () => {
+    if (cleaned) return;
+    cleaned = true;
+    clearInterval(keepalive);
+    sseConnections.delete(res);
+    log.debug("telemetry-mock", "SSE closed", { open: sseConnections.size });
+  };
+  req.on("close", cleanup);
+  res.on("close", cleanup);
+  res.on("error", cleanup);
+  log.debug("telemetry-mock", "SSE opened", { open: sseConnections.size });
+}
+
 // src/dev/stdin-commands/types.ts
 var CommandError = class extends Error {
   constructor(message, code) {
@@ -2276,6 +2372,12 @@ var DevProxy = class _DevProxy {
   commandQueue = [];
   /** Last mirror snapshot — sent to new mirror viewers so they don't wait for the next checkout. */
   lastMirrorSnapshot = null;
+  /** Open /_/telemetry/presence SSE responses, drained on stop(). */
+  sseConnections = /* @__PURE__ */ new Set();
+  /** Waiters resolved when a headless (sandbox-owned) client registers via WS.
+   *  Lets the supervisor block on the real readiness signal instead of a
+   *  network-idle predicate that gets defeated by long-lived SSE responses. */
+  headlessReadyWaiters = /* @__PURE__ */ new Set();
   /** Upstream dev server health tracking. */
   upstreamUp = true;
   healthCheckTimer = null;
@@ -2294,6 +2396,32 @@ var DevProxy = class _DevProxy {
   isBrowserConnected() {
     return this.clients.hasConnected();
   }
+  /**
+   * Resolve when a sandbox-owned headless client has registered via WS hello.
+   * If one is already connected, resolves immediately. Otherwise queues a
+   * one-shot waiter with a timeout. Used by `BrowserSupervisor` so it doesn't
+   * declare `running` until the browser-agent is actually reachable for
+   * commands — replacing the prior `networkidle0`-based readiness check
+   * which is defeated by long-lived SSE responses (e.g. /_/telemetry/presence).
+   */
+  waitForHeadlessClient(timeoutMs = 15e3) {
+    if (this.clients.hasHeadless()) return Promise.resolve();
+    return new Promise((resolve3, reject) => {
+      const waiter = {
+        resolve: resolve3,
+        reject,
+        timer: setTimeout(() => {
+          this.headlessReadyWaiters.delete(waiter);
+          reject(
+            new Error(
+              `Sandbox browser-agent did not connect within ${timeoutMs}ms`
+            )
+          );
+        }, timeoutMs)
+      };
+      this.headlessReadyWaiters.add(waiter);
+    });
+  }
   /**
    * Dispatch a command to the preferred browser client and wait for the result.
    * Commands are queued and executed one at a time per client (FIFO).
@@ -2473,6 +2601,18 @@ var DevProxy = class _DevProxy {
       this.wss.close();
       this.wss = null;
     }
+    for (const sseRes of this.sseConnections) {
+      try {
+        sseRes.end();
+      } catch {
+      }
+    }
+    this.sseConnections.clear();
+    for (const w of this.headlessReadyWaiters) {
+      clearTimeout(w.timer);
+      w.reject(new Error("Proxy stopped"));
+    }
+    this.headlessReadyWaiters.clear();
     if (this.server) {
       log.info("proxy", "Dev proxy stopping");
       this.server.close();
@@ -2557,6 +2697,13 @@ var DevProxy = class _DevProxy {
           viewport,
           mirror: !!msg.mirror
         });
+        if (mode === "headless" && this.headlessReadyWaiters.size > 0) {
+          for (const w of this.headlessReadyWaiters) {
+            clearTimeout(w.timer);
+            w.resolve();
+          }
+          this.headlessReadyWaiters.clear();
+        }
         ws.send(JSON.stringify({ type: "ack", clientId }));
         if (mode === "mirror" && this.lastMirrorSnapshot) {
           try {
@@ -2791,6 +2938,9 @@ var DevProxy = class _DevProxy {
       clientRes.end();
       return;
     }
+    if (tryHandleTelemetry(clientReq, clientRes, this.sseConnections)) {
+      return;
+    }
     if (clientReq.url?.startsWith("/_/")) {
       this.forwardToApi(clientReq, clientRes);
       return;
@@ -3541,4 +3691,4 @@ export {
   watchConfigFile,
   watchManifestFiles
 };
-//# sourceMappingURL=chunk-45DC6K4V.js.map
+//# sourceMappingURL=chunk-7CY3GAYS.js.map