opendevbrowser 0.0.15 → 0.0.16

package/extension/dist/ops/ops-session-store.js

@@ -1,3 +1,4 @@
+import { DEFAULT_OPS_PARALLELISM_POLICY, createOpsGovernorState } from "./parallelism-governor.js";
 export class OpsRefStore {
     refsByTarget = new Map();
     snapshotByTarget = new Map();
@@ -32,9 +33,10 @@ export class OpsRefStore {
 export class OpsSessionStore {
     sessions = new Map();
     tabToSession = new Map();
-    createSession(ownerClientId, tabId, leaseId, info) {
+    createSession(ownerClientId, tabId, leaseId, info, options) {
         const id = createId();
         const targetId = `tab-${tabId}`;
+        const parallelismPolicy = options?.parallelismPolicy ?? DEFAULT_OPS_PARALLELISM_POLICY;
         const target = {
             targetId,
             tabId,
@@ -60,7 +62,16 @@ export class OpsSessionStore {
             networkRequests: new Map(),
             consoleSeq: 0,
             networkSeq: 0,
-            queue: Promise.resolve()
+            queue: Promise.resolve(),
+            targetQueues: new Map(),
+            targetQueueDepth: new Map(),
+            targetQueueOldestAt: new Map(),
+            parallelInFlight: 0,
+            pendingParallel: 0,
+            discardedSignals: 0,
+            frozenSignals: 0,
+            parallelismPolicy,
+            parallelismState: createOpsGovernorState(parallelismPolicy, "extensionOpsHeaded")
         };
         this.sessions.set(id, session);
         this.tabToSession.set(tabId, id);
@@ -120,6 +131,9 @@ export class OpsSessionStore {
             const [first] = session.targets.keys();
             session.activeTargetId = first ?? "";
         }
+        session.targetQueues.delete(targetId);
+        session.targetQueueDepth.delete(targetId);
+        session.targetQueueOldestAt.delete(targetId);
         session.refStore.clearTarget(targetId);
         return target;
     }

package/extension/dist/ops/parallelism-governor.js

@@ -0,0 +1,117 @@
+export const DEFAULT_OPS_PARALLELISM_POLICY = {
+    floor: 1,
+    backpressureTimeoutMs: 5000,
+    sampleIntervalMs: 2000,
+    recoveryStableWindows: 3,
+    hostFreeMemMediumPct: 25,
+    hostFreeMemHighPct: 18,
+    hostFreeMemCriticalPct: 10,
+    rssBudgetMb: 2048,
+    rssSoftPct: 65,
+    rssHighPct: 75,
+    rssCriticalPct: 85,
+    queueAgeHighMs: 2000,
+    queueAgeCriticalMs: 5000,
+    modeCaps: {
+        managedHeaded: 6,
+        managedHeadless: 8,
+        cdpConnectHeaded: 6,
+        cdpConnectHeadless: 8,
+        extensionOpsHeaded: 6,
+        extensionLegacyCdpHeaded: 1
+    }
+};
+const clamp = (value, floor, ceil) => {
+    if (value < floor)
+        return floor;
+    if (value > ceil)
+        return ceil;
+    return value;
+};
+const floorPercent = (value) => clamp(Number.isFinite(value) ? value : 0, 0, 100);
+const classifyPressure = (policy, input) => {
+    const hostFreeMemPct = floorPercent(input.hostFreeMemPct);
+    const rssUsagePct = floorPercent(input.rssUsagePct);
+    const queueAgeMs = Math.max(0, Number.isFinite(input.queueAgeMs) ? input.queueAgeMs : 0);
+    const discardedSignals = Math.max(0, input.discardedSignals ?? 0);
+    const frozenSignals = Math.max(0, input.frozenSignals ?? 0);
+    const critical = hostFreeMemPct <= policy.hostFreeMemCriticalPct
+        || rssUsagePct >= policy.rssCriticalPct
+        || queueAgeMs >= policy.queueAgeCriticalMs;
+    if (critical)
+        return "critical";
+    const high = hostFreeMemPct <= policy.hostFreeMemHighPct
+        || rssUsagePct >= policy.rssHighPct
+        || queueAgeMs >= policy.queueAgeHighMs
+        || discardedSignals > 0;
+    if (high)
+        return "high";
+    const medium = hostFreeMemPct <= policy.hostFreeMemMediumPct
+        || rssUsagePct >= policy.rssSoftPct
+        || frozenSignals > 0;
+    return medium ? "medium" : "healthy";
+};
+const pressurePenalty = (pressure) => {
+    switch (pressure) {
+        case "medium":
+            return 1;
+        case "high":
+            return 2;
+        case "critical":
+            return Number.MAX_SAFE_INTEGER;
+        default:
+            return 0;
+    }
+};
+export const resolveOpsStaticCap = (policy, modeVariant) => {
+    const cap = policy.modeCaps[modeVariant];
+    return clamp(cap, policy.floor, cap);
+};
+export const createOpsGovernorState = (policy, modeVariant) => {
+    const staticCap = resolveOpsStaticCap(policy, modeVariant);
+    return {
+        modeVariant,
+        staticCap,
+        effectiveCap: staticCap,
+        healthyWindows: 0,
+        lastSampleAt: 0,
+        lastPressure: "healthy"
+    };
+};
+export const evaluateOpsGovernor = (policy, current, input, sampledAt = Date.now()) => {
+    const normalizedQueueDepth = Math.max(0, Number.isFinite(input.queueDepth) ? input.queueDepth : 0);
+    const normalizedQueueAgeMs = Math.max(0, Number.isFinite(input.queueAgeMs) ? input.queueAgeMs : 0);
+    const pressure = classifyPressure(policy, input);
+    const basePenalty = pressurePenalty(pressure);
+    const lifecyclePenalty = Math.max(0, input.discardedSignals ?? 0) + Math.max(0, input.frozenSignals ?? 0);
+    const targetCap = pressure === "critical"
+        ? policy.floor
+        : clamp(current.staticCap - basePenalty - lifecyclePenalty, policy.floor, current.staticCap);
+    let effectiveCap = current.effectiveCap;
+    let healthyWindows = pressure === "healthy" ? current.healthyWindows + 1 : 0;
+    if (targetCap < current.effectiveCap) {
+        effectiveCap = targetCap;
+        healthyWindows = 0;
+    }
+    else if (targetCap > current.effectiveCap) {
+        const windowsRequired = Math.max(1, policy.recoveryStableWindows);
+        if (healthyWindows >= windowsRequired) {
+            effectiveCap = clamp(current.effectiveCap + 1, policy.floor, targetCap);
+            healthyWindows = 0;
+        }
+    }
+    return {
+        state: {
+            modeVariant: current.modeVariant,
+            staticCap: current.staticCap,
+            effectiveCap,
+            healthyWindows,
+            lastSampleAt: sampledAt,
+            lastPressure: pressure
+        },
+        pressure,
+        targetCap,
+        waitQueueDepth: normalizedQueueDepth,
+        waitQueueAgeMs: normalizedQueueAgeMs
+    };
+};

package/extension/dist/ops/snapshot-shared.js

@@ -49,13 +49,27 @@ export const selectorFunction = function () {
         }
         return String(value).replace(/([^\w-])/g, "\\$1");
     };
+    const isUniqueSelector = (selector) => {
+        try {
+            return document.querySelectorAll(selector).length === 1;
+        }
+        catch {
+            return false;
+        }
+    };
     const testId = this.getAttribute("data-testid");
     if (testId) {
-        return '[data-testid="' + escape(testId) + '"]';
+        const selector = '[data-testid="' + escape(testId) + '"]';
+        if (isUniqueSelector(selector)) {
+            return selector;
+        }
     }
     const ariaLabel = this.getAttribute("aria-label");
     if (ariaLabel && ariaLabel.length < 50) {
-        return '[aria-label="' + escape(ariaLabel) + '"]';
+        const selector = '[aria-label="' + escape(ariaLabel) + '"]';
+        if (isUniqueSelector(selector)) {
+            return selector;
+        }
     }
     const buildPathSelector = (start) => {
         const parts = [];
@@ -63,9 +77,11 @@ export const selectorFunction = function () {
         while (current && current.nodeType === Node.ELEMENT_NODE) {
             let selector = current.nodeName.toLowerCase();
             if (current.id) {
-                selector += "#" + escape(current.id);
-                parts.unshift(selector);
-                break;
+                const withId = selector + "#" + escape(current.id);
+                if (isUniqueSelector(withId)) {
+                    parts.unshift(withId);
+                    break;
+                }
             }
             const parentEl = current.parentElement;
             if (!parentEl) {

package/extension/dist/services/CDPRouter.js

@@ -64,14 +64,47 @@ export class CDPRouter {
             }
             await this.safeDetach(debuggee);
             if (allowRetry && this.isStaleTabError(error)) {
+                const attemptedTabIds = new Set([tabId]);
+                let lastStaleError = error;
                 const activeTabId = await this.tabManager.getActiveTabId();
-                if (activeTabId && activeTabId !== tabId) {
-                    return await this.attachInternal(activeTabId, false);
+                if (activeTabId && !attemptedTabIds.has(activeTabId)) {
+                    attemptedTabIds.add(activeTabId);
+                    try {
+                        return await this.attachInternal(activeTabId, false);
+                    }
+                    catch (candidateError) {
+                        if (!this.isStaleTabError(candidateError)) {
+                            throw candidateError;
+                        }
+                        lastStaleError = candidateError;
+                    }
                 }
                 const fallbackTabId = await this.tabManager.getFirstHttpTabId();
-                if (fallbackTabId && fallbackTabId !== tabId) {
-                    return await this.attachInternal(fallbackTabId, false);
+                if (fallbackTabId && !attemptedTabIds.has(fallbackTabId)) {
+                    attemptedTabIds.add(fallbackTabId);
+                    try {
+                        return await this.attachInternal(fallbackTabId, false);
+                    }
+                    catch (candidateError) {
+                        if (!this.isStaleTabError(candidateError)) {
+                            throw candidateError;
+                        }
+                        lastStaleError = candidateError;
+                    }
                 }
+                try {
+                    const createdTab = await this.tabManager.createTab("about:blank", true);
+                    if (typeof createdTab.id === "number" && !attemptedTabIds.has(createdTab.id)) {
+                        return await this.attachInternal(createdTab.id, false);
+                    }
+                }
+                catch (candidateError) {
+                    if (!this.isStaleTabError(candidateError)) {
+                        throw candidateError;
+                    }
+                    lastStaleError = candidateError;
+                }
+                throw lastStaleError;
             }
             throw error;
         }
@@ -503,7 +536,23 @@ export class CDPRouter {
         return sessionId;
     }
     async sendCommand(debuggee, method, params) {
-        return new Promise((resolve, reject) => {
+        try {
+            return await this.sendCommandOnce(debuggee, method, params);
+        }
+        catch (error) {
+            const hasChildSession = typeof debuggee.sessionId === "string";
+            if (!this.isStaleTabError(error) || hasChildSession) {
+                throw error;
+            }
+            const recovered = await this.recoverFromStaleTab(debuggee);
+            if (!recovered) {
+                throw error;
+            }
+            return await this.sendCommandOnce(recovered, method, params);
+        }
+    }
+    async sendCommandOnce(debuggee, method, params) {
+        return await new Promise((resolve, reject) => {
             chrome.debugger.sendCommand(debuggee, method, params, (result) => {
                 const lastError = chrome.runtime.lastError;
                 if (lastError) {
@@ -514,6 +563,22 @@ export class CDPRouter {
             });
         });
     }
+    async recoverFromStaleTab(debuggee) {
+        const staleTabId = typeof debuggee.tabId === "number" ? debuggee.tabId : null;
+        if (staleTabId === null) {
+            return null;
+        }
+        this.debuggees.delete(staleTabId);
+        this.detachTabState(staleTabId);
+        await this.safeDetach({ tabId: staleTabId });
+        try {
+            await this.attachInternal(staleTabId, true);
+        }
+        catch {
+            return null;
+        }
+        return this.getPrimaryDebuggee();
+    }
     isStaleTabError(error) {
         const message = error instanceof Error ? error.message : String(error);
         return message.includes("No tab with given id");

package/extension/dist/services/ConnectionManager.js

@@ -29,6 +29,8 @@ const logInfo = (message) => {
 const logWarn = (message) => {
     console.warn(`[opendevbrowser] ${message}`);
 };
+const RECONNECT_INITIAL_DELAY_MS = 12_000;
+const RECONNECT_MAX_DELAY_MS = 30_000;
 export class ConnectionManager {
     status = "disconnected";
     lastError = null;
@@ -41,7 +43,7 @@ export class ConnectionManager {
     shouldReconnect = false;
     reconnectTimer = null;
     reconnectAttempts = 0;
-    reconnectDelayMs = 500;
+    reconnectDelayMs = RECONNECT_INITIAL_DELAY_MS;
     pairingToken = DEFAULT_PAIRING_TOKEN;
     pairingEnabled = DEFAULT_PAIRING_ENABLED;
     relayPort = DEFAULT_RELAY_PORT;
@@ -49,7 +51,7 @@ export class ConnectionManager {
     relayEpoch = null;
     relayConfirmedPort = null;
     relayNotice = null;
-    maxReconnectDelayMs = 5000;
+    maxReconnectDelayMs = RECONNECT_MAX_DELAY_MS;
     connectPromise = null;
     annotationHandler = null;
     opsHandler = null;
@@ -405,7 +407,7 @@ export class ConnectionManager {
             this.setStatus("connected");
             this.startHeartbeat();
             this.reconnectAttempts = 0;
-            this.reconnectDelayMs = 500;
+            this.reconnectDelayMs = RECONNECT_INITIAL_DELAY_MS;
         }
         catch (error) {
             const detail = error instanceof Error ? error.message : "Unknown error";

package/extension/manifest.json

@@ -1,7 +1,7 @@
 {
   "manifest_version": 3,
   "name": "OpenDevBrowser Relay",
-  "version": "0.0.15",
+  "version": "0.0.16",
   "description": "Optional bridge to reuse existing Chrome tabs with OpenDevBrowser.",
   "permissions": [
     "debugger",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opendevbrowser",
-  "version": "0.0.15",
+  "version": "0.0.16",
   "description": "OpenCode plugin for browser automation via CDP with snapshot-refs-actions workflow",
   "type": "module",
   "main": "dist/index.js",
@@ -11,6 +11,7 @@
   "files": [
     "dist",
     "skills",
+    "scripts/native",
     "extension/manifest.json",
     "extension/popup.html",
     "extension/dist",
@@ -36,36 +37,44 @@
     "node": ">=18"
   },
   "scripts": {
-    "build": "tsup src/index.ts src/cli/index.ts --format esm --dts --clean --sourcemap && node --input-type=module -e \"import { copyFileSync, existsSync } from 'node:fs';\nimport { resolve } from 'node:path';\nconst dist = resolve('dist');\nconst pairs = [\n  ['index.js', 'opendevbrowser.js'],\n  ['index.js.map', 'opendevbrowser.js.map'],\n  ['index.d.ts', 'opendevbrowser.d.ts'],\n  ['index.d.ts.map', 'opendevbrowser.d.ts.map'],\n];\nfor (const [src, dst] of pairs) {\n  const from = resolve(dist, src);\n  const to = resolve(dist, dst);\n  if (existsSync(from)) copyFileSync(from, to);\n}\"",
+    "build": "tsup src/index.ts src/cli/index.ts --format esm --clean --sourcemap && tsc --emitDeclarationOnly --declaration --declarationMap -p tsconfig.json && node --input-type=module -e \"import { copyFileSync, existsSync } from 'node:fs';\nimport { resolve } from 'node:path';\nconst dist = resolve('dist');\nconst pairs = [\n  ['index.js', 'opendevbrowser.js'],\n  ['index.js.map', 'opendevbrowser.js.map'],\n  ['index.d.ts', 'opendevbrowser.d.ts'],\n  ['index.d.ts.map', 'opendevbrowser.d.ts.map'],\n];\nfor (const [src, dst] of pairs) {\n  const from = resolve(dist, src);\n  const to = resolve(dist, dst);\n  if (existsSync(from)) copyFileSync(from, to);\n}\"",
     "dev": "tsup src/index.ts src/cli/index.ts --format esm --dts --watch",
-    "lint": "eslint \"{src,tests}/**/*.ts\"",
+    "lint": "eslint \"src/**/*.ts\" \"tests/**/*.ts\"",
+    "typecheck": "tsc --noEmit -p tsconfig.json",
     "test": "vitest run --coverage",
+    "test:release-gate": "node scripts/release-gate-test-groups.mjs",
+    "test:release-gate:g1": "node scripts/release-gate-test-groups.mjs --group 1",
+    "test:release-gate:g2": "node scripts/release-gate-test-groups.mjs --group 2",
+    "test:release-gate:g3": "node scripts/release-gate-test-groups.mjs --group 3",
+    "test:release-gate:g4": "node scripts/release-gate-test-groups.mjs --group 4",
+    "test:release-gate:g5": "node scripts/release-gate-test-groups.mjs --group 5",
     "extension:sync": "node scripts/sync-extension-version.mjs",
     "extension:build": "npm run extension:sync && tsc -p extension/tsconfig.json && node scripts/copy-extension-assets.mjs",
     "extension:pack": "cd extension && zip -r ../opendevbrowser-extension.zip manifest.json popup.html dist/ icons/",
+    "extension:store": "node scripts/chrome-store-publish.mjs",
     "version:check": "node scripts/verify-versions.mjs",
     "prepack": "npm run version:check && npm run build && npm run extension:build"
   },
   "dependencies": {
-    "@opencode-ai/plugin": "^1.0.203",
-    "@puppeteer/browsers": "^2.2.0",
+    "@opencode-ai/plugin": "^1.2.11",
+    "@puppeteer/browsers": "^2.13.0",
     "async-mutex": "^0.5.0",
     "jsonc-parser": "^3.2.0",
-    "playwright-core": "^1.49.1",
-    "ws": "^8.17.1",
-    "zod": "^3.23.8"
+    "playwright-core": "^1.58.2",
+    "ws": "^8.19.0",
+    "zod": "^3.25.76"
   },
   "devDependencies": {
-    "@types/chrome": "^0.0.270",
-    "@types/node": "^20.19.27",
+    "@types/chrome": "^0.1.37",
+    "@types/node": "^20.19.35",
     "@types/ws": "^8.18.1",
-    "@typescript-eslint/eslint-plugin": "^8.9.0",
-    "@typescript-eslint/parser": "^8.9.0",
-    "@vitest/coverage-v8": "^4.0.16",
-    "eslint": "^9.12.0",
-    "happy-dom": "^20.0.11",
+    "@typescript-eslint/eslint-plugin": "^8.56.1",
+    "@typescript-eslint/parser": "^8.56.1",
+    "@vitest/coverage-v8": "^4.0.18",
+    "eslint": "^9.39.3",
+    "happy-dom": "^20.7.0",
     "tsup": "^8.5.1",
     "typescript": "^5.9.3",
-    "vitest": "^4.0.16"
+    "vitest": "^4.0.18"
   }
 }

package/scripts/native/host.cjs

@@ -0,0 +1,230 @@
+#!/usr/bin/env node
+"use strict";
+
+const fs = require("fs");
+const path = require("path");
+const net = require("net");
+const crypto = require("crypto");
+const os = require("os");
+
+const IS_WINDOWS = process.platform === "win32";
+const DEFAULT_BASE_DIR = IS_WINDOWS ? os.tmpdir() : "/tmp";
+const BASE_DIR = process.env.OPD_NATIVE_BASE_DIR || DEFAULT_BASE_DIR;
+const MAX_MESSAGE_BYTES = 8 * 1024 * 1024;
+const LOG_ROTATE_BYTES = 5 * 1024 * 1024;
+
+const buildPaths = (baseDir, pid) => {
+  const socketPath = IS_WINDOWS
+    ? `\\\\.\\pipe\\opendevbrowser-${pid}.sock`
+    : path.join(baseDir, `opendevbrowser-${pid}.sock`);
+  return {
+    tokenPath: path.join(baseDir, `opendevbrowser-${pid}.token`),
+    socketPath,
+    logPath: path.join(baseDir, "opendevbrowser-native.log")
+  };
+};
+
+const redactLogLine = (line, token) => {
+  let output = line;
+  if (token) {
+    output = output.split(token).join("[redacted]");
+  }
+  output = output.replace(/Authorization\\s*[:=]\\s*Bearer\\s+[^\\s"\']+/gi, "Authorization: Bearer [redacted]");
+  output = output.replace(/\"token\"\\s*:\\s*\"[^\"]+\"/gi, "\"token\":\"[redacted]\"");
+  return output;
+};
+
+const rotateLogIfNeeded = (logPath) => {
+  try {
+    const stat = fs.statSync(logPath);
+    if (stat.size <= LOG_ROTATE_BYTES) return false;
+    const rotated = `${logPath}.1`;
+    fs.renameSync(logPath, rotated);
+    return true;
+  } catch {
+    return false;
+  }
+};
+
+const writeLog = (logPath, message, token) => {
+  rotateLogIfNeeded(logPath);
+  const line = redactLogLine(message, token);
+  fs.appendFileSync(logPath, `${line}\\n`, { encoding: "utf8" });
+};
+
+const writeTokenFile = (tokenPath) => {
+  const token = crypto.randomBytes(32).toString("hex");
+  fs.writeFileSync(tokenPath, token, { encoding: "utf8", mode: 0o600 });
+  return token;
+};
+
+const parseNativeMessages = (buffer) => {
+  const messages = [];
+  let offset = 0;
+  while (buffer.length >= offset + 4) {
+    const size = buffer.readUInt32LE(offset);
+    if (size > MAX_MESSAGE_BYTES) {
+      return { error: new Error("Message exceeds size limit"), remainder: Buffer.alloc(0) };
+    }
+    if (buffer.length < offset + 4 + size) {
+      break;
+    }
+    const slice = buffer.slice(offset + 4, offset + 4 + size);
+    offset += 4 + size;
+    try {
+      messages.push(JSON.parse(slice.toString("utf8")));
+    } catch {
+      // Ignore invalid JSON.
+    }
+  }
+  return { messages, remainder: buffer.slice(offset) };
+};
+
+const sendNativeMessage = (payload) => {
+  const json = JSON.stringify(payload);
+  const data = Buffer.from(json, "utf8");
+  if (data.length > MAX_MESSAGE_BYTES) {
+    return false;
+  }
+  const header = Buffer.alloc(4);
+  header.writeUInt32LE(data.length, 0);
+  process.stdout.write(Buffer.concat([header, data]));
+  return true;
+};
+
+const runHost = () => {
+  fs.mkdirSync(BASE_DIR, { recursive: true });
+  const { tokenPath, socketPath, logPath } = buildPaths(BASE_DIR, process.pid);
+  const token = writeTokenFile(tokenPath);
+
+  let socketClient = null;
+  let socketAuthorized = false;
+  let socketBuffer = "";
+
+  const cleanup = () => {
+    try {
+      if (socketClient) {
+        socketClient.destroy();
+      }
+    } catch {}
+    if (!IS_WINDOWS) {
+      try {
+        if (fs.existsSync(socketPath)) {
+          fs.unlinkSync(socketPath);
+        }
+      } catch {}
+    }
+    try {
+      if (fs.existsSync(tokenPath)) {
+        fs.unlinkSync(tokenPath);
+      }
+    } catch {}
+  };
+
+  process.on("SIGINT", () => {
+    cleanup();
+    process.exit(0);
+  });
+  process.on("SIGTERM", () => {
+    cleanup();
+    process.exit(0);
+  });
+  process.on("exit", () => {
+    cleanup();
+  });
+
+  const server = net.createServer((socket) => {
+    if (socketClient) {
+      socketClient.destroy();
+    }
+    socketClient = socket;
+    socketAuthorized = false;
+    socketBuffer = "";
+    socket.setEncoding("utf8");
+    socket.on("data", (chunk) => {
+      socketBuffer += chunk;
+      const lines = socketBuffer.split("\\n");
+      socketBuffer = lines.pop() ?? "";
+      for (const line of lines) {
+        const trimmed = line.trim();
+        if (!trimmed) continue;
+        let message = null;
+        try {
+          message = JSON.parse(trimmed);
+        } catch {
+          socket.write(JSON.stringify({ type: "error", code: "invalid_json", message: "Invalid JSON" }) + "\\n");
+          continue;
+        }
+        if (!socketAuthorized) {
+          if (message?.type === "auth" && message?.token === token) {
+            socketAuthorized = true;
+            socket.write(JSON.stringify({ type: "auth_ok" }) + "\\n");
+            continue;
+          }
+          socket.write(JSON.stringify({ type: "error", code: "unauthorized", message: "Unauthorized" }) + "\\n");
+          socket.destroy();
+          return;
+        }
+        const encoded = Buffer.from(JSON.stringify(message), "utf8");
+        if (encoded.length > MAX_MESSAGE_BYTES) {
+          socket.write(JSON.stringify({ type: "error", code: "host_message_too_large", message: "Message too large" }) + "\\n");
+          continue;
+        }
+        sendNativeMessage(message);
+      }
+    });
+    socket.on("error", () => {});
+    socket.on("close", () => {
+      if (socketClient === socket) {
+        socketClient = null;
+        socketAuthorized = false;
+      }
+    });
+  });
+
+  server.listen(socketPath, () => {
+    if (!IS_WINDOWS) {
+      try {
+        fs.chmodSync(socketPath, 0o600);
+      } catch {}
+    }
+    writeLog(logPath, "Native host ready", token);
+  });
+
+  let nativeBuffer = Buffer.alloc(0);
+  process.stdin.on("data", (chunk) => {
+    nativeBuffer = Buffer.concat([nativeBuffer, chunk]);
+    const result = parseNativeMessages(nativeBuffer);
+    if (result.error) {
+      sendNativeMessage({ type: "error", code: "host_message_too_large", message: result.error.message });
+      nativeBuffer = Buffer.alloc(0);
+      return;
+    }
+    nativeBuffer = result.remainder;
+    for (const message of result.messages ?? []) {
+      if (message?.type === "ping" && typeof message.id === "string") {
+        sendNativeMessage({ type: "pong", id: message.id });
+        continue;
+      }
+      if (socketClient && socketAuthorized) {
+        const line = JSON.stringify(message);
+        socketClient.write(line + "\\n");
+      }
+    }
+  });
+};
+
+if (require.main === module) {
+  runHost();
+}
+
+module.exports = {
+  runHost,
+  __test__: {
+    buildPaths,
+    redactLogLine,
+    rotateLogIfNeeded,
+    writeTokenFile,
+    parseNativeMessages
+  }
+};