@mindstudio-ai/local-model-tunnel 0.5.47 → 0.5.49

package/dist/{chunk-UT7QCCAJ.js → chunk-UFGZOWZ6.js}

@@ -274,6 +274,7 @@ var ApiError = class extends Error {
     this.statusCode = statusCode;
     this.name = "ApiError";
   }
+  statusCode;
 };
 var DevPollError = class extends Error {
   constructor(message, statusCode) {
@@ -281,6 +282,7 @@ var DevPollError = class extends Error {
     this.statusCode = statusCode;
     this.name = "DevPollError";
   }
+  statusCode;
 };
 
 // src/dev/logging/ndjson-log.ts
@@ -293,6 +295,10 @@ var NdjsonLog = class {
     this.keepLines = keepLines;
     this.maxBytes = maxBytes;
   }
+  filename;
+  maxLines;
+  keepLines;
+  maxBytes;
   fd = null;
   logPath = null;
   lineCount = 0;
@@ -701,6 +707,34 @@ console.error = (...args) => {
 // Track secret keys so we can clean up between requests
 let _activeSecretKeys = [];
 
+// ---------------------------------------------------------------------------
+// Single flush loop for all active requests
+// ---------------------------------------------------------------------------
+// One interval sweeps all tracked requests instead of one interval per
+// request. This stays efficient even with thousands of concurrent requests.
+
+const BACKGROUND_TIMEOUT = 30 * 60 * 1000; // 30 minutes after method returns
+
+const activeRequests = new Map();
+
+setInterval(() => {
+  const now = Date.now();
+  for (const [id, req] of activeRequests) {
+    if (req.stdout.length > req.flushed) {
+      const lines = req.stdout.slice(req.flushed);
+      req.flushed = req.stdout.length;
+      try {
+        process.send({ type: req.done ? 'background-stdout' : 'stdout', id, lines });
+      } catch {}
+    } else if (req.done && now - req.doneAt > BACKGROUND_TIMEOUT) {
+      activeRequests.delete(id);
+      try { process.send({ type: 'stdout-end', id }); } catch {}
+    }
+  }
+}, 1000);
+
+// ---------------------------------------------------------------------------
+
 process.on('message', async (msg) => {
   const { id, transpiledPath, methodExport, input, auth, databases, authorizationToken, apiBaseUrl, streamId, secrets } = msg;
 
@@ -717,36 +751,15 @@ process.on('message', async (msg) => {
     streamId: streamId ?? undefined,
   };
 
-  const stdout = [];
-  let flushed = 0;
-  let done = false;
-
-  // Flush new stdout lines every 1s while the method is running.
-  // After the method returns, switches to background-stdout type.
-  const flushInterval = setInterval(() => {
-    if (stdout.length > flushed) {
-      const lines = stdout.slice(flushed);
-      flushed = stdout.length;
-      try {
-        process.send({ type: done ? 'background-stdout' : 'stdout', id, lines });
-      } catch {}
-      idleTicks = 0;
-    } else if (done) {
-      idleTicks++;
-      if (idleTicks >= 2) {
-        clearInterval(flushInterval);
-        try { process.send({ type: 'stdout-end', id }); } catch {}
-      }
-    }
-  }, 1000);
-  let idleTicks = 0;
+  const req = { stdout: [], flushed: 0, done: false, doneAt: 0 };
+  activeRequests.set(id, req);
 
   process.send({ type: 'start', id });
 
   const startTime = Date.now();
 
   try {
-    const returnValue = await consoleAls.run(stdout, () =>
+    const returnValue = await consoleAls.run(req.stdout, () =>
       runWithContext(ctx, async () => {
         const mod = await import(transpiledPath + '?t=' + Date.now());
         const fn = mod[methodExport];
@@ -759,22 +772,24 @@ process.on('message', async (msg) => {
     const stats = { memoryUsedBytes: process.memoryUsage().heapUsed, executionTimeMs: Date.now() - startTime };
 
     // Final flush of any remaining lines before sending result
-    if (stdout.length > flushed) {
-      try { process.send({ type: 'stdout', id, lines: stdout.slice(flushed) }); } catch {}
-      flushed = stdout.length;
+    if (req.stdout.length > req.flushed) {
+      try { process.send({ type: 'stdout', id, lines: req.stdout.slice(req.flushed) }); } catch {}
+      req.flushed = req.stdout.length;
     }
 
-    done = true;
+    req.done = true;
+    req.doneAt = Date.now();
     process.send({ id, success: true, output: returnValue, stats });
   } catch (err) {
     const stats = { memoryUsedBytes: process.memoryUsage().heapUsed, executionTimeMs: Date.now() - startTime };
 
-    if (stdout.length > flushed) {
-      try { process.send({ type: 'stdout', id, lines: stdout.slice(flushed) }); } catch {}
-      flushed = stdout.length;
+    if (req.stdout.length > req.flushed) {
+      try { process.send({ type: 'stdout', id, lines: req.stdout.slice(req.flushed) }); } catch {}
+      req.flushed = req.stdout.length;
     }
 
-    done = true;
+    req.done = true;
+    req.doneAt = Date.now();
     process.send({ id, success: false, error: serializeError(err), stats });
   }
 });
@@ -1502,6 +1517,9 @@ var DevRunner = class {
     this.projectRoot = projectRoot;
     this.startOpts = startOpts;
   }
+  appId;
+  projectRoot;
+  startOpts;
   isRunning = false;
   session = null;
   transpiler = null;
@@ -1530,6 +1548,7 @@ var DevRunner = class {
     }
     log.info("runner", "Dev session starting", { appId: this.appId, branch: this.startOpts.branch });
     const session = await startDevSession(this.appId, this.startOpts);
+    session.auth = { userId: null, roleAssignments: [] };
     this.session = session;
     this.transpiler = new Transpiler(this.projectRoot);
     this.isRunning = true;
@@ -2159,6 +2178,15 @@ var ClientRegistry = class {
   }
 };
 
+// src/dev/stdin-commands/types.ts
+var CommandError = class extends Error {
+  constructor(message, code) {
+    super(message);
+    this.code = code;
+  }
+  code;
+};
+
 // src/dev/proxy/proxy.ts
 var DevProxy = class _DevProxy {
   constructor(upstreamPort, clientContext, appId, bindAddress = "127.0.0.1", browserAgentUrl) {
@@ -2168,6 +2196,11 @@ var DevProxy = class _DevProxy {
     this.bindAddress = bindAddress;
     this.browserAgentUrl = browserAgentUrl;
   }
+  upstreamPort;
+  clientContext;
+  appId;
+  bindAddress;
+  browserAgentUrl;
   server = null;
   proxyPort = null;
   wss = null;
@@ -2201,9 +2234,7 @@ var DevProxy = class _DevProxy {
   dispatchBrowserCommand(steps, timeoutMs = 12e4) {
     if (!this.clients.hasConnected()) {
       return Promise.reject(
-        new Error(
-          "No browser connected, please refresh the MindStudio preview"
-        )
+        new CommandError("No browser connected", "NO_BROWSER")
       );
     }
     const id = randomBytes4(4).toString("hex");
@@ -2228,6 +2259,13 @@ var DevProxy = class _DevProxy {
    * Try to send the next queued command to an available client.
    */
   drainCommandQueue() {
+    if (!this.clients.hasConnected() && this.commandQueue.length > 0) {
+      const orphaned = this.commandQueue.splice(0);
+      for (const cmd of orphaned) {
+        cmd.reject(new CommandError("No browser connected", "NO_BROWSER"));
+      }
+      return;
+    }
     while (this.commandQueue.length > 0) {
       const target = this.clients.getCommandTarget();
       if (!target) break;
@@ -2249,10 +2287,10 @@ var DevProxy = class _DevProxy {
           id,
           pendingCount: this.pendingResults.size
         });
-        reject(new Error("Browser command timed out"));
+        reject(new CommandError("Browser command timed out", "BROWSER_TIMEOUT"));
         this.drainCommandQueue();
       }, timeoutMs);
-      this.pendingResults.set(id, { resolve: resolve3, timeout, clientId: target.id });
+      this.pendingResults.set(id, { resolve: resolve3, reject, timeout, clientId: target.id });
       target.activeCommandId = id;
       try {
         target.ws.send(JSON.stringify({ type: "command", id, steps }));
@@ -2264,7 +2302,7 @@ var DevProxy = class _DevProxy {
           id,
           clientId: target.id
         });
-        reject(new Error("Failed to send command to browser"));
+        reject(new CommandError("Failed to send command to browser", "BROWSER_SEND_FAILED"));
       }
     }
   }
@@ -2357,13 +2395,13 @@ var DevProxy = class _DevProxy {
       this.server = null;
       this.proxyPort = null;
     }
-    for (const [id, pending2] of this.pendingResults) {
+    for (const [, pending2] of this.pendingResults) {
       clearTimeout(pending2.timeout);
-      pending2.resolve({ id, steps: [], error: "Proxy stopped" });
+      pending2.reject(new CommandError("Proxy stopped", "INFRASTRUCTURE"));
     }
     this.pendingResults.clear();
     for (const queued of this.commandQueue) {
-      queued.reject(new Error("Proxy stopped"));
+      queued.reject(new CommandError("Proxy stopped", "INFRASTRUCTURE"));
     }
     this.commandQueue.length = 0;
   }
@@ -2468,13 +2506,14 @@ var DevProxy = class _DevProxy {
       if (clientId) {
         const client = this.clients.remove(clientId);
         if (client?.activeCommandId) {
-          log.debug(
-            "proxy",
-            "Browser disconnected with active command, keeping pending",
-            {
-              commandId: client.activeCommandId
+          const commandId = client.activeCommandId;
+          log.debug("proxy", "Browser disconnected with active command", { commandId });
+          setTimeout(() => {
+            if (this.pendingResults.has(commandId) && !this.clients.findByCommandId(commandId)) {
+              this.rejectPendingCommand(commandId, new CommandError("Browser disconnected", "BROWSER_DISCONNECTED"));
+              this.drainCommandQueue();
             }
-          );
+          }, 1e4);
         }
       }
     });
@@ -2508,13 +2547,13 @@ var DevProxy = class _DevProxy {
       );
     }
   }
-  rejectPendingCommand(commandId, reason) {
+  rejectPendingCommand(commandId, error) {
     const pending2 = this.pendingResults.get(commandId);
     if (pending2) {
       clearTimeout(pending2.timeout);
       this.pendingResults.delete(commandId);
-      pending2.resolve({ id: commandId, steps: [], error: reason });
-      log.warn("proxy", "Pending command rejected", { id: commandId, reason });
+      pending2.reject(error);
+      log.warn("proxy", "Pending command rejected", { id: commandId, code: error.code, reason: error.message });
       this.drainCommandQueue();
     }
   }
@@ -2528,7 +2567,7 @@ var DevProxy = class _DevProxy {
         if (activeCommandId) {
           this.rejectPendingCommand(
             activeCommandId,
-            "Browser client timed out"
+            new CommandError("Browser client timed out", "BROWSER_DISCONNECTED")
           );
         }
       }
@@ -3318,6 +3357,7 @@ export {
   DevRunner,
   initBrowserLog,
   closeBrowserLog,
+  CommandError,
   DevProxy,
   detectAppConfig,
   getWebInterfaceConfig,
@@ -3329,4 +3369,4 @@ export {
   watchTableFiles,
   watchConfigFile
 };
-//# sourceMappingURL=chunk-UT7QCCAJ.js.map
+//# sourceMappingURL=chunk-UFGZOWZ6.js.map