@mindstudio-ai/local-model-tunnel 0.5.48 → 0.5.50

package/dist/{chunk-XGPRYHAD.js → chunk-FEZRTRFM.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;
@@ -534,6 +540,7 @@ import { build } from "esbuild";
 var Transpiler = class {
   projectRoot;
   outputFiles = /* @__PURE__ */ new Set();
+  outDir = null;
   constructor(projectRoot) {
     this.projectRoot = projectRoot;
     this.cleanupOrphans();
@@ -564,6 +571,7 @@ var Transpiler = class {
     }
     const outDir = join3(nodeModulesDir, ".cache", "mindstudio-dev");
     await mkdir(outDir, { recursive: true });
+    this.outDir = outDir;
     const outfile = join3(outDir, `${name}.__ms_dev__.mjs`);
     await build({
       entryPoints: [absolutePath],
@@ -580,6 +588,15 @@ var Transpiler = class {
     log.info("transpiler", "Method transpiled", { duration: Date.now() - start, methodPath, outfile });
     return outfile;
   }
+  /**
+   * Get the output directory where transpiled files and the worker script
+   * are written. Returns null if no method has been transpiled yet.
+   * This is inside node_modules/.cache/mindstudio-dev/ — Node's module
+   * resolution can find @mindstudio-ai/agent from here.
+   */
+  getOutputDir() {
+    return this.outDir;
+  }
   /**
    * Clean up all transpiled output files.
    */
@@ -620,9 +637,9 @@ function findNearestNodeModules(startDir) {
 
 // src/dev/execution/executor.ts
 import { fork } from "child_process";
-import { writeFile, unlink as unlink2 } from "fs/promises";
+import { writeFile, unlink as unlink2, mkdir as mkdir2 } from "fs/promises";
 import { readFileSync } from "fs";
-import { join as join4 } from "path";
+import { join as join4, dirname as dirname2 } from "path";
 import { tmpdir } from "os";
 import { randomBytes } from "crypto";
 var EXECUTION_TIMEOUT_MS = 30 * 60 * 1e3;
@@ -701,6 +718,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 +762,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 +783,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 });
   }
 });
@@ -845,18 +871,24 @@ process.on('message', async (msg) => {
 process.send({ type: 'ready' });
 `;
 }
-function detectAlsSupport(projectRoot) {
-  try {
-    const pkgPath = join4(projectRoot, "node_modules", "@mindstudio-ai", "agent", "package.json");
-    const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
-    const parts = (pkg.version || "").split(".").map(Number);
-    const [major = 0, minor = 0, patch = 0] = parts;
-    return major > 0 || minor > 1 || minor === 1 && patch >= 46;
-  } catch {
-    return false;
+function detectAlsSupport(scriptDir) {
+  let dir = scriptDir;
+  while (true) {
+    const candidate = join4(dir, "node_modules", "@mindstudio-ai", "agent", "package.json");
+    try {
+      const pkg = JSON.parse(readFileSync(candidate, "utf-8"));
+      const parts = (pkg.version || "").split(".").map(Number);
+      const [major = 0, minor = 0, patch = 0] = parts;
+      return major > 0 || minor > 1 || minor === 1 && patch >= 46;
+    } catch {
+    }
+    const parent = join4(dir, "..");
+    if (parent === dir) break;
+    dir = parent;
   }
+  return false;
 }
-async function ensureWorker(projectRoot) {
+async function ensureWorker(projectRoot, scriptDir) {
   if (worker?.connected && workerProjectRoot === projectRoot) {
     return worker;
   }
@@ -874,10 +906,14 @@ async function ensureWorker(projectRoot) {
     });
     workerScriptPath = null;
   }
-  workerSupportsAls = detectAlsSupport(projectRoot);
-  log.info("executor", "SDK context support", { als: workerSupportsAls });
+  workerSupportsAls = scriptDir ? detectAlsSupport(scriptDir) : false;
+  log.info("executor", "SDK context support", { als: workerSupportsAls, scriptDir: scriptDir ?? null });
+  const workerDir = workerSupportsAls && scriptDir ? scriptDir : tmpdir();
+  if (workerDir !== tmpdir()) {
+    await mkdir2(workerDir, { recursive: true });
+  }
   const scriptPath = join4(
-    tmpdir(),
+    workerDir,
     `ms-dev-worker-${randomBytes(4).toString("hex")}.mjs`
   );
   const script = workerSupportsAls ? buildAlsWorkerScript() : buildLegacyWorkerScript();
@@ -955,8 +991,8 @@ function executeMethod(opts) {
   return enqueue(() => executeMethodInWorker(opts));
 }
 async function executeMethodInWorker(opts) {
-  const w = await ensureWorker(opts.projectRoot);
-  const id = randomBytes(8).toString("hex");
+  const w = await ensureWorker(opts.projectRoot, dirname2(opts.transpiledPath));
+  const id = opts.requestId;
   log.debug("executor", "Sending method to execution process", { id, methodExport: opts.methodExport });
   return new Promise((resolve3) => {
     const timer = setTimeout(() => {
@@ -1195,7 +1231,7 @@ function formatErrorForDisplay(error) {
 
 // src/dev/interfaces/agent-config.ts
 import { readFileSync as readFileSync4 } from "fs";
-import { join as join6, dirname as dirname3 } from "path";
+import { join as join6, dirname as dirname4 } from "path";
 
 // src/dev/interfaces/schema/extract.ts
 import ts3 from "typescript";
@@ -1204,7 +1240,7 @@ import { readFileSync as readFileSync3 } from "fs";
 // src/dev/interfaces/schema/type-map.ts
 import ts from "typescript";
 import { readFileSync as readFileSync2 } from "fs";
-import { dirname as dirname2 } from "path";
+import { dirname as dirname3 } from "path";
 
 // src/dev/interfaces/schema/resolve-import.ts
 import { existsSync as existsSync2 } from "fs";
@@ -1241,7 +1277,7 @@ function collectTypeMap(filePath) {
 function collectFromFile(sourceFile, filePath, typeMap, visited) {
   if (visited.has(filePath)) return;
   visited.add(filePath);
-  const dir = dirname2(filePath);
+  const dir = dirname3(filePath);
   for (const stmt of sourceFile.statements) {
     if (ts.isTypeAliasDeclaration(stmt)) {
       typeMap.set(stmt.name.text, stmt.type);
@@ -1410,7 +1446,7 @@ function readAgentConfig(projectRoot, appConfig) {
   }
   const parsed = JSON.parse(raw);
   const config2 = parsed.agent ?? parsed;
-  const agentDir = dirname3(configPath);
+  const agentDir = dirname4(configPath);
   const systemPromptPath = join6(agentDir, config2.systemPrompt);
   let systemPrompt;
   try {
@@ -1502,6 +1538,9 @@ var DevRunner = class {
     this.projectRoot = projectRoot;
     this.startOpts = startOpts;
   }
+  appId;
+  projectRoot;
+  startOpts;
   isRunning = false;
   session = null;
   transpiler = null;
@@ -1612,6 +1651,7 @@ var DevRunner = class {
         roleAssignments: roles.map((roleName) => ({ userId, roleName }))
       } : { ...this.session.auth, userId };
       const result = await executeMethod({
+        requestId,
         transpiledPath,
         methodExport: opts.methodExport,
         input: opts.input,
@@ -1677,9 +1717,10 @@ var DevRunner = class {
     if (!this.session || !this.transpiler) {
       return { success: false, databases: [], error: "Session not started" };
     }
+    const requestId = randomBytes2(8).toString("hex");
     const startTime = Date.now();
     const scenarioName = scenario.name ?? scenario.export;
-    log.info("runner", "Scenario starting", { id: scenario.id, name: scenarioName });
+    log.info("runner", "Scenario starting", { requestId, id: scenario.id, name: scenarioName });
     try {
       if (!opts?.skipTruncate) {
         log.debug("runner", "Resetting database for scenario");
@@ -1691,6 +1732,7 @@ var DevRunner = class {
       const authorizationToken = await fetchCallbackToken(this.appId, this.session.sessionId);
       log.debug("runner", "Running scenario seed function", { export: scenario.export });
       const result = await executeMethod({
+        requestId,
         transpiledPath,
         methodExport: scenario.export,
         input: {},
@@ -1828,6 +1870,7 @@ var DevRunner = class {
         roleAssignments: overrideRoles ? overrideRoles.map((roleName) => ({ userId, roleName })) : request.roleAssignments ?? []
       };
       const result = await executeMethod({
+        requestId: request.requestId,
         transpiledPath,
         methodExport: method.export,
         input: request.input,
@@ -2160,6 +2203,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) {
@@ -2169,6 +2221,11 @@ var DevProxy = class _DevProxy {
     this.bindAddress = bindAddress;
     this.browserAgentUrl = browserAgentUrl;
   }
+  upstreamPort;
+  clientContext;
+  appId;
+  bindAddress;
+  browserAgentUrl;
   server = null;
   proxyPort = null;
   wss = null;
@@ -2202,9 +2259,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");
@@ -2229,6 +2284,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;
@@ -2250,10 +2312,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 }));
@@ -2265,7 +2327,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"));
       }
     }
   }
@@ -2358,13 +2420,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;
   }
@@ -2469,13 +2531,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);
         }
       }
     });
@@ -2509,13 +2572,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();
     }
   }
@@ -2529,7 +2592,7 @@ var DevProxy = class _DevProxy {
         if (activeCommandId) {
           this.rejectPendingCommand(
             activeCommandId,
-            "Browser client timed out"
+            new CommandError("Browser client timed out", "BROWSER_DISCONNECTED")
           );
         }
       }
@@ -3087,7 +3150,7 @@ ${agentScript}`;
 
 // src/dev/config/app-config.ts
 import { readFileSync as readFileSync6, existsSync as existsSync3 } from "fs";
-import { join as join8, dirname as dirname4 } from "path";
+import { join as join8, dirname as dirname5 } from "path";
 function detectAppConfig(cwd = process.cwd()) {
   const appJsonPath = join8(cwd, "mindstudio.json");
   if (!existsSync3(appJsonPath)) return null;
@@ -3155,7 +3218,7 @@ function getWebProjectDir(appConfig, cwd = process.cwd()) {
   if (!webInterface) {
     return null;
   }
-  return dirname4(join8(cwd, webInterface.path));
+  return dirname5(join8(cwd, webInterface.path));
 }
 function readTableSources(appConfig, cwd = process.cwd()) {
   const results = [];
@@ -3224,7 +3287,7 @@ function detectGitBranch() {
 
 // src/dev/config/table-watcher.ts
 import { watch } from "chokidar";
-import { join as join9, dirname as dirname5, basename as basename2 } from "path";
+import { join as join9, dirname as dirname6, basename as basename2 } from "path";
 function watchTableFiles(tables, cwd, onChanged) {
   if (tables.length === 0) return () => {
   };
@@ -3242,7 +3305,7 @@ function watchTableFiles(tables, cwd, onChanged) {
   const dirToFiles = /* @__PURE__ */ new Map();
   for (const table of tables) {
     const absPath = join9(cwd, table.path);
-    const dir = dirname5(absPath);
+    const dir = dirname6(absPath);
     const file = basename2(absPath);
     if (!dirToFiles.has(dir)) dirToFiles.set(dir, /* @__PURE__ */ new Set());
     dirToFiles.get(dir).add(file);
@@ -3319,6 +3382,7 @@ export {
   DevRunner,
   initBrowserLog,
   closeBrowserLog,
+  CommandError,
   DevProxy,
   detectAppConfig,
   getWebInterfaceConfig,
@@ -3330,4 +3394,4 @@ export {
   watchTableFiles,
   watchConfigFile
 };
-//# sourceMappingURL=chunk-XGPRYHAD.js.map
+//# sourceMappingURL=chunk-FEZRTRFM.js.map