@mindstudio-ai/local-model-tunnel 0.5.25 → 0.5.27

package/dist/{chunk-VCBGX5ND.js → chunk-JRLMRABX.js}

@@ -88,6 +88,7 @@ function deleteLocalInterfacePath(key) {
 
 // src/dev/logging/logger.ts
 import fs from "fs";
+import { join } from "path";
 var LEVELS = {
   error: 0,
   warn: 1,
@@ -97,31 +98,28 @@ var LEVELS = {
 var currentLevel = LEVELS.error;
 var writeFn = () => {
 };
-function timestamp() {
-  return (/* @__PURE__ */ new Date()).toISOString();
-}
-function write(level, msg, data) {
+function write(level, module, msg, data) {
   if (LEVELS[level] > currentLevel) {
     return;
   }
-  const parts = [`[${timestamp()}]`, level.toUpperCase().padEnd(5), msg];
+  const entry = { ts: Date.now(), level, module, msg };
   if (data) {
-    parts.push(JSON.stringify(data));
+    Object.assign(entry, data);
   }
-  writeFn(parts.join(" "));
+  writeFn(JSON.stringify(entry));
 }
 var log = {
-  error(msg, data) {
-    write("error", msg, data);
+  error(module, msg, data) {
+    write("error", module, msg, data);
   },
-  warn(msg, data) {
-    write("warn", msg, data);
+  warn(module, msg, data) {
+    write("warn", module, msg, data);
   },
-  info(msg, data) {
-    write("info", msg, data);
+  info(module, msg, data) {
+    write("info", module, msg, data);
   },
-  debug(msg, data) {
-    write("debug", msg, data);
+  debug(module, msg, data) {
+    write("debug", module, msg, data);
   }
 };
 function initLoggerHeadless(level = "info") {
@@ -136,7 +134,9 @@ function initLoggerInteractive(level = "error") {
   writeFn = (line) => {
     try {
       if (fd === null) {
-        fd = fs.openSync(".mindstudio-dev.log", "a");
+        const logsDir = join(process.cwd(), ".logs");
+        fs.mkdirSync(logsDir, { recursive: true });
+        fd = fs.openSync(join(logsDir, "tunnel.ndjson"), "a");
       }
       fs.writeSync(fd, line + "\n");
     } catch {
@@ -162,7 +162,8 @@ function basePath(appId) {
 }
 async function apiRequest(method, url, headers, body) {
   const start = Date.now();
-  const logTag = `${method} ${url.replace(getApiBaseUrl(), "")}`;
+  const httpMethod = method;
+  const path2 = url.replace(getApiBaseUrl(), "").replace(/^\/_internal\/v2\/apps\/[^/]+\/dev/, "");
   const response = await fetch(url, {
     method,
     headers,
@@ -170,16 +171,16 @@ async function apiRequest(method, url, headers, body) {
   });
   const duration = Date.now() - start;
   if (response.status === 204) {
-    log.debug(`api ${logTag} \u2192 204 (${duration}ms)`);
+    log.debug("api", "Request complete", { method: httpMethod, path: path2, status: 204, duration });
     return null;
   }
   if (!response.ok) {
     const error = await response.text();
-    log.error(`api ${logTag} \u2192 ${response.status} (${duration}ms)`, { error });
-    throw new ApiError(`${logTag} failed: ${response.status} ${error}`, response.status);
+    log.error("api", "Request failed", { method: httpMethod, path: path2, status: response.status, duration, error });
+    throw new ApiError(`${httpMethod} ${path2} failed: ${response.status} ${error}`, response.status);
   }
   const data = await response.json();
-  log.info(`api ${logTag} \u2192 ${response.status} (${duration}ms)`);
+  log.info("api", "Request complete", { method: httpMethod, path: path2, status: response.status, duration });
   return data;
 }
 async function startDevSession(appId, opts) {
@@ -276,7 +277,7 @@ var DevPollError = class extends Error {
 
 // src/dev/logging/ndjson-log.ts
 import fs2 from "fs";
-import { join } from "path";
+import { join as join2 } from "path";
 var NdjsonLog = class {
   constructor(filename, maxLines = 500, keepLines = 300, maxBytes = 2 * 1024 * 1024) {
     this.filename = filename;
@@ -291,9 +292,9 @@ var NdjsonLog = class {
   init(projectRoot) {
     this.close();
     try {
-      const logsDir = join(projectRoot, ".logs");
+      const logsDir = join2(projectRoot, ".logs");
       fs2.mkdirSync(logsDir, { recursive: true });
-      this.logPath = join(logsDir, this.filename);
+      this.logPath = join2(logsDir, this.filename);
       if (fs2.existsSync(this.logPath)) {
         const content = fs2.readFileSync(this.logPath, "utf-8");
         this.lineCount = content.split("\n").filter((l) => l.trim()).length;
@@ -301,12 +302,12 @@ var NdjsonLog = class {
         this.lineCount = 0;
       }
       this.fd = fs2.openSync(this.logPath, "a");
-      log.info(`${this.filename} log initialized`, {
+      log.debug("logging", `${this.filename} log initialized`, {
         path: this.logPath,
         existingEntries: this.lineCount
       });
     } catch (err) {
-      log.warn(`Failed to initialize ${this.filename} log`, {
+      log.warn("logging", `Failed to initialize ${this.filename} log`, {
         error: err instanceof Error ? err.message : String(err)
       });
       this.fd = null;
@@ -320,10 +321,7 @@ var NdjsonLog = class {
       fs2.writeSync(this.fd, line);
       this.lineCount++;
       this.maybeRotate();
-    } catch (err) {
-      log.debug(`Failed to write ${this.filename} log entry`, {
-        error: err instanceof Error ? err.message : String(err)
-      });
+    } catch {
     }
   }
   close() {
@@ -355,11 +353,7 @@ var NdjsonLog = class {
       fs2.writeFileSync(this.logPath, kept.join("\n") + "\n", "utf-8");
       this.fd = fs2.openSync(this.logPath, "a");
       this.lineCount = kept.length;
-      log.debug(`${this.filename} log rotated`, { kept: this.lineCount });
-    } catch (err) {
-      log.debug(`${this.filename} log rotation failed`, {
-        error: err instanceof Error ? err.message : String(err)
-      });
+    } catch {
     } finally {
       this.rotating = false;
     }
@@ -373,8 +367,11 @@ function initRequestLog(projectRoot) {
 }
 function logMethodExecution(entry) {
   ndjsonLog.append({
+    ts: Date.now(),
+    level: "info",
+    module: "execution",
+    msg: entry.result.success ? "Method complete" : "Method failed",
     type: "method",
-    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
     requestId: entry.requestId,
     sessionId: entry.sessionId,
     method: entry.methodExport,
@@ -393,8 +390,11 @@ function logMethodExecution(entry) {
 }
 function logScenarioExecution(entry) {
   ndjsonLog.append({
+    ts: Date.now(),
+    level: "info",
+    module: "execution",
+    msg: entry.result?.success ?? false ? "Scenario complete" : "Scenario failed",
     type: "scenario",
-    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
     sessionId: entry.sessionId,
     scenario: {
       id: entry.scenario.id,
@@ -480,7 +480,7 @@ var devRequestEvents = new DevEventEmitter();
 // src/dev/execution/transpiler.ts
 import { unlink, mkdir, readdir } from "fs/promises";
 import { existsSync } from "fs";
-import { resolve, dirname, basename, join as join2 } from "path";
+import { resolve, dirname, basename, join as join3 } from "path";
 import { build } from "esbuild";
 var Transpiler = class {
   projectRoot;
@@ -506,18 +506,16 @@ var Transpiler = class {
     const start = Date.now();
     const absolutePath = resolve(this.projectRoot, methodPath);
     const name = basename(absolutePath).replace(/\.[^.]+$/, "");
-    log.debug("Transpiling method", { methodPath });
     const nodeModulesDir = findNearestNodeModules(dirname(absolutePath));
     if (!nodeModulesDir) {
-      log.error("Cannot find node_modules for method", { methodPath, searchStart: dirname(absolutePath) });
+      log.error("transpiler", "Cannot find node_modules for method", { methodPath, searchStart: dirname(absolutePath) });
       throw new Error(
         `No node_modules found near ${methodPath}. Run npm install first.`
       );
     }
-    log.debug("Found node_modules", { path: nodeModulesDir });
-    const outDir = join2(nodeModulesDir, ".cache", "mindstudio-dev");
+    const outDir = join3(nodeModulesDir, ".cache", "mindstudio-dev");
     await mkdir(outDir, { recursive: true });
-    const outfile = join2(outDir, `${name}.__ms_dev__.mjs`);
+    const outfile = join3(outDir, `${name}.__ms_dev__.mjs`);
     await build({
       entryPoints: [absolutePath],
       bundle: true,
@@ -530,14 +528,13 @@ var Transpiler = class {
       logLevel: "silent"
     });
     this.outputFiles.add(outfile);
-    log.info(`Method transpiled in ${Date.now() - start}ms`, { methodPath, outfile });
+    log.info("transpiler", "Method transpiled", { duration: Date.now() - start, methodPath, outfile });
     return outfile;
   }
   /**
    * Clean up all transpiled output files.
    */
   async cleanup() {
-    log.debug("Cleaning up transpiled files", { fileCount: this.outputFiles.size });
     for (const file of this.outputFiles) {
       await unlink(file).catch(() => {
       });
@@ -549,11 +546,10 @@ async function removeOrphanedDevFiles(dir) {
   const entries = await readdir(dir, { withFileTypes: true });
   for (const entry of entries) {
     if (entry.name === "node_modules" || entry.name === ".git") continue;
-    const fullPath = join2(dir, entry.name);
+    const fullPath = join3(dir, entry.name);
     if (entry.isDirectory()) {
       await removeOrphanedDevFiles(fullPath);
     } else if (entry.name.endsWith(".__ms_dev__.mjs")) {
-      log.debug("Removing orphaned transpiled file", { path: fullPath });
       await unlink(fullPath).catch(() => {
       });
     }
@@ -562,7 +558,7 @@ async function removeOrphanedDevFiles(dir) {
 function findNearestNodeModules(startDir) {
   let dir = startDir;
   while (true) {
-    const candidate = join2(dir, "node_modules");
+    const candidate = join3(dir, "node_modules");
     if (existsSync(candidate)) {
       return candidate;
     }
@@ -576,7 +572,7 @@ function findNearestNodeModules(startDir) {
 // src/dev/execution/executor.ts
 import { fork } from "child_process";
 import { writeFile, unlink as unlink2 } from "fs/promises";
-import { join as join3 } from "path";
+import { join as join4 } from "path";
 import { tmpdir } from "os";
 import { randomBytes } from "crypto";
 var EXECUTION_TIMEOUT_MS = 30 * 60 * 1e3;
@@ -675,6 +671,10 @@ async function ensureWorker(projectRoot) {
   if (worker?.connected && workerProjectRoot === projectRoot) {
     return worker;
   }
+  if (worker || workerProjectRoot) {
+    const reason = workerProjectRoot !== projectRoot ? "project-root-changed" : "disconnected";
+    log.info("executor", "Respawning worker process", { reason });
+  }
   if (worker) {
     worker.removeAllListeners();
     worker.kill();
@@ -685,14 +685,14 @@ async function ensureWorker(projectRoot) {
     });
     workerScriptPath = null;
   }
-  const scriptPath = join3(
+  const scriptPath = join4(
     tmpdir(),
     `ms-dev-worker-${randomBytes(4).toString("hex")}.mjs`
   );
   await writeFile(scriptPath, buildWorkerScript(), "utf-8");
   workerScriptPath = scriptPath;
   workerProjectRoot = projectRoot;
-  log.debug("Spawning method execution process", { cwd: projectRoot, scriptPath });
+  log.debug("executor", "Spawning method execution process", { cwd: projectRoot, scriptPath });
   const child = fork(scriptPath, [], {
     cwd: projectRoot,
     stdio: ["ignore", "pipe", "pipe", "ipc"],
@@ -718,7 +718,7 @@ async function ensureWorker(projectRoot) {
     req.resolve(msg);
   });
   child.on("exit", (code) => {
-    log.warn("Method execution process exited unexpectedly", { code });
+    log.warn("executor", "Method execution process exited unexpectedly", { code });
     for (const [id, req] of pending) {
       clearTimeout(req.timer);
       req.resolve({ success: false, error: { message: `Worker process exited with code ${code}` } });
@@ -728,23 +728,33 @@ async function ensureWorker(projectRoot) {
   });
   child.stderr?.on("data", (chunk) => {
     const text = chunk.toString().trim();
-    if (text) log.warn("Method process stderr", { text: text.slice(0, 500) });
+    if (text) log.warn("executor", "Method process stderr", { text: text.slice(0, 500) });
   });
   worker = child;
-  log.info("Method execution process ready", { pid: child.pid });
+  log.info("executor", "Method execution process ready", { pid: child.pid });
   return child;
 }
-async function executeMethod(opts) {
+var queueTail = Promise.resolve();
+function enqueue(fn) {
+  const task = queueTail.then(fn, fn);
+  queueTail = task.catch(() => {
+  });
+  return task;
+}
+function executeMethod(opts) {
+  return enqueue(() => executeMethodInWorker(opts));
+}
+async function executeMethodInWorker(opts) {
   const w = await ensureWorker(opts.projectRoot);
   const id = randomBytes(8).toString("hex");
-  log.debug("Sending method to execution process", { id, methodExport: opts.methodExport });
+  log.debug("executor", "Sending method to execution process", { id, methodExport: opts.methodExport });
   return new Promise((resolve2) => {
     const timer = setTimeout(() => {
       pending.delete(id);
-      log.warn("Method execution timed out", { id, methodExport: opts.methodExport });
+      log.warn("executor", "Method execution timed out", { id, methodExport: opts.methodExport });
       resolve2({
         success: false,
-        error: { message: "Method execution timed out after 30s" }
+        error: { message: "Method execution timed out after 30m" }
       });
     }, EXECUTION_TIMEOUT_MS);
     pending.set(id, { resolve: resolve2, timer });
@@ -777,6 +787,7 @@ async function cleanupWorker() {
     clearTimeout(req.timer);
   }
   pending.clear();
+  queueTail = Promise.resolve();
 }
 
 // src/api.ts
@@ -980,6 +991,7 @@ var DevRunner = class {
   hadConnectionWarning = false;
   proxyUrl;
   proxy = null;
+  roleOverride = null;
   // proxyUrl is sent on every poll request so the platform dashboard can
   // show the developer's preview URL. Also included in the start request
   // so the dashboard sees it immediately without waiting for the first poll.
@@ -994,13 +1006,13 @@ var DevRunner = class {
     if (this.isRunning) {
       throw new Error("DevRunner is already running");
     }
-    log.info("Dev session starting", { appId: this.appId, branch: this.startOpts.branch });
+    log.info("runner", "Dev session starting", { appId: this.appId, branch: this.startOpts.branch });
     const session = await startDevSession(this.appId, this.startOpts);
     this.session = session;
     this.transpiler = new Transpiler(this.projectRoot);
     this.isRunning = true;
     this.backoffMs = 1e3;
-    log.info("Dev session started", { sessionId: session.sessionId, branch: session.branch });
+    log.info("runner", "Dev session started", { sessionId: session.sessionId, branch: session.branch });
     return session;
   }
   // Begin polling for platform method requests. Call this after all
@@ -1010,16 +1022,17 @@ var DevRunner = class {
     this.pollLoop();
   }
   async stop() {
-    log.info("Dev session stopping");
+    log.info("runner", "Dev session stopping");
     this.isRunning = false;
     if (this.session) {
       try {
         await stopDevSession(this.appId, this.session.sessionId);
       } catch (err) {
-        log.warn("Failed to stop dev session cleanly", { error: err instanceof Error ? err.message : String(err) });
+        log.warn("runner", "Failed to stop dev session cleanly", { error: err instanceof Error ? err.message : String(err) });
       }
       this.session = null;
     }
+    this.roleOverride = null;
     await cleanupWorker();
     if (this.transpiler) {
       await this.transpiler.cleanup();
@@ -1032,15 +1045,17 @@ var DevRunner = class {
   // Set role override for subsequent method executions.
   async setImpersonation(roles) {
     if (!this.session) return;
-    log.info("Setting role override", { roles });
+    log.info("runner", "Setting role override", { roles });
     await impersonate(this.appId, this.session.sessionId, roles);
+    this.roleOverride = roles;
     await this.refreshClientContext();
   }
   // Clear role override — revert to session's default roles.
   async clearImpersonation() {
     if (!this.session) return;
-    log.info("Clearing role override");
+    log.info("runner", "Clearing role override");
     await impersonate(this.appId, this.session.sessionId, null);
+    this.roleOverride = null;
     await this.refreshClientContext();
   }
   // Fetch fresh clientContext from platform and update the proxy.
@@ -1052,7 +1067,7 @@ var DevRunner = class {
       this.session.clientContext = context;
       this.proxy.updateClientContext(context);
     } catch (err) {
-      log.warn("Failed to refresh session context after role change", { error: err instanceof Error ? err.message : String(err) });
+      log.warn("runner", "Failed to refresh session context after role change", { error: err instanceof Error ? err.message : String(err) });
     }
   }
   // Run a method directly (not via poll loop). Used by headless stdin commands
@@ -1063,15 +1078,22 @@ var DevRunner = class {
     }
     const requestId = randomBytes2(8).toString("hex");
     const startTime = Date.now();
-    log.info("Method received (direct)", { requestId, method: opts.methodExport });
+    log.info("runner", "Method received", { requestId, method: opts.methodExport, source: "direct", sessionId: this.session.sessionId });
     try {
       const authorizationToken = await fetchCallbackToken(this.appId, this.session.sessionId);
       const transpiledPath = await this.transpiler.transpile(opts.methodPath);
+      const auth = this.roleOverride ? {
+        userId: this.session.auth.userId,
+        roleAssignments: this.roleOverride.map((roleName) => ({
+          userId: this.session.auth.userId,
+          roleName
+        }))
+      } : this.session.auth;
       const result = await executeMethod({
         transpiledPath,
         methodExport: opts.methodExport,
         input: opts.input,
-        auth: this.session.auth,
+        auth,
         databases: this.session.databases,
         authorizationToken,
         apiBaseUrl: getApiBaseUrl(),
@@ -1079,13 +1101,14 @@ var DevRunner = class {
       });
       const duration = Date.now() - startTime;
       if (result.success) {
-        log.info("Method complete", { requestId, method: opts.methodExport, duration });
+        log.info("runner", "Method complete", { requestId, method: opts.methodExport, duration, sessionId: this.session.sessionId });
       } else {
-        log.warn("Method failed", {
+        log.warn("runner", "Method failed", {
           requestId,
           method: opts.methodExport,
           duration,
-          error: result.error ? formatErrorForDisplay(result.error) : void 0
+          error: result.error ? formatErrorForDisplay(result.error) : void 0,
+          sessionId: this.session.sessionId
         });
       }
       logMethodExecution({
@@ -1109,7 +1132,7 @@ var DevRunner = class {
     } catch (err) {
       const message = err instanceof Error ? err.message : "Unknown error";
       const duration = Date.now() - startTime;
-      log.error("Method error", { requestId, method: opts.methodExport, duration, error: message });
+      log.error("runner", "Method execution error", { requestId, method: opts.methodExport, duration, error: message, sessionId: this.session.sessionId });
       logMethodExecution({
         requestId,
         sessionId: this.session.sessionId,
@@ -1132,15 +1155,15 @@ var DevRunner = class {
     }
     const startTime = Date.now();
     const scenarioName = scenario.name ?? scenario.export;
-    log.info("Scenario starting", { id: scenario.id, name: scenarioName });
+    log.info("runner", "Scenario starting", { id: scenario.id, name: scenarioName });
     try {
-      log.info("Resetting database for scenario");
+      log.debug("runner", "Resetting database for scenario");
       const databases = await resetDevDatabase(this.appId, this.session.sessionId, "truncate");
       this.session.databases = databases;
-      log.info("Transpiling scenario", { path: scenario.path });
+      log.debug("runner", "Transpiling scenario", { path: scenario.path });
       const transpiledPath = await this.transpiler.transpile(scenario.path);
       const authorizationToken = await fetchCallbackToken(this.appId, this.session.sessionId);
-      log.info("Running scenario seed function", { export: scenario.export });
+      log.debug("runner", "Running scenario seed function", { export: scenario.export });
       const result = await executeMethod({
         transpiledPath,
         methodExport: scenario.export,
@@ -1153,7 +1176,7 @@ var DevRunner = class {
       });
       if (!result.success) {
         const error = result.error?.message ?? "Scenario seed failed";
-        log.error("Scenario seed function failed", { id: scenario.id, error });
+        log.error("runner", "Scenario seed function failed", { id: scenario.id, name: scenarioName, duration: Date.now() - startTime, error });
         logScenarioExecution({
           sessionId: this.session.sessionId,
           scenario,
@@ -1164,12 +1187,12 @@ var DevRunner = class {
         return { success: false, databases, error };
       }
       if (scenario.roles.length > 0) {
-        log.info("Setting role override for scenario", { roles: scenario.roles });
+        log.debug("runner", "Setting role override for scenario", { roles: scenario.roles });
         await impersonate(this.appId, this.session.sessionId, scenario.roles);
         await this.refreshClientContext();
       }
       const duration = Date.now() - startTime;
-      log.info("Scenario complete", { id: scenario.id, duration, roles: scenario.roles });
+      log.info("runner", "Scenario complete", { id: scenario.id, name: scenarioName, duration, roles: scenario.roles });
       logScenarioExecution({
         sessionId: this.session.sessionId,
         scenario,
@@ -1180,7 +1203,7 @@ var DevRunner = class {
       return { success: true, databases };
     } catch (err) {
       const error = err instanceof Error ? err.message : "Unknown error";
-      log.error("Scenario failed", { id: scenario.id, error });
+      log.error("runner", "Scenario failed", { id: scenario.id, name: scenarioName, duration: Date.now() - startTime, error });
       logScenarioExecution({
         sessionId: this.session.sessionId,
         scenario,
@@ -1202,7 +1225,7 @@ var DevRunner = class {
         );
         if (this.hadConnectionWarning) {
           this.hadConnectionWarning = false;
-          log.info("Connection to platform restored");
+          log.info("runner", "Connection to platform restored");
           devRequestEvents.emitConnectionRestored();
         }
         if (request) {
@@ -1211,31 +1234,29 @@ var DevRunner = class {
         this.backoffMs = 1e3;
       } catch (error) {
         if (error instanceof DevPollError && error.statusCode === 404) {
-          log.error("Dev session expired", { statusCode: 404 });
+          log.error("runner", "Dev session expired", { statusCode: 404 });
           devRequestEvents.emitSessionExpired();
           this.isRunning = false;
           return;
         }
         if ((error instanceof DevPollError || error instanceof ApiError) && error.statusCode === 401) {
-          log.warn("Session token expired, re-authenticating");
           const refreshed = await this.refreshAuth();
           if (refreshed) {
             this.backoffMs = 1e3;
             continue;
           }
-          log.error("Re-authentication failed");
+          log.error("runner", "Re-authentication failed");
           devRequestEvents.emitSessionExpired();
           this.isRunning = false;
           return;
         }
         if (!this.hadConnectionWarning) {
           this.hadConnectionWarning = true;
-          log.warn("Lost connection to platform, retrying");
+          log.warn("runner", "Lost connection to platform, retrying");
           devRequestEvents.emitConnectionWarning(
             "Lost connection to platform, retrying..."
           );
         }
-        log.debug("Backing off", { ms: this.backoffMs });
         await this.sleep(this.backoffMs);
         this.backoffMs = Math.min(this.backoffMs * 2, 3e4);
       }
@@ -1249,9 +1270,8 @@ var DevRunner = class {
       method: request.methodExport,
       timestamp: startTime
     });
-    log.info("Method received", { requestId: request.requestId, method: request.methodExport });
+    log.info("runner", "Method received", { requestId: request.requestId, method: request.methodExport, source: "poll", sessionId: this.session.sessionId });
     try {
-      log.debug("Transpiling method", { path: request.methodPath });
       const transpiledPath = await this.transpiler.transpile(request.methodPath);
       const auth = request.roleOverride ? {
         userId: this.session.auth.userId,
@@ -1287,13 +1307,14 @@ var DevRunner = class {
       );
       const duration = Date.now() - startTime;
       if (result.success) {
-        log.info("Method complete", { requestId: request.requestId, method: request.methodExport, duration });
+        log.info("runner", "Method complete", { requestId: request.requestId, method: request.methodExport, duration, sessionId: this.session.sessionId });
       } else {
-        log.warn("Method failed", {
+        log.warn("runner", "Method failed", {
           requestId: request.requestId,
           method: request.methodExport,
           duration,
-          error: result.error ? formatErrorForDisplay(result.error) : void 0
+          error: result.error ? formatErrorForDisplay(result.error) : void 0,
+          sessionId: this.session.sessionId
         });
       }
       logMethodExecution({
@@ -1317,7 +1338,7 @@ var DevRunner = class {
     } catch (error) {
       const message = error instanceof Error ? error.message : "Unknown error";
       const duration = Date.now() - startTime;
-      log.error("Method error", { requestId: request.requestId, method: request.methodExport, duration, error: message });
+      log.error("runner", "Method execution error", { requestId: request.requestId, method: request.methodExport, duration, error: message, sessionId: this.session.sessionId });
       try {
         await submitDevResult(
           this.appId,
@@ -1330,7 +1351,7 @@ var DevRunner = class {
           }
         );
       } catch (submitErr) {
-        log.error("Failed to report method error to platform", { error: submitErr instanceof Error ? submitErr.message : String(submitErr) });
+        log.error("runner", "Failed to report method error to platform", { error: submitErr instanceof Error ? submitErr.message : String(submitErr) });
       }
       logMethodExecution({
         requestId: request.requestId,
@@ -1361,14 +1382,14 @@ var DevRunner = class {
     const POLL_INTERVAL = 2e3;
     const MAX_ATTEMPTS = 30;
     try {
-      log.info("Session token expired, requesting re-authentication");
+      log.info("runner", "Session token expired, requesting re-authentication");
       const { url, token } = await requestDeviceAuth();
       devRequestEvents.emitAuthRefreshStart(url);
       try {
         const open = (await import("open")).default;
         await open(url);
       } catch {
-        log.warn("Could not open browser \u2014 visit URL to re-authenticate");
+        log.warn("runner", "Could not open browser \u2014 visit URL to re-authenticate");
       }
       for (let i = 0; i < MAX_ATTEMPTS; i++) {
         await this.sleep(POLL_INTERVAL);
@@ -1379,7 +1400,7 @@ var DevRunner = class {
           if (result.userId) {
             setUserId(result.userId);
           }
-          log.info("Re-authentication successful");
+          log.info("runner", "Re-authentication successful");
           devRequestEvents.emitAuthRefreshSuccess();
           return true;
         }
@@ -1387,11 +1408,11 @@ var DevRunner = class {
           break;
         }
       }
-      log.error("Re-authentication timed out or was denied");
+      log.error("runner", "Re-authentication timed out or was denied");
       devRequestEvents.emitAuthRefreshFailed();
       return false;
     } catch (err) {
-      log.error("Re-authentication failed", { error: err instanceof Error ? err.message : String(err) });
+      log.error("runner", "Re-authentication failed", { error: err instanceof Error ? err.message : String(err) });
       devRequestEvents.emitAuthRefreshFailed();
       return false;
     }
@@ -1406,10 +1427,19 @@ var ndjsonLog2 = new NdjsonLog("browser.ndjson");
 function initBrowserLog(projectRoot) {
   ndjsonLog2.init(projectRoot);
 }
+function inferLevel(entry) {
+  const type = entry.type;
+  if (type === "error") return "error";
+  const level = entry.level;
+  if (level === "warn" || level === "error" || level === "debug") return level;
+  return "info";
+}
 function appendBrowserLogEntries(entries) {
   for (const entry of entries) {
     ndjsonLog2.append({
-      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      ts: Date.now(),
+      level: inferLevel(entry),
+      module: "browser",
       ...entry
     });
   }
@@ -1439,14 +1469,14 @@ var ClientRegistry = class {
       alive: true,
       activeCommandId: null
     });
-    log.info("Browser client connected", { clientId: id, mode: hello.mode, url: hello.url });
+    log.info("proxy", "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 });
+      log.info("proxy", "Browser client disconnected", { clientId: id, mode: client.mode });
     }
     return client;
   }
@@ -1502,7 +1532,7 @@ var ClientRegistry = class {
     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 });
+        log.warn("proxy", "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();
@@ -1537,7 +1567,6 @@ var DevProxy = class _DevProxy {
   static HELLO_TIMEOUT = 5e3;
   updateClientContext(context) {
     this.clientContext = context;
-    log.info("Dev proxy context updated after role change");
   }
   /**
    * Whether any browser agent is actively connected via WebSocket.
@@ -1552,13 +1581,26 @@ 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 Error(
+          "No browser connected, please refresh the MindStudio preview"
+        )
       );
     }
     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.commandQueue.push({
+        id,
+        steps,
+        timeoutMs,
+        resolve: resolve2,
+        reject,
+        queuedAt: Date.now()
+      });
+      log.debug("proxy", "Browser command queued", {
+        id,
+        queueLength: this.commandQueue.length,
+        commands: steps.map((s) => s.command)
+      });
       this.drainCommandQueue();
     });
   }
@@ -1571,12 +1613,22 @@ var DevProxy = class _DevProxy {
       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) });
+      log.info("proxy", "Browser command sent", {
+        id,
+        clientId: target.id,
+        mode: target.mode,
+        stepCount: steps.length,
+        commands: steps.map((s) => s.command),
+        queueWaitMs: Date.now() - queued.queuedAt
+      });
       const timeout = setTimeout(() => {
         this.pendingResults.delete(id);
         const client = this.clients.findByCommandId(id);
         if (client) client.activeCommandId = null;
-        log.warn("Browser command timed out", { id, pendingCount: this.pendingResults.size });
+        log.warn("proxy", "Browser command timed out", {
+          id,
+          pendingCount: this.pendingResults.size
+        });
         reject(new Error("Browser command timed out"));
         this.drainCommandQueue();
       }, timeoutMs);
@@ -1588,6 +1640,10 @@ var DevProxy = class _DevProxy {
         this.pendingResults.delete(id);
         clearTimeout(timeout);
         target.activeCommandId = null;
+        log.warn("proxy", "Browser command send failed", {
+          id,
+          clientId: target.id
+        });
         reject(new Error("Failed to send command to browser"));
       }
     }
@@ -1598,7 +1654,10 @@ var DevProxy = class _DevProxy {
   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 });
+    log.info("proxy", "Broadcasting to browser clients", {
+      action,
+      clientCount: clients.length
+    });
     for (const client of clients) {
       try {
         client.ws.send(msg);
@@ -1629,10 +1688,13 @@ var DevProxy = class _DevProxy {
         this.proxyPort = assignedPort;
         this.startHealthCheck();
         this.startPingTimer();
-        log.info("Dev proxy started", { port: assignedPort, bind: this.bindAddress });
+        log.info("proxy", "Dev proxy started", {
+          port: assignedPort,
+          bind: this.bindAddress
+        });
         return assignedPort;
       } catch {
-        log.warn("Proxy port in use, trying next", { port });
+        log.warn("proxy", "Proxy port in use, trying next", { port });
       }
     }
     throw new Error("Failed to start proxy server");
@@ -1670,7 +1732,7 @@ var DevProxy = class _DevProxy {
       this.wss = null;
     }
     if (this.server) {
-      log.info("Dev proxy stopping");
+      log.info("proxy", "Dev proxy stopping");
       this.server.close();
       this.server = null;
       this.proxyPort = null;
@@ -1695,7 +1757,10 @@ var DevProxy = class _DevProxy {
     let clientId = null;
     const helloTimeout = setTimeout(() => {
       if (!clientId) {
-        log.warn("Browser WS client did not send hello in time, closing");
+        log.warn(
+          "proxy",
+          "Browser WS client did not send hello in time, closing"
+        );
         ws.close(4e3, "Hello timeout");
       }
     }, _DevProxy.HELLO_TIMEOUT);
@@ -1713,7 +1778,10 @@ var DevProxy = class _DevProxy {
         }
         clearTimeout(helloTimeout);
         const mode = msg.mode === "iframe" ? "iframe" : "standalone";
-        const viewport = msg.viewport || { w: 0, h: 0 };
+        const viewport = msg.viewport || {
+          w: 0,
+          h: 0
+        };
         clientId = this.clients.add(ws, {
           mode,
           url: String(msg.url || ""),
@@ -1741,7 +1809,10 @@ var DevProxy = class _DevProxy {
       if (clientId) {
         const client = this.clients.remove(clientId);
         if (client?.activeCommandId) {
-          this.rejectPendingCommand(client.activeCommandId, "Browser disconnected during command execution");
+          this.rejectPendingCommand(
+            client.activeCommandId,
+            "Browser disconnected during command execution"
+          );
         }
       }
     });
@@ -1751,12 +1822,16 @@ var DevProxy = class _DevProxy {
   handleCommandResult(msg) {
     const id = msg.id;
     if (!id) {
-      log.warn("Browser command result received with no id");
+      log.warn("proxy", "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 });
+      log.info("proxy", "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);
@@ -1764,7 +1839,11 @@ var DevProxy = class _DevProxy {
       pending2.resolve(msg);
       this.drainCommandQueue();
     } else {
-      log.warn("Browser command result received but no pending command found", { id, pendingIds: [...this.pendingResults.keys()] });
+      log.warn(
+        "proxy",
+        "Browser command result received but no pending command found",
+        { id, pendingIds: [...this.pendingResults.keys()] }
+      );
     }
   }
   rejectPendingCommand(commandId, reason) {
@@ -1773,7 +1852,7 @@ var DevProxy = class _DevProxy {
       clearTimeout(pending2.timeout);
       this.pendingResults.delete(commandId);
       pending2.resolve({ id: commandId, steps: [], error: reason });
-      log.warn("Pending command rejected", { id: commandId, reason });
+      log.warn("proxy", "Pending command rejected", { id: commandId, reason });
       this.drainCommandQueue();
     }
   }
@@ -1785,7 +1864,10 @@ var DevProxy = class _DevProxy {
       const removed = this.clients.sweepDead();
       for (const { activeCommandId } of removed) {
         if (activeCommandId) {
-          this.rejectPendingCommand(activeCommandId, "Browser client timed out");
+          this.rejectPendingCommand(
+            activeCommandId,
+            "Browser client timed out"
+          );
         }
       }
       this.clients.pingAll();
@@ -1809,7 +1891,7 @@ var DevProxy = class _DevProxy {
   markUpstreamDown() {
     if (!this.upstreamUp) return;
     this.upstreamUp = false;
-    log.info("Upstream dev server marked as down (explicit signal)");
+    log.info("proxy", "Upstream dev server marked as down (explicit signal)");
     this.scheduleHealthCheck(_DevProxy.HEALTH_CHECK_INTERVAL_DOWN);
   }
   startHealthCheck() {
@@ -1836,9 +1918,9 @@ var DevProxy = class _DevProxy {
       this.upstreamUp = false;
     }
     if (wasUp && !this.upstreamUp) {
-      log.warn("Upstream dev server is down");
+      log.warn("proxy", "Upstream dev server is down");
     } else if (!wasUp && this.upstreamUp) {
-      log.info("Upstream dev server is back up, reloading browser");
+      log.info("proxy", "Upstream dev server is back up, reloading browser");
       this.broadcastToClients("reload");
     }
     const interval = this.upstreamUp ? _DevProxy.HEALTH_CHECK_INTERVAL : _DevProxy.HEALTH_CHECK_INTERVAL_DOWN;
@@ -1891,7 +1973,10 @@ var DevProxy = class _DevProxy {
         port: this.upstreamPort,
         path: clientReq.url,
         method: clientReq.method,
-        headers: { ...clientReq.headers, host: `localhost:${this.upstreamPort}` }
+        headers: {
+          ...clientReq.headers,
+          host: `localhost:${this.upstreamPort}`
+        }
       },
       (upstreamRes) => {
         const contentType = upstreamRes.headers["content-type"] ?? "";
@@ -1910,7 +1995,6 @@ var DevProxy = class _DevProxy {
             };
             delete headers["content-encoding"];
             delete headers["etag"];
-            log.debug("Dev proxy injected context into HTML", { path: clientReq.url, size: html.length });
             clientRes.writeHead(upstreamRes.statusCode ?? 200, headers);
             clientRes.end(html);
           });
@@ -1927,7 +2011,10 @@ var DevProxy = class _DevProxy {
       }
     );
     upstreamReq.on("error", (err) => {
-      log.warn("Dev proxy cannot reach dev server", { path: clientReq.url, error: err.message });
+      log.warn("proxy", "Dev proxy cannot reach dev server", {
+        path: clientReq.url,
+        error: err.message
+      });
       clientRes.writeHead(502);
       clientRes.end(`Proxy error: ${err.message}`);
     });
@@ -1994,7 +2081,9 @@ var DevProxy = class _DevProxy {
       clientRes.end(body);
     } catch (err) {
       clientRes.writeHead(502, cors);
-      clientRes.end(`Font proxy error: ${err instanceof Error ? err.message : String(err)}`);
+      clientRes.end(
+        `Font proxy error: ${err instanceof Error ? err.message : String(err)}`
+      );
     }
   }
   /**
@@ -2016,7 +2105,6 @@ ${agentScript}`;
   // 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,
@@ -2056,13 +2144,10 @@ ${agentScript}`;
 
 // src/dev/config/app-config.ts
 import { readFileSync, existsSync as existsSync2 } from "fs";
-import { join as join4, dirname as dirname2 } from "path";
+import { join as join5, dirname as dirname2 } from "path";
 function detectAppConfig(cwd = process.cwd()) {
-  const appJsonPath = join4(cwd, "mindstudio.json");
-  if (!existsSync2(appJsonPath)) {
-    log.debug("mindstudio.json not found", { path: appJsonPath });
-    return null;
-  }
+  const appJsonPath = join5(cwd, "mindstudio.json");
+  if (!existsSync2(appJsonPath)) return null;
   try {
     const raw = readFileSync(appJsonPath, "utf-8");
     const parsed = JSON.parse(raw);
@@ -2079,7 +2164,7 @@ function detectAppConfig(cwd = process.cwd()) {
       scenarios: parsed.scenarios ?? [],
       interfaces: parsed.interfaces ?? []
     };
-    log.info("Loaded mindstudio.json", {
+    log.info("config", "Loaded mindstudio.json", {
       appId: config2.appId,
       roles: config2.roles.length,
       methods: config2.methods.length,
@@ -2089,7 +2174,7 @@ function detectAppConfig(cwd = process.cwd()) {
     });
     return config2;
   } catch (err) {
-    log.warn("Failed to parse mindstudio.json", { error: err instanceof Error ? err.message : String(err) });
+    log.warn("config", "Failed to parse mindstudio.json", { error: err instanceof Error ? err.message : String(err) });
     return null;
   }
 }
@@ -2100,7 +2185,7 @@ function getWebInterfaceConfig(appConfig, cwd = process.cwd()) {
   if (!webInterface) {
     return null;
   }
-  const configPath = join4(cwd, webInterface.path);
+  const configPath = join5(cwd, webInterface.path);
   if (!existsSync2(configPath)) {
     return null;
   }
@@ -2126,14 +2211,14 @@ function getWebProjectDir(appConfig, cwd = process.cwd()) {
   if (!webInterface) {
     return null;
   }
-  return dirname2(join4(cwd, webInterface.path));
+  return dirname2(join5(cwd, webInterface.path));
 }
 function readTableSources(appConfig, cwd = process.cwd()) {
   const results = [];
   for (const table of appConfig.tables) {
-    const filePath = join4(cwd, table.path);
+    const filePath = join5(cwd, table.path);
     if (!existsSync2(filePath)) {
-      log.warn("Table source file not found", { table: table.export, path: table.path });
+      log.warn("config", "Table source file not found", { table: table.export, path: table.path });
       continue;
     }
     try {
@@ -2141,11 +2226,11 @@ function readTableSources(appConfig, cwd = process.cwd()) {
       const name = table.export;
       results.push({ name, source });
     } catch (err) {
-      log.warn("Table source file unreadable", { table: table.export, path: table.path, error: err instanceof Error ? err.message : String(err) });
+      log.warn("config", "Table source file unreadable", { table: table.export, path: table.path, error: err instanceof Error ? err.message : String(err) });
     }
   }
   if (results.length < appConfig.tables.length) {
-    log.warn("Missing " + (appConfig.tables.length - results.length) + " table source file(s)", { found: results.length, expected: appConfig.tables.length });
+    log.warn("config", "Table source files missing", { missing: appConfig.tables.length - results.length, found: results.length, expected: appConfig.tables.length });
   }
   return results;
 }
@@ -2155,9 +2240,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 = join4(cwd, ...parts.slice(0, i));
-      if (existsSync2(join4(candidate, "package.json"))) {
-        if (!existsSync2(join4(candidate, "node_modules"))) {
+      const candidate = join5(cwd, ...parts.slice(0, i));
+      if (existsSync2(join5(candidate, "package.json"))) {
+        if (!existsSync2(join5(candidate, "node_modules"))) {
           dirs.push(candidate);
         }
         break;
@@ -2165,8 +2250,8 @@ function findDirsNeedingInstall(appConfig, cwd = process.cwd()) {
     }
   }
   const webProjectDir = getWebProjectDir(appConfig, cwd);
-  if (webProjectDir && existsSync2(join4(webProjectDir, "package.json"))) {
-    if (!existsSync2(join4(webProjectDir, "node_modules"))) {
+  if (webProjectDir && existsSync2(join5(webProjectDir, "package.json"))) {
+    if (!existsSync2(join5(webProjectDir, "node_modules"))) {
       dirs.push(webProjectDir);
     }
   }
@@ -2195,11 +2280,11 @@ function detectGitBranch() {
 
 // src/dev/config/table-watcher.ts
 import { watch } from "chokidar";
-import { join as join5, dirname as dirname3, basename as basename2 } from "path";
+import { join as join6, dirname as dirname3, basename as basename2 } from "path";
 function watchTableFiles(tables, cwd, onChanged) {
   if (tables.length === 0) return () => {
   };
-  const filePaths = tables.map((t) => join5(cwd, t.path));
+  const filePaths = tables.map((t) => join6(cwd, t.path));
   let syncTimer;
   const watcher = watch(filePaths, {
     ignoreInitial: true,
@@ -2212,13 +2297,13 @@ function watchTableFiles(tables, cwd, onChanged) {
   });
   const dirToFiles = /* @__PURE__ */ new Map();
   for (const table of tables) {
-    const absPath = join5(cwd, table.path);
+    const absPath = join6(cwd, table.path);
     const dir = dirname3(absPath);
     const file = basename2(absPath);
     if (!dirToFiles.has(dir)) dirToFiles.set(dir, /* @__PURE__ */ new Set());
     dirToFiles.get(dir).add(file);
   }
-  log.info("Watching table source files", {
+  log.info("config", "Watching table source files", {
     dirs: dirToFiles.size,
     tables: tables.length
   });
@@ -2230,9 +2315,9 @@ function watchTableFiles(tables, cwd, onChanged) {
 
 // src/dev/config/config-watcher.ts
 import { watch as watch2 } from "chokidar";
-import { join as join6 } from "path";
+import { join as join7 } from "path";
 function watchConfigFile(cwd, onChanged) {
-  const configPath = join6(cwd, "mindstudio.json");
+  const configPath = join7(cwd, "mindstudio.json");
   let debounceTimer;
   const watcher = watch2(configPath, {
     ignoreInitial: true,
@@ -2244,7 +2329,7 @@ function watchConfigFile(cwd, onChanged) {
       onChanged();
     }, 500);
   });
-  log.info("Watching mindstudio.json for changes", { path: configPath });
+  log.info("config", "Watching mindstudio.json for changes", { path: configPath });
   return () => {
     clearTimeout(debounceTimer);
     watcher.close();
@@ -2299,4 +2384,4 @@ export {
   watchTableFiles,
   watchConfigFile
 };
-//# sourceMappingURL=chunk-VCBGX5ND.js.map
+//# sourceMappingURL=chunk-JRLMRABX.js.map