@mindstudio-ai/local-model-tunnel 0.5.9 → 0.5.11

package/dist/{chunk-4CMGJFH3.js → chunk-XP4GPID6.js}

@@ -266,6 +266,147 @@ var DevPollError = class extends Error {
   }
 };
 
+// src/dev/ndjson-log.ts
+import fs2 from "fs";
+import { join } from "path";
+var NdjsonLog = class {
+  constructor(filename, maxLines = 500, keepLines = 300, maxBytes = 2 * 1024 * 1024) {
+    this.filename = filename;
+    this.maxLines = maxLines;
+    this.keepLines = keepLines;
+    this.maxBytes = maxBytes;
+  }
+  fd = null;
+  logPath = null;
+  lineCount = 0;
+  rotating = false;
+  init(projectRoot) {
+    this.close();
+    try {
+      const logsDir = join(projectRoot, ".logs");
+      fs2.mkdirSync(logsDir, { recursive: true });
+      this.logPath = join(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;
+      } else {
+        this.lineCount = 0;
+      }
+      this.fd = fs2.openSync(this.logPath, "a");
+      log.info(`${this.filename} log initialized`, {
+        path: this.logPath,
+        existingEntries: this.lineCount
+      });
+    } catch (err) {
+      log.warn(`Failed to initialize ${this.filename} log`, {
+        error: err instanceof Error ? err.message : String(err)
+      });
+      this.fd = null;
+      this.logPath = null;
+    }
+  }
+  append(record) {
+    if (this.fd === null) return;
+    try {
+      const line = JSON.stringify(record) + "\n";
+      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)
+      });
+    }
+  }
+  close() {
+    if (this.fd !== null) {
+      try {
+        fs2.closeSync(this.fd);
+      } catch {
+      }
+      this.fd = null;
+    }
+    this.logPath = null;
+    this.lineCount = 0;
+    this.rotating = false;
+  }
+  maybeRotate() {
+    if (this.fd === null || this.logPath === null || this.rotating) return;
+    try {
+      let needsRotation = this.lineCount > this.maxLines;
+      if (!needsRotation) {
+        const stat = fs2.fstatSync(this.fd);
+        needsRotation = stat.size > this.maxBytes;
+      }
+      if (!needsRotation) return;
+      this.rotating = true;
+      const content = fs2.readFileSync(this.logPath, "utf-8");
+      const lines = content.split("\n").filter((l) => l.trim());
+      const kept = lines.slice(-this.keepLines);
+      fs2.closeSync(this.fd);
+      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)
+      });
+    } finally {
+      this.rotating = false;
+    }
+  }
+};
+
+// src/dev/request-log.ts
+var ndjsonLog = new NdjsonLog("requests.ndjson");
+function initRequestLog(projectRoot) {
+  ndjsonLog.init(projectRoot);
+}
+function logMethodExecution(entry) {
+  ndjsonLog.append({
+    type: "method",
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    requestId: entry.requestId,
+    sessionId: entry.sessionId,
+    method: entry.methodExport,
+    path: entry.methodPath,
+    input: entry.input,
+    roleOverride: entry.roleOverride ?? null,
+    authorizationToken: entry.authorizationToken,
+    databases: entry.databases,
+    success: entry.result.success,
+    output: entry.result.output ?? null,
+    error: entry.result.error ?? null,
+    stdout: entry.result.stdout ?? [],
+    duration: entry.duration,
+    stats: entry.result.stats ?? null
+  });
+}
+function logScenarioExecution(entry) {
+  ndjsonLog.append({
+    type: "scenario",
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    sessionId: entry.sessionId,
+    scenario: {
+      id: entry.scenario.id,
+      name: entry.scenario.name ?? entry.scenario.export,
+      export: entry.scenario.export,
+      path: entry.scenario.path
+    },
+    databases: entry.databases,
+    success: entry.result?.success ?? false,
+    output: entry.result?.output ?? null,
+    error: entry.result?.error ?? (entry.infrastructureError ? { message: entry.infrastructureError } : null),
+    stdout: entry.result?.stdout ?? [],
+    duration: entry.duration,
+    stats: entry.result?.stats ?? null
+  });
+}
+function closeRequestLog() {
+  ndjsonLog.close();
+}
+
 // src/dev/events.ts
 import { EventEmitter } from "events";
 var DevEventEmitter = class extends EventEmitter {
@@ -352,7 +493,7 @@ var devRequestEvents = new DevEventEmitter();
 // src/dev/transpiler.ts
 import { unlink, mkdir, readdir } from "fs/promises";
 import { existsSync } from "fs";
-import { resolve, dirname, basename, join } from "path";
+import { resolve, dirname, basename, join as join2 } from "path";
 import { build } from "esbuild";
 var Transpiler = class {
   projectRoot;
@@ -378,18 +519,18 @@ var Transpiler = class {
     const start = Date.now();
     const absolutePath = resolve(this.projectRoot, methodPath);
     const name = basename(absolutePath).replace(/\.[^.]+$/, "");
-    log.debug("transpiler Transpiling", { methodPath });
+    log.debug("Transpiling method", { methodPath });
     const nodeModulesDir = findNearestNodeModules(dirname(absolutePath));
     if (!nodeModulesDir) {
-      log.error("transpiler No node_modules found", { methodPath, searchStart: dirname(absolutePath) });
+      log.error("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("transpiler Found node_modules", { path: nodeModulesDir });
-    const outDir = join(nodeModulesDir, ".cache", "mindstudio-dev");
+    log.debug("Found node_modules", { path: nodeModulesDir });
+    const outDir = join2(nodeModulesDir, ".cache", "mindstudio-dev");
     await mkdir(outDir, { recursive: true });
-    const outfile = join(outDir, `${name}.__ms_dev__.mjs`);
+    const outfile = join2(outDir, `${name}.__ms_dev__.mjs`);
     await build({
       entryPoints: [absolutePath],
       bundle: true,
@@ -402,14 +543,14 @@ var Transpiler = class {
       logLevel: "silent"
     });
     this.outputFiles.add(outfile);
-    log.info(`transpiler Transpiled in ${Date.now() - start}ms`, { methodPath, outfile });
+    log.info(`Method transpiled in ${Date.now() - start}ms`, { methodPath, outfile });
     return outfile;
   }
   /**
    * Clean up all transpiled output files.
    */
   async cleanup() {
-    log.debug("transpiler Cleaning up", { fileCount: this.outputFiles.size });
+    log.debug("Cleaning up transpiled files", { fileCount: this.outputFiles.size });
     for (const file of this.outputFiles) {
       await unlink(file).catch(() => {
       });
@@ -421,11 +562,11 @@ 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 = join(dir, entry.name);
+    const fullPath = join2(dir, entry.name);
     if (entry.isDirectory()) {
       await removeOrphanedDevFiles(fullPath);
     } else if (entry.name.endsWith(".__ms_dev__.mjs")) {
-      log.debug("transpiler Removing orphaned file", { path: fullPath });
+      log.debug("Removing orphaned transpiled file", { path: fullPath });
       await unlink(fullPath).catch(() => {
       });
     }
@@ -434,7 +575,7 @@ async function removeOrphanedDevFiles(dir) {
 function findNearestNodeModules(startDir) {
   let dir = startDir;
   while (true) {
-    const candidate = join(dir, "node_modules");
+    const candidate = join2(dir, "node_modules");
     if (existsSync(candidate)) {
       return candidate;
     }
@@ -446,19 +587,18 @@ function findNearestNodeModules(startDir) {
 }
 
 // src/dev/executor.ts
-import { spawn } from "child_process";
+import { fork } from "child_process";
 import { writeFile, unlink as unlink2 } from "fs/promises";
-import { join as join2 } from "path";
+import { join as join3 } from "path";
 import { tmpdir } from "os";
 import { randomBytes } from "crypto";
 var EXECUTION_TIMEOUT_MS = 3e4;
-function buildBootstrapScript(opts) {
+var worker = null;
+var workerScriptPath = null;
+var workerProjectRoot = null;
+var pending = /* @__PURE__ */ new Map();
+function buildWorkerScript() {
   return `
-global.ai = {
-  auth: ${JSON.stringify(opts.auth)},
-  databases: ${JSON.stringify(opts.databases)},
-};
-
 function serializeError(err) {
   if (!err) return { message: 'Unknown error' };
 
@@ -467,7 +607,6 @@ function serializeError(err) {
     stack: err.stack,
   };
 
-  // Capture common extra properties from SDK/HTTP errors
   if (err.code !== undefined) serialized.code = err.code;
   if (err.statusCode !== undefined) serialized.statusCode = err.statusCode;
   if (err.status !== undefined) serialized.status = err.status;
@@ -481,7 +620,6 @@ function serializeError(err) {
     serialized.cause = serializeError(err.cause);
   }
 
-  // Capture any other enumerable properties
   for (const key of Object.keys(err)) {
     if (!(key in serialized)) {
       try {
@@ -496,91 +634,162 @@ function serializeError(err) {
   return serialized;
 }
 
-// Capture console output from method code
-const _stdout = [];
-console.log = (...args) => _stdout.push(args.map(String).join(' '));
-console.warn = (...args) => _stdout.push(args.map(String).join(' '));
-console.error = (...args) => _stdout.push(args.map(String).join(' '));
+// Save original console methods so we can restore after each request
+const _origLog = console.log;
+const _origWarn = console.warn;
+const _origError = console.error;
 
-const _startTime = Date.now();
+process.on('message', async (msg) => {
+  const { id, transpiledPath, methodExport, input, auth, databases, authorizationToken, apiBaseUrl, streamId } = msg;
 
-const { ${opts.methodExport} } = await import(${JSON.stringify(opts.transpiledPath + "?t=" + Date.now())});
+  // Update per-request env vars
+  process.env.CALLBACK_TOKEN = authorizationToken;
+  process.env.REMOTE_HOSTNAME = apiBaseUrl;
+  if (streamId) process.env.STREAM_ID = streamId;
+  else delete process.env.STREAM_ID;
 
-try {
-  const returnValue = await ${opts.methodExport}(${JSON.stringify(opts.input)});
-  const _stats = { memoryUsedBytes: process.memoryUsage().heapUsed, executionTimeMs: Date.now() - _startTime };
-  process.stdout.write(JSON.stringify({ success: true, output: returnValue, stdout: _stdout, stats: _stats }));
-} catch (err) {
-  const _stats = { memoryUsedBytes: process.memoryUsage().heapUsed, executionTimeMs: Date.now() - _startTime };
-  process.stdout.write(JSON.stringify({
-    success: false,
-    error: serializeError(err),
-    stdout: _stdout,
-    stats: _stats,
-  }));
-}
+  // Update global context
+  global.ai = { auth, databases };
+
+  // Capture console output for this request
+  const stdout = [];
+  console.log = (...args) => stdout.push(args.map(String).join(' '));
+  console.warn = (...args) => stdout.push(args.map(String).join(' '));
+  console.error = (...args) => stdout.push(args.map(String).join(' '));
+
+  const startTime = Date.now();
+
+  try {
+    // Cache-bust so code changes are picked up
+    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 + ')');
+    }
+    const returnValue = await fn(input);
+    const stats = { memoryUsedBytes: process.memoryUsage().heapUsed, executionTimeMs: Date.now() - startTime };
+    process.send({ id, success: true, output: returnValue, stdout, stats });
+  } catch (err) {
+    const stats = { memoryUsedBytes: process.memoryUsage().heapUsed, executionTimeMs: Date.now() - startTime };
+    process.send({ id, success: false, error: serializeError(err), stdout, stats });
+  } finally {
+    // Restore console
+    console.log = _origLog;
+    console.warn = _origWarn;
+    console.error = _origError;
+  }
+});
+
+// Signal ready
+process.send({ type: 'ready' });
 `;
 }
-async function executeMethod(opts) {
-  const tempFile = join2(
+async function ensureWorker(projectRoot) {
+  if (worker?.connected && workerProjectRoot === projectRoot) {
+    return worker;
+  }
+  if (worker) {
+    worker.removeAllListeners();
+    worker.kill();
+    worker = null;
+  }
+  if (workerScriptPath) {
+    await unlink2(workerScriptPath).catch(() => {
+    });
+    workerScriptPath = null;
+  }
+  const scriptPath = join3(
     tmpdir(),
-    `ms-dev-${randomBytes(8).toString("hex")}.mjs`
+    `ms-dev-worker-${randomBytes(4).toString("hex")}.mjs`
   );
-  const script = buildBootstrapScript(opts);
-  try {
-    await writeFile(tempFile, script, "utf-8");
-    log.debug("executor Spawning node process", { methodExport: opts.methodExport, cwd: opts.projectRoot, tempFile });
-    return await new Promise((resolve2, reject) => {
-      const stdoutChunks = [];
-      const stderrChunks = [];
-      const child = spawn("node", [tempFile], {
-        cwd: opts.projectRoot,
-        env: {
-          ...process.env,
-          // Auth + config env vars read by @mindstudio-ai/agent SDK
-          // for platform callbacks (db queries, etc.)
-          CALLBACK_TOKEN: opts.authorizationToken,
-          REMOTE_HOSTNAME: opts.apiBaseUrl,
-          ...opts.streamId ? { STREAM_ID: opts.streamId } : {}
-        },
-        stdio: ["ignore", "pipe", "pipe"]
-      });
-      child.stdout.on("data", (chunk) => stdoutChunks.push(chunk));
-      child.stderr.on("data", (chunk) => stderrChunks.push(chunk));
-      const timeout = setTimeout(() => {
-        log.warn("executor Timeout after 30s, sending SIGKILL", { methodExport: opts.methodExport });
-        child.kill("SIGKILL");
-        reject(new Error("Method execution timed out after 30s"));
-      }, EXECUTION_TIMEOUT_MS);
-      child.on("close", (code) => {
-        clearTimeout(timeout);
-        const stdout = Buffer.concat(stdoutChunks).toString("utf-8").trim();
-        const stderr = Buffer.concat(stderrChunks).toString("utf-8").trim();
-        log.debug("executor Process exited", { code, stdoutLen: stdout.length, stderrLen: stderr.length });
-        if (stdout) {
-          try {
-            resolve2(JSON.parse(stdout));
-            return;
-          } catch {
-            log.warn("executor Invalid JSON from stdout", { stdout: stdout.slice(0, 200) });
-          }
-        }
-        const errorMessage = stderr || stdout || `Method process exited with code ${code ?? "unknown"}`;
-        resolve2({
-          success: false,
-          error: { message: errorMessage }
-        });
-      });
-      child.on("error", (err) => {
-        clearTimeout(timeout);
-        log.error("executor Process error", { error: err.message });
-        reject(err);
+  await writeFile(scriptPath, buildWorkerScript(), "utf-8");
+  workerScriptPath = scriptPath;
+  workerProjectRoot = projectRoot;
+  log.debug("Spawning method execution process", { cwd: projectRoot, scriptPath });
+  const child = fork(scriptPath, [], {
+    cwd: projectRoot,
+    stdio: ["ignore", "pipe", "pipe", "ipc"],
+    env: { ...process.env }
+  });
+  await new Promise((resolve2, reject) => {
+    const onMessage = (msg) => {
+      if (msg?.type === "ready") {
+        child.off("message", onMessage);
+        resolve2();
+      }
+    };
+    child.on("message", onMessage);
+    child.on("error", reject);
+    child.on("exit", (code) => reject(new Error(`Worker exited during startup with code ${code}`)));
+  });
+  child.on("message", (msg) => {
+    if (!msg?.id) return;
+    const req = pending.get(msg.id);
+    if (!req) return;
+    pending.delete(msg.id);
+    clearTimeout(req.timer);
+    req.resolve(msg);
+  });
+  child.on("exit", (code) => {
+    log.warn("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}` } });
+    }
+    pending.clear();
+    worker = null;
+  });
+  child.stderr?.on("data", (chunk) => {
+    const text = chunk.toString().trim();
+    if (text) log.warn("Method process stderr", { text: text.slice(0, 500) });
+  });
+  worker = child;
+  log.info("Method execution process ready", { pid: child.pid });
+  return child;
+}
+async function executeMethod(opts) {
+  const w = await ensureWorker(opts.projectRoot);
+  const id = randomBytes(8).toString("hex");
+  log.debug("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 });
+      resolve2({
+        success: false,
+        error: { message: "Method execution timed out after 30s" }
       });
+    }, EXECUTION_TIMEOUT_MS);
+    pending.set(id, { resolve: resolve2, timer });
+    w.send({
+      id,
+      transpiledPath: opts.transpiledPath,
+      methodExport: opts.methodExport,
+      input: opts.input,
+      auth: opts.auth,
+      databases: opts.databases,
+      authorizationToken: opts.authorizationToken,
+      apiBaseUrl: opts.apiBaseUrl,
+      streamId: opts.streamId
     });
-  } finally {
-    await unlink2(tempFile).catch(() => {
+  });
+}
+async function cleanupWorker() {
+  if (worker) {
+    worker.removeAllListeners();
+    worker.kill();
+    worker = null;
+  }
+  if (workerScriptPath) {
+    await unlink2(workerScriptPath).catch(() => {
     });
+    workerScriptPath = null;
+  }
+  workerProjectRoot = null;
+  for (const [, req] of pending) {
+    clearTimeout(req.timer);
   }
+  pending.clear();
 }
 
 // src/api.ts
@@ -743,6 +952,33 @@ async function disconnectHeartbeat() {
   }
 }
 
+// src/dev/runner.ts
+import { randomBytes as randomBytes2 } from "crypto";
+
+// src/dev/format-error.ts
+function formatErrorForDisplay(error) {
+  const parts = [];
+  if (error.message) {
+    parts.push(String(error.message));
+  }
+  const code = error.code ?? error.statusCode ?? error.status;
+  if (code !== void 0) {
+    parts.push(`(code: ${code})`);
+  }
+  if (error.body) {
+    parts.push(`Response: ${String(error.body).slice(0, 200)}`);
+  } else if (error.response) {
+    parts.push(`Response: ${String(error.response).slice(0, 200)}`);
+  }
+  if (error.cause && typeof error.cause === "object") {
+    const cause = error.cause;
+    if (cause.message) {
+      parts.push(`Caused by: ${cause.message}`);
+    }
+  }
+  return parts.join("\n");
+}
+
 // src/dev/runner.ts
 var DevRunner = class {
   constructor(appId, projectRoot, startOpts = {}) {
@@ -771,27 +1007,28 @@ var DevRunner = class {
     if (this.isRunning) {
       throw new Error("DevRunner is already running");
     }
-    log.info("runner Starting session", { appId: this.appId, branch: this.startOpts.branch });
+    log.info("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("runner Session started", { sessionId: session.sessionId, branch: session.branch });
+    log.info("Dev session started", { sessionId: session.sessionId, branch: session.branch });
     this.pollLoop();
     return session;
   }
   async stop() {
-    log.info("runner Stopping session");
+    log.info("Dev session stopping");
     this.isRunning = false;
     if (this.session) {
       try {
         await stopDevSession(this.appId, this.session.sessionId);
       } catch (err) {
-        log.warn("runner Failed to stop session cleanly", { error: err instanceof Error ? err.message : String(err) });
+        log.warn("Failed to stop dev session cleanly", { error: err instanceof Error ? err.message : String(err) });
       }
       this.session = null;
     }
+    await cleanupWorker();
     if (this.transpiler) {
       await this.transpiler.cleanup();
       this.transpiler = null;
@@ -803,7 +1040,7 @@ var DevRunner = class {
   // Set role override for subsequent method executions.
   async setImpersonation(roles) {
     if (!this.session) return;
-    log.info("runner Impersonating", { roles });
+    log.info("Setting role override", { roles });
     const result = await impersonate(this.appId, this.session.sessionId, roles);
     await this.refreshClientContext();
     devRequestEvents.emitImpersonate({ roles: result.roles });
@@ -811,7 +1048,7 @@ var DevRunner = class {
   // Clear role override — revert to session's default roles.
   async clearImpersonation() {
     if (!this.session) return;
-    log.info("runner Clearing impersonation");
+    log.info("Clearing role override");
     const result = await impersonate(this.appId, this.session.sessionId, null);
     await this.refreshClientContext();
     devRequestEvents.emitImpersonate({ roles: result.roles });
@@ -825,7 +1062,94 @@ var DevRunner = class {
       this.session.clientContext = context;
       this.proxy.updateClientContext(context);
     } catch (err) {
-      log.warn("runner Failed to refresh client context", { error: err instanceof Error ? err.message : String(err) });
+      log.warn("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
+  // and programmatic callers to test methods without a browser.
+  async runMethod(opts) {
+    if (!this.session || !this.transpiler) {
+      return { success: false, error: { message: "Session not started" }, duration: 0 };
+    }
+    const requestId = randomBytes2(8).toString("hex");
+    const startTime = Date.now();
+    devRequestEvents.emitStart({
+      id: requestId,
+      type: "execute",
+      method: opts.methodExport,
+      timestamp: startTime
+    });
+    log.info("Method received (direct)", { requestId, method: opts.methodExport });
+    try {
+      const authorizationToken = await fetchCallbackToken(this.appId, this.session.sessionId);
+      const transpiledPath = await this.transpiler.transpile(opts.methodPath);
+      const result = await executeMethod({
+        transpiledPath,
+        methodExport: opts.methodExport,
+        input: opts.input,
+        auth: this.session.auth,
+        databases: this.session.databases,
+        authorizationToken,
+        apiBaseUrl: getApiBaseUrl(),
+        projectRoot: this.projectRoot
+      });
+      const duration = Date.now() - startTime;
+      if (result.success) {
+        log.info("Method complete", { requestId, method: opts.methodExport, duration });
+      } else {
+        log.warn("Method failed", {
+          requestId,
+          method: opts.methodExport,
+          duration,
+          error: result.error ? formatErrorForDisplay(result.error) : void 0
+        });
+      }
+      logMethodExecution({
+        requestId,
+        sessionId: this.session.sessionId,
+        methodExport: opts.methodExport,
+        methodPath: opts.methodPath,
+        input: opts.input,
+        authorizationToken,
+        databases: this.session.databases,
+        result,
+        duration
+      });
+      devRequestEvents.emitComplete({
+        id: requestId,
+        success: result.success,
+        duration,
+        error: result.error ? formatErrorForDisplay(result.error) : void 0
+      });
+      return {
+        success: result.success,
+        output: result.output,
+        error: result.error ?? null,
+        stdout: result.stdout,
+        duration
+      };
+    } 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 });
+      logMethodExecution({
+        requestId,
+        sessionId: this.session.sessionId,
+        methodExport: opts.methodExport,
+        methodPath: opts.methodPath,
+        input: opts.input,
+        authorizationToken: "",
+        databases: this.session.databases,
+        result: { success: false, error: { message } },
+        duration
+      });
+      devRequestEvents.emitComplete({
+        id: requestId,
+        success: false,
+        duration,
+        error: message
+      });
+      return { success: false, error: { message }, duration };
     }
   }
   // Run a scenario: truncate tables → execute seed → impersonate roles.
@@ -841,16 +1165,15 @@ var DevRunner = class {
       name: scenarioName,
       timestamp: startTime
     });
-    log.info("runner Running scenario", { id: scenario.id, name: scenarioName });
+    log.info("Scenario starting", { id: scenario.id, name: scenarioName });
     try {
-      log.debug("runner Truncating database for scenario");
+      log.info("Resetting database for scenario");
       const databases = await resetDevDatabase(this.appId, this.session.sessionId, "truncate");
       this.session.databases = databases;
-      log.debug("runner Transpiling scenario", { path: scenario.path });
+      log.info("Transpiling scenario", { path: scenario.path });
       const transpiledPath = await this.transpiler.transpile(scenario.path);
-      log.debug("runner Fetching callback token for scenario");
       const authorizationToken = await fetchCallbackToken(this.appId, this.session.sessionId);
-      log.debug("runner Executing scenario seed", { export: scenario.export });
+      log.info("Running scenario seed function", { export: scenario.export });
       const result = await executeMethod({
         transpiledPath,
         methodExport: scenario.export,
@@ -863,7 +1186,14 @@ var DevRunner = class {
       });
       if (!result.success) {
         const error = result.error?.message ?? "Scenario seed failed";
-        log.error("runner Scenario seed failed", { id: scenario.id, error });
+        log.error("Scenario seed function failed", { id: scenario.id, error });
+        logScenarioExecution({
+          sessionId: this.session.sessionId,
+          scenario,
+          databases: this.session.databases,
+          result,
+          duration: Date.now() - startTime
+        });
         devRequestEvents.emitScenarioComplete({
           id: scenario.id,
           success: false,
@@ -874,12 +1204,19 @@ var DevRunner = class {
         return { success: false, databases, error };
       }
       if (scenario.roles.length > 0) {
-        log.debug("runner Impersonating for scenario", { roles: scenario.roles });
+        log.info("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("runner Scenario complete", { id: scenario.id, duration, roles: scenario.roles });
+      log.info("Scenario complete", { id: scenario.id, duration, roles: scenario.roles });
+      logScenarioExecution({
+        sessionId: this.session.sessionId,
+        scenario,
+        databases: this.session.databases,
+        result,
+        duration
+      });
       devRequestEvents.emitScenarioComplete({
         id: scenario.id,
         success: true,
@@ -889,7 +1226,15 @@ var DevRunner = class {
       return { success: true, databases };
     } catch (err) {
       const error = err instanceof Error ? err.message : "Unknown error";
-      log.error("runner Scenario failed", { id: scenario.id, error });
+      log.error("Scenario failed", { id: scenario.id, error });
+      logScenarioExecution({
+        sessionId: this.session.sessionId,
+        scenario,
+        databases: this.session.databases,
+        result: null,
+        infrastructureError: error,
+        duration: Date.now() - startTime
+      });
       devRequestEvents.emitScenarioComplete({
         id: scenario.id,
         success: false,
@@ -910,7 +1255,7 @@ var DevRunner = class {
         );
         if (this.hadConnectionWarning) {
           this.hadConnectionWarning = false;
-          log.info("runner Connection restored");
+          log.info("Connection to platform restored");
           devRequestEvents.emitConnectionRestored();
         }
         if (request) {
@@ -919,31 +1264,31 @@ var DevRunner = class {
         this.backoffMs = 1e3;
       } catch (error) {
         if (error instanceof DevPollError && error.statusCode === 404) {
-          log.error("runner Session expired (404)");
+          log.error("Dev session expired", { statusCode: 404 });
           devRequestEvents.emitSessionExpired();
           this.isRunning = false;
           return;
         }
         if ((error instanceof DevPollError || error instanceof ApiError) && error.statusCode === 401) {
-          log.warn("runner Auth token expired (401), attempting refresh");
+          log.warn("Session token expired, re-authenticating");
           const refreshed = await this.refreshAuth();
           if (refreshed) {
             this.backoffMs = 1e3;
             continue;
           }
-          log.error("runner Auth refresh failed, stopping");
+          log.error("Re-authentication failed");
           devRequestEvents.emitSessionExpired();
           this.isRunning = false;
           return;
         }
         if (!this.hadConnectionWarning) {
           this.hadConnectionWarning = true;
-          log.warn("runner Connection lost, retrying...");
+          log.warn("Lost connection to platform, retrying");
           devRequestEvents.emitConnectionWarning(
             "Lost connection to platform, retrying..."
           );
         }
-        log.debug("runner Backing off", { ms: this.backoffMs });
+        log.debug("Backing off", { ms: this.backoffMs });
         await this.sleep(this.backoffMs);
         this.backoffMs = Math.min(this.backoffMs * 2, 3e4);
       }
@@ -957,9 +1302,9 @@ var DevRunner = class {
       method: request.methodExport,
       timestamp: startTime
     });
-    log.info("runner Request received", { requestId: request.requestId, method: request.methodExport });
+    log.info("Method received", { requestId: request.requestId, method: request.methodExport });
     try {
-      log.debug("runner Transpiling", { path: request.methodPath });
+      log.debug("Transpiling method", { path: request.methodPath });
       const transpiledPath = await this.transpiler.transpile(request.methodPath);
       const auth = request.roleOverride ? {
         userId: this.session.auth.userId,
@@ -994,7 +1339,28 @@ var DevRunner = class {
         devResult
       );
       const duration = Date.now() - startTime;
-      log.info("runner Request complete", { requestId: request.requestId, success: result.success, duration });
+      if (result.success) {
+        log.info("Method complete", { requestId: request.requestId, method: request.methodExport, duration });
+      } else {
+        log.warn("Method failed", {
+          requestId: request.requestId,
+          method: request.methodExport,
+          duration,
+          error: result.error ? formatErrorForDisplay(result.error) : void 0
+        });
+      }
+      logMethodExecution({
+        requestId: request.requestId,
+        sessionId: this.session.sessionId,
+        methodExport: request.methodExport,
+        methodPath: request.methodPath,
+        input: request.input,
+        roleOverride: request.roleOverride,
+        authorizationToken: request.authorizationToken,
+        databases: this.session.databases,
+        result,
+        duration
+      });
       devRequestEvents.emitComplete({
         id: request.requestId,
         success: result.success,
@@ -1004,7 +1370,7 @@ var DevRunner = class {
     } catch (error) {
       const message = error instanceof Error ? error.message : "Unknown error";
       const duration = Date.now() - startTime;
-      log.error("runner Request failed", { requestId: request.requestId, duration, error: message });
+      log.error("Method error", { requestId: request.requestId, method: request.methodExport, duration, error: message });
       try {
         await submitDevResult(
           this.appId,
@@ -1017,8 +1383,20 @@ var DevRunner = class {
           }
         );
       } catch (submitErr) {
-        log.error("runner Failed to submit error result", { error: submitErr instanceof Error ? submitErr.message : String(submitErr) });
+        log.error("Failed to report method error to platform", { error: submitErr instanceof Error ? submitErr.message : String(submitErr) });
       }
+      logMethodExecution({
+        requestId: request.requestId,
+        sessionId: this.session.sessionId,
+        methodExport: request.methodExport,
+        methodPath: request.methodPath,
+        input: request.input,
+        roleOverride: request.roleOverride,
+        authorizationToken: request.authorizationToken,
+        databases: this.session.databases,
+        result: { success: false, error: { message } },
+        duration: Date.now() - startTime
+      });
       devRequestEvents.emitComplete({
         id: request.requestId,
         success: false,
@@ -1036,14 +1414,14 @@ var DevRunner = class {
     const POLL_INTERVAL = 2e3;
     const MAX_ATTEMPTS = 30;
     try {
-      log.info("runner Auth expired, requesting re-authentication");
+      log.info("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("runner Could not open browser for auth \u2014 user must visit URL manually");
+        log.warn("Could not open browser \u2014 visit URL to re-authenticate");
       }
       for (let i = 0; i < MAX_ATTEMPTS; i++) {
         await this.sleep(POLL_INTERVAL);
@@ -1054,7 +1432,7 @@ var DevRunner = class {
           if (result.userId) {
             setUserId(result.userId);
           }
-          log.info("runner Auth refreshed successfully");
+          log.info("Re-authentication successful");
           devRequestEvents.emitAuthRefreshSuccess();
           return true;
         }
@@ -1062,11 +1440,11 @@ var DevRunner = class {
           break;
         }
       }
-      log.error("runner Auth refresh timed out or was denied");
+      log.error("Re-authentication timed out or was denied");
       devRequestEvents.emitAuthRefreshFailed();
       return false;
     } catch (err) {
-      log.error("runner Auth refresh failed", { error: err instanceof Error ? err.message : String(err) });
+      log.error("Re-authentication failed", { error: err instanceof Error ? err.message : String(err) });
       devRequestEvents.emitAuthRefreshFailed();
       return false;
     }
@@ -1075,42 +1453,72 @@ var DevRunner = class {
     return new Promise((resolve2) => setTimeout(resolve2, ms));
   }
 };
-function formatErrorForDisplay(error) {
-  const parts = [];
-  if (error.message) {
-    parts.push(String(error.message));
-  }
-  const code = error.code ?? error.statusCode ?? error.status;
-  if (code !== void 0) {
-    parts.push(`(code: ${code})`);
-  }
-  if (error.body) {
-    parts.push(`Response: ${String(error.body).slice(0, 200)}`);
-  } else if (error.response) {
-    parts.push(`Response: ${String(error.response).slice(0, 200)}`);
-  }
-  if (error.cause && typeof error.cause === "object") {
-    const cause = error.cause;
-    if (cause.message) {
-      parts.push(`Caused by: ${cause.message}`);
-    }
+
+// src/dev/browser-log.ts
+var ndjsonLog2 = new NdjsonLog("browser.ndjson");
+function initBrowserLog(projectRoot) {
+  ndjsonLog2.init(projectRoot);
+}
+function appendBrowserLogEntries(entries) {
+  for (const entry of entries) {
+    ndjsonLog2.append({
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      ...entry
+    });
   }
-  return parts.join("\n");
+}
+function closeBrowserLog() {
+  ndjsonLog2.close();
 }
 
 // src/dev/proxy.ts
 import http from "http";
+import { randomBytes as randomBytes3 } from "crypto";
 var DevProxy = class {
-  constructor(upstreamPort, clientContext, bindAddress = "127.0.0.1") {
+  constructor(upstreamPort, clientContext, bindAddress = "127.0.0.1", browserAgentUrl) {
     this.upstreamPort = upstreamPort;
     this.clientContext = clientContext;
     this.bindAddress = bindAddress;
+    this.browserAgentUrl = browserAgentUrl;
   }
   server = null;
   proxyPort = null;
+  commandQueue = [];
+  pendingResults = /* @__PURE__ */ new Map();
+  lastBrowserPoll = 0;
   updateClientContext(context) {
     this.clientContext = context;
-    log.info("proxy Client context updated");
+    log.info("Dev proxy context updated after role change");
+  }
+  /**
+   * Whether a browser agent is actively polling for commands.
+   * Based on whether we've seen a poll within the last 500ms.
+   */
+  isBrowserConnected() {
+    return Date.now() - this.lastBrowserPoll < 500;
+  }
+  /**
+   * Dispatch a browser command and wait for the result.
+   * The command is queued for the browser agent to pick up via polling.
+   * Returns a promise that resolves when the browser posts the result back.
+   */
+  dispatchBrowserCommand(steps, timeoutMs = 3e4) {
+    if (!this.isBrowserConnected()) {
+      return Promise.reject(
+        new Error("No browser connected, please refresh the MindStudio preview")
+      );
+    }
+    const id = randomBytes3(4).toString("hex");
+    log.info("Browser command queued", { id, stepCount: steps.length, commands: steps.map((s) => s.command) });
+    return new Promise((resolve2, reject) => {
+      const timeout = setTimeout(() => {
+        this.pendingResults.delete(id);
+        log.warn("Browser command timed out", { id, pendingCount: this.pendingResults.size, queueLength: this.commandQueue.length });
+        reject(new Error("Browser command timed out"));
+      }, timeoutMs);
+      this.pendingResults.set(id, { resolve: resolve2, timeout });
+      this.commandQueue.push({ id, steps });
+    });
   }
   async start(preferredPort) {
     const server = http.createServer((req, res) => {
@@ -1125,10 +1533,10 @@ var DevProxy = class {
         const assignedPort = await this.listenOnPort(server, port);
         this.server = server;
         this.proxyPort = assignedPort;
-        log.info("proxy Started", { port: assignedPort, bind: this.bindAddress });
+        log.info("Dev proxy started", { port: assignedPort, bind: this.bindAddress });
         return assignedPort;
       } catch {
-        log.warn("proxy Port in use, trying next", { port });
+        log.warn("Proxy port in use, trying next", { port });
       }
     }
     throw new Error("Failed to start proxy server");
@@ -1153,77 +1561,196 @@ var DevProxy = class {
   }
   stop() {
     if (this.server) {
-      log.info("proxy Stopping");
+      log.info("Dev proxy stopping");
       this.server.close();
       this.server = null;
       this.proxyPort = null;
     }
+    for (const [id, pending2] of this.pendingResults) {
+      clearTimeout(pending2.timeout);
+      pending2.resolve({ id, steps: [], error: "Proxy stopped" });
+    }
+    this.pendingResults.clear();
+    this.commandQueue.length = 0;
   }
   getPort() {
     return this.proxyPort;
   }
+  // ---------------------------------------------------------------------------
+  // CORS helper
+  // ---------------------------------------------------------------------------
+  corsHeaders(req) {
+    const origin = req.headers.origin;
+    if (!origin) return {};
+    return {
+      "access-control-allow-origin": origin,
+      "access-control-allow-private-network": "true"
+    };
+  }
+  // ---------------------------------------------------------------------------
+  // Request routing
+  // ---------------------------------------------------------------------------
   handleRequest(clientReq, clientRes) {
-    const origin = clientReq.headers.origin;
-    if (clientReq.method === "OPTIONS" && origin) {
+    if (clientReq.url?.startsWith("/__mindstudio_dev__/")) {
+      if (clientReq.url === "/__mindstudio_dev__/logs" && clientReq.method === "POST") {
+        this.handleBrowserLogs(clientReq, clientRes);
+        return;
+      }
+      if (clientReq.url === "/__mindstudio_dev__/commands" && clientReq.method === "GET") {
+        this.handleGetCommand(clientReq, clientRes);
+        return;
+      }
+      if (clientReq.url === "/__mindstudio_dev__/results" && clientReq.method === "POST") {
+        this.handlePostResult(clientReq, clientRes);
+        return;
+      }
+    }
+    if (clientReq.method === "OPTIONS" && clientReq.headers.origin) {
       clientRes.writeHead(204, {
-        "Access-Control-Allow-Origin": origin,
-        "Access-Control-Allow-Private-Network": "true",
-        "Access-Control-Allow-Methods": "GET, OPTIONS",
-        "Access-Control-Allow-Headers": "*"
+        ...this.corsHeaders(clientReq),
+        "access-control-allow-methods": "GET, POST, OPTIONS",
+        "access-control-allow-headers": "*"
       });
       clientRes.end();
       return;
     }
-    const options = {
-      hostname: "127.0.0.1",
-      port: this.upstreamPort,
-      path: clientReq.url,
-      method: clientReq.method,
-      headers: { ...clientReq.headers, host: `localhost:${this.upstreamPort}` }
-    };
-    const upstreamReq = http.request(options, (upstreamRes) => {
-      const contentType = upstreamRes.headers["content-type"] ?? "";
-      const isHtml = contentType.startsWith("text/html");
-      if (isHtml) {
-        const chunks = [];
-        upstreamRes.on("data", (chunk) => chunks.push(chunk));
-        upstreamRes.on("end", () => {
-          let html = Buffer.concat(chunks).toString("utf-8");
-          html = injectClientContext(html, this.clientContext);
-          const headers = { ...upstreamRes.headers };
-          headers["content-length"] = String(Buffer.byteLength(html, "utf-8"));
-          headers["cache-control"] = "no-store, no-cache, must-revalidate";
-          delete headers["content-encoding"];
+    this.forwardToUpstream(clientReq, clientRes);
+  }
+  // ---------------------------------------------------------------------------
+  // Upstream forwarding
+  // ---------------------------------------------------------------------------
+  forwardToUpstream(clientReq, clientRes) {
+    const cors = this.corsHeaders(clientReq);
+    const upstreamReq = http.request(
+      {
+        hostname: "127.0.0.1",
+        port: this.upstreamPort,
+        path: clientReq.url,
+        method: clientReq.method,
+        headers: { ...clientReq.headers, host: `localhost:${this.upstreamPort}` }
+      },
+      (upstreamRes) => {
+        const contentType = upstreamRes.headers["content-type"] ?? "";
+        const isHtml = contentType.startsWith("text/html");
+        if (isHtml) {
+          const chunks = [];
+          upstreamRes.on("data", (chunk) => chunks.push(chunk));
+          upstreamRes.on("end", () => {
+            let html = Buffer.concat(chunks).toString("utf-8");
+            html = this.injectScripts(html);
+            const headers = {
+              ...upstreamRes.headers,
+              ...cors,
+              "content-length": String(Buffer.byteLength(html, "utf-8")),
+              "cache-control": "no-store, no-cache, must-revalidate"
+            };
+            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);
+          });
+        } else {
+          const headers = {
+            ...upstreamRes.headers,
+            ...cors,
+            "cache-control": "no-store, no-cache, must-revalidate"
+          };
           delete headers["etag"];
-          if (origin) {
-            headers["access-control-allow-origin"] = origin;
-            headers["access-control-allow-private-network"] = "true";
-          }
-          log.debug("proxy HTML injected", { path: clientReq.url, size: html.length });
           clientRes.writeHead(upstreamRes.statusCode ?? 200, headers);
-          clientRes.end(html);
-        });
-      } else {
-        const headers = { ...upstreamRes.headers };
-        headers["cache-control"] = "no-store, no-cache, must-revalidate";
-        delete headers["etag"];
-        if (origin) {
-          headers["access-control-allow-origin"] = origin;
-          headers["access-control-allow-private-network"] = "true";
+          upstreamRes.pipe(clientRes);
         }
-        clientRes.writeHead(upstreamRes.statusCode ?? 200, headers);
-        upstreamRes.pipe(clientRes);
       }
-    });
+    );
     upstreamReq.on("error", (err) => {
-      log.warn("proxy Upstream error", { path: clientReq.url, error: err.message });
+      log.warn("Dev proxy cannot reach dev server", { path: clientReq.url, error: err.message });
       clientRes.writeHead(502);
       clientRes.end(`Proxy error: ${err.message}`);
     });
     clientReq.pipe(upstreamReq);
   }
+  // ---------------------------------------------------------------------------
+  // Browser agent endpoints
+  // ---------------------------------------------------------------------------
+  handleBrowserLogs(clientReq, clientRes) {
+    const chunks = [];
+    clientReq.on("data", (chunk) => chunks.push(chunk));
+    clientReq.on("end", () => {
+      try {
+        const body = Buffer.concat(chunks).toString("utf-8");
+        const entries = JSON.parse(body);
+        if (Array.isArray(entries)) {
+          appendBrowserLogEntries(entries);
+        }
+      } catch {
+      }
+      clientRes.writeHead(204, this.corsHeaders(clientReq));
+      clientRes.end();
+    });
+  }
+  handleGetCommand(clientReq, clientRes) {
+    this.lastBrowserPoll = Date.now();
+    const command = this.commandQueue.shift();
+    if (command) {
+      log.info("Browser command dispatched to agent", { id: command.id, commands: command.steps.map((s) => s.command) });
+      clientRes.writeHead(200, {
+        ...this.corsHeaders(clientReq),
+        "content-type": "application/json",
+        "cache-control": "no-store"
+      });
+      clientRes.end(JSON.stringify(command));
+    } else {
+      clientRes.writeHead(204, {
+        ...this.corsHeaders(clientReq),
+        "cache-control": "no-store"
+      });
+      clientRes.end();
+    }
+  }
+  handlePostResult(clientReq, clientRes) {
+    const chunks = [];
+    clientReq.on("data", (chunk) => chunks.push(chunk));
+    clientReq.on("end", () => {
+      try {
+        const body = Buffer.concat(chunks).toString("utf-8");
+        const result = JSON.parse(body);
+        if (result?.id) {
+          const pending2 = this.pendingResults.get(result.id);
+          if (pending2) {
+            log.info("Browser command result received", { id: result.id, stepCount: result.steps?.length, duration: result.duration });
+            clearTimeout(pending2.timeout);
+            this.pendingResults.delete(result.id);
+            pending2.resolve(result);
+          } else {
+            log.warn("Browser command result received but no pending command found", { id: result.id, pendingIds: [...this.pendingResults.keys()] });
+          }
+        } else {
+          log.warn("Browser command result received with no id", { bodyLength: body.length });
+        }
+      } catch (err) {
+        log.warn("Browser command result parse error", { error: err instanceof Error ? err.message : String(err) });
+      }
+      clientRes.writeHead(204, this.corsHeaders(clientReq));
+      clientRes.end();
+    });
+  }
+  /**
+   * Inject window.__MINDSTUDIO__ context and browser agent script tag into HTML.
+   */
+  injectScripts(html) {
+    const contextScript = `<script>window.__MINDSTUDIO__=${JSON.stringify(this.clientContext)};</script>`;
+    const agentUrl = this.browserAgentUrl || "https://unpkg.com/@mindstudio-ai/browser-agent/dist/index.js";
+    const agentScript = `<script async src="${agentUrl}"></script>`;
+    const injection = `${contextScript}
+${agentScript}`;
+    if (html.includes("</head>")) {
+      return html.replace("</head>", `${injection}
+</head>`);
+    }
+    return injection + "\n" + html;
+  }
   handleUpgrade(clientReq, clientSocket, head) {
-    log.debug("proxy WebSocket upgrade", { path: clientReq.url });
+    log.debug("Dev proxy WebSocket upgrade", { path: clientReq.url });
     const options = {
       hostname: "127.0.0.1",
       port: this.upstreamPort,
@@ -1260,22 +1787,14 @@ var DevProxy = class {
     upstreamReq.end();
   }
 };
-function injectClientContext(html, context) {
-  const script = `<script>window.__MINDSTUDIO__=${JSON.stringify(context)};</script>`;
-  if (html.includes("</head>")) {
-    return html.replace("</head>", `${script}
-</head>`);
-  }
-  return script + "\n" + html;
-}
 
 // src/dev/app-config.ts
 import { readFileSync, existsSync as existsSync2 } from "fs";
-import { join as join3, dirname as dirname2 } from "path";
+import { join as join4, dirname as dirname2 } from "path";
 function detectAppConfig(cwd = process.cwd()) {
-  const appJsonPath = join3(cwd, "mindstudio.json");
+  const appJsonPath = join4(cwd, "mindstudio.json");
   if (!existsSync2(appJsonPath)) {
-    log.debug("config mindstudio.json not found", { path: appJsonPath });
+    log.debug("mindstudio.json not found", { path: appJsonPath });
     return null;
   }
   try {
@@ -1294,7 +1813,7 @@ function detectAppConfig(cwd = process.cwd()) {
       scenarios: parsed.scenarios ?? [],
       interfaces: parsed.interfaces ?? []
     };
-    log.debug("config Detected mindstudio.json", {
+    log.info("Loaded mindstudio.json", {
       appId: config2.appId,
       roles: config2.roles.length,
       methods: config2.methods.length,
@@ -1304,7 +1823,7 @@ function detectAppConfig(cwd = process.cwd()) {
     });
     return config2;
   } catch (err) {
-    log.warn("config Failed to parse mindstudio.json", { error: err instanceof Error ? err.message : String(err) });
+    log.warn("Failed to parse mindstudio.json", { error: err instanceof Error ? err.message : String(err) });
     return null;
   }
 }
@@ -1315,7 +1834,7 @@ function getWebInterfaceConfig(appConfig, cwd = process.cwd()) {
   if (!webInterface) {
     return null;
   }
-  const configPath = join3(cwd, webInterface.path);
+  const configPath = join4(cwd, webInterface.path);
   if (!existsSync2(configPath)) {
     return null;
   }
@@ -1341,22 +1860,27 @@ function getWebProjectDir(appConfig, cwd = process.cwd()) {
   if (!webInterface) {
     return null;
   }
-  return dirname2(join3(cwd, webInterface.path));
+  return dirname2(join4(cwd, webInterface.path));
 }
 function readTableSources(appConfig, cwd = process.cwd()) {
   const results = [];
   for (const table of appConfig.tables) {
-    const filePath = join3(cwd, table.path);
+    const filePath = join4(cwd, table.path);
     if (!existsSync2(filePath)) {
+      log.warn("Table source file not found", { table: table.export, path: table.path });
       continue;
     }
     try {
       const source = readFileSync(filePath, "utf-8");
       const name = table.export;
       results.push({ name, source });
-    } catch {
+    } catch (err) {
+      log.warn("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 });
+  }
   return results;
 }
 function findDirsNeedingInstall(appConfig, cwd = process.cwd()) {
@@ -1365,9 +1889,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 = join3(cwd, ...parts.slice(0, i));
-      if (existsSync2(join3(candidate, "package.json"))) {
-        if (!existsSync2(join3(candidate, "node_modules"))) {
+      const candidate = join4(cwd, ...parts.slice(0, i));
+      if (existsSync2(join4(candidate, "package.json"))) {
+        if (!existsSync2(join4(candidate, "node_modules"))) {
           dirs.push(candidate);
         }
         break;
@@ -1375,8 +1899,8 @@ function findDirsNeedingInstall(appConfig, cwd = process.cwd()) {
     }
   }
   const webProjectDir = getWebProjectDir(appConfig, cwd);
-  if (webProjectDir && existsSync2(join3(webProjectDir, "package.json"))) {
-    if (!existsSync2(join3(webProjectDir, "node_modules"))) {
+  if (webProjectDir && existsSync2(join4(webProjectDir, "package.json"))) {
+    if (!existsSync2(join4(webProjectDir, "node_modules"))) {
       dirs.push(webProjectDir);
     }
   }
@@ -1405,11 +1929,11 @@ function detectGitBranch() {
 
 // src/dev/table-watcher.ts
 import { watch } from "chokidar";
-import { join as join4, dirname as dirname3, basename as basename2 } from "path";
+import { join as join5, dirname as dirname3, basename as basename2 } from "path";
 function watchTableFiles(tables, cwd, onChanged) {
   if (tables.length === 0) return () => {
   };
-  const filePaths = tables.map((t) => join4(cwd, t.path));
+  const filePaths = tables.map((t) => join5(cwd, t.path));
   let syncTimer;
   const watcher = watch(filePaths, {
     ignoreInitial: true,
@@ -1422,13 +1946,13 @@ function watchTableFiles(tables, cwd, onChanged) {
   });
   const dirToFiles = /* @__PURE__ */ new Map();
   for (const table of tables) {
-    const absPath = join4(cwd, table.path);
+    const absPath = join5(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("table-watcher Watching files", {
+  log.info("Watching table source files", {
     dirs: dirToFiles.size,
     tables: tables.length
   });
@@ -1440,9 +1964,9 @@ function watchTableFiles(tables, cwd, onChanged) {
 
 // src/dev/config-watcher.ts
 import { watch as watch2 } from "chokidar";
-import { join as join5 } from "path";
+import { join as join6 } from "path";
 function watchConfigFile(cwd, onChanged) {
-  const configPath = join5(cwd, "mindstudio.json");
+  const configPath = join6(cwd, "mindstudio.json");
   let debounceTimer;
   const watcher = watch2(configPath, {
     ignoreInitial: true,
@@ -1451,11 +1975,10 @@ function watchConfigFile(cwd, onChanged) {
   watcher.on("all", () => {
     clearTimeout(debounceTimer);
     debounceTimer = setTimeout(() => {
-      log.info("config-watcher mindstudio.json changed");
       onChanged();
     }, 500);
   });
-  log.info("config-watcher Watching mindstudio.json", { path: configPath });
+  log.info("Watching mindstudio.json for changes", { path: configPath });
   return () => {
     clearTimeout(debounceTimer);
     watcher.close();
@@ -1482,6 +2005,7 @@ export {
   initLoggerHeadless,
   initLoggerInteractive,
   syncSchema,
+  fetchCallbackToken,
   devRequestEvents,
   pollForRequest,
   submitProgress,
@@ -1493,7 +2017,11 @@ export {
   pollDeviceAuth,
   getEditorSessions,
   disconnectHeartbeat,
+  initRequestLog,
+  closeRequestLog,
   DevRunner,
+  initBrowserLog,
+  closeBrowserLog,
   DevProxy,
   detectAppConfig,
   getWebInterfaceConfig,
@@ -1505,4 +2033,4 @@ export {
   watchTableFiles,
   watchConfigFile
 };
-//# sourceMappingURL=chunk-4CMGJFH3.js.map
+//# sourceMappingURL=chunk-XP4GPID6.js.map