@mindstudio-ai/local-model-tunnel 0.5.53 → 0.5.55

package/dist/{chunk-MRDQMUYZ.js → chunk-5A5ASXUO.js}

@@ -25,7 +25,118 @@ import {
   syncSchema,
   watchConfigFile,
   watchTableFiles
-} from "./chunk-4HSYB4GX.js";
+} from "./chunk-ERAJTIOM.js";
+
+// src/dev/browser/launcher.ts
+import puppeteer from "puppeteer-core";
+
+// src/dev/browser/chrome-path.ts
+import { existsSync } from "fs";
+import { execSync } from "child_process";
+var CANDIDATES = [
+  "/usr/bin/google-chrome-stable",
+  "/usr/bin/google-chrome",
+  "/usr/bin/chromium",
+  "/usr/bin/chromium-browser",
+  "/opt/google/chrome/google-chrome",
+  "/Applications/Google Chrome.app/Contents/MacOS/Google Chrome",
+  "/Applications/Chromium.app/Contents/MacOS/Chromium"
+];
+var PATH_COMMANDS = ["google-chrome-stable", "google-chrome", "chromium"];
+function resolveChromePath() {
+  for (const candidate of CANDIDATES) {
+    if (existsSync(candidate)) return candidate;
+  }
+  for (const cmd of PATH_COMMANDS) {
+    try {
+      const resolved = execSync(`command -v ${cmd}`, {
+        encoding: "utf-8",
+        stdio: ["ignore", "pipe", "ignore"]
+      }).trim();
+      if (resolved && existsSync(resolved)) return resolved;
+    } catch {
+    }
+  }
+  return null;
+}
+
+// src/dev/browser/launcher.ts
+var LAUNCH_ARGS = [
+  "--no-sandbox",
+  "--disable-dev-shm-usage",
+  "--disable-gpu",
+  "--hide-scrollbars",
+  "--force-color-profile=srgb",
+  "--font-render-hinting=none",
+  "--disable-blink-features=AutomationControlled",
+  "--lang=en-US"
+];
+var DESKTOP_VIEWPORT = {
+  width: 1440,
+  height: 900,
+  deviceScaleFactor: 1,
+  isMobile: false,
+  hasTouch: false
+};
+var MOBILE_VIEWPORT = {
+  width: 390,
+  height: 844,
+  deviceScaleFactor: 2,
+  isMobile: true,
+  hasTouch: true
+};
+function viewportFor(mode) {
+  return mode === "mobile" ? MOBILE_VIEWPORT : DESKTOP_VIEWPORT;
+}
+async function launchSandboxBrowser(opts) {
+  const executablePath = resolveChromePath();
+  if (!executablePath) {
+    log.warn(
+      "browser",
+      "No Chrome executable found \u2014 sandbox-browser mode disabled for this session"
+    );
+    return null;
+  }
+  const previewMode = opts.previewMode === "mobile" ? "mobile" : "desktop";
+  const viewport = viewportFor(previewMode);
+  const browser = await puppeteer.launch({
+    executablePath,
+    headless: true,
+    args: LAUNCH_ARGS,
+    defaultViewport: viewport
+  });
+  const proc = browser.process();
+  proc?.stderr?.on("data", (buf) => {
+    const line = buf.toString().trim();
+    if (line) log.debug("browser-chrome", line);
+  });
+  const pages = await browser.pages();
+  const page = pages[0] ?? await browser.newPage();
+  const target = `http://127.0.0.1:${opts.proxyPort}/?ms_sandbox=1`;
+  try {
+    await page.goto(target, { waitUntil: "networkidle0", timeout: 15e3 });
+  } catch (err) {
+    await browser.close().catch(() => {
+    });
+    throw err;
+  }
+  const viewportStr = `${viewport.width}x${viewport.height}@${viewport.deviceScaleFactor}x`;
+  log.info("browser", "Sandbox browser launched", {
+    executablePath,
+    target,
+    previewMode,
+    viewport: viewportStr,
+    pid: proc?.pid ?? null
+  });
+  return {
+    browser,
+    page,
+    executablePath,
+    pid: proc?.pid ?? null,
+    previewMode,
+    viewport: viewportStr
+  };
+}
 
 // src/dev/ipc/ipc.ts
 function emitEvent(event, data) {
@@ -37,6 +148,349 @@ function emitResponse(action, requestId, status, data) {
   );
 }
 
+// src/dev/browser/supervisor.ts
+var BACKOFF_MS = [1e3, 2e3, 4e3, 8e3, 16e3, 3e4];
+var MAX_FAILURES = 5;
+var CLOSE_TIMEOUT_MS = 5e3;
+var BrowserSupervisor = class {
+  constructor(proxyPort, previewMode = "desktop") {
+    this.proxyPort = proxyPort;
+    this.previewMode = previewMode;
+  }
+  proxyPort;
+  previewMode;
+  browser = null;
+  page = null;
+  stopping = false;
+  degraded = false;
+  consecutiveFailures = 0;
+  restartTimer = null;
+  runningSince = null;
+  lastExitInfo = null;
+  async start() {
+    if (this.browser) return;
+    await this.launchOnce();
+  }
+  async stop() {
+    if (this.stopping) return;
+    this.stopping = true;
+    if (this.restartTimer) {
+      clearTimeout(this.restartTimer);
+      this.restartTimer = null;
+    }
+    const browser = this.browser;
+    this.browser = null;
+    this.page = null;
+    if (browser) {
+      await this.closeBrowser(browser);
+    }
+    this.runningSince = null;
+    this.lastExitInfo = null;
+    emitEvent("sandbox-browser-state", { state: "stopped" });
+  }
+  isRunning() {
+    return !!this.browser && !this.degraded;
+  }
+  isDegraded() {
+    return this.degraded;
+  }
+  /**
+   * Returns the active puppeteer Page when the sandbox browser is running
+   * and not degraded; null otherwise. Callers use this to decide whether
+   * a CDP-side fast path is available for a given command.
+   */
+  getActivePage() {
+    if (this.stopping || this.degraded) return null;
+    if (!this.browser || !this.page) return null;
+    return this.page;
+  }
+  async launchOnce() {
+    if (this.stopping) return;
+    const attempt = this.consecutiveFailures + 1;
+    log.info("browser", "Sandbox browser launch starting", {
+      proxyPort: this.proxyPort,
+      attempt
+    });
+    emitEvent("sandbox-browser-state", {
+      state: "starting",
+      attempt,
+      previewMode: this.previewMode
+    });
+    try {
+      const launched = await launchSandboxBrowser({
+        proxyPort: this.proxyPort,
+        previewMode: this.previewMode
+      });
+      if (!launched) {
+        this.degraded = true;
+        emitEvent("sandbox-browser-state", {
+          state: "degraded",
+          reason: "no-executable"
+        });
+        return;
+      }
+      if (this.stopping) {
+        await this.closeBrowser(launched.browser).catch(() => {
+        });
+        return;
+      }
+      this.browser = launched.browser;
+      this.page = launched.page;
+      this.consecutiveFailures = 0;
+      this.degraded = false;
+      this.runningSince = Date.now();
+      this.lastExitInfo = null;
+      const proc = launched.browser.process();
+      proc?.once("exit", (code, signal) => {
+        this.lastExitInfo = { exitCode: code, signal: signal ?? null };
+      });
+      launched.browser.on("disconnected", () => this.onDisconnect());
+      emitEvent("sandbox-browser-state", {
+        state: "running",
+        pid: launched.pid,
+        previewMode: launched.previewMode,
+        viewport: launched.viewport,
+        executablePath: launched.executablePath
+      });
+    } catch (err) {
+      if (this.stopping) return;
+      this.consecutiveFailures++;
+      const message = err instanceof Error ? err.message : String(err);
+      log.warn("browser", "Failed to launch sandbox browser", {
+        attempt: this.consecutiveFailures,
+        error: message
+      });
+      emitEvent("sandbox-browser-state", {
+        state: "crashed",
+        exitCode: null,
+        signal: null,
+        durationMs: 0,
+        consecutiveFailures: this.consecutiveFailures,
+        error: message
+      });
+      this.scheduleRestart();
+    }
+  }
+  async onDisconnect() {
+    if (this.stopping) return;
+    const hadBrowser = !!this.browser;
+    this.browser = null;
+    this.page = null;
+    if (!hadBrowser) return;
+    this.consecutiveFailures++;
+    const durationMs = this.runningSince ? Date.now() - this.runningSince : 0;
+    this.runningSince = null;
+    log.warn("browser", "Sandbox browser disconnected", {
+      attempt: this.consecutiveFailures
+    });
+    await this.waitForExitInfo();
+    emitEvent("sandbox-browser-state", {
+      state: "crashed",
+      exitCode: this.lastExitInfo?.exitCode ?? null,
+      signal: this.lastExitInfo?.signal ?? null,
+      durationMs,
+      consecutiveFailures: this.consecutiveFailures
+    });
+    this.lastExitInfo = null;
+    this.scheduleRestart();
+  }
+  async waitForExitInfo(timeoutMs = 200) {
+    if (this.lastExitInfo) return;
+    const deadline = Date.now() + timeoutMs;
+    while (!this.lastExitInfo && Date.now() < deadline) {
+      await new Promise((r) => setTimeout(r, 20));
+    }
+  }
+  scheduleRestart() {
+    if (this.stopping) return;
+    if (this.consecutiveFailures >= MAX_FAILURES) {
+      this.degraded = true;
+      log.warn(
+        "browser",
+        "Sandbox browser entering degraded mode after repeated failures \u2014 automation will fall back to user browsers",
+        { failures: this.consecutiveFailures }
+      );
+      emitEvent("sandbox-browser-state", {
+        state: "degraded",
+        reason: "repeated-crashes",
+        consecutiveFailures: this.consecutiveFailures
+      });
+      return;
+    }
+    const delay = BACKOFF_MS[Math.min(this.consecutiveFailures, BACKOFF_MS.length - 1)];
+    log.info("browser", "Scheduling sandbox browser restart", {
+      delayMs: delay,
+      attempt: this.consecutiveFailures
+    });
+    emitEvent("sandbox-browser-state", {
+      state: "restarting",
+      delayMs: delay,
+      nextAttempt: this.consecutiveFailures + 1
+    });
+    this.restartTimer = setTimeout(() => {
+      this.restartTimer = null;
+      void this.launchOnce();
+    }, delay);
+  }
+  async closeBrowser(browser) {
+    let resolved = false;
+    await new Promise((resolve) => {
+      const done = () => {
+        if (resolved) return;
+        resolved = true;
+        resolve();
+      };
+      const timeout = setTimeout(() => {
+        try {
+          browser.process()?.kill("SIGKILL");
+        } catch {
+        }
+        done();
+      }, CLOSE_TIMEOUT_MS);
+      browser.close().then(() => {
+        clearTimeout(timeout);
+        done();
+      }).catch(() => {
+        clearTimeout(timeout);
+        try {
+          browser.process()?.kill("SIGKILL");
+        } catch {
+        }
+        done();
+      });
+    });
+  }
+};
+
+// src/dev/browser/screenshot.ts
+var GOTO_TIMEOUT_MS = 15e3;
+var SETTLE_TIMEOUT_MS = 3e3;
+var SETTLE_IDLE_MS = 200;
+var JPEG_QUALITY = 85;
+var PREROLL_BOTTOM_DWELL_MS = 300;
+var PREROLL_NETWORK_IDLE_MS = 1500;
+var PREROLL_TOP_DWELL_MS = 100;
+async function captureViaCdp(page, opts) {
+  if (opts.path) {
+    await page.goto(opts.path, {
+      waitUntil: "networkidle0",
+      timeout: GOTO_TIMEOUT_MS
+    });
+  }
+  await page.waitForNetworkIdle({ timeout: SETTLE_TIMEOUT_MS, idleTime: SETTLE_IDLE_MS }).catch(() => {
+  });
+  if (opts.fullPage) {
+    await preRollScroll(page);
+  }
+  let width;
+  let height;
+  if (opts.fullPage) {
+    const dims = await page.evaluate(() => ({
+      width: document.documentElement.scrollWidth,
+      height: document.documentElement.scrollHeight
+    }));
+    width = dims.width;
+    height = dims.height;
+  } else {
+    const vp = page.viewport();
+    width = vp?.width ?? 0;
+    height = vp?.height ?? 0;
+  }
+  let styleMap;
+  try {
+    const result = await page.evaluate(() => {
+      const api = window.__MINDSTUDIO_BROWSER_AGENT__;
+      return api?.computeStyleMap?.() ?? null;
+    });
+    if (typeof result === "string" && result.length > 0) styleMap = result;
+  } catch {
+  }
+  const buf = await page.screenshot({
+    type: "jpeg",
+    quality: JPEG_QUALITY,
+    fullPage: opts.fullPage
+  });
+  await uploadToPresigned(opts.uploadUrl, opts.uploadFields, buf);
+  return {
+    uploaded: true,
+    width,
+    height,
+    ...styleMap ? { styleMap } : {}
+  };
+}
+async function preRollScroll(page) {
+  try {
+    const scrolled = await page.evaluate(() => {
+      const el = document.scrollingElement || document.documentElement;
+      const max = Math.max(
+        document.documentElement.scrollHeight,
+        document.body.scrollHeight
+      );
+      if (max <= window.innerHeight + 10) return false;
+      el.scrollTo({ top: max, left: 0, behavior: "instant" });
+      return true;
+    });
+    if (!scrolled) return;
+    await new Promise((r) => setTimeout(r, PREROLL_BOTTOM_DWELL_MS));
+    await page.waitForNetworkIdle({
+      timeout: PREROLL_NETWORK_IDLE_MS,
+      idleTime: SETTLE_IDLE_MS
+    }).catch(() => {
+    });
+    await page.evaluate(() => {
+      const el = document.scrollingElement || document.documentElement;
+      el.scrollTo({ top: 0, left: 0, behavior: "instant" });
+    });
+    await new Promise((r) => setTimeout(r, PREROLL_TOP_DWELL_MS));
+  } catch {
+  }
+}
+async function uploadToPresigned(uploadUrl, uploadFields, buf) {
+  const form = new FormData();
+  for (const [k, v] of Object.entries(uploadFields)) form.append(k, v);
+  form.append(
+    "file",
+    new Blob([buf], { type: "image/jpeg" }),
+    "screenshot.jpg"
+  );
+  const res = await fetch(uploadUrl, { method: "POST", body: form });
+  if (!res.ok) {
+    throw new Error(`Screenshot upload failed: ${res.status}`);
+  }
+}
+
+// src/dev/browser/cookies.ts
+var AUTH_COOKIE_NAME = "__ms_auth";
+function cookieHost(page) {
+  try {
+    return new URL(page.url()).hostname || "127.0.0.1";
+  } catch {
+    return "127.0.0.1";
+  }
+}
+async function clearAuthCookies(page) {
+  const domain = cookieHost(page);
+  try {
+    await page.deleteCookie({ name: AUTH_COOKIE_NAME, domain });
+  } catch {
+  }
+  try {
+    await page.deleteCookie({ name: AUTH_COOKIE_NAME });
+  } catch {
+  }
+}
+async function setAuthCookie(page, value) {
+  const domain = cookieHost(page);
+  await page.setCookie({
+    name: AUTH_COOKIE_NAME,
+    value,
+    domain,
+    path: "/",
+    sameSite: "None",
+    secure: true
+  });
+}
+
 // src/dev/ipc/session-events.ts
 function subscribeDevEvents(shutdown) {
   const unsubs = [];
@@ -154,68 +608,159 @@ async function handleClearImpersonation(ctx) {
 }
 
 // src/dev/stdin-commands/browser.ts
+var MIN_RECORDING_BYTES = 5e3;
 async function handleBrowser(ctx, cmd) {
   if (!ctx.state.proxy) throw new CommandError("No active proxy", "NO_BROWSER");
   const steps = cmd.steps;
   if (!Array.isArray(steps) || steps.length === 0) {
     throw new CommandError('browser action requires a non-empty "steps" array', "INVALID_INPUT");
   }
-  const preparedSteps = await injectScreenshotUploads(ctx, steps);
-  const result = await ctx.state.proxy.dispatchBrowserCommand(preparedSteps);
-  const resultSteps = result.steps ?? [];
-  for (const step of resultSteps) {
-    const stepResult = step.result;
-    if (stepResult?.uploaded && stepResult?._publicUrl) {
-      stepResult.url = stepResult._publicUrl;
-      delete stepResult.uploaded;
-      delete stepResult._publicUrl;
-      delete stepResult.image;
+  const page = ctx.state.browser?.getActivePage();
+  if (!page) {
+    throw new CommandError(
+      "Sandbox browser unavailable \u2014 headless Chrome is required for automation",
+      "NO_BROWSER"
+    );
+  }
+  const resultsByIndex = new Array(
+    steps.length
+  );
+  let lastSnapshot = "";
+  let lastLogs = [];
+  let totalDuration = 0;
+  const allEvents = [];
+  let buffer = [];
+  const flushBuffer = async () => {
+    if (buffer.length === 0) return;
+    const batch = buffer.map((b) => b.step);
+    const out = await ctx.state.proxy.dispatchBrowserCommand(batch);
+    const outSteps = out.steps ?? [];
+    for (let i = 0; i < buffer.length; i++) {
+      const returned = outSteps[i] ?? {};
+      resultsByIndex[buffer[i].idx] = {
+        ...returned,
+        index: buffer[i].idx,
+        command: buffer[i].step.command
+      };
+    }
+    if (typeof out.snapshot === "string" && out.snapshot.length > 0) {
+      lastSnapshot = out.snapshot;
+    }
+    if (Array.isArray(out.logs)) lastLogs = out.logs;
+    if (typeof out.duration === "number") totalDuration += out.duration;
+    if (Array.isArray(out.events)) allEvents.push(...out.events);
+    buffer = [];
+  };
+  for (let i = 0; i < steps.length; i++) {
+    const step = steps[i];
+    const command = step.command;
+    if (command === "screenshotFullPage" || command === "screenshotViewport") {
+      await flushBuffer();
+      const captured = await captureScreenshotStep(ctx, page, step, command);
+      resultsByIndex[i] = { index: i, command, result: captured };
+      totalDuration += captured._durationMs ?? 0;
+      delete captured._durationMs;
+    } else {
+      buffer.push({ idx: i, step });
     }
   }
-  const hasStepError = resultSteps.some((s) => s.error);
+  await flushBuffer();
+  const densified = resultsByIndex.map(
+    (r, idx) => r ?? { index: idx, command: steps[idx].command, error: "no result" }
+  );
+  const hasStepError = densified.some((s) => s?.error);
+  const recordingUrl = await uploadRecording(ctx, allEvents);
   return {
     success: !hasStepError,
     ...hasStepError ? { errorCode: "BROWSER_ERROR" } : {},
-    steps: resultSteps,
-    snapshot: result.snapshot,
-    logs: result.logs,
-    duration: result.duration
+    steps: densified,
+    snapshot: lastSnapshot,
+    logs: lastLogs,
+    duration: totalDuration,
+    ...recordingUrl ? { recordingUrl } : {}
   };
 }
-async function injectScreenshotUploads(ctx, steps) {
+async function captureScreenshotStep(ctx, page, step, command) {
   const session = ctx.state.runner?.getSession();
   const appId = ctx.state.appConfig?.appId;
-  if (!session || !appId) return steps;
-  const prepared = [];
-  for (const step of steps) {
-    if (step.command === "screenshotViewport") {
-      try {
-        const { uploadUrl, uploadFields, publicUrl } = await getUploadUrl(
-          appId,
-          session.sessionId,
-          "jpg",
-          "image/jpeg"
-        );
-        prepared.push({ ...step, uploadUrl, uploadFields, _publicUrl: publicUrl });
-      } catch {
-        prepared.push(step);
-      }
-    } else {
-      prepared.push(step);
+  if (!session || !appId) {
+    throw new CommandError("No active session", "NO_SESSION");
+  }
+  const { uploadUrl, uploadFields, publicUrl } = await getUploadUrl(
+    appId,
+    session.sessionId,
+    "jpg",
+    "image/jpeg"
+  );
+  const start = Date.now();
+  const r = await captureViaCdp(page, {
+    fullPage: command === "screenshotFullPage",
+    path: typeof step.path === "string" ? step.path : void 0,
+    uploadUrl,
+    uploadFields
+  });
+  return {
+    url: publicUrl,
+    width: r.width,
+    height: r.height,
+    ...r.styleMap ? { styleMap: r.styleMap } : {},
+    _durationMs: Date.now() - start
+  };
+}
+async function uploadRecording(ctx, events) {
+  if (events.length === 0) return null;
+  const session = ctx.state.runner?.getSession();
+  const appId = ctx.state.appConfig?.appId;
+  if (!session || !appId) return null;
+  const body = JSON.stringify(events);
+  if (body.length < MIN_RECORDING_BYTES) return null;
+  try {
+    const { uploadUrl, uploadFields, publicUrl } = await getUploadUrl(
+      appId,
+      session.sessionId,
+      "json",
+      "application/json"
+    );
+    const form = new FormData();
+    for (const [k, v] of Object.entries(uploadFields)) form.append(k, v);
+    form.append(
+      "file",
+      new Blob([body], { type: "application/json" }),
+      "recording.json"
+    );
+    const res = await fetch(uploadUrl, { method: "POST", body: form });
+    if (!res.ok) {
+      log.warn("browser", "Recording upload failed", {
+        status: res.status,
+        bytes: body.length
+      });
+      return null;
     }
+    log.info("browser", "Recording uploaded", {
+      bytes: body.length,
+      events: events.length
+    });
+    return publicUrl;
+  } catch (err) {
+    log.warn("browser", "Recording upload errored", {
+      error: err instanceof Error ? err.message : String(err)
+    });
+    return null;
   }
-  return prepared;
 }
 
 // src/dev/stdin-commands/screenshot-full-page.ts
 async function handleScreenshotFullPage(ctx, cmd) {
-  if (!ctx.state.proxy) throw new CommandError("No active proxy", "NO_BROWSER");
-  if (!ctx.state.proxy.isBrowserConnected()) {
-    throw new CommandError("No browser connected", "NO_BROWSER");
-  }
   if (!ctx.state.runner?.getSession() || !ctx.state.appConfig?.appId) {
     throw new CommandError("No active session", "NO_SESSION");
   }
+  const page = ctx.state.browser?.getActivePage();
+  if (!page) {
+    throw new CommandError(
+      "Sandbox browser unavailable \u2014 headless Chrome is required for screenshots",
+      "NO_BROWSER"
+    );
+  }
   const startTime = Date.now();
   const session = ctx.state.runner.getSession();
   const { uploadUrl, uploadFields, publicUrl } = await getUploadUrl(
@@ -224,23 +769,18 @@ async function handleScreenshotFullPage(ctx, cmd) {
     "jpg",
     "image/jpeg"
   );
-  const steps = [];
-  if (cmd.path) {
-    steps.push({ command: "navigate", url: cmd.path });
-  }
-  steps.push({ command: "screenshotFullPage", uploadUrl, uploadFields });
-  const result = await ctx.state.proxy.dispatchBrowserCommand(steps, 12e4);
-  const resultSteps = result.steps;
-  const stepResult = resultSteps?.[resultSteps.length - 1]?.result;
-  if (!stepResult?.uploaded) {
-    throw new CommandError("Screenshot capture or upload failed", "UPLOAD_FAILED");
-  }
+  const r = await captureViaCdp(page, {
+    fullPage: true,
+    path: typeof cmd.path === "string" ? cmd.path : void 0,
+    uploadUrl,
+    uploadFields
+  });
   return {
     success: true,
     url: publicUrl,
-    width: stepResult.width,
-    height: stepResult.height,
-    ...stepResult.styleMap ? { styleMap: stepResult.styleMap } : {},
+    width: r.width,
+    height: r.height,
+    ...r.styleMap ? { styleMap: r.styleMap } : {},
     duration: Date.now() - startTime
   };
 }
@@ -252,33 +792,6 @@ async function handleDevServerRestarting(ctx) {
   return { success: true };
 }
 
-// src/dev/stdin-commands/browser-status.ts
-async function handleBrowserStatus(ctx) {
-  return { connected: ctx.state.proxy?.isBrowserConnected() ?? false };
-}
-
-// src/dev/stdin-commands/reset-browser.ts
-async function handleResetBrowser(ctx) {
-  if (!ctx.state.proxy) throw new CommandError("No active proxy", "NO_BROWSER");
-  if (!ctx.state.proxy.isBrowserConnected()) throw new CommandError("No browser connected", "NO_BROWSER");
-  const restoreResult = await ctx.state.proxy.dispatchBrowserCommand([
-    { command: "restoreState" }
-  ]);
-  const stepResult = restoreResult.steps?.[0];
-  const restored = stepResult?.result;
-  if (restored?.restored) {
-    const steps = [{ command: "reload" }];
-    if (restored.path && restored.path !== "/") {
-      steps.push({ command: "navigate", url: restored.path });
-    }
-    steps.push({ command: "snapshot" });
-    await ctx.state.proxy.dispatchBrowserCommand(steps);
-    return { success: true, restored: true, path: restored.path };
-  }
-  ctx.state.proxy.broadcastToClients("reload");
-  return { success: true, restored: false };
-}
-
 // src/dev/stdin-commands/db-query.ts
 async function handleDbQuery(ctx, cmd) {
   if (!ctx.state.runner) throw new CommandError("No active session", "NO_SESSION");
@@ -321,32 +834,30 @@ async function handleDbQuery(ctx, cmd) {
 
 // src/dev/stdin-commands/setup-browser.ts
 async function handleSetupBrowser(ctx, cmd) {
-  if (!ctx.state.proxy) throw new CommandError("No active proxy", "NO_BROWSER");
-  if (!ctx.state.proxy.isBrowserConnected()) {
-    throw new CommandError("No browser connected", "NO_BROWSER");
-  }
   if (!ctx.state.appConfig?.appId) throw new CommandError("No active session", "NO_SESSION");
+  const page = ctx.state.browser?.getActivePage();
+  if (!page) {
+    throw new CommandError(
+      "Sandbox browser unavailable \u2014 headless Chrome is required for setup-browser",
+      "NO_BROWSER"
+    );
+  }
   const auth = cmd.auth;
   const path = cmd.path || "/";
-  const steps = [];
-  steps.push({ command: "stashState" });
-  steps.push({
-    command: "evaluate",
-    script: `document.cookie = '__ms_auth=; Max-Age=0; Path=/; Secure; SameSite=None'`
-  });
+  await clearAuthCookies(page);
   if (auth) {
     const { cookie } = await createAuthSession(ctx.state.appConfig.appId, auth);
-    steps.push({
-      command: "evaluate",
-      script: `document.cookie = '__ms_auth=${cookie}; Path=/; Secure; SameSite=None'`
-    });
+    await setAuthCookie(page, cookie);
   }
-  steps.push({ command: "reload" });
-  if (path !== "/") {
-    steps.push({ command: "navigate", url: path });
+  const absolute = new URL(path, page.url()).toString();
+  try {
+    await page.goto(absolute, { waitUntil: "networkidle0", timeout: 15e3 });
+  } catch (err) {
+    throw new CommandError(
+      `Navigation to ${path} failed: ${err instanceof Error ? err.message : String(err)}`,
+      "BROWSER_ERROR"
+    );
   }
-  steps.push({ command: "snapshot" });
-  await ctx.state.proxy.dispatchBrowserCommand(steps);
   return { success: true, path, authenticated: !!auth };
 }
 
@@ -358,8 +869,6 @@ var handlers = {
   "clear-impersonation": handleClearImpersonation,
   "browser": handleBrowser,
   "screenshotFullPage": handleScreenshotFullPage,
-  "browser-status": handleBrowserStatus,
-  "reset-browser": handleResetBrowser,
   "db-query": handleDbQuery,
   "setup-browser": handleSetupBrowser,
   "dev-server-restarting": handleDevServerRestarting
@@ -490,6 +999,17 @@ async function startSession(cwd, opts, state, shutdown) {
       }
       runner.setProxyUrl(`http://${bindAddress === "0.0.0.0" ? "localhost" : bindAddress}:${state.proxyPort}`);
       runner.setProxy(state.proxy);
+      if (opts.sandboxBrowser && state.proxyPort !== null && !state.browser) {
+        const webConfig = getWebInterfaceConfig(appConfig, cwd);
+        const previewMode = webConfig?.defaultPreviewMode ?? "desktop";
+        const supervisor = new BrowserSupervisor(state.proxyPort, previewMode);
+        state.browser = supervisor;
+        supervisor.start().catch((err) => {
+          log.warn("browser", "Sandbox browser failed to start", {
+            error: err instanceof Error ? err.message : String(err)
+          });
+        });
+      }
     }
     emitEvent("session-started", {
       sessionId: session.sessionId,
@@ -563,6 +1083,11 @@ async function teardownRunner(state) {
 }
 async function teardownAll(state) {
   await teardownRunner(state);
+  if (state.browser) {
+    await state.browser.stop().catch(() => {
+    });
+    state.browser = null;
+  }
   state.proxy?.stop();
   state.proxy = null;
   state.proxyPort = null;
@@ -585,6 +1110,7 @@ async function startHeadless(opts = {}) {
   const state = {
     runner: null,
     proxy: null,
+    browser: null,
     appConfig: null,
     proxyPort: null,
     unsubscribers: []
@@ -698,4 +1224,4 @@ async function startHeadless(opts = {}) {
 export {
   startHeadless
 };
-//# sourceMappingURL=chunk-MRDQMUYZ.js.map
+//# sourceMappingURL=chunk-5A5ASXUO.js.map