@mindstudio-ai/local-model-tunnel 0.5.41 → 0.5.43

package/dist/{chunk-VO5KLV5S.js → chunk-UCESXK4F.js}

@@ -421,6 +421,45 @@ function logScenarioExecution(entry) {
     stats: entry.result?.stats ?? null
   });
 }
+function logMethodStart(requestId, sessionId, method, input) {
+  ndjsonLog.append({
+    ts: Date.now(),
+    level: "info",
+    module: "execution",
+    msg: "Method started",
+    type: "method-start",
+    requestId,
+    sessionId,
+    method,
+    input
+  });
+}
+function logMethodStdout(requestId, sessionId, method, lines) {
+  ndjsonLog.append({
+    ts: Date.now(),
+    level: "info",
+    module: "execution",
+    msg: "Method stdout",
+    type: "method-stdout",
+    requestId,
+    sessionId,
+    method,
+    stdout: lines
+  });
+}
+function logBackgroundStdout(requestId, sessionId, method, lines) {
+  ndjsonLog.append({
+    ts: Date.now(),
+    level: "info",
+    module: "execution",
+    msg: "Background stdout",
+    type: "method-background-stdout",
+    requestId,
+    sessionId,
+    method,
+    stdout: lines
+  });
+}
 function closeRequestLog() {
   ndjsonLog.close();
 }
@@ -582,6 +621,7 @@ function findNearestNodeModules(startDir) {
 // src/dev/execution/executor.ts
 import { fork } from "child_process";
 import { writeFile, unlink as unlink2 } from "fs/promises";
+import { readFileSync } from "fs";
 import { join as join4 } from "path";
 import { tmpdir } from "os";
 import { randomBytes } from "crypto";
@@ -589,9 +629,10 @@ var EXECUTION_TIMEOUT_MS = 30 * 60 * 1e3;
 var worker = null;
 var workerScriptPath = null;
 var workerProjectRoot = null;
+var workerSupportsAls = false;
 var pending = /* @__PURE__ */ new Map();
-function buildWorkerScript() {
-  return `
+var requestMeta = /* @__PURE__ */ new Map();
+var SERIALIZE_ERROR_FN = `
 function serializeError(err) {
   if (!err) return { message: 'Unknown error' };
 
@@ -626,14 +667,136 @@ function serializeError(err) {
 
   return serialized;
 }
+`;
+function buildAlsWorkerScript() {
+  return `
+import { AsyncLocalStorage } from 'node:async_hooks';
+import { format } from 'node:util';
+import { runWithContext } from '@mindstudio-ai/agent';
+
+${SERIALIZE_ERROR_FN}
+
+// Per-request console capture via AsyncLocalStorage
+const consoleAls = new AsyncLocalStorage();
+const _origLog = console.log;
+const _origWarn = console.warn;
+const _origError = console.error;
+
+console.log = (...args) => {
+  const stdout = consoleAls.getStore();
+  if (stdout) stdout.push(format(...args));
+  _origLog(...args);
+};
+console.warn = (...args) => {
+  const stdout = consoleAls.getStore();
+  if (stdout) stdout.push(format(...args));
+  _origWarn(...args);
+};
+console.error = (...args) => {
+  const stdout = consoleAls.getStore();
+  if (stdout) stdout.push(format(...args));
+  _origError(...args);
+};
+
+// Track secret keys so we can clean up between requests
+let _activeSecretKeys = [];
+
+process.on('message', async (msg) => {
+  const { id, transpiledPath, methodExport, input, auth, databases, authorizationToken, apiBaseUrl, streamId, secrets } = msg;
+
+  // Apply per-request secrets to process.env (clean up previous first)
+  for (const key of _activeSecretKeys) delete process.env[key];
+  _activeSecretKeys = secrets ? Object.keys(secrets) : [];
+  if (secrets) Object.assign(process.env, secrets);
+
+  const ctx = {
+    callbackToken: authorizationToken,
+    remoteHostname: apiBaseUrl,
+    auth: auth ?? { userId: null, roleAssignments: [] },
+    databases: databases ?? [],
+    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;
+
+  process.send({ type: 'start', id });
+
+  const startTime = Date.now();
+
+  try {
+    const returnValue = await consoleAls.run(stdout, () =>
+      runWithContext(ctx, async () => {
+        const mod = await import(transpiledPath + '?t=' + Date.now());
+        const fn = mod[methodExport];
+        if (typeof fn !== 'function') {
+          throw new Error(methodExport + ' is not a function (got ' + typeof fn + ')');
+        }
+        return fn(input);
+      }),
+    );
+    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;
+    }
+
+    done = true;
+    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;
+    }
+
+    done = true;
+    process.send({ id, success: false, error: serializeError(err), stats });
+  }
+});
+
+// Signal ready
+process.send({ type: 'ready' });
+`;
+}
+function buildLegacyWorkerScript() {
+  return `
+${SERIALIZE_ERROR_FN}
 
 // Save original console methods so we can restore after each request
 const _origLog = console.log;
 const _origWarn = console.warn;
 const _origError = console.error;
 
+// Track secret keys so we can clean up between requests
+let _activeSecretKeys = [];
+
 process.on('message', async (msg) => {
-  const { id, transpiledPath, methodExport, input, auth, databases, authorizationToken, apiBaseUrl, streamId } = msg;
+  const { id, transpiledPath, methodExport, input, auth, databases, authorizationToken, apiBaseUrl, streamId, secrets } = msg;
 
   // Update per-request env vars
   process.env.CALLBACK_TOKEN = authorizationToken;
@@ -641,6 +804,11 @@ process.on('message', async (msg) => {
   if (streamId) process.env.STREAM_ID = streamId;
   else delete process.env.STREAM_ID;
 
+  // Apply per-request secrets to process.env (clean up previous first)
+  for (const key of _activeSecretKeys) delete process.env[key];
+  _activeSecretKeys = secrets ? Object.keys(secrets) : [];
+  if (secrets) Object.assign(process.env, secrets);
+
   // Update global context
   global.ai = { auth, databases };
 
@@ -677,6 +845,17 @@ 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;
+  }
+}
 async function ensureWorker(projectRoot) {
   if (worker?.connected && workerProjectRoot === projectRoot) {
     return worker;
@@ -695,14 +874,17 @@ async function ensureWorker(projectRoot) {
     });
     workerScriptPath = null;
   }
+  workerSupportsAls = detectAlsSupport(projectRoot);
+  log.info("executor", "SDK context support", { als: workerSupportsAls });
   const scriptPath = join4(
     tmpdir(),
     `ms-dev-worker-${randomBytes(4).toString("hex")}.mjs`
   );
-  await writeFile(scriptPath, buildWorkerScript(), "utf-8");
+  const script = workerSupportsAls ? buildAlsWorkerScript() : buildLegacyWorkerScript();
+  await writeFile(scriptPath, script, "utf-8");
   workerScriptPath = scriptPath;
   workerProjectRoot = projectRoot;
-  log.debug("executor", "Spawning method execution process", { cwd: projectRoot, scriptPath });
+  log.debug("executor", "Spawning method execution process", { cwd: projectRoot, scriptPath, als: workerSupportsAls });
   const child = fork(scriptPath, [], {
     cwd: projectRoot,
     stdio: ["ignore", "pipe", "pipe", "ipc"],
@@ -721,6 +903,21 @@ async function ensureWorker(projectRoot) {
   });
   child.on("message", (msg) => {
     if (!msg?.id) return;
+    const meta = requestMeta.get(msg.id);
+    switch (msg.type) {
+      case "start":
+        if (meta) logMethodStart(msg.id, meta.sessionId, meta.method, meta.input);
+        return;
+      case "stdout":
+        if (meta && msg.lines?.length) logMethodStdout(msg.id, meta.sessionId, meta.method, msg.lines);
+        return;
+      case "background-stdout":
+        if (meta && msg.lines?.length) logBackgroundStdout(msg.id, meta.sessionId, meta.method, msg.lines);
+        return;
+      case "stdout-end":
+        requestMeta.delete(msg.id);
+        return;
+    }
     const req = pending.get(msg.id);
     if (!req) return;
     pending.delete(msg.id);
@@ -752,6 +949,9 @@ function enqueue(fn) {
   return task;
 }
 function executeMethod(opts) {
+  if (workerSupportsAls) {
+    return executeMethodInWorker(opts);
+  }
   return enqueue(() => executeMethodInWorker(opts));
 }
 async function executeMethodInWorker(opts) {
@@ -768,6 +968,9 @@ async function executeMethodInWorker(opts) {
       });
     }, EXECUTION_TIMEOUT_MS);
     pending.set(id, { resolve: resolve2, timer });
+    if (opts.sessionId) {
+      requestMeta.set(id, { sessionId: opts.sessionId, method: opts.methodExport, input: opts.input });
+    }
     w.send({
       id,
       transpiledPath: opts.transpiledPath,
@@ -777,7 +980,8 @@ async function executeMethodInWorker(opts) {
       databases: opts.databases,
       authorizationToken: opts.authorizationToken,
       apiBaseUrl: opts.apiBaseUrl,
-      streamId: opts.streamId
+      streamId: opts.streamId,
+      secrets: opts.secrets
     });
   });
 }
@@ -793,10 +997,12 @@ async function cleanupWorker() {
     workerScriptPath = null;
   }
   workerProjectRoot = null;
+  workerSupportsAls = false;
   for (const [, req] of pending) {
     clearTimeout(req.timer);
   }
   pending.clear();
+  requestMeta.clear();
   queueTail = Promise.resolve();
 }
 
@@ -961,6 +1167,8 @@ async function disconnectHeartbeat() {
 }
 
 // src/dev/execution/runner.ts
+import { readFileSync as readFileSync3 } from "fs";
+import { join as join6 } from "path";
 import { randomBytes as randomBytes2 } from "crypto";
 
 // src/dev/execution/format-error.ts
@@ -988,7 +1196,7 @@ function formatErrorForDisplay(error) {
 }
 
 // src/dev/execution/agent-config.ts
-import { readFileSync } from "fs";
+import { readFileSync as readFileSync2 } from "fs";
 import { join as join5, dirname as dirname2 } from "path";
 function readAgentConfig(projectRoot, appConfig) {
   const agentInterface = appConfig.interfaces.find(
@@ -1000,7 +1208,7 @@ function readAgentConfig(projectRoot, appConfig) {
   const configPath = join5(projectRoot, agentInterface.path);
   let raw;
   try {
-    raw = readFileSync(configPath, "utf-8");
+    raw = readFileSync2(configPath, "utf-8");
   } catch {
     throw new Error(
       `Agent config not found at ${agentInterface.path} \u2014 run your build command`
@@ -1012,7 +1220,7 @@ function readAgentConfig(projectRoot, appConfig) {
   const systemPromptPath = join5(agentDir, config2.systemPrompt);
   let systemPrompt;
   try {
-    systemPrompt = readFileSync(systemPromptPath, "utf-8");
+    systemPrompt = readFileSync2(systemPromptPath, "utf-8");
   } catch {
     throw new Error(
       `Agent system prompt not found at ${config2.systemPrompt} \u2014 run your build command`
@@ -1023,7 +1231,7 @@ function readAgentConfig(projectRoot, appConfig) {
       const descPath = join5(agentDir, tool.description);
       let description;
       try {
-        description = readFileSync(descPath, "utf-8");
+        description = readFileSync2(descPath, "utf-8");
       } catch {
         throw new Error(
           `Agent tool description not found at ${tool.description} for method "${tool.method}" \u2014 run your build command`
@@ -1168,7 +1376,8 @@ var DevRunner = class {
         databases: this.session.databases,
         authorizationToken,
         apiBaseUrl: getApiBaseUrl(),
-        projectRoot: this.projectRoot
+        projectRoot: this.projectRoot,
+        sessionId: this.session.sessionId
       });
       const duration = Date.now() - startTime;
       if (result.success) {
@@ -1246,7 +1455,8 @@ var DevRunner = class {
         databases: this.session.databases,
         authorizationToken,
         apiBaseUrl: getApiBaseUrl(),
-        projectRoot: this.projectRoot
+        projectRoot: this.projectRoot,
+        sessionId: this.session.sessionId
       });
       if (!result.success) {
         const error = result.error?.message ?? "Scenario seed failed";
@@ -1345,6 +1555,10 @@ var DevRunner = class {
       await this.handleGetAuthConfig(request);
       return;
     }
+    if (request.type === "get-api-config") {
+      await this.handleGetApiConfig(request);
+      return;
+    }
     const startTime = Date.now();
     const method = this.appConfig?.methods.find((m) => m.id === request.methodId);
     if (!method) {
@@ -1387,7 +1601,9 @@ var DevRunner = class {
         authorizationToken: request.authorizationToken,
         apiBaseUrl: getApiBaseUrl(),
         projectRoot: this.projectRoot,
-        streamId: request.streamId
+        sessionId: this.session.sessionId,
+        streamId: request.streamId,
+        secrets: request.secrets
       });
       const t2 = Date.now();
       const devResult = {
@@ -1555,6 +1771,51 @@ var DevRunner = class {
       }
     }
   }
+  async handleGetApiConfig(request) {
+    log.info("runner", "API config requested", { requestId: request.requestId, sessionId: this.session.sessionId });
+    try {
+      const apiInterface = this.appConfig?.interfaces.find(
+        (i) => i.type === "api" && i.enabled !== false
+      );
+      if (!apiInterface) {
+        throw new Error("No API interface config found");
+      }
+      const apiJsonPath = join6(this.projectRoot, apiInterface.path);
+      const raw = readFileSync3(apiJsonPath, "utf-8");
+      const parsed = JSON.parse(raw);
+      if (!parsed.api) {
+        throw new Error("No API interface config found");
+      }
+      await submitDevResult(
+        this.appId,
+        this.session.sessionId,
+        request.requestId,
+        {
+          type: "get-api-config",
+          success: true,
+          output: parsed.api
+        }
+      );
+      log.info("runner", "API config sent", { requestId: request.requestId });
+    } catch (err) {
+      const message = err instanceof Error ? err.message : "Unknown error";
+      log.error("runner", "API config failed", { requestId: request.requestId, error: message });
+      try {
+        await submitDevResult(
+          this.appId,
+          this.session.sessionId,
+          request.requestId,
+          {
+            type: "get-api-config",
+            success: false,
+            error: { message }
+          }
+        );
+      } catch (submitErr) {
+        log.error("runner", "Failed to report API config error to platform", { error: submitErr instanceof Error ? submitErr.message : String(submitErr) });
+      }
+    }
+  }
   /**
    * Attempt to refresh expired auth credentials via the device auth flow.
    * Opens the browser for the user to re-authorize, polls for the new token.
@@ -2252,6 +2513,9 @@ var DevProxy = class _DevProxy {
     };
     delete headers["connection"];
     delete headers["accept-encoding"];
+    if (originalPath.startsWith("/_/api/") && this.clientContext.releaseId) {
+      headers["x-dev-session"] = this.clientContext.releaseId;
+    }
     const proxyReq = httpModule.request(
       {
         hostname: target.hostname,
@@ -2669,13 +2933,13 @@ ${agentScript}`;
 };
 
 // src/dev/config/app-config.ts
-import { readFileSync as readFileSync2, existsSync as existsSync2 } from "fs";
-import { join as join6, dirname as dirname3 } from "path";
+import { readFileSync as readFileSync4, existsSync as existsSync2 } from "fs";
+import { join as join7, dirname as dirname3 } from "path";
 function detectAppConfig(cwd = process.cwd()) {
-  const appJsonPath = join6(cwd, "mindstudio.json");
+  const appJsonPath = join7(cwd, "mindstudio.json");
   if (!existsSync2(appJsonPath)) return null;
   try {
-    const raw = readFileSync2(appJsonPath, "utf-8");
+    const raw = readFileSync4(appJsonPath, "utf-8");
     const parsed = JSON.parse(raw);
     if (!parsed.name || !Array.isArray(parsed.methods)) {
       return null;
@@ -2712,12 +2976,12 @@ function getWebInterfaceConfig(appConfig, cwd = process.cwd()) {
   if (!webInterface) {
     return null;
   }
-  const configPath = join6(cwd, webInterface.path);
+  const configPath = join7(cwd, webInterface.path);
   if (!existsSync2(configPath)) {
     return null;
   }
   try {
-    const raw = readFileSync2(configPath, "utf-8");
+    const raw = readFileSync4(configPath, "utf-8");
     const parsed = JSON.parse(raw);
     const web = parsed.web;
     if (!web || typeof web !== "object") {
@@ -2738,18 +3002,18 @@ function getWebProjectDir(appConfig, cwd = process.cwd()) {
   if (!webInterface) {
     return null;
   }
-  return dirname3(join6(cwd, webInterface.path));
+  return dirname3(join7(cwd, webInterface.path));
 }
 function readTableSources(appConfig, cwd = process.cwd()) {
   const results = [];
   for (const table of appConfig.tables) {
-    const filePath = join6(cwd, table.path);
+    const filePath = join7(cwd, table.path);
     if (!existsSync2(filePath)) {
       log.warn("config", "Table source file not found", { table: table.export, path: table.path });
       continue;
     }
     try {
-      const source = readFileSync2(filePath, "utf-8");
+      const source = readFileSync4(filePath, "utf-8");
       const name = table.export;
       results.push({ name, source });
     } catch (err) {
@@ -2767,9 +3031,9 @@ function findDirsNeedingInstall(appConfig, cwd = process.cwd()) {
     const firstMethodPath = appConfig.methods[0].path;
     const parts = firstMethodPath.split("/");
     for (let i = parts.length - 1; i >= 1; i--) {
-      const candidate = join6(cwd, ...parts.slice(0, i));
-      if (existsSync2(join6(candidate, "package.json"))) {
-        if (!existsSync2(join6(candidate, "node_modules"))) {
+      const candidate = join7(cwd, ...parts.slice(0, i));
+      if (existsSync2(join7(candidate, "package.json"))) {
+        if (!existsSync2(join7(candidate, "node_modules"))) {
           dirs.push(candidate);
         }
         break;
@@ -2777,8 +3041,8 @@ function findDirsNeedingInstall(appConfig, cwd = process.cwd()) {
     }
   }
   const webProjectDir = getWebProjectDir(appConfig, cwd);
-  if (webProjectDir && existsSync2(join6(webProjectDir, "package.json"))) {
-    if (!existsSync2(join6(webProjectDir, "node_modules"))) {
+  if (webProjectDir && existsSync2(join7(webProjectDir, "package.json"))) {
+    if (!existsSync2(join7(webProjectDir, "node_modules"))) {
       dirs.push(webProjectDir);
     }
   }
@@ -2807,11 +3071,11 @@ function detectGitBranch() {
 
 // src/dev/config/table-watcher.ts
 import { watch } from "chokidar";
-import { join as join7, dirname as dirname4, basename as basename2 } from "path";
+import { join as join8, dirname as dirname4, basename as basename2 } from "path";
 function watchTableFiles(tables, cwd, onChanged) {
   if (tables.length === 0) return () => {
   };
-  const filePaths = tables.map((t) => join7(cwd, t.path));
+  const filePaths = tables.map((t) => join8(cwd, t.path));
   let syncTimer;
   const watcher = watch(filePaths, {
     ignoreInitial: true,
@@ -2824,7 +3088,7 @@ function watchTableFiles(tables, cwd, onChanged) {
   });
   const dirToFiles = /* @__PURE__ */ new Map();
   for (const table of tables) {
-    const absPath = join7(cwd, table.path);
+    const absPath = join8(cwd, table.path);
     const dir = dirname4(absPath);
     const file = basename2(absPath);
     if (!dirToFiles.has(dir)) dirToFiles.set(dir, /* @__PURE__ */ new Set());
@@ -2842,9 +3106,9 @@ function watchTableFiles(tables, cwd, onChanged) {
 
 // src/dev/config/config-watcher.ts
 import { watch as watch2 } from "chokidar";
-import { join as join8 } from "path";
+import { join as join9 } from "path";
 function watchConfigFile(cwd, onChanged) {
-  const configPath = join8(cwd, "mindstudio.json");
+  const configPath = join9(cwd, "mindstudio.json");
   let debounceTimer;
   const watcher = watch2(configPath, {
     ignoreInitial: true,
@@ -2887,6 +3151,8 @@ export {
   getUploadUrl,
   createAuthSession,
   devRequestEvents,
+  initRequestLog,
+  closeRequestLog,
   pollForRequest,
   submitProgress,
   submitResult,
@@ -2897,8 +3163,6 @@ export {
   pollDeviceAuth,
   getEditorSessions,
   disconnectHeartbeat,
-  initRequestLog,
-  closeRequestLog,
   DevRunner,
   initBrowserLog,
   closeBrowserLog,
@@ -2913,4 +3177,4 @@ export {
   watchTableFiles,
   watchConfigFile
 };
-//# sourceMappingURL=chunk-VO5KLV5S.js.map
+//# sourceMappingURL=chunk-UCESXK4F.js.map