opensteer 0.9.0 → 0.9.1

package/dist/chunk-Z53HNZ7Z.js

@@ -0,0 +1,1800 @@
+import { writeLocalViewServiceState, CURRENT_PROCESS_OWNER, OPENSTEER_LOCAL_VIEW_SERVICE_VERSION, OPENSTEER_LOCAL_VIEW_SERVICE_LAYOUT, clearLocalViewServiceState, readLocalViewSessionManifest, listLocalViewSessionManifests, deleteLocalViewSessionManifest, isProcessRunning, pathExists, readPersistedLocalBrowserSessionRecord, inspectCdpEndpoint } from './chunk-BMPUL66S.js';
+import { randomBytes } from 'crypto';
+import { createServer } from 'http';
+import { readFile } from 'fs/promises';
+import { existsSync } from 'fs';
+import { once } from 'events';
+import path2 from 'path';
+import { fileURLToPath } from 'url';
+import * as WebSocket2 from 'ws';
+import WebSocket2__default from 'ws';
+
+// src/local-view/resolve-browser-websocket.ts
+async function resolveBrowserWebSocketUrl(record) {
+  if (record.engine === "playwright") {
+    if (!record.endpoint) {
+      throw new Error("Local Playwright session is missing a browser WebSocket endpoint.");
+    }
+    return record.endpoint;
+  }
+  if (!record.remoteDebuggingUrl) {
+    throw new Error("Local ABP session is missing a remote debugging URL.");
+  }
+  const inspected = await inspectCdpEndpoint({
+    endpoint: record.remoteDebuggingUrl,
+    timeoutMs: 5e3
+  });
+  return inspected.endpoint;
+}
+
+// src/local-view/discovery.ts
+async function listResolvedLocalViewSessions() {
+  const manifests = await listLocalViewSessionManifests();
+  const resolved = await Promise.all(manifests.map((manifest) => resolveSessionSummary(manifest)));
+  return resolved.filter((session) => session !== void 0).sort(
+    (left, right) => right.startedAt - left.startedAt || left.label.localeCompare(right.label)
+  );
+}
+async function resolveLocalViewSession(sessionId) {
+  const manifest = await readLocalViewSessionManifest(sessionId);
+  if (!manifest) {
+    return void 0;
+  }
+  return readResolvedLocalViewSession(manifest);
+}
+async function resolveSessionSummary(manifest) {
+  const record = await readLiveRecord(manifest);
+  if (!record) {
+    await deleteLocalViewSessionManifest(manifest.sessionId);
+    return void 0;
+  }
+  const browserName = record.executablePath ? path2.basename(record.executablePath).replace(/\.[A-Za-z0-9]+$/u, "") : void 0;
+  return {
+    sessionId: manifest.sessionId,
+    label: manifest.workspace ?? (path2.basename(manifest.rootPath) || manifest.sessionId),
+    status: isProcessRunning(record.pid) ? "live" : "stale",
+    ...manifest.workspace === void 0 ? {} : { workspace: manifest.workspace },
+    rootPath: manifest.rootPath,
+    engine: record.engine,
+    ownership: manifest.ownership,
+    pid: record.pid,
+    startedAt: record.startedAt,
+    ...browserName === void 0 ? {} : { browserName }
+  };
+}
+async function readResolvedLocalViewSession(manifest) {
+  const record = await readLiveRecord(manifest);
+  if (!record) {
+    await deleteLocalViewSessionManifest(manifest.sessionId);
+    return void 0;
+  }
+  const browserWebSocketUrl = await resolveBrowserWebSocketUrl(record).catch(() => void 0);
+  if (!browserWebSocketUrl) {
+    return void 0;
+  }
+  return {
+    manifest,
+    record,
+    browserWebSocketUrl
+  };
+}
+async function readLiveRecord(manifest) {
+  if (!await pathExists(manifest.rootPath)) {
+    return void 0;
+  }
+  const record = await readPersistedLocalBrowserSessionRecord(manifest.rootPath);
+  if (!record) {
+    return void 0;
+  }
+  if (record.pid !== manifest.pid || record.startedAt !== manifest.startedAt || !isProcessRunning(record.pid)) {
+    return void 0;
+  }
+  return record;
+}
+
+// src/local-view/runtime-state.ts
+var LocalViewRuntimeState = class {
+  activationIntentBySessionId = /* @__PURE__ */ new Map();
+  setPageActivationIntent(sessionId, targetId) {
+    this.activationIntentBySessionId.set(sessionId, {
+      targetId,
+      ts: Date.now()
+    });
+  }
+  getPageActivationIntent(sessionId) {
+    return this.activationIntentBySessionId.get(sessionId);
+  }
+  clearPageActivationIntent(sessionId, targetId) {
+    const current = this.activationIntentBySessionId.get(sessionId);
+    if (!current) {
+      return;
+    }
+    if (targetId !== void 0 && current.targetId !== targetId) {
+      return;
+    }
+    this.activationIntentBySessionId.delete(sessionId);
+  }
+};
+var LocalViewWebSocketServer = WebSocket2.WebSocketServer;
+
+// src/local-view/cdp-proxy.ts
+var DEFAULT_MAX_PENDING_CLIENT_BUFFER_BYTES = 1e6;
+var DEFAULT_UPSTREAM_OPEN_TIMEOUT_MS = 1e4;
+var LocalViewCdpProxy = class {
+  constructor(deps) {
+    this.deps = deps;
+    this.wss = new LocalViewWebSocketServer({ noServer: true });
+    this.createUpstreamSocket = deps.createUpstreamSocket ?? ((url) => new WebSocket2__default(url));
+    this.maxPendingClientBufferBytes = deps.maxPendingClientBufferBytes ?? DEFAULT_MAX_PENDING_CLIENT_BUFFER_BYTES;
+    this.upstreamOpenTimeoutMs = deps.upstreamOpenTimeoutMs ?? DEFAULT_UPSTREAM_OPEN_TIMEOUT_MS;
+  }
+  wss;
+  createUpstreamSocket;
+  maxPendingClientBufferBytes;
+  upstreamOpenTimeoutMs;
+  handleUpgrade(req, socket, head) {
+    const url = new URL(req.url || "/", "http://localhost");
+    const parts = url.pathname.split("/").filter(Boolean);
+    const isCdpPath = parts.length === 3 && parts[0] === "ws" && parts[1] === "cdp";
+    if (!isCdpPath) {
+      socket.destroy();
+      return;
+    }
+    const sessionId = parts[2];
+    this.wss.handleUpgrade(req, socket, head, (clientSocket) => {
+      void this.bindProxy(clientSocket, sessionId).catch(() => {
+        safeCloseSocket(clientSocket);
+      });
+    });
+  }
+  close() {
+    for (const client of this.wss.clients) {
+      safeCloseSocket(client);
+    }
+    this.wss.close();
+  }
+  async bindProxy(clientSocket, sessionId) {
+    const resolved = await resolveLocalViewSession(sessionId);
+    if (!resolved) {
+      safeCloseSocket(clientSocket);
+      return;
+    }
+    const upstream = this.createUpstreamSocket(resolved.browserWebSocketUrl);
+    const pendingCreateTargetCommandIds = /* @__PURE__ */ new Set();
+    const pendingAttachTargetCommandTargetIds = /* @__PURE__ */ new Map();
+    const targetIdByAttachedSessionId = /* @__PURE__ */ new Map();
+    const pendingClientMessages = [];
+    let pendingClientBufferBytes = 0;
+    let closed = false;
+    let upstreamOpenTimeout = null;
+    const closeConnection = () => {
+      if (closed) {
+        return;
+      }
+      closed = true;
+      if (upstreamOpenTimeout) {
+        clearTimeout(upstreamOpenTimeout);
+        upstreamOpenTimeout = null;
+      }
+      pendingClientMessages.length = 0;
+      pendingClientBufferBytes = 0;
+      safeCloseSocket(upstream);
+      safeCloseSocket(clientSocket);
+    };
+    upstreamOpenTimeout = setTimeout(() => {
+      if (upstream.readyState === WebSocket2__default.OPEN) {
+        return;
+      }
+      closeConnection();
+    }, this.upstreamOpenTimeoutMs);
+    clientSocket.on("message", (data, isBinary) => {
+      const outboundData = data;
+      if (!isBinary) {
+        const message = parseCdpProtocolMessage(data);
+        if (message) {
+          const activatedTargetId = readActivateTargetCommandTargetId(message);
+          if (activatedTargetId) {
+            this.deps.runtimeState.setPageActivationIntent(sessionId, activatedTargetId);
+          }
+          const createTargetCommandId = readCreateTargetCommandId(message);
+          if (createTargetCommandId !== null) {
+            pendingCreateTargetCommandIds.add(createTargetCommandId);
+          }
+          const attachTargetCommand = readAttachTargetCommand(message);
+          if (attachTargetCommand) {
+            pendingAttachTargetCommandTargetIds.set(
+              attachTargetCommand.id,
+              attachTargetCommand.targetId
+            );
+          }
+          const interactionTargetId = readInteractionTargetId(message, targetIdByAttachedSessionId);
+          if (interactionTargetId) {
+            this.deps.runtimeState.setPageActivationIntent(sessionId, interactionTargetId);
+          }
+        }
+      }
+      if (upstream.readyState === WebSocket2__default.OPEN) {
+        upstream.send(outboundData, { binary: isBinary });
+        return;
+      }
+      if (upstream.readyState !== WebSocket2__default.CONNECTING) {
+        closeConnection();
+        return;
+      }
+      const sizeBytes = rawDataSizeBytes(outboundData);
+      if (pendingClientBufferBytes + sizeBytes > this.maxPendingClientBufferBytes) {
+        closeConnection();
+        return;
+      }
+      pendingClientMessages.push({ data: outboundData, isBinary });
+      pendingClientBufferBytes += sizeBytes;
+    });
+    upstream.on("open", () => {
+      if (upstreamOpenTimeout) {
+        clearTimeout(upstreamOpenTimeout);
+        upstreamOpenTimeout = null;
+      }
+      for (const pendingMessage of pendingClientMessages.splice(0)) {
+        upstream.send(pendingMessage.data, { binary: pendingMessage.isBinary });
+      }
+      pendingClientBufferBytes = 0;
+    });
+    upstream.on("message", (data, isBinary) => {
+      if (!isBinary) {
+        const message = parseCdpProtocolMessage(data);
+        if (message) {
+          const createdTargetId = readCreateTargetResultTargetId(
+            message,
+            pendingCreateTargetCommandIds
+          );
+          if (createdTargetId) {
+            this.deps.runtimeState.setPageActivationIntent(sessionId, createdTargetId);
+          }
+          const attachedTarget = readAttachTargetResult(
+            message,
+            pendingAttachTargetCommandTargetIds
+          );
+          if (attachedTarget) {
+            targetIdByAttachedSessionId.set(attachedTarget.sessionId, attachedTarget.targetId);
+          }
+          const detachedSessionId = readDetachedTargetSessionId(message);
+          if (detachedSessionId) {
+            targetIdByAttachedSessionId.delete(detachedSessionId);
+          }
+        }
+      }
+      if (clientSocket.readyState === WebSocket2__default.OPEN) {
+        clientSocket.send(data, { binary: isBinary });
+      }
+    });
+    clientSocket.on("close", closeConnection);
+    clientSocket.on("error", closeConnection);
+    upstream.on("close", closeConnection);
+    upstream.on("error", closeConnection);
+  }
+};
+function parseCdpProtocolMessage(data) {
+  try {
+    const parsed = JSON.parse(rawDataToString(data));
+    return parsed && typeof parsed === "object" ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+function readCreateTargetCommandId(message) {
+  return message.method === "Target.createTarget" && typeof message.id === "number" ? message.id : null;
+}
+function readCreateTargetResultTargetId(message, pendingCommandIds) {
+  if (typeof message.id !== "number" || !pendingCommandIds.has(message.id)) {
+    return null;
+  }
+  pendingCommandIds.delete(message.id);
+  const targetId = message.result?.targetId;
+  return typeof targetId === "string" && targetId.length > 0 ? targetId : null;
+}
+function readActivateTargetCommandTargetId(message) {
+  const targetId = message.method === "Target.activateTarget" ? message.params?.targetId : void 0;
+  return typeof targetId === "string" && targetId.length > 0 ? targetId : null;
+}
+function readAttachTargetCommand(message) {
+  if (message.method !== "Target.attachToTarget" || typeof message.id !== "number") {
+    return null;
+  }
+  const targetId = message.params?.targetId;
+  if (typeof targetId !== "string" || targetId.length === 0) {
+    return null;
+  }
+  return {
+    id: message.id,
+    targetId
+  };
+}
+function readAttachTargetResult(message, pendingTargetIds) {
+  if (typeof message.id !== "number") {
+    return null;
+  }
+  const targetId = pendingTargetIds.get(message.id);
+  if (!targetId) {
+    return null;
+  }
+  pendingTargetIds.delete(message.id);
+  const sessionId = message.result?.sessionId;
+  if (typeof sessionId !== "string" || sessionId.length === 0) {
+    return null;
+  }
+  return {
+    sessionId,
+    targetId
+  };
+}
+function readInteractionTargetId(message, targetIdByAttachedSessionId) {
+  const sessionId = message.sessionId;
+  if (typeof sessionId !== "string" || sessionId.length === 0) {
+    return null;
+  }
+  if (!message.method || !message.method.startsWith("Input.") && !message.method.startsWith("Page.")) {
+    return null;
+  }
+  return targetIdByAttachedSessionId.get(sessionId) ?? null;
+}
+function readDetachedTargetSessionId(message) {
+  if (message.method !== "Target.detachedFromTarget") {
+    return null;
+  }
+  const sessionId = message.params?.sessionId;
+  return typeof sessionId === "string" && sessionId.length > 0 ? sessionId : null;
+}
+function rawDataToString(data) {
+  if (typeof data === "string") {
+    return data;
+  }
+  if (data instanceof ArrayBuffer) {
+    return Buffer.from(data).toString("utf8");
+  }
+  if (Array.isArray(data)) {
+    return Buffer.concat(data).toString("utf8");
+  }
+  return data.toString("utf8");
+}
+function rawDataSizeBytes(data) {
+  if (typeof data === "string") {
+    return Buffer.byteLength(data);
+  }
+  if (data instanceof ArrayBuffer) {
+    return data.byteLength;
+  }
+  if (Array.isArray(data)) {
+    return data.reduce((total, entry) => total + entry.byteLength, 0);
+  }
+  return data.byteLength;
+}
+function safeCloseSocket(socket) {
+  try {
+    socket.close();
+  } catch {
+  }
+}
+
+// src/local-view/tab-state-tracker.ts
+var ACTIVATION_INTENT_DISCOVERY_GRACE_MS = 2e3;
+var TabStateTracker = class {
+  deps;
+  timer = null;
+  running = false;
+  lastActivePage = null;
+  lastTabsSignature = "";
+  tickInFlight = false;
+  metadataByPage = /* @__PURE__ */ new Map();
+  targetIdByPage = /* @__PURE__ */ new WeakMap();
+  pageCleanupByPage = /* @__PURE__ */ new Map();
+  boundContextCleanup = null;
+  constructor(deps) {
+    this.deps = deps;
+  }
+  start() {
+    if (this.running) {
+      return;
+    }
+    this.running = true;
+    this.bindContextEvents();
+    void this.reconcile({
+      includeFocus: true,
+      refreshMetadata: true
+    });
+  }
+  stop() {
+    this.running = false;
+    if (this.timer) {
+      clearInterval(this.timer);
+      this.timer = null;
+    }
+    this.boundContextCleanup?.();
+    this.boundContextCleanup = null;
+    for (const cleanup of this.pageCleanupByPage.values()) {
+      cleanup();
+    }
+    this.pageCleanupByPage.clear();
+    this.metadataByPage.clear();
+  }
+  bindContextEvents() {
+    if (this.boundContextCleanup) {
+      this.syncTrackedPages(this.deps.browserContext.pages());
+      this.updatePolling(this.deps.browserContext.pages().length);
+      return;
+    }
+    const onPage = (page) => {
+      this.syncTrackedPages(this.deps.browserContext.pages());
+      this.updatePolling(this.deps.browserContext.pages().length);
+      this.attachPageListeners(page);
+      void this.reconcile({
+        includeFocus: true,
+        refreshMetadata: true
+      });
+    };
+    this.deps.browserContext.on("page", onPage);
+    this.boundContextCleanup = () => {
+      this.deps.browserContext.off("page", onPage);
+    };
+    this.syncTrackedPages(this.deps.browserContext.pages());
+    this.updatePolling(this.deps.browserContext.pages().length);
+  }
+  syncTrackedPages(pages) {
+    const nextPages = new Set(pages);
+    for (const [page, cleanup] of this.pageCleanupByPage.entries()) {
+      if (nextPages.has(page)) {
+        continue;
+      }
+      cleanup();
+      this.pageCleanupByPage.delete(page);
+      this.metadataByPage.delete(page);
+    }
+    for (const page of pages) {
+      this.attachPageListeners(page);
+    }
+  }
+  attachPageListeners(page) {
+    if (this.pageCleanupByPage.has(page)) {
+      return;
+    }
+    const refreshMetadata = () => {
+      void this.reconcile({
+        includeFocus: false,
+        refreshMetadata: true
+      });
+    };
+    const handleClose = () => {
+      this.pageCleanupByPage.get(page)?.();
+      this.pageCleanupByPage.delete(page);
+      this.metadataByPage.delete(page);
+      void this.reconcile({
+        includeFocus: true,
+        refreshMetadata: true
+      });
+    };
+    page.on("close", handleClose);
+    page.on("domcontentloaded", refreshMetadata);
+    page.on("load", refreshMetadata);
+    page.on("framenavigated", refreshMetadata);
+    this.pageCleanupByPage.set(page, () => {
+      page.off("close", handleClose);
+      page.off("domcontentloaded", refreshMetadata);
+      page.off("load", refreshMetadata);
+      page.off("framenavigated", refreshMetadata);
+    });
+  }
+  updatePolling(pageCount) {
+    const shouldPoll = this.running && pageCount > 0;
+    if (!shouldPoll) {
+      if (this.timer) {
+        clearInterval(this.timer);
+        this.timer = null;
+      }
+      return;
+    }
+    if (this.timer) {
+      return;
+    }
+    this.timer = setInterval(() => {
+      const trackedPageCount = this.deps.browserContext.pages().length;
+      void this.reconcile({
+        includeFocus: trackedPageCount > 1,
+        refreshMetadata: true
+      });
+    }, this.deps.pollMs);
+  }
+  async reconcile(args) {
+    if (!this.running || this.tickInFlight) {
+      return;
+    }
+    this.tickInFlight = true;
+    try {
+      this.bindContextEvents();
+      const pages = this.deps.browserContext.pages();
+      this.syncTrackedPages(pages);
+      this.updatePolling(pages.length);
+      const preferredActivePage = this.lastActivePage ?? pages[0] ?? null;
+      const pageStates = await Promise.all(
+        pages.map(async (page, index) => {
+          const metadata = await this.readPageMetadata(page, {
+            refresh: args.refreshMetadata
+          });
+          const focusState = args.includeFocus ? await this.readFocusState(page) : {
+            isVisible: page === preferredActivePage,
+            hasFocus: page === preferredActivePage
+          };
+          return {
+            page,
+            index,
+            targetId: metadata.targetId,
+            url: page.url(),
+            title: metadata.title,
+            isVisible: focusState.isVisible,
+            hasFocus: focusState.hasFocus
+          };
+        })
+      );
+      const activePage = this.pickActivePage(
+        pageStates,
+        this.lastActivePage,
+        preferredActivePage,
+        this.resolveIntentPage(pageStates)
+      );
+      if (activePage && activePage !== this.lastActivePage) {
+        this.lastActivePage = activePage;
+        this.deps.onActivePageChanged(activePage);
+      }
+      const tabs = pageStates.map((state) => ({
+        index: state.index,
+        ...state.targetId === void 0 ? {} : { targetId: state.targetId },
+        url: state.url,
+        title: state.title,
+        active: activePage ? state.page === activePage : false
+      }));
+      const activeTabIndex = tabs.findIndex((tab) => tab.active);
+      const signature = JSON.stringify({
+        activeTabIndex,
+        tabs: tabs.map((tab) => ({
+          index: tab.index,
+          targetId: tab.targetId,
+          url: tab.url,
+          title: tab.title,
+          active: tab.active
+        }))
+      });
+      if (signature !== this.lastTabsSignature) {
+        this.lastTabsSignature = signature;
+        this.deps.onTabsChanged({
+          tabs,
+          activeTabIndex
+        });
+      }
+    } finally {
+      this.tickInFlight = false;
+    }
+  }
+  async readPageMetadata(page, options) {
+    const cached = this.metadataByPage.get(page);
+    if (cached && !options.refresh) {
+      return cached;
+    }
+    const [title, targetId] = await Promise.all([
+      page.title().catch(() => cached?.title ?? ""),
+      this.resolveTargetId(page).catch(() => cached?.targetId)
+    ]);
+    const nextMetadata = {
+      title,
+      targetId: targetId ?? void 0
+    };
+    this.metadataByPage.set(page, nextMetadata);
+    return nextMetadata;
+  }
+  async resolveTargetId(page) {
+    const cached = this.targetIdByPage.get(page);
+    if (cached) {
+      return cached;
+    }
+    const cdp = await page.context().newCDPSession(page);
+    try {
+      const result = await cdp.send("Target.getTargetInfo");
+      const targetId = result?.targetInfo?.targetId;
+      if (typeof targetId === "string" && targetId.length > 0) {
+        this.targetIdByPage.set(page, targetId);
+        return targetId;
+      }
+      return null;
+    } finally {
+      await cdp.detach().catch(() => void 0);
+    }
+  }
+  async readFocusState(page) {
+    try {
+      const result = await page.evaluate(() => ({
+        visibilityState: globalThis.document?.visibilityState,
+        hasFocus: globalThis.document?.hasFocus?.() ?? false
+      }));
+      return {
+        isVisible: result.visibilityState === "visible",
+        hasFocus: result.hasFocus === true
+      };
+    } catch {
+      return {
+        isVisible: false,
+        hasFocus: false
+      };
+    }
+  }
+  pickActivePage(pageStates, lastActivePage, fallbackPage, intent) {
+    if (intent) {
+      return intent.page;
+    }
+    const focusedVisiblePages = pageStates.filter((state) => state.isVisible && state.hasFocus);
+    if (focusedVisiblePages.length === 1) {
+      return focusedVisiblePages[0]?.page ?? null;
+    }
+    const visiblePages = pageStates.filter((state) => state.isVisible);
+    if (visiblePages.length === 1) {
+      return visiblePages[0]?.page ?? null;
+    }
+    const lastActivePageState = lastActivePage ? pageStates.find((state) => state.page === lastActivePage) ?? null : null;
+    if (lastActivePageState && (focusedVisiblePages.length > 1 && lastActivePageState.isVisible && lastActivePageState.hasFocus || visiblePages.length > 1 && lastActivePageState.isVisible || visiblePages.length === 0)) {
+      return lastActivePage;
+    }
+    const fallbackPageState = fallbackPage ? pageStates.find((state) => state.page === fallbackPage) ?? null : null;
+    if (fallbackPageState && (focusedVisiblePages.length > 1 && fallbackPageState.isVisible && fallbackPageState.hasFocus || visiblePages.length > 1 && fallbackPageState.isVisible)) {
+      return fallbackPage;
+    }
+    if (focusedVisiblePages.length > 0) {
+      return focusedVisiblePages[0]?.page ?? null;
+    }
+    if (visiblePages.length > 0) {
+      return visiblePages[0]?.page ?? null;
+    }
+    if (lastActivePageState) {
+      return lastActivePageState.page;
+    }
+    if (fallbackPageState) {
+      return fallbackPageState.page;
+    }
+    return pageStates[0]?.page ?? null;
+  }
+  resolveIntentPage(pageStates) {
+    const intent = this.deps.runtimeState.getPageActivationIntent(this.deps.sessionId);
+    if (!intent) {
+      return null;
+    }
+    const matched = pageStates.find((state) => state.targetId === intent.targetId);
+    if (!matched) {
+      if (Date.now() - intent.ts > ACTIVATION_INTENT_DISCOVERY_GRACE_MS) {
+        this.deps.runtimeState.clearPageActivationIntent(this.deps.sessionId, intent.targetId);
+      }
+      return null;
+    }
+    this.deps.runtimeState.clearPageActivationIntent(this.deps.sessionId, intent.targetId);
+    return { page: matched.page };
+  }
+};
+
+// src/local-view/view-stream-capture-policy.ts
+var MIN_CAPTURE_DIMENSION_PX = 100;
+var MAX_CAPTURE_DIMENSION_PX = 8192;
+var CAPTURE_BUCKET_PX = 64;
+function selectScreencastSize(args) {
+  const viewport = normalizeViewport(args.viewport);
+  if (!viewport) {
+    return null;
+  }
+  let maxRequestedWidth = 0;
+  let maxRequestedHeight = 0;
+  for (const requestedSize of args.requestedSizes) {
+    const normalized = normalizeRequestedSize(requestedSize);
+    if (!normalized) {
+      return null;
+    }
+    maxRequestedWidth = Math.max(maxRequestedWidth, normalized.width);
+    maxRequestedHeight = Math.max(maxRequestedHeight, normalized.height);
+  }
+  if (maxRequestedWidth < MIN_CAPTURE_DIMENSION_PX || maxRequestedHeight < MIN_CAPTURE_DIMENSION_PX) {
+    return null;
+  }
+  const desiredScale = Math.max(
+    maxRequestedWidth / viewport.width,
+    maxRequestedHeight / viewport.height
+  );
+  if (desiredScale >= 1) {
+    return viewport;
+  }
+  const landscape = viewport.width >= viewport.height;
+  const sourcePrimary = landscape ? viewport.width : viewport.height;
+  const sourceSecondary = landscape ? viewport.height : viewport.width;
+  const nextPrimary = bucketDimension(sourcePrimary * desiredScale);
+  const nextSecondary = clampDimension(Math.round(nextPrimary / sourcePrimary * sourceSecondary));
+  if (!nextSecondary) {
+    return null;
+  }
+  return landscape ? { width: nextPrimary, height: nextSecondary } : { width: nextSecondary, height: nextPrimary };
+}
+function normalizeViewport(viewport) {
+  const width = clampDimension(viewport.width);
+  const height = clampDimension(viewport.height);
+  return width && height ? { width, height } : null;
+}
+function normalizeRequestedSize(requestedSize) {
+  const width = clampDimension(requestedSize.width);
+  const height = clampDimension(requestedSize.height);
+  return width && height ? { width, height } : null;
+}
+function clampDimension(value) {
+  if (!Number.isFinite(value)) {
+    return null;
+  }
+  const normalized = Math.floor(value);
+  if (normalized < MIN_CAPTURE_DIMENSION_PX) {
+    return null;
+  }
+  return Math.min(MAX_CAPTURE_DIMENSION_PX, normalized);
+}
+function bucketDimension(value) {
+  const bucketed = Math.ceil(Math.max(MIN_CAPTURE_DIMENSION_PX, value) / CAPTURE_BUCKET_PX) * CAPTURE_BUCKET_PX;
+  return Math.min(MAX_CAPTURE_DIMENSION_PX, bucketed);
+}
+function buildHelloMessage(args) {
+  return {
+    type: "hello",
+    sessionId: args.sessionId,
+    ts: Date.now(),
+    mimeType: "image/jpeg",
+    fps: args.fps,
+    quality: args.quality,
+    viewport: args.viewport
+  };
+}
+function buildTabsMessage(args) {
+  return {
+    type: "tabs",
+    sessionId: args.sessionId,
+    ts: Date.now(),
+    tabs: args.tabs,
+    activeTabIndex: args.activeTabIndex
+  };
+}
+function buildStatusMessage(args) {
+  return {
+    type: "status",
+    sessionId: args.sessionId,
+    ts: Date.now(),
+    status: args.status
+  };
+}
+function buildErrorMessage(args) {
+  return {
+    type: "error",
+    sessionId: args.sessionId,
+    ts: Date.now(),
+    error: args.error
+  };
+}
+function sendControlMessage(ws, message) {
+  if (ws.readyState !== WebSocket2__default.OPEN) {
+    return;
+  }
+  try {
+    ws.send(JSON.stringify(message), { binary: false });
+  } catch {
+  }
+}
+function parseViewClientMessage(raw) {
+  try {
+    const parsed = JSON.parse(raw);
+    if (parsed?.type !== "stream-config") {
+      return null;
+    }
+    const renderWidth = normalizeRenderDimension(parsed.renderWidth);
+    const renderHeight = normalizeRenderDimension(parsed.renderHeight);
+    if (renderWidth === null || renderHeight === null) {
+      return null;
+    }
+    return {
+      type: "stream-config",
+      renderWidth,
+      renderHeight
+    };
+  } catch {
+    return null;
+  }
+}
+function normalizeRenderDimension(value) {
+  if (typeof value !== "number" || !Number.isFinite(value)) {
+    return null;
+  }
+  const normalized = Math.floor(value);
+  if (normalized < 100) {
+    return null;
+  }
+  return Math.min(8192, normalized);
+}
+
+// src/local-view/view-stream.ts
+var INITIAL_FRAME_CAPTURE_ATTEMPTS = 3;
+var INITIAL_FRAME_CAPTURE_RETRY_DELAY_MS = 150;
+var TAB_STATE_POLL_MS = 1e3;
+var CLIENT_FRAME_FLUSH_RETRY_MS = 16;
+var LocalViewStreamHub = class {
+  deps;
+  producers = /* @__PURE__ */ new Map();
+  constructor(deps) {
+    this.deps = deps;
+  }
+  attachClient(sessionId, ws) {
+    let producer = this.producers.get(sessionId);
+    if (!producer) {
+      producer = new SessionViewStreamProducer({
+        sessionId,
+        runtimeState: this.deps.runtimeState,
+        maxFps: this.deps.maxFps,
+        quality: this.deps.quality,
+        maxClientBufferBytes: this.deps.maxClientBufferBytes,
+        onDrained: () => {
+          this.producers.delete(sessionId);
+        }
+      });
+      this.producers.set(sessionId, producer);
+    }
+    producer.addClient(ws);
+  }
+};
+var SessionViewStreamProducer = class {
+  deps;
+  clients = /* @__PURE__ */ new Set();
+  clientStateBySocket = /* @__PURE__ */ new Map();
+  frameIntervalMs;
+  tracker = null;
+  browser = null;
+  browserDisconnectedHandler = null;
+  context = null;
+  cdpSession = null;
+  screencastHandler = null;
+  pageLifecycleCleanup = null;
+  activePage = null;
+  activeViewport = null;
+  activeScreencastSizeKey = null;
+  pendingFrameAckTimer = null;
+  starting = null;
+  started = false;
+  rebinding = Promise.resolve();
+  stopped = false;
+  lastFrameSentAt = 0;
+  lastFrameBuffer = null;
+  lastTabsPayload = null;
+  constructor(deps) {
+    this.deps = deps;
+    this.frameIntervalMs = Math.max(1, Math.floor(1e3 / Math.max(1, deps.maxFps)));
+  }
+  addClient(ws) {
+    if (this.stopped) {
+      ws.close(1011, "View stream is unavailable.");
+      return;
+    }
+    this.clients.add(ws);
+    this.clientStateBySocket.set(ws, {
+      requestedRenderSize: null,
+      frameSendInFlight: false,
+      pendingFrameBuffer: null,
+      pendingFlushTimer: null
+    });
+    if (this.activeViewport) {
+      sendControlMessage(
+        ws,
+        buildHelloMessage({
+          sessionId: this.deps.sessionId,
+          fps: this.deps.maxFps,
+          quality: this.deps.quality,
+          viewport: this.activeViewport
+        })
+      );
+    }
+    if (this.lastTabsPayload) {
+      sendControlMessage(
+        ws,
+        buildTabsMessage({
+          sessionId: this.deps.sessionId,
+          tabs: this.lastTabsPayload.tabs,
+          activeTabIndex: this.lastTabsPayload.activeTabIndex
+        })
+      );
+    }
+    if (this.lastFrameBuffer) {
+      const queued = this.enqueueFrameForClient(ws, this.lastFrameBuffer);
+      if (!queued) {
+        this.removeClient(ws);
+        return;
+      }
+    }
+    ws.on("close", () => {
+      this.removeClient(ws);
+    });
+    ws.on("error", () => {
+      this.removeClient(ws);
+    });
+    ws.on("message", (raw, isBinary) => {
+      if (isBinary) {
+        return;
+      }
+      const message = parseViewClientMessage(readTextFrame(raw));
+      if (message?.type !== "stream-config") {
+        return;
+      }
+      const nextSize = {
+        width: message.renderWidth,
+        height: message.renderHeight
+      };
+      const clientState = this.clientStateBySocket.get(ws);
+      if (!clientState) {
+        return;
+      }
+      const priorSize = clientState.requestedRenderSize;
+      if (priorSize?.width === nextSize.width && priorSize?.height === nextSize.height) {
+        return;
+      }
+      clientState.requestedRenderSize = nextSize;
+      this.maybeRebindForStreamConfigChange();
+    });
+    void this.ensureStarted();
+  }
+  maybeRebindForStreamConfigChange() {
+    if (!this.activePage || !this.started || this.stopped) {
+      return;
+    }
+    const nextSizeKey = this.getRequestedScreencastSizeKey();
+    if (nextSizeKey === this.activeScreencastSizeKey) {
+      return;
+    }
+    void this.queueBindToPage(this.activePage, { force: true }).catch(() => void 0);
+  }
+  removeClient(ws) {
+    this.clients.delete(ws);
+    const clientState = this.clientStateBySocket.get(ws);
+    if (clientState?.pendingFlushTimer) {
+      clearTimeout(clientState.pendingFlushTimer);
+    }
+    this.clientStateBySocket.delete(ws);
+    if (this.clients.size === 0) {
+      void this.stop();
+      return;
+    }
+    this.maybeRebindForStreamConfigChange();
+  }
+  async ensureStarted() {
+    if (this.stopped || this.started) {
+      return;
+    }
+    if (this.starting) {
+      return this.starting;
+    }
+    this.starting = this.start().then(() => {
+      if (!this.stopped) {
+        this.started = true;
+      }
+    }).finally(() => {
+      this.starting = null;
+    });
+    try {
+      await this.starting;
+    } catch {
+      this.broadcastControl(
+        buildErrorMessage({
+          sessionId: this.deps.sessionId,
+          error: "Failed to start live browser stream."
+        })
+      );
+      this.closeAllClients(1011, "View stream failed");
+      await this.stop();
+    }
+  }
+  async start() {
+    const session = await this.connectSession();
+    this.broadcastControl(
+      buildStatusMessage({
+        sessionId: this.deps.sessionId,
+        status: "starting"
+      })
+    );
+    this.browser = session.browser;
+    this.browserDisconnectedHandler = () => {
+      if (this.stopped) {
+        return;
+      }
+      this.browserDisconnectedHandler = null;
+      this.broadcastControl(
+        buildErrorMessage({
+          sessionId: this.deps.sessionId,
+          error: "Live browser stream disconnected."
+        })
+      );
+      this.closeAllClients(1011, "View stream failed");
+      void this.stop();
+    };
+    this.browser.once("disconnected", this.browserDisconnectedHandler);
+    this.context = session.context;
+    this.activePage = session.page;
+    this.activeViewport = await readViewportForPage(session.page);
+    if (this.stopped) {
+      return;
+    }
+    if (this.activeViewport) {
+      this.broadcastControl(
+        buildHelloMessage({
+          sessionId: this.deps.sessionId,
+          fps: this.deps.maxFps,
+          quality: this.deps.quality,
+          viewport: this.activeViewport
+        })
+      );
+    }
+    this.tracker = new TabStateTracker({
+      browserContext: session.context,
+      sessionId: this.deps.sessionId,
+      pollMs: TAB_STATE_POLL_MS,
+      runtimeState: this.deps.runtimeState,
+      onActivePageChanged: (page) => {
+        this.activePage = page;
+        void this.queueBindToPage(page).catch(() => void 0);
+      },
+      onTabsChanged: ({ tabs, activeTabIndex }) => {
+        this.lastTabsPayload = { tabs, activeTabIndex };
+        this.broadcastControl(
+          buildTabsMessage({
+            sessionId: this.deps.sessionId,
+            tabs,
+            activeTabIndex
+          })
+        );
+      }
+    });
+    this.tracker.start();
+    await this.queueBindToPage(session.page);
+    if (this.stopped) {
+      return;
+    }
+    this.broadcastControl(
+      buildStatusMessage({
+        sessionId: this.deps.sessionId,
+        status: "live"
+      })
+    );
+  }
+  queueBindToPage(page, options = {}) {
+    this.rebinding = this.rebinding.catch(() => void 0).then(() => this.bindToPage(page, options));
+    return this.rebinding;
+  }
+  async bindToPage(page, options = {}) {
+    if (this.stopped) {
+      return;
+    }
+    const requestedSizeKey = this.getRequestedScreencastSizeKey();
+    if (!options.force && this.activePage === page && this.cdpSession && this.activeScreencastSizeKey === requestedSizeKey) {
+      return;
+    }
+    await this.stopScreencast();
+    if (this.stopped) {
+      return;
+    }
+    const context = this.context;
+    if (!context) {
+      throw new Error("Browser context is unavailable.");
+    }
+    const requestedSize = this.getRequestedScreencastSize();
+    this.activePage = page;
+    this.activeScreencastSizeKey = requestedSizeKey;
+    this.activeViewport = await readViewportForPage(page);
+    if (this.activeViewport) {
+      this.broadcastControl(
+        buildHelloMessage({
+          sessionId: this.deps.sessionId,
+          fps: this.deps.maxFps,
+          quality: this.deps.quality,
+          viewport: this.activeViewport
+        })
+      );
+    }
+    const cdpSession = await context.newCDPSession(page);
+    if (this.stopped) {
+      await cdpSession.detach().catch(() => void 0);
+      return;
+    }
+    this.cdpSession = cdpSession;
+    const onFrame = (event) => {
+      void this.handleScreencastFrame(event);
+    };
+    this.screencastHandler = onFrame;
+    cdpSession.on("Page.screencastFrame", onFrame);
+    await cdpSession.send("Page.enable");
+    await cdpSession.send("Page.startScreencast", {
+      format: "jpeg",
+      quality: this.deps.quality,
+      everyNthFrame: 1,
+      ...requestedSize ? {
+        maxWidth: requestedSize.width,
+        maxHeight: requestedSize.height
+      } : {}
+    });
+    this.bindPageLifecycleFrameRefresh(page, cdpSession);
+    void this.seedInitialFrame(cdpSession).catch(() => void 0);
+  }
+  async connectSession() {
+    const resolved = await resolveLocalViewSession(this.deps.sessionId);
+    if (!resolved) {
+      throw new Error(`Local view session ${this.deps.sessionId} is unavailable.`);
+    }
+    const browser = await connectPlaywrightChromiumBrowser({
+      url: resolved.browserWebSocketUrl
+    });
+    try {
+      const context = browser.contexts()[0];
+      if (!context) {
+        throw new Error("Connected browser did not expose a Chromium browser context.");
+      }
+      const page = context.pages()[0] ?? await context.newPage();
+      return {
+        browser,
+        context,
+        page
+      };
+    } catch (error) {
+      await disconnectPlaywrightChromiumBrowser(browser).catch(() => void 0);
+      throw error;
+    }
+  }
+  async handleScreencastFrame(event) {
+    const cdpSession = this.cdpSession;
+    if (!cdpSession || this.stopped) {
+      return;
+    }
+    const frameBuffer = Buffer.from(event.data, "base64");
+    this.lastFrameBuffer = frameBuffer;
+    const now = Date.now();
+    const delayMs = Math.max(0, this.frameIntervalMs - (now - this.lastFrameSentAt));
+    if (delayMs === 0) {
+      this.flushScreencastFrame({
+        cdpSession,
+        sessionId: event.sessionId,
+        frameBuffer
+      });
+      return;
+    }
+    if (this.pendingFrameAckTimer !== null) {
+      return;
+    }
+    this.pendingFrameAckTimer = setTimeout(() => {
+      this.pendingFrameAckTimer = null;
+      if (this.stopped || this.cdpSession !== cdpSession) {
+        return;
+      }
+      this.flushScreencastFrame({
+        cdpSession,
+        sessionId: event.sessionId,
+        frameBuffer
+      });
+    }, delayMs);
+  }
+  flushScreencastFrame(args) {
+    this.lastFrameSentAt = Date.now();
+    this.broadcastFrame(args.frameBuffer);
+    void args.cdpSession.send("Page.screencastFrameAck", { sessionId: args.sessionId }).catch(() => void 0);
+  }
+  broadcastFrame(frameBuffer) {
+    for (const client of this.clients) {
+      if (!this.enqueueFrameForClient(client, frameBuffer)) {
+        this.removeClient(client);
+      }
+    }
+    if (this.clients.size === 0) {
+      void this.stop();
+    }
+  }
+  enqueueFrameForClient(client, frameBuffer) {
+    if (client.readyState !== WebSocket2__default.OPEN) {
+      return false;
+    }
+    const clientState = this.clientStateBySocket.get(client);
+    if (!clientState) {
+      return false;
+    }
+    clientState.pendingFrameBuffer = frameBuffer;
+    this.flushQueuedFrameToClient(client);
+    return true;
+  }
+  flushQueuedFrameToClient(client) {
+    if (client.readyState !== WebSocket2__default.OPEN) {
+      this.removeClient(client);
+      return;
+    }
+    const clientState = this.clientStateBySocket.get(client);
+    if (!clientState || clientState.frameSendInFlight || !clientState.pendingFrameBuffer) {
+      return;
+    }
+    if (clientState.pendingFlushTimer) {
+      clearTimeout(clientState.pendingFlushTimer);
+      clientState.pendingFlushTimer = null;
+    }
+    if (client.bufferedAmount > this.deps.maxClientBufferBytes) {
+      clientState.pendingFlushTimer = setTimeout(() => {
+        clientState.pendingFlushTimer = null;
+        this.flushQueuedFrameToClient(client);
+      }, CLIENT_FRAME_FLUSH_RETRY_MS);
+      return;
+    }
+    const frameBuffer = clientState.pendingFrameBuffer;
+    clientState.pendingFrameBuffer = null;
+    clientState.frameSendInFlight = true;
+    try {
+      client.send(frameBuffer, { binary: true }, (error) => {
+        const latestClientState = this.clientStateBySocket.get(client);
+        if (latestClientState) {
+          latestClientState.frameSendInFlight = false;
+        }
+        if (error) {
+          this.removeClient(client);
+          return;
+        }
+        this.flushQueuedFrameToClient(client);
+      });
+    } catch {
+      clientState.frameSendInFlight = false;
+      this.removeClient(client);
+    }
+  }
+  broadcastControl(message) {
+    for (const client of this.clients) {
+      sendControlMessage(client, message);
+    }
+  }
+  closeAllClients(code, reason) {
+    for (const client of this.clients) {
+      try {
+        client.close(code, reason);
+      } catch {
+      }
+    }
+    this.clients.clear();
+    for (const clientState of this.clientStateBySocket.values()) {
+      if (clientState.pendingFlushTimer) {
+        clearTimeout(clientState.pendingFlushTimer);
+      }
+    }
+    this.clientStateBySocket.clear();
+  }
+  async stop() {
+    if (this.stopped) {
+      return;
+    }
+    this.stopped = true;
+    this.started = false;
+    if (this.tracker) {
+      this.tracker.stop();
+      this.tracker = null;
+    }
+    await this.rebinding.catch(() => void 0);
+    await this.stopScreencast();
+    const browser = this.browser;
+    const browserDisconnectedHandler = this.browserDisconnectedHandler;
+    this.browser = null;
+    this.browserDisconnectedHandler = null;
+    this.context = null;
+    this.activePage = null;
+    if (browser) {
+      if (browserDisconnectedHandler) {
+        browser.off("disconnected", browserDisconnectedHandler);
+      }
+      await disconnectPlaywrightChromiumBrowser(browser).catch(() => void 0);
+    }
+    this.deps.onDrained();
+  }
+  async stopScreencast() {
+    const cdpSession = this.cdpSession;
+    const handler = this.screencastHandler;
+    const pageLifecycleCleanup = this.pageLifecycleCleanup;
+    this.cdpSession = null;
+    this.screencastHandler = null;
+    this.pageLifecycleCleanup = null;
+    this.activeScreencastSizeKey = null;
+    if (this.pendingFrameAckTimer !== null) {
+      clearTimeout(this.pendingFrameAckTimer);
+      this.pendingFrameAckTimer = null;
+    }
+    pageLifecycleCleanup?.();
+    if (!cdpSession) {
+      return;
+    }
+    if (handler) {
+      cdpSession.off("Page.screencastFrame", handler);
+    }
+    await cdpSession.send("Page.stopScreencast").catch(() => void 0);
+    await cdpSession.detach().catch(() => void 0);
+  }
+  bindPageLifecycleFrameRefresh(page, cdpSession) {
+    this.pageLifecycleCleanup?.();
+    const refresh = () => {
+      void this.refreshPageFrame(page, cdpSession).catch(() => void 0);
+    };
+    page.on("domcontentloaded", refresh);
+    page.on("load", refresh);
+    page.on("framenavigated", refresh);
+    this.pageLifecycleCleanup = () => {
+      page.off("domcontentloaded", refresh);
+      page.off("load", refresh);
+      page.off("framenavigated", refresh);
+    };
+  }
+  async refreshPageFrame(page, cdpSession) {
+    if (this.stopped || this.cdpSession !== cdpSession || this.activePage !== page) {
+      return;
+    }
+    const viewport = await readViewportForPage(page);
+    if (viewport && this.cdpSession === cdpSession && this.activePage === page) {
+      this.activeViewport = viewport;
+      this.broadcastControl(
+        buildHelloMessage({
+          sessionId: this.deps.sessionId,
+          fps: this.deps.maxFps,
+          quality: this.deps.quality,
+          viewport
+        })
+      );
+    }
+    if (this.stopped || this.cdpSession !== cdpSession || this.activePage !== page) {
+      return;
+    }
+    await this.seedInitialFrame(cdpSession);
+  }
+  async seedInitialFrame(cdpSession) {
+    let lastError = null;
+    for (let attempt = 1; attempt <= INITIAL_FRAME_CAPTURE_ATTEMPTS; attempt += 1) {
+      if (this.stopped || this.cdpSession !== cdpSession) {
+        return;
+      }
+      try {
+        const screenshotData = await this.captureCurrentFrame(cdpSession);
+        if (this.stopped || this.cdpSession !== cdpSession) {
+          return;
+        }
+        const frameBuffer = Buffer.from(screenshotData, "base64");
+        this.lastFrameBuffer = frameBuffer;
+        this.lastFrameSentAt = Date.now();
+        this.broadcastFrame(frameBuffer);
+        return;
+      } catch (error) {
+        lastError = error;
+      }
+      if (attempt < INITIAL_FRAME_CAPTURE_ATTEMPTS) {
+        await new Promise((resolve) => setTimeout(resolve, INITIAL_FRAME_CAPTURE_RETRY_DELAY_MS));
+      }
+    }
+    if (lastError instanceof Error) {
+      throw lastError;
+    }
+    throw new Error("Failed to capture initial stream screenshot.");
+  }
+  async captureCurrentFrame(cdpSession) {
+    const primaryParams = {
+      format: "jpeg",
+      quality: this.deps.quality,
+      optimizeForSpeed: true
+    };
+    try {
+      const result = await cdpSession.send("Page.captureScreenshot", primaryParams);
+      if (result && typeof result.data === "string" && result.data.length > 0) {
+        return result.data;
+      }
+    } catch {
+    }
+    const fallbackResult = await cdpSession.send("Page.captureScreenshot", {
+      format: "jpeg",
+      quality: this.deps.quality
+    });
+    if (!fallbackResult || typeof fallbackResult.data !== "string" || fallbackResult.data.length === 0) {
+      throw new Error("Failed to capture initial stream screenshot.");
+    }
+    return fallbackResult.data;
+  }
+  getRequestedScreencastSize() {
+    if (this.clients.size === 0 || !this.activeViewport) {
+      return null;
+    }
+    const requestedSizes = [];
+    for (const client of this.clients) {
+      const requestedSize = this.clientStateBySocket.get(client)?.requestedRenderSize ?? null;
+      if (!requestedSize) {
+        return null;
+      }
+      requestedSizes.push(requestedSize);
+    }
+    return selectScreencastSize({
+      viewport: this.activeViewport,
+      requestedSizes
+    });
+  }
+  getRequestedScreencastSizeKey() {
+    const size = this.getRequestedScreencastSize();
+    return size ? `${size.width}x${size.height}` : null;
+  }
+};
+async function readViewportForPage(page) {
+  const cdp = await page.context().newCDPSession(page);
+  try {
+    const result = await cdp.send("Page.getLayoutMetrics");
+    const candidates = [
+      result?.cssVisualViewport,
+      result?.cssLayoutViewport,
+      result?.visualViewport,
+      result?.layoutViewport
+    ];
+    for (const candidate of candidates) {
+      const width = normalizeViewportDimension(candidate?.clientWidth);
+      const height = normalizeViewportDimension(candidate?.clientHeight);
+      if (width !== null && height !== null) {
+        return { width, height };
+      }
+    }
+    return null;
+  } catch {
+    const viewportSize = page.viewportSize();
+    if (!viewportSize) {
+      return null;
+    }
+    const width = normalizeViewportDimension(viewportSize.width);
+    const height = normalizeViewportDimension(viewportSize.height);
+    return width !== null && height !== null ? { width, height } : null;
+  } finally {
+    await cdp.detach().catch(() => void 0);
+  }
+}
+function normalizeViewportDimension(value) {
+  if (typeof value !== "number" || !Number.isFinite(value)) {
+    return null;
+  }
+  const normalized = Math.floor(value);
+  if (normalized < 100) {
+    return null;
+  }
+  return Math.min(8192, normalized);
+}
+function readTextFrame(raw) {
+  if (typeof raw === "string") {
+    return raw;
+  }
+  if (raw instanceof ArrayBuffer) {
+    return Buffer.from(raw).toString("utf8");
+  }
+  if (Array.isArray(raw)) {
+    return Buffer.concat(raw).toString("utf8");
+  }
+  return raw.toString("utf8");
+}
+async function connectPlaywrightChromiumBrowser(input) {
+  const { connectPlaywrightChromiumBrowser: connect } = await import('@opensteer/engine-playwright');
+  return connect(input);
+}
+async function disconnectPlaywrightChromiumBrowser(browser) {
+  const { disconnectPlaywrightChromiumBrowser: disconnect } = await import('@opensteer/engine-playwright');
+  await disconnect(browser);
+}
+
+// src/local-view/server.ts
+var DEFAULT_MAX_FPS = 12;
+var DEFAULT_QUALITY = 75;
+var DEFAULT_MAX_CLIENT_BUFFER_BYTES = 512 * 1024;
+var LOCAL_VIEW_ACCESS_EXPIRES_AT = Number.MAX_SAFE_INTEGER;
+async function startLocalViewServer(input = {}) {
+  const token = input.token ?? randomBytes(24).toString("hex");
+  const runtimeState = new LocalViewRuntimeState();
+  const viewStreamHub = new LocalViewStreamHub({
+    runtimeState,
+    maxFps: DEFAULT_MAX_FPS,
+    quality: DEFAULT_QUALITY,
+    maxClientBufferBytes: DEFAULT_MAX_CLIENT_BUFFER_BYTES
+  });
+  const cdpProxy = new LocalViewCdpProxy({
+    runtimeState
+  });
+  const httpServer = createServer((request, response) => {
+    void handleHttpRequest({ request, response, token, shutdown: closeServer }).catch(() => {
+      if (!response.headersSent && !response.writableEnded) {
+        writeJson(response, 500, { error: "Internal server error." });
+        return;
+      }
+      response.destroy();
+    });
+  });
+  const viewWss = new LocalViewWebSocketServer({ noServer: true });
+  viewWss.on("connection", (ws, request) => {
+    const url2 = new URL(request.url ?? "/", "http://localhost");
+    const parts = url2.pathname.split("/").filter(Boolean);
+    const sessionId = parts[2];
+    if (!sessionId) {
+      ws.close(1008, "Session id is required.");
+      return;
+    }
+    viewStreamHub.attachClient(sessionId, ws);
+  });
+  httpServer.on("upgrade", (request, socket, head) => {
+    const url2 = new URL(request.url ?? "/", "http://localhost");
+    const tokenParam = url2.searchParams.get("token");
+    if (tokenParam !== token || !isAllowedOrigin(request.headers.origin)) {
+      socket.destroy();
+      return;
+    }
+    const parts = url2.pathname.split("/").filter(Boolean);
+    if (parts[0] !== "ws" || parts.length !== 3) {
+      socket.destroy();
+      return;
+    }
+    if (parts[1] === "view") {
+      viewWss.handleUpgrade(request, socket, head, (ws) => {
+        viewWss.emit("connection", ws, request);
+      });
+      return;
+    }
+    if (parts[1] === "cdp") {
+      cdpProxy.handleUpgrade(request, socket, head);
+      return;
+    }
+    socket.destroy();
+  });
+  let closePromise;
+  async function closeServer() {
+    closePromise ??= (async () => {
+      viewWss.clients.forEach((client) => {
+        try {
+          client.close();
+        } catch {
+        }
+      });
+      viewWss.close();
+      cdpProxy.close();
+      httpServer.close();
+      await once(httpServer, "close");
+      await clearLocalViewServiceState({ pid: process.pid, token });
+      await input.onClosed?.();
+    })();
+    await closePromise;
+  }
+  httpServer.listen(input.port ?? 0, "127.0.0.1");
+  await once(httpServer, "listening");
+  const address = httpServer.address();
+  if (!address || typeof address === "string") {
+    throw new Error("Failed to resolve the local view server address.");
+  }
+  const url = `http://127.0.0.1:${String(address.port)}`;
+  await writeLocalViewServiceState({
+    layout: OPENSTEER_LOCAL_VIEW_SERVICE_LAYOUT,
+    version: OPENSTEER_LOCAL_VIEW_SERVICE_VERSION,
+    pid: process.pid,
+    processStartedAtMs: CURRENT_PROCESS_OWNER.processStartedAtMs,
+    startedAt: Date.now(),
+    port: address.port,
+    token,
+    url
+  });
+  return {
+    url,
+    token,
+    close: closeServer
+  };
+}
+async function handleHttpRequest(args) {
+  const url = new URL(args.request.url ?? "/", "http://localhost");
+  if (url.pathname === "/api/health") {
+    if (!isAuthorizedApiRequest(args.request, args.token)) {
+      writeJson(args.response, 401, { error: "Unauthorized." });
+      return;
+    }
+    writeJson(args.response, 200, { ok: true });
+    return;
+  }
+  if (url.pathname === "/api/sessions") {
+    if (!isAuthorizedApiRequest(args.request, args.token)) {
+      writeJson(args.response, 401, { error: "Unauthorized." });
+      return;
+    }
+    const sessions = await listResolvedLocalViewSessions();
+    const payload = { sessions };
+    writeJson(args.response, 200, payload);
+    return;
+  }
+  if (url.pathname === "/api/service/stop") {
+    if (!isAuthorizedApiRequest(args.request, args.token)) {
+      writeJson(args.response, 401, { error: "Unauthorized." });
+      return;
+    }
+    if (args.request.method !== "POST") {
+      writeJson(args.response, 405, { error: "Method not allowed." });
+      return;
+    }
+    args.response.once("finish", () => {
+      void args.shutdown();
+    });
+    writeJson(args.response, 200, { stopped: true });
+    return;
+  }
+  const accessMatch = url.pathname.match(/^\/api\/sessions\/([^/]+)\/access$/u);
+  if (accessMatch) {
+    if (!isAuthorizedApiRequest(args.request, args.token)) {
+      writeJson(args.response, 401, { error: "Unauthorized." });
+      return;
+    }
+    const sessionId = decodeURIComponent(accessMatch[1]);
+    if (!await resolveLocalViewSession(sessionId)) {
+      writeJson(args.response, 404, { error: "Session not found." });
+      return;
+    }
+    const payload = {
+      sessionId,
+      expiresAt: LOCAL_VIEW_ACCESS_EXPIRES_AT,
+      grants: {
+        view: {
+          kind: "view",
+          transport: "ws",
+          url: `${resolveWsBaseUrl(args.request)}/ws/view/${encodeURIComponent(sessionId)}`,
+          token: args.token,
+          expiresAt: LOCAL_VIEW_ACCESS_EXPIRES_AT
+        },
+        cdp: {
+          kind: "cdp",
+          transport: "ws",
+          url: `${resolveWsBaseUrl(args.request)}/ws/cdp/${encodeURIComponent(sessionId)}`,
+          token: args.token,
+          expiresAt: LOCAL_VIEW_ACCESS_EXPIRES_AT
+        }
+      }
+    };
+    writeJson(args.response, 200, payload);
+    return;
+  }
+  const closeMatch = url.pathname.match(/^\/api\/sessions\/([^/]+)\/close$/u);
+  if (closeMatch) {
+    if (!isAuthorizedApiRequest(args.request, args.token)) {
+      writeJson(args.response, 401, { error: "Unauthorized." });
+      return;
+    }
+    if (args.request.method !== "POST") {
+      writeJson(args.response, 405, { error: "Method not allowed." });
+      return;
+    }
+    const sessionId = decodeURIComponent(closeMatch[1]);
+    const { closeLocalViewSessionBrowser, LocalViewSessionCloseError } = await import('./session-control-VGBFOH3Y.js');
+    try {
+      await closeLocalViewSessionBrowser(sessionId);
+    } catch (error) {
+      if (error instanceof LocalViewSessionCloseError) {
+        writeJson(args.response, error.statusCode, { error: error.message });
+        return;
+      }
+      throw error;
+    }
+    const payload = {
+      sessionId,
+      closed: true
+    };
+    writeJson(args.response, 200, payload);
+    return;
+  }
+  if (url.pathname === "/favicon.ico") {
+    args.response.statusCode = 204;
+    args.response.end();
+    return;
+  }
+  if (url.pathname === "/" || url.pathname.startsWith("/assets/") || url.pathname.startsWith("/images/")) {
+    await serveStaticAsset(args.response, url.pathname, args.token);
+    return;
+  }
+  args.response.statusCode = 404;
+  args.response.end("not found");
+}
+async function serveStaticAsset(response, pathname, token) {
+  const publicDir = resolveLocalViewPublicDir();
+  const relativePath = pathname === "/" ? "index.html" : pathname.slice(1);
+  const assetPath = path2.resolve(publicDir, relativePath);
+  const relativeAssetPath = path2.relative(publicDir, assetPath);
+  if (relativeAssetPath.startsWith("..") || path2.isAbsolute(relativeAssetPath) || !existsSync(assetPath)) {
+    response.statusCode = 404;
+    response.end("not found");
+    return;
+  }
+  if (relativePath === "index.html") {
+    const html = await readFile(assetPath, "utf8");
+    response.setHeader("content-type", "text/html; charset=utf-8");
+    response.setHeader("cache-control", "no-store");
+    response.end(
+      html.replace(
+        "__OPENSTEER_LOCAL_BOOTSTRAP_JSON__",
+        JSON.stringify({
+          apiBasePath: "/api",
+          token
+        })
+      )
+    );
+    return;
+  }
+  response.setHeader("content-type", guessContentType(assetPath));
+  response.setHeader("cache-control", "no-store");
+  response.end(await readFile(assetPath));
+}
+function resolveLocalViewPublicDir() {
+  const moduleDir = path2.dirname(fileURLToPath(import.meta.url));
+  const candidates = [
+    path2.resolve(moduleDir, "local-view", "public"),
+    path2.resolve(moduleDir, "public"),
+    path2.resolve(moduleDir, "..", "local-view", "public")
+  ];
+  for (const candidate of candidates) {
+    if (existsSync(candidate)) {
+      return candidate;
+    }
+  }
+  throw new Error(`Could not resolve local view public assets from ${moduleDir}.`);
+}
+function isAuthorizedApiRequest(request, token) {
+  return request.headers["x-opensteer-local-token"] === token && isAllowedOrigin(request.headers.origin);
+}
+function isAllowedOrigin(origin) {
+  if (origin === void 0) {
+    return true;
+  }
+  try {
+    const url = new URL(origin);
+    const host = url.hostname;
+    return host === "localhost" || host === "127.0.0.1" || host === "::1" || host === "[::1]";
+  } catch {
+    return false;
+  }
+}
+function resolveWsBaseUrl(request) {
+  const host = request.headers.host ?? "127.0.0.1";
+  return `ws://${host}`;
+}
+function writeJson(response, statusCode, value) {
+  response.statusCode = statusCode;
+  response.setHeader("content-type", "application/json; charset=utf-8");
+  response.end(JSON.stringify(value));
+}
+function guessContentType(assetPath) {
+  if (assetPath.endsWith(".css")) {
+    return "text/css; charset=utf-8";
+  }
+  if (assetPath.endsWith(".js")) {
+    return "application/javascript; charset=utf-8";
+  }
+  if (assetPath.endsWith(".svg")) {
+    return "image/svg+xml";
+  }
+  if (assetPath.endsWith(".json")) {
+    return "application/json; charset=utf-8";
+  }
+  if (assetPath.endsWith(".png")) {
+    return "image/png";
+  }
+  if (assetPath.endsWith(".ico")) {
+    return "image/x-icon";
+  }
+  return "application/octet-stream";
+}
+
+// src/local-view/serve.ts
+async function runLocalViewService() {
+  const server = await startLocalViewServer({
+    token: process.env.OPENSTEER_LOCAL_VIEW_BOOT_TOKEN ?? randomBytes(24).toString("hex"),
+    onClosed: () => {
+      process.exit(0);
+    }
+  });
+  const handleShutdownSignal = () => {
+    void server.close();
+  };
+  process.once("SIGINT", handleShutdownSignal);
+  process.once("SIGTERM", handleShutdownSignal);
+  await new Promise(() => void 0);
+}
+
+export { runLocalViewService };
+//# sourceMappingURL=chunk-Z53HNZ7Z.js.map
+//# sourceMappingURL=chunk-Z53HNZ7Z.js.map