@mindstudio-ai/local-model-tunnel 0.5.21 → 0.5.23

package/dist/{chunk-VJTZSOKC.js → chunk-HZZVPY7J.js}

@@ -442,15 +442,6 @@ var DevEventEmitter = class extends EventEmitter {
   emitConnectionRestored() {
     this.emit("dev:connection-restored");
   }
-  emitImpersonate(event) {
-    this.emit("dev:impersonate", event);
-  }
-  emitScenarioStart(event) {
-    this.emit("dev:scenario-start", event);
-  }
-  emitScenarioComplete(event) {
-    this.emit("dev:scenario-complete", event);
-  }
   onStart(handler) {
     this.on("dev:start", handler);
     return () => this.off("dev:start", handler);
@@ -483,18 +474,6 @@ var DevEventEmitter = class extends EventEmitter {
     this.on("dev:connection-restored", handler);
     return () => this.off("dev:connection-restored", handler);
   }
-  onImpersonate(handler) {
-    this.on("dev:impersonate", handler);
-    return () => this.off("dev:impersonate", handler);
-  }
-  onScenarioStart(handler) {
-    this.on("dev:scenario-start", handler);
-    return () => this.off("dev:scenario-start", handler);
-  }
-  onScenarioComplete(handler) {
-    this.on("dev:scenario-complete", handler);
-    return () => this.off("dev:scenario-complete", handler);
-  }
 };
 var devRequestEvents = new DevEventEmitter();
 
@@ -1049,17 +1028,15 @@ var DevRunner = class {
   async setImpersonation(roles) {
     if (!this.session) return;
     log.info("Setting role override", { roles });
-    const result = await impersonate(this.appId, this.session.sessionId, roles);
+    await impersonate(this.appId, this.session.sessionId, roles);
     await this.refreshClientContext();
-    devRequestEvents.emitImpersonate({ roles: result.roles });
   }
   // Clear role override — revert to session's default roles.
   async clearImpersonation() {
     if (!this.session) return;
     log.info("Clearing role override");
-    const result = await impersonate(this.appId, this.session.sessionId, null);
+    await impersonate(this.appId, this.session.sessionId, null);
     await this.refreshClientContext();
-    devRequestEvents.emitImpersonate({ roles: result.roles });
   }
   // Fetch fresh clientContext from platform and update the proxy.
   // Called after impersonation changes so the browser gets a new ms_iface token.
@@ -1081,12 +1058,6 @@ var DevRunner = class {
     }
     const requestId = randomBytes2(8).toString("hex");
     const startTime = Date.now();
-    devRequestEvents.emitStart({
-      id: requestId,
-      type: "execute",
-      method: opts.methodExport,
-      timestamp: startTime
-    });
     log.info("Method received (direct)", { requestId, method: opts.methodExport });
     try {
       const authorizationToken = await fetchCallbackToken(this.appId, this.session.sessionId);
@@ -1123,12 +1094,6 @@ var DevRunner = class {
         result,
         duration
       });
-      devRequestEvents.emitComplete({
-        id: requestId,
-        success: result.success,
-        duration,
-        error: result.error ? formatErrorForDisplay(result.error) : void 0
-      });
       return {
         success: result.success,
         output: result.output,
@@ -1151,12 +1116,6 @@ var DevRunner = class {
         result: { success: false, error: { message } },
         duration
       });
-      devRequestEvents.emitComplete({
-        id: requestId,
-        success: false,
-        duration,
-        error: message
-      });
       return { success: false, error: { message }, duration };
     }
   }
@@ -1168,11 +1127,6 @@ var DevRunner = class {
     }
     const startTime = Date.now();
     const scenarioName = scenario.name ?? scenario.export;
-    devRequestEvents.emitScenarioStart({
-      id: scenario.id,
-      name: scenarioName,
-      timestamp: startTime
-    });
     log.info("Scenario starting", { id: scenario.id, name: scenarioName });
     try {
       log.info("Resetting database for scenario");
@@ -1202,13 +1156,6 @@ var DevRunner = class {
           result,
           duration: Date.now() - startTime
         });
-        devRequestEvents.emitScenarioComplete({
-          id: scenario.id,
-          success: false,
-          duration: Date.now() - startTime,
-          roles: scenario.roles,
-          error
-        });
         return { success: false, databases, error };
       }
       if (scenario.roles.length > 0) {
@@ -1225,12 +1172,6 @@ var DevRunner = class {
         result,
         duration
       });
-      devRequestEvents.emitScenarioComplete({
-        id: scenario.id,
-        success: true,
-        duration,
-        roles: scenario.roles
-      });
       return { success: true, databases };
     } catch (err) {
       const error = err instanceof Error ? err.message : "Unknown error";
@@ -1243,13 +1184,6 @@ var DevRunner = class {
         infrastructureError: error,
         duration: Date.now() - startTime
       });
-      devRequestEvents.emitScenarioComplete({
-        id: scenario.id,
-        success: false,
-        duration: Date.now() - startTime,
-        roles: scenario.roles,
-        error
-      });
       return { success: false, databases: this.session.databases, error };
     }
   }
@@ -1481,7 +1415,99 @@ function closeBrowserLog() {
 
 // src/dev/proxy.ts
 import http from "http";
+import { randomBytes as randomBytes4 } from "crypto";
+import { WebSocketServer } from "ws";
+
+// src/dev/ws-clients.ts
 import { randomBytes as randomBytes3 } from "crypto";
+var ClientRegistry = class {
+  clients = /* @__PURE__ */ new Map();
+  add(ws, hello) {
+    const id = randomBytes3(4).toString("hex");
+    this.clients.set(id, {
+      id,
+      ws,
+      mode: hello.mode,
+      url: hello.url,
+      viewport: hello.viewport,
+      connectedAt: Date.now(),
+      alive: true,
+      activeCommandId: null
+    });
+    log.info("Browser client connected", { clientId: id, mode: hello.mode, url: hello.url });
+    return id;
+  }
+  remove(id) {
+    const client = this.clients.get(id);
+    if (client) {
+      this.clients.delete(id);
+      log.info("Browser client disconnected", { clientId: id, mode: client.mode });
+    }
+    return client;
+  }
+  get(id) {
+    return this.clients.get(id);
+  }
+  /**
+   * Get the preferred client for C&C commands.
+   * Prefers idle iframe clients, falls back to any idle client.
+   * Skips clients that are already executing a command.
+   */
+  getCommandTarget() {
+    let fallback = null;
+    for (const client of this.clients.values()) {
+      if (client.activeCommandId) continue;
+      if (client.mode === "iframe") return client;
+      if (!fallback) fallback = client;
+    }
+    return fallback;
+  }
+  getAll() {
+    return [...this.clients.values()];
+  }
+  hasConnected() {
+    return this.clients.size > 0;
+  }
+  count() {
+    return this.clients.size;
+  }
+  /** Find the client executing a given command. */
+  findByCommandId(commandId) {
+    for (const client of this.clients.values()) {
+      if (client.activeCommandId === commandId) return client;
+    }
+    return void 0;
+  }
+  markAlive(id) {
+    const client = this.clients.get(id);
+    if (client) client.alive = true;
+  }
+  /** Mark all clients as not-alive, then ping. Clients that respond set alive=true. */
+  pingAll() {
+    for (const client of this.clients.values()) {
+      client.alive = false;
+      try {
+        client.ws.ping();
+      } catch {
+      }
+    }
+  }
+  /** Remove clients that didn't respond to the last ping. Returns active command IDs that need rejection. */
+  sweepDead() {
+    const removed = [];
+    for (const client of this.clients.values()) {
+      if (!client.alive) {
+        log.warn("Browser client timed out (no pong)", { clientId: client.id, activeCommandId: client.activeCommandId });
+        removed.push({ clientId: client.id, activeCommandId: client.activeCommandId });
+        this.clients.delete(client.id);
+        client.ws.terminate();
+      }
+    }
+    return removed;
+  }
+};
+
+// src/dev/proxy.ts
 var DevProxy = class _DevProxy {
   constructor(upstreamPort, clientContext, bindAddress = "127.0.0.1", browserAgentUrl) {
     this.upstreamPort = upstreamPort;
@@ -1491,58 +1517,104 @@ var DevProxy = class _DevProxy {
   }
   server = null;
   proxyPort = null;
-  commandQueue = [];
+  wss = null;
+  clients = new ClientRegistry();
   pendingResults = /* @__PURE__ */ new Map();
-  lastBrowserPoll = 0;
-  /** Long-poll waiters — browser agents waiting for the next command. */
-  commandWaiters = [];
+  commandQueue = [];
   /** Upstream dev server health tracking. */
   upstreamUp = true;
   healthCheckTimer = null;
+  pingTimer = null;
   static HEALTH_CHECK_INTERVAL = 3e3;
   static HEALTH_CHECK_INTERVAL_DOWN = 1e3;
   static HEALTH_CHECK_TIMEOUT = 2e3;
+  static PING_INTERVAL = 3e4;
+  static HELLO_TIMEOUT = 5e3;
   updateClientContext(context) {
     this.clientContext = context;
     log.info("Dev proxy context updated after role change");
   }
   /**
-   * Whether a browser agent is actively connected.
-   * True if there's a long-poll waiter or we've seen activity recently.
+   * Whether any browser agent is actively connected via WebSocket.
    */
   isBrowserConnected() {
-    return this.commandWaiters.length > 0 || Date.now() - this.lastBrowserPoll < 500;
+    return this.clients.hasConnected();
   }
   /**
-   * Dispatch a browser command and wait for the result.
-   * The command is queued for the browser agent to pick up via polling.
-   * Returns a promise that resolves when the browser posts the result back.
+   * 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).
    */
   dispatchBrowserCommand(steps, timeoutMs = 3e4) {
-    if (!this.isBrowserConnected()) {
+    if (!this.clients.hasConnected()) {
       return Promise.reject(
         new Error("No browser connected, please refresh the MindStudio preview")
       );
     }
-    const id = randomBytes3(4).toString("hex");
-    log.info("Browser command queued", { id, stepCount: steps.length, commands: steps.map((s) => s.command) });
+    const id = randomBytes4(4).toString("hex");
     return new Promise((resolve2, reject) => {
+      this.commandQueue.push({ id, steps, timeoutMs, resolve: resolve2, reject, queuedAt: Date.now() });
+      log.info("Browser command queued", { id, queueLength: this.commandQueue.length, commands: steps.map((s) => s.command) });
+      this.drainCommandQueue();
+    });
+  }
+  /**
+   * Try to send the next queued command to an available client.
+   */
+  drainCommandQueue() {
+    while (this.commandQueue.length > 0) {
+      const target = this.clients.getCommandTarget();
+      if (!target) break;
+      const queued = this.commandQueue.shift();
+      const { id, steps, timeoutMs, resolve: resolve2, reject } = queued;
+      log.info("Browser command sent", { id, clientId: target.id, mode: target.mode, stepCount: steps.length, commands: steps.map((s) => s.command) });
       const timeout = setTimeout(() => {
         this.pendingResults.delete(id);
-        log.warn("Browser command timed out", { id, pendingCount: this.pendingResults.size, queueLength: this.commandQueue.length });
+        const client = this.clients.findByCommandId(id);
+        if (client) client.activeCommandId = null;
+        log.warn("Browser command timed out", { id, pendingCount: this.pendingResults.size });
         reject(new Error("Browser command timed out"));
+        this.drainCommandQueue();
       }, timeoutMs);
-      this.pendingResults.set(id, { resolve: resolve2, timeout });
-      this.commandQueue.push({ id, steps });
-      this.flushCommandToWaiter();
-    });
+      this.pendingResults.set(id, { resolve: resolve2, timeout, clientId: target.id });
+      target.activeCommandId = id;
+      try {
+        target.ws.send(JSON.stringify({ type: "command", id, steps }));
+      } catch {
+        this.pendingResults.delete(id);
+        clearTimeout(timeout);
+        target.activeCommandId = null;
+        reject(new Error("Failed to send command to browser"));
+      }
+    }
+  }
+  /**
+   * Send a broadcast message to all connected browser clients.
+   */
+  broadcastToClients(action, payload) {
+    const msg = JSON.stringify({ type: "broadcast", action, payload });
+    const clients = this.clients.getAll();
+    log.info("Broadcasting to browser clients", { action, clientCount: clients.length });
+    for (const client of clients) {
+      try {
+        client.ws.send(msg);
+      } catch {
+      }
+    }
   }
   async start(preferredPort) {
     const server = http.createServer((req, res) => {
       this.handleRequest(req, res);
     });
+    this.wss = new WebSocketServer({ noServer: true });
+    this.wss.on("connection", (ws) => this.handleWsConnection(ws));
     server.on("upgrade", (req, socket, head) => {
-      this.handleUpgrade(req, socket, head);
+      if (req.url === "/__mindstudio_dev__/ws") {
+        this.wss.handleUpgrade(req, socket, head, (ws) => {
+          this.wss.emit("connection", ws, req);
+        });
+      } else {
+        this.handleUpstreamUpgrade(req, socket, head);
+      }
     });
     const portsToTry = preferredPort ? [preferredPort, 0] : [0];
     for (const port of portsToTry) {
@@ -1551,6 +1623,7 @@ var DevProxy = class _DevProxy {
         this.server = server;
         this.proxyPort = assignedPort;
         this.startHealthCheck();
+        this.startPingTimer();
         log.info("Dev proxy started", { port: assignedPort, bind: this.bindAddress });
         return assignedPort;
       } catch {
@@ -1579,6 +1652,18 @@ var DevProxy = class _DevProxy {
   }
   stop() {
     this.stopHealthCheck();
+    this.stopPingTimer();
+    for (const client of this.clients.getAll()) {
+      try {
+        client.ws.close(1001, "Proxy stopping");
+      } catch {
+        client.ws.terminate();
+      }
+    }
+    if (this.wss) {
+      this.wss.close();
+      this.wss = null;
+    }
     if (this.server) {
       log.info("Dev proxy stopping");
       this.server.close();
@@ -1590,19 +1675,124 @@ var DevProxy = class _DevProxy {
       pending2.resolve({ id, steps: [], error: "Proxy stopped" });
     }
     this.pendingResults.clear();
-    this.commandQueue.length = 0;
-    for (const waiter of this.commandWaiters) {
-      clearTimeout(waiter.timer);
-      if (!waiter.res.writableEnded) {
-        waiter.res.writeHead(204).end();
-      }
+    for (const queued of this.commandQueue) {
+      queued.reject(new Error("Proxy stopped"));
     }
-    this.commandWaiters.length = 0;
+    this.commandQueue.length = 0;
   }
   getPort() {
     return this.proxyPort;
   }
   // ---------------------------------------------------------------------------
+  // WebSocket connection handler
+  // ---------------------------------------------------------------------------
+  handleWsConnection(ws) {
+    let clientId = null;
+    const helloTimeout = setTimeout(() => {
+      if (!clientId) {
+        log.warn("Browser WS client did not send hello in time, closing");
+        ws.close(4e3, "Hello timeout");
+      }
+    }, _DevProxy.HELLO_TIMEOUT);
+    ws.on("message", (data) => {
+      let msg;
+      try {
+        msg = JSON.parse(data.toString());
+      } catch {
+        return;
+      }
+      if (!clientId) {
+        if (msg.type !== "hello") {
+          ws.close(4001, "Expected hello");
+          return;
+        }
+        clearTimeout(helloTimeout);
+        const mode = msg.mode === "iframe" ? "iframe" : "standalone";
+        const viewport = msg.viewport || { w: 0, h: 0 };
+        clientId = this.clients.add(ws, {
+          mode,
+          url: String(msg.url || ""),
+          viewport
+        });
+        ws.send(JSON.stringify({ type: "ack", clientId }));
+        return;
+      }
+      switch (msg.type) {
+        case "result":
+          this.handleCommandResult(msg);
+          break;
+        case "log":
+          if (Array.isArray(msg.entries)) {
+            appendBrowserLogEntries(msg.entries);
+          }
+          break;
+      }
+    });
+    ws.on("pong", () => {
+      if (clientId) this.clients.markAlive(clientId);
+    });
+    ws.on("close", () => {
+      clearTimeout(helloTimeout);
+      if (clientId) {
+        const client = this.clients.remove(clientId);
+        if (client?.activeCommandId) {
+          this.rejectPendingCommand(client.activeCommandId, "Browser disconnected during command execution");
+        }
+      }
+    });
+    ws.on("error", () => {
+    });
+  }
+  handleCommandResult(msg) {
+    const id = msg.id;
+    if (!id) {
+      log.warn("Browser command result received with no id");
+      return;
+    }
+    const pending2 = this.pendingResults.get(id);
+    if (pending2) {
+      log.info("Browser command result received", { id, stepCount: msg.steps?.length, duration: msg.duration });
+      clearTimeout(pending2.timeout);
+      this.pendingResults.delete(id);
+      const client = this.clients.findByCommandId(id);
+      if (client) client.activeCommandId = null;
+      pending2.resolve(msg);
+      this.drainCommandQueue();
+    } else {
+      log.warn("Browser command result received but no pending command found", { id, pendingIds: [...this.pendingResults.keys()] });
+    }
+  }
+  rejectPendingCommand(commandId, reason) {
+    const pending2 = this.pendingResults.get(commandId);
+    if (pending2) {
+      clearTimeout(pending2.timeout);
+      this.pendingResults.delete(commandId);
+      pending2.resolve({ id: commandId, steps: [], error: reason });
+      log.warn("Pending command rejected", { id: commandId, reason });
+      this.drainCommandQueue();
+    }
+  }
+  // ---------------------------------------------------------------------------
+  // Ping/pong liveness
+  // ---------------------------------------------------------------------------
+  startPingTimer() {
+    this.pingTimer = setInterval(() => {
+      const removed = this.clients.sweepDead();
+      for (const { activeCommandId } of removed) {
+        if (activeCommandId) {
+          this.rejectPendingCommand(activeCommandId, "Browser client timed out");
+        }
+      }
+      this.clients.pingAll();
+    }, _DevProxy.PING_INTERVAL);
+  }
+  stopPingTimer() {
+    if (this.pingTimer) {
+      clearInterval(this.pingTimer);
+      this.pingTimer = null;
+    }
+  }
+  // ---------------------------------------------------------------------------
   // Upstream health check
   // ---------------------------------------------------------------------------
   /**
@@ -1644,8 +1834,7 @@ var DevProxy = class _DevProxy {
       log.warn("Upstream dev server is down");
     } else if (!wasUp && this.upstreamUp) {
       log.info("Upstream dev server is back up, reloading browser");
-      this.dispatchBrowserCommand([{ command: "reload" }]).catch(() => {
-      });
+      this.broadcastToClients("reload");
     }
     const interval = this.upstreamUp ? _DevProxy.HEALTH_CHECK_INTERVAL : _DevProxy.HEALTH_CHECK_INTERVAL_DOWN;
     this.scheduleHealthCheck(interval);
@@ -1670,14 +1859,6 @@ var DevProxy = class _DevProxy {
         this.handleBrowserLogs(clientReq, clientRes);
         return;
       }
-      if (clientReq.url === "/__mindstudio_dev__/commands" && clientReq.method === "GET") {
-        this.handleGetCommand(clientReq, clientRes);
-        return;
-      }
-      if (clientReq.url === "/__mindstudio_dev__/results" && clientReq.method === "POST") {
-        this.handlePostResult(clientReq, clientRes);
-        return;
-      }
       if (clientReq.url?.startsWith("/__mindstudio_dev__/font-proxy?") && clientReq.method === "GET") {
         this.handleFontProxy(clientReq, clientRes);
         return;
@@ -1748,8 +1929,9 @@ var DevProxy = class _DevProxy {
     clientReq.pipe(upstreamReq);
   }
   // ---------------------------------------------------------------------------
-  // Browser agent endpoints
+  // Browser agent HTTP endpoints (fallbacks)
   // ---------------------------------------------------------------------------
+  /** Accept log entries via HTTP POST — used by sendBeacon on page unload. */
   handleBrowserLogs(clientReq, clientRes) {
     const chunks = [];
     clientReq.on("data", (chunk) => chunks.push(chunk));
@@ -1810,86 +1992,6 @@ var DevProxy = class _DevProxy {
       clientRes.end(`Font proxy error: ${err instanceof Error ? err.message : String(err)}`);
     }
   }
-  handleGetCommand(clientReq, clientRes) {
-    this.lastBrowserPoll = Date.now();
-    const command = this.commandQueue.shift();
-    if (command) {
-      log.info("Browser command dispatched to agent", { id: command.id, commands: command.steps.map((s) => s.command) });
-      clientRes.writeHead(200, {
-        ...this.corsHeaders(clientReq),
-        "content-type": "application/json",
-        "cache-control": "no-store"
-      });
-      clientRes.end(JSON.stringify(command));
-      return;
-    }
-    const timer = setTimeout(() => {
-      this.removeCommandWaiter(clientRes);
-      clientRes.writeHead(204, {
-        ...this.corsHeaders(clientReq),
-        "cache-control": "no-store"
-      });
-      clientRes.end();
-    }, 25e3);
-    this.commandWaiters.push({ req: clientReq, res: clientRes, timer });
-    clientReq.on("close", () => {
-      this.removeCommandWaiter(clientRes);
-    });
-  }
-  /**
-   * Flush a queued command to a waiting long-poll connection, if any.
-   */
-  flushCommandToWaiter() {
-    while (this.commandWaiters.length > 0 && this.commandQueue.length > 0) {
-      const waiter = this.commandWaiters.shift();
-      clearTimeout(waiter.timer);
-      if (waiter.res.writableEnded) continue;
-      const command = this.commandQueue.shift();
-      this.lastBrowserPoll = Date.now();
-      log.info("Browser command dispatched to agent", { id: command.id, commands: command.steps.map((s) => s.command) });
-      waiter.res.writeHead(200, {
-        ...this.corsHeaders(waiter.req),
-        "content-type": "application/json",
-        "cache-control": "no-store"
-      });
-      waiter.res.end(JSON.stringify(command));
-      return;
-    }
-  }
-  removeCommandWaiter(res) {
-    const idx = this.commandWaiters.findIndex((w) => w.res === res);
-    if (idx !== -1) {
-      clearTimeout(this.commandWaiters[idx].timer);
-      this.commandWaiters.splice(idx, 1);
-    }
-  }
-  handlePostResult(clientReq, clientRes) {
-    const chunks = [];
-    clientReq.on("data", (chunk) => chunks.push(chunk));
-    clientReq.on("end", () => {
-      try {
-        const body = Buffer.concat(chunks).toString("utf-8");
-        const result = JSON.parse(body);
-        if (result?.id) {
-          const pending2 = this.pendingResults.get(result.id);
-          if (pending2) {
-            log.info("Browser command result received", { id: result.id, stepCount: result.steps?.length, duration: result.duration });
-            clearTimeout(pending2.timeout);
-            this.pendingResults.delete(result.id);
-            pending2.resolve(result);
-          } else {
-            log.warn("Browser command result received but no pending command found", { id: result.id, pendingIds: [...this.pendingResults.keys()] });
-          }
-        } else {
-          log.warn("Browser command result received with no id", { bodyLength: body.length });
-        }
-      } catch (err) {
-        log.warn("Browser command result parse error", { error: err instanceof Error ? err.message : String(err) });
-      }
-      clientRes.writeHead(204, this.corsHeaders(clientReq));
-      clientRes.end();
-    });
-  }
   /**
    * Inject window.__MINDSTUDIO__ context and browser agent script tag into HTML.
    */
@@ -1905,8 +2007,11 @@ ${agentScript}`;
     }
     return injection + "\n" + html;
   }
-  handleUpgrade(clientReq, clientSocket, head) {
-    log.debug("Dev proxy WebSocket upgrade", { path: clientReq.url });
+  // ---------------------------------------------------------------------------
+  // Upstream WebSocket forwarding (HMR etc.)
+  // ---------------------------------------------------------------------------
+  handleUpstreamUpgrade(clientReq, clientSocket, head) {
+    log.debug("Dev proxy WebSocket upgrade (upstream)", { path: clientReq.url });
     const options = {
       hostname: "127.0.0.1",
       port: this.upstreamPort,
@@ -2189,4 +2294,4 @@ export {
   watchTableFiles,
   watchConfigFile
 };
-//# sourceMappingURL=chunk-VJTZSOKC.js.map
+//# sourceMappingURL=chunk-HZZVPY7J.js.map