@opencode/browse 0.0.6-dev.18 → 0.0.6-dev.20

package/dist/cli.mjs

@@ -2,26 +2,26 @@
 
 // src/main.ts
 import path from "node:path";
-var embeddedVersion = "0.0.6-dev.18";
+var embeddedVersion = "0.0.6-dev.20";
 var setupCommands = new Set(["install", "uninstall", "extension", "pair", "rollback", "set"]);
 var command = process.argv[2];
 var invokedAs = path.basename(process.argv[1] ?? "");
 if (command === "--version" || command === "-v") {
-  const opencodeBrowserVersion = embeddedVersion ?? (await import("./version-6g6gtnra.mjs")).opencodeBrowserVersion;
+  const opencodeBrowserVersion = embeddedVersion ?? (await import("./version-gfpqxbzm.mjs")).opencodeBrowserVersion;
   process.stdout.write(`${opencodeBrowserVersion}
 `);
 } else if (invokedAs === "opencode-browser-mcp" || command === "mcp" && process.argv.length === 3) {
   const { NodeRuntime } = await import("@effect/platform-node");
-  const { runMcpServer } = await import("./mcp-qh25n9s0.mjs");
+  const { runMcpServer } = await import("./mcp-j9e2da4y.mjs");
   runMcpServer.pipe(NodeRuntime.runMain);
 } else if (command === "runtime-install" || command === "runtime-switch") {
-  const { runRuntimeInstall, runRuntimeSwitch } = await import("./runtime-update-8wte78jj.mjs");
+  const { runRuntimeInstall, runRuntimeSwitch } = await import("./runtime-update-baranjc5.mjs");
   await (command === "runtime-install" ? runRuntimeInstall : runRuntimeSwitch)(process.argv.slice(3));
 } else if (command === "update") {
-  const { runUpdateCommand } = await import("./update-st5c8grg.mjs");
+  const { runUpdateCommand } = await import("./update-vkspb2rz.mjs");
   await runUpdateCommand(process.argv.slice(3));
 } else if (command && setupCommands.has(command)) {
-  const { runSetup } = await import("./setup-cqjdfcy0.mjs");
+  const { runSetup } = await import("./setup-7shrgdza.mjs");
   await runSetup(command, process.argv.slice(3));
 } else {
   if (!command || command === "--help" || command === "-h") {
@@ -55,9 +55,9 @@ if (command === "--version" || command === "-v") {
 `);
   }
   if (command === "status" && !process.argv.includes("--json")) {
-    const { printSetupStatus } = await import("./setup-cqjdfcy0.mjs");
+    const { printSetupStatus } = await import("./setup-7shrgdza.mjs");
     printSetupStatus();
   }
-  const { runCli } = await import("./cli-z00ttket.mjs");
+  const { runCli } = await import("./cli-anqhds1e.mjs");
   runCli();
 }

package/dist/{relay-helpers-6a2vvzx9.mjs → helpers-n4k4pdag.mjs}

@@ -1,20 +1,20 @@
 import {
-  defaultHost2,
-  defaultPort2,
-  stableUnpackedExtensionOrigin2,
-  chromeExtensionOriginForPath2,
-  parseAdditionalExtensionOrigins2,
   HttpRouteError2,
   formatHostForUrl2,
-  validateHostHeader2,
-  validateBrowserFetchSite2,
-  validateWebSocketOrigin2,
   listenHttpServer2,
   closeHttpServer2,
   closeWebSocketServer2,
   logCloseError2,
   sendJson2,
   readJsonBody2,
+  stableUnpackedExtensionOrigin2,
+  chromeExtensionOriginForPath2,
+  parseAdditionalExtensionOrigins2,
+  validateHostHeader2,
+  validateBrowserFetchSite2,
+  validateWebSocketOrigin2,
+  defaultHost2,
+  defaultPort2,
   optionalSessionId2,
   isValidSessionId2,
   requiredSessionId2,
@@ -31,7 +31,7 @@ import {
   isRestrictedTarget2,
   isRestrictedUrl2,
   dataUrlDocument2
-} from "./main-jjny7bmm.mjs";
+} from "./main-0nta0a2z.mjs";
 export {
   HttpRouteError2 as HttpRouteError,
   chromeExtensionOriginForPath2 as chromeExtensionOriginForPath,

package/dist/{main-jjny7bmm.mjs → main-0nta0a2z.mjs}

@@ -1,24 +1,26 @@
 import {
+  cliCommand,
+  installCommand,
+  npmRuntime,
   unpackedExtensionId,
   extensionReconnectAlarmPeriodMs,
   extensionProtocolAdvice,
-  parseJsonObject,
-  cliCommand,
-  installCommand,
-  npmRuntime
-} from "./main-ha5bnd77.mjs";
+  parseJsonObject
+} from "./main-ma25hhqh.mjs";
 import {
   relayAuthorization
-} from "./main-9y22cffn.mjs";
+} from "./main-20ahaz2q.mjs";
 import {
   opencodeBrowserBuildId2
-} from "./main-ppz7sv9s.mjs";
+} from "./main-arx3pfyn.mjs";
 
-// src/relay-helpers.ts
-import crypto from "node:crypto";
-import { Effect, Option, Predicate, Schema as Schema2 } from "effect";
+// src/relay/helpers.ts
+import { Option, Predicate, Schema as Schema3 } from "effect";
 
-// src/relay-schema.ts
+// src/relay/http.ts
+import { Effect, Schema as Schema2 } from "effect";
+
+// src/relay/schema.ts
 import { Schema } from "effect";
 var SessionSummary = Schema.Struct({
   id: Schema.String,
@@ -524,37 +526,7 @@ var ErrorEnvelope = Schema.Struct({
   code: Schema.optionalKey(RelayErrorCode)
 });
 
-// src/relay-helpers.ts
-var defaultHost2 = "127.0.0.1";
-var defaultPort2 = 19988;
-var stableUnpackedExtensionOrigin2 = `chrome-extension://${unpackedExtensionId}`;
-function chromeExtensionOriginForPath2(extensionPath, platform = process.platform) {
-  const normalizedPath = platform === "win32" && /^[a-z]:/.test(extensionPath) ? extensionPath.charAt(0).toUpperCase() + extensionPath.slice(1) : extensionPath;
-  const pathBytes = platform === "win32" ? Buffer.from(normalizedPath, "utf16le") : normalizedPath;
-  const digest = crypto.createHash("sha256").update(pathBytes).digest();
-  let extensionId = "";
-  for (const byte of digest.subarray(0, 16)) {
-    extensionId += String.fromCharCode(97 + (byte >> 4), 97 + (byte & 15));
-  }
-  return `chrome-extension://${extensionId}`;
-}
-var chromeExtensionOriginPattern = /^chrome-extension:\/\/[a-p]+$/;
-function parseAdditionalExtensionOrigins2(raw) {
-  if (!raw) {
-    return [];
-  }
-  const seen = new Set;
-  const origins = [];
-  for (const token of raw.split(/[\s,]+/)) {
-    const value = token.trim();
-    if (!value || !chromeExtensionOriginPattern.test(value) || seen.has(value)) {
-      continue;
-    }
-    seen.add(value);
-    origins.push(value);
-  }
-  return origins;
-}
+// src/relay/http.ts
 var maxCliBodyBytes = 1e6;
 
 class HttpRouteError2 extends Schema2.TaggedError()("HttpApi.HttpRouteError", { message: Schema2.String, status: Schema2.Number, code: RelayErrorCode }) {
@@ -565,98 +537,6 @@ function formatHostForUrl2(host) {
   }
   return host;
 }
-function validateHostHeader2(options) {
-  const parsed = parseHostHeader(options.hostHeader);
-  if (!parsed) {
-    return "Invalid Host header";
-  }
-  if (parsed.port !== undefined && parsed.port !== options.port) {
-    return "Invalid Host header port";
-  }
-  const allowedHosts = new Set(["localhost", "127.0.0.1", "::1", normalizeHostname(options.host)]);
-  if (!allowedHosts.has(parsed.hostname)) {
-    return "Invalid Host header";
-  }
-  return;
-}
-function validateBrowserFetchSite2(request) {
-  const secFetchSite = request.headers["sec-fetch-site"];
-  const value = Array.isArray(secFetchSite) ? secFetchSite[0] : secFetchSite;
-  if (!value || value === "same-origin" || value === "none") {
-    return;
-  }
-  return "Cross-origin browser requests are not allowed";
-}
-function validateWebSocketOrigin2(options) {
-  if (!options.origin) {
-    return options.requireChromeExtension ? "Extension WebSocket origin is required" : undefined;
-  }
-  if (options.origin === stableUnpackedExtensionOrigin2 || options.additionalChromeExtensionOrigins?.has(options.origin)) {
-    return;
-  }
-  if (options.requireChromeExtension) {
-    return "Extension WebSocket origin is not allowed";
-  }
-  return "WebSocket origin is not allowed";
-}
-function normalizeHostname(host) {
-  const value = host.trim().toLowerCase();
-  if (value.startsWith("[") && value.endsWith("]")) {
-    return value.slice(1, -1);
-  }
-  return value;
-}
-function parseHostHeader(hostHeader) {
-  const value = hostHeader?.trim().toLowerCase();
-  if (!value) {
-    return;
-  }
-  if (value.startsWith("[")) {
-    const closingBracket = value.indexOf("]");
-    if (closingBracket === -1) {
-      return;
-    }
-    const hostname = value.slice(1, closingBracket);
-    const rest = value.slice(closingBracket + 1);
-    if (!hostname) {
-      return;
-    }
-    if (!rest) {
-      return { hostname };
-    }
-    if (!rest.startsWith(":")) {
-      return;
-    }
-    const port = parsePort(rest.slice(1));
-    return port === undefined ? undefined : { hostname, port };
-  }
-  if (value === "::1") {
-    return { hostname: "::1" };
-  }
-  const colonCount = value.split(":").length - 1;
-  if (colonCount > 1) {
-    return;
-  }
-  if (colonCount === 0) {
-    return { hostname: value };
-  }
-  const [hostname, portText] = value.split(":");
-  if (!hostname || portText === undefined) {
-    return;
-  }
-  const port = parsePort(portText);
-  return port === undefined ? undefined : { hostname, port };
-}
-function parsePort(value) {
-  if (!/^\d+$/.test(value)) {
-    return;
-  }
-  const port = Number(value);
-  if (!Number.isInteger(port) || port < 1 || port > 65535) {
-    return;
-  }
-  return port;
-}
 function listenHttpServer2(options) {
   return Effect.callback((resume) => {
     const onError = (error) => {
@@ -791,22 +671,149 @@ function readJsonBody2(request) {
     });
   });
 }
-var RawTargetSelection = Schema2.Struct({
-  urlIncludes: Schema2.optionalKey(Schema2.String),
-  index: Schema2.optionalKey(Schema2.Int.check(Schema2.isGreaterThanOrEqualTo(0)))
+
+// src/relay/origins.ts
+import crypto from "node:crypto";
+var stableUnpackedExtensionOrigin2 = `chrome-extension://${unpackedExtensionId}`;
+function chromeExtensionOriginForPath2(extensionPath, platform = process.platform) {
+  const normalizedPath = platform === "win32" && /^[a-z]:/.test(extensionPath) ? extensionPath.charAt(0).toUpperCase() + extensionPath.slice(1) : extensionPath;
+  const pathBytes = platform === "win32" ? Buffer.from(normalizedPath, "utf16le") : normalizedPath;
+  const digest = crypto.createHash("sha256").update(pathBytes).digest();
+  let extensionId = "";
+  for (const byte of digest.subarray(0, 16)) {
+    extensionId += String.fromCharCode(97 + (byte >> 4), 97 + (byte & 15));
+  }
+  return `chrome-extension://${extensionId}`;
+}
+var chromeExtensionOriginPattern = /^chrome-extension:\/\/[a-p]+$/;
+function parseAdditionalExtensionOrigins2(raw) {
+  if (!raw) {
+    return [];
+  }
+  const seen = new Set;
+  const origins = [];
+  for (const token of raw.split(/[\s,]+/)) {
+    const value = token.trim();
+    if (!value || !chromeExtensionOriginPattern.test(value) || seen.has(value)) {
+      continue;
+    }
+    seen.add(value);
+    origins.push(value);
+  }
+  return origins;
+}
+function validateHostHeader2(options) {
+  const parsed = parseHostHeader(options.hostHeader);
+  if (!parsed) {
+    return "Invalid Host header";
+  }
+  if (parsed.port !== undefined && parsed.port !== options.port) {
+    return "Invalid Host header port";
+  }
+  const allowedHosts = new Set(["localhost", "127.0.0.1", "::1", normalizeHostname(options.host)]);
+  if (!allowedHosts.has(parsed.hostname)) {
+    return "Invalid Host header";
+  }
+  return;
+}
+function validateBrowserFetchSite2(request) {
+  const secFetchSite = request.headers["sec-fetch-site"];
+  const value = Array.isArray(secFetchSite) ? secFetchSite[0] : secFetchSite;
+  if (!value || value === "same-origin" || value === "none") {
+    return;
+  }
+  return "Cross-origin browser requests are not allowed";
+}
+function validateWebSocketOrigin2(options) {
+  if (!options.origin) {
+    return options.requireChromeExtension ? "Extension WebSocket origin is required" : undefined;
+  }
+  if (options.origin === stableUnpackedExtensionOrigin2 || options.additionalChromeExtensionOrigins?.has(options.origin)) {
+    return;
+  }
+  if (options.requireChromeExtension) {
+    return "Extension WebSocket origin is not allowed";
+  }
+  return "WebSocket origin is not allowed";
+}
+function normalizeHostname(host) {
+  const value = host.trim().toLowerCase();
+  if (value.startsWith("[") && value.endsWith("]")) {
+    return value.slice(1, -1);
+  }
+  return value;
+}
+function parseHostHeader(hostHeader) {
+  const value = hostHeader?.trim().toLowerCase();
+  if (!value) {
+    return;
+  }
+  if (value.startsWith("[")) {
+    const closingBracket = value.indexOf("]");
+    if (closingBracket === -1) {
+      return;
+    }
+    const hostname = value.slice(1, closingBracket);
+    const rest = value.slice(closingBracket + 1);
+    if (!hostname) {
+      return;
+    }
+    if (!rest) {
+      return { hostname };
+    }
+    if (!rest.startsWith(":")) {
+      return;
+    }
+    const port = parsePort(rest.slice(1));
+    return port === undefined ? undefined : { hostname, port };
+  }
+  if (value === "::1") {
+    return { hostname: "::1" };
+  }
+  const colonCount = value.split(":").length - 1;
+  if (colonCount > 1) {
+    return;
+  }
+  if (colonCount === 0) {
+    return { hostname: value };
+  }
+  const [hostname, portText] = value.split(":");
+  if (!hostname || portText === undefined) {
+    return;
+  }
+  const port = parsePort(portText);
+  return port === undefined ? undefined : { hostname, port };
+}
+function parsePort(value) {
+  if (!/^\d+$/.test(value)) {
+    return;
+  }
+  const port = Number(value);
+  if (!Number.isInteger(port) || port < 1 || port > 65535) {
+    return;
+  }
+  return port;
+}
+
+// src/relay/helpers.ts
+var defaultHost2 = "127.0.0.1";
+var defaultPort2 = 19988;
+var RawTargetSelection = Schema3.Struct({
+  urlIncludes: Schema3.optionalKey(Schema3.String),
+  index: Schema3.optionalKey(Schema3.Int.check(Schema3.isGreaterThanOrEqualTo(0)))
 });
-var decodeRawTargetSelection = Schema2.decodeUnknownOption(RawTargetSelection);
-var RawTargetInfo = Schema2.Struct({
-  targetId: Schema2.String,
-  type: Schema2.Literals(["page", "iframe", "worker"]),
-  title: Schema2.optionalKey(Schema2.String),
-  url: Schema2.String,
-  canAccessOpener: Schema2.optionalKey(Schema2.Boolean),
-  browserContextId: Schema2.optionalKey(Schema2.String),
-  openerId: Schema2.optionalKey(Schema2.String),
-  parentFrameId: Schema2.optionalKey(Schema2.String)
+var decodeRawTargetSelection = Schema3.decodeUnknownOption(RawTargetSelection);
+var RawTargetInfo = Schema3.Struct({
+  targetId: Schema3.String,
+  type: Schema3.Literals(["page", "iframe", "worker"]),
+  title: Schema3.optionalKey(Schema3.String),
+  url: Schema3.String,
+  canAccessOpener: Schema3.optionalKey(Schema3.Boolean),
+  browserContextId: Schema3.optionalKey(Schema3.String),
+  openerId: Schema3.optionalKey(Schema3.String),
+  parentFrameId: Schema3.optionalKey(Schema3.String)
 });
-var decodeRawTargetInfo = Schema2.decodeUnknownOption(RawTargetInfo);
+var decodeRawTargetInfo = Schema3.decodeUnknownOption(RawTargetInfo);
 function optionalSessionId2(value) {
   if (!Predicate.isString(value) || !value.trim()) {
     return;
@@ -946,54 +953,62 @@ async function dataUrlDocument2(url) {
   return;
 }
 
-// src/relay-client.ts
+// src/relay/lifecycle.ts
+import { Config as Config2, Effect as Effect3, Result, Schedule, Schema as Schema5 } from "effect";
+import { spawn } from "node:child_process";
+import crypto2 from "node:crypto";
+import path from "node:path";
+import process2 from "node:process";
+import { fileURLToPath } from "node:url";
+
+// src/relay/client.ts
 import { NodeHttpClient } from "@effect/platform-node";
-import { Config, Context, Effect as Effect2, Layer, Option as Option2, Schema as Schema3 } from "effect";
+import { Config, Context, Effect as Effect2, Layer, Option as Option2, Schema as Schema4 } from "effect";
 import { HttpClient, HttpClientRequest } from "effect/http";
 var portConfig = Config.Int("OPENCODE_BROWSER_PORT").pipe(Config.withDefault(defaultPort2));
 var extensionOriginsConfig = Config.String("OPENCODE_BROWSER_EXTENSION_ORIGINS").pipe(Config.withDefault(""));
 var endpointForPort = (port) => `http://127.0.0.1:${port}`;
 
-class RelayUnreachable extends Schema3.TaggedError()("RelayClient.RelayUnreachable", {
-  message: Schema3.String,
-  endpoint: Schema3.String,
-  path: Schema3.String,
-  cause: Schema3.Defect()
+class RelayUnreachable extends Schema4.TaggedError()("RelayClient.RelayUnreachable", {
+  message: Schema4.String,
+  endpoint: Schema4.String,
+  path: Schema4.String,
+  cause: Schema4.Defect()
 }) {
 }
 
-class RelayRejected extends Schema3.TaggedError()("RelayClient.RelayRejected", {
-  message: Schema3.String,
-  status: Schema3.Number,
-  path: Schema3.String,
-  code: Schema3.optionalKey(RelayErrorCode)
+class RelayRejected extends Schema4.TaggedError()("RelayClient.RelayRejected", {
+  message: Schema4.String,
+  status: Schema4.Number,
+  path: Schema4.String,
+  code: Schema4.optionalKey(RelayErrorCode)
 }) {
 }
 
-class RelayDecodeFailed extends Schema3.TaggedError()("RelayClient.RelayDecodeFailed", {
-  message: Schema3.String,
-  path: Schema3.String,
-  cause: Schema3.Defect()
+class RelayDecodeFailed extends Schema4.TaggedError()("RelayClient.RelayDecodeFailed", {
+  message: Schema4.String,
+  path: Schema4.String,
+  cause: Schema4.Defect()
 }) {
 }
 
-class RelayEncodeFailed extends Schema3.TaggedError()("RelayClient.RelayEncodeFailed", {
-  message: Schema3.String,
-  path: Schema3.String,
-  cause: Schema3.Defect()
+class RelayEncodeFailed extends Schema4.TaggedError()("RelayClient.RelayEncodeFailed", {
+  message: Schema4.String,
+  path: Schema4.String,
+  cause: Schema4.Defect()
 }) {
 }
 
-class RelayConfigInvalid extends Schema3.TaggedError()("RelayClient.RelayConfigInvalid", {
-  message: Schema3.String,
-  cause: Schema3.Defect()
+class RelayConfigInvalid extends Schema4.TaggedError()("RelayClient.RelayConfigInvalid", {
+  message: Schema4.String,
+  cause: Schema4.Defect()
 }) {
 }
 
 class Service extends Context.Service()("opencode-browser-cli/RelayClient") {
 }
-var decodeErrorEnvelope = Schema3.decodeUnknownOption(ErrorEnvelope);
-var decodeErrorMessage = Schema3.decodeUnknownOption(Schema3.Struct({ error: Schema3.String }));
+var decodeErrorEnvelope = Schema4.decodeUnknownOption(ErrorEnvelope);
+var decodeErrorMessage = Schema4.decodeUnknownOption(Schema4.Struct({ error: Schema4.String }));
 var make = Effect2.fn("RelayClient.make")(function* (options) {
   const port = yield* portConfig.pipe(Effect2.mapError((cause) => new RelayConfigInvalid({
     message: `Invalid OPENCODE_BROWSER_PORT configuration: ${cause.message}`,
@@ -1017,7 +1032,7 @@ var make = Effect2.fn("RelayClient.make")(function* (options) {
         ...Option2.isSome(envelope) && envelope.value.code ? { code: envelope.value.code } : {}
       }));
     }
-    return Schema3.decodeUnknownEffect(schema)(body).pipe(Effect2.mapError((cause) => new RelayDecodeFailed({
+    return Schema4.decodeUnknownEffect(schema)(body).pipe(Effect2.mapError((cause) => new RelayDecodeFailed({
       message: `Relay response for ${path} did not match the expected shape: ${cause.message}`,
       path,
       cause
@@ -1118,14 +1133,8 @@ function mcpClientPid() {
 }
 var layerFetchMcp = Layer.effect(Service, make({ clientPid: mcpClientPid() })).pipe(Layer.provide(NodeHttpClient.layerNodeHttp));
 
-// src/relay-lifecycle.ts
-import { Config as Config2, Effect as Effect3, Result, Schedule, Schema as Schema4 } from "effect";
-import { spawn } from "node:child_process";
-import crypto2 from "node:crypto";
-import path from "node:path";
-import process2 from "node:process";
-import { fileURLToPath } from "node:url";
-var loadedCliEntrypoint = fileURLToPath(new URL(import.meta.url.endsWith(".ts") ? "./main.ts" : "./cli.mjs", import.meta.url));
+// src/relay/lifecycle.ts
+var loadedCliEntrypoint = fileURLToPath(new URL(import.meta.url.endsWith(".ts") ? "../main.ts" : "./cli.mjs", import.meta.url));
 var clientInstanceId = crypto2.randomUUID();
 function shouldWaitForExtensionReconnect(readiness) {
   return readiness.started || readiness.waitForReconnect === true;
@@ -1134,19 +1143,19 @@ function shouldWaitForExtensionReconnect(readiness) {
 class RelayStillRunning extends Error {
 }
 
-class RelayStartFailed extends Schema4.TaggedError()("RelayLifecycle.RelayStartFailed", {
-  message: Schema4.String,
-  endpoint: Schema4.String,
-  cause: Schema4.Defect()
+class RelayStartFailed extends Schema5.TaggedError()("RelayLifecycle.RelayStartFailed", {
+  message: Schema5.String,
+  endpoint: Schema5.String,
+  cause: Schema5.Defect()
 }) {
 }
 
-class ExtensionDisconnected extends Schema4.TaggedError()("RelayLifecycle.ExtensionDisconnected", { message: Schema4.String, needsPairing: Schema4.optionalKey(Schema4.Boolean) }) {
+class ExtensionDisconnected extends Schema5.TaggedError()("RelayLifecycle.ExtensionDisconnected", { message: Schema5.String, needsPairing: Schema5.optionalKey(Schema5.Boolean) }) {
 }
 
-class ExtensionProtocolIncompatible extends Schema4.TaggedError()("RelayLifecycle.ExtensionProtocolIncompatible", {
-  message: Schema4.String,
-  protocolVersion: Schema4.NullOr(Schema4.Number)
+class ExtensionProtocolIncompatible extends Schema5.TaggedError()("RelayLifecycle.ExtensionProtocolIncompatible", {
+  message: Schema5.String,
+  protocolVersion: Schema5.NullOr(Schema5.Number)
 }) {
 }
 function supersededRuntime() {
@@ -1422,4 +1431,4 @@ function isRelayStartingOrUnreachable(error) {
   return isRelayStarting(error) || isRelayUnreachable(error);
 }
 
-export { ExecuteRequest, SessionAdoptRequest, SessionNewRequest, SessionEnsureRequest, SessionIdRequest, SessionAllowlistRequest, AuthenticatedJsonRequest, AuthenticatedJsonOutcome, RelayShutdownRequest, NetworkStartRequest, NetworkSessionRequest, NetworkStopRequest, DeadboltLoginsRequest, AuthProfileRequest, AuthRefreshRequest, AuthRunRequest, RecordingTargetRequest, RecordingStartRequest, FlightRecorderStartRequest, FlightRecorderSaveRequest, defaultHost2, defaultPort2, stableUnpackedExtensionOrigin2, chromeExtensionOriginForPath2, parseAdditionalExtensionOrigins2, HttpRouteError2, formatHostForUrl2, validateHostHeader2, validateBrowserFetchSite2, validateWebSocketOrigin2, listenHttpServer2, closeHttpServer2, closeWebSocketServer2, logCloseError2, sendJson2, readJsonBody2, optionalSessionId2, isValidSessionId2, requiredSessionId2, parseTargetSelection2, generateSessionId2, sendCdpResponse2, sendCdpEvent2, getObject2, getString2, getNumber2, getIdText2, headerValue2, getTargetInfo2, isRestrictedTarget2, isRestrictedUrl2, dataUrlDocument2, portConfig, extensionOriginsConfig, endpointForPort, RelayUnreachable, RelayRejected, Service, layerFetch, layerFetchMcp, shouldWaitForExtensionReconnect, relayBuildProblem, ensureRelay, restartRelay, extensionReconnectWaitMs, ensureExtensionConnected, stoppedRelayStatus, statusCollections, startManagedRelay };
+export { ExecuteRequest, SessionAdoptRequest, SessionNewRequest, SessionEnsureRequest, SessionIdRequest, SessionAllowlistRequest, AuthenticatedJsonRequest, AuthenticatedJsonOutcome, RelayShutdownRequest, NetworkStartRequest, NetworkSessionRequest, NetworkStopRequest, DeadboltLoginsRequest, AuthProfileRequest, AuthRefreshRequest, AuthRunRequest, RecordingTargetRequest, RecordingStartRequest, FlightRecorderStartRequest, FlightRecorderSaveRequest, HttpRouteError2, formatHostForUrl2, listenHttpServer2, closeHttpServer2, closeWebSocketServer2, logCloseError2, sendJson2, readJsonBody2, stableUnpackedExtensionOrigin2, chromeExtensionOriginForPath2, parseAdditionalExtensionOrigins2, validateHostHeader2, validateBrowserFetchSite2, validateWebSocketOrigin2, defaultHost2, defaultPort2, optionalSessionId2, isValidSessionId2, requiredSessionId2, parseTargetSelection2, generateSessionId2, sendCdpResponse2, sendCdpEvent2, getObject2, getString2, getNumber2, getIdText2, headerValue2, getTargetInfo2, isRestrictedTarget2, isRestrictedUrl2, dataUrlDocument2, portConfig, extensionOriginsConfig, endpointForPort, RelayUnreachable, RelayRejected, Service, layerFetch, layerFetchMcp, shouldWaitForExtensionReconnect, relayBuildProblem, ensureRelay, restartRelay, extensionReconnectWaitMs, ensureExtensionConnected, stoppedRelayStatus, statusCollections, startManagedRelay };

package/dist/{main-9y22cffn.mjs → main-20ahaz2q.mjs}

@@ -1,8 +1,8 @@
 import {
   dataRoot
-} from "./main-ha5bnd77.mjs";
+} from "./main-ma25hhqh.mjs";
 
-// src/relay-secrets.ts
+// src/relay/secrets.ts
 import crypto2 from "node:crypto";
 import fs2 from "node:fs";
 import path2 from "node:path";
@@ -65,7 +65,7 @@ function writePrivateJsonFileSync(filePath, value, options = {}) {
   }
 }
 
-// src/relay-secrets.ts
+// src/relay/secrets.ts
 var relayTokenQueryParam = "opencodeBrowserToken";
 var tokenPattern = /^[A-Za-z0-9_-]{43}$/;
 function relayTokenPath(root = dataRoot()) {

package/dist/{main-w5sta7hq.mjs → main-3rsfghef.mjs}

@@ -1,12 +1,12 @@
 import {
-  unpackedReloadAdvice,
   dataRoot,
   checkoutRoot,
   cliCommand,
   compareVersions,
   npmRuntime,
-  autoUpdateStatus
-} from "./main-ha5bnd77.mjs";
+  autoUpdateStatus,
+  unpackedReloadAdvice
+} from "./main-ma25hhqh.mjs";
 
 // src/update.ts
 import { execFile, spawnSync } from "node:child_process";
@@ -312,7 +312,7 @@ function runUpdate(args, deps) {
 async function runUpdateCommand2(args) {
   const log = (line) => process.stdout.write(line + `
 `);
-  const { runNpmUpdate } = await import("./runtime-update-8wte78jj.mjs");
+  const { runNpmUpdate } = await import("./runtime-update-baranjc5.mjs");
   if (await runNpmUpdate(args))
     return;
   if (args.includes("--check")) {

package/dist/{main-d7rbre73.mjs → main-42qfr69q.mjs}

@@ -1,14 +1,14 @@
 import {
   isNodeError
-} from "./main-9y22cffn.mjs";
+} from "./main-20ahaz2q.mjs";
 import {
   dataRoot
-} from "./main-ha5bnd77.mjs";
+} from "./main-ma25hhqh.mjs";
 import {
   isValidSessionId2
-} from "./main-jjny7bmm.mjs";
+} from "./main-0nta0a2z.mjs";
 
-// src/session-journal.ts
+// src/session-manager/journal.ts
 import fs from "node:fs";
 import path from "node:path";
 import { Option, Schema } from "effect";

package/dist/main-arx3pfyn.mjs

@@ -0,0 +1,4 @@
+// src/version.ts
+var opencodeBrowserVersion2 = "0.0.6-dev.20";
+var opencodeBrowserBuildId2 = "2026-11-04T16:45:59.381Z";
+export { opencodeBrowserVersion2, opencodeBrowserBuildId2 };

package/dist/{main-0egy8naa.mjs → main-hywb9qbv.mjs}

@@ -1,13 +1,13 @@
 import {
   writePrivateJsonFileSync
-} from "./main-9y22cffn.mjs";
+} from "./main-20ahaz2q.mjs";
 import {
   dataRoot,
   devExtensionUrl,
   devExtensionFolder
-} from "./main-ha5bnd77.mjs";
+} from "./main-ma25hhqh.mjs";
 
-// src/browser-pairing.ts
+// src/relay/browser-pairing.ts
 import crypto from "node:crypto";
 import fs from "node:fs";
 import path from "node:path";
@@ -155,7 +155,7 @@ function wrapToken(sessionKey, token) {
   return Buffer.from(Buffer.from(token, "base64url").map((byte, index) => byte ^ mask[index])).toString("base64url");
 }
 
-// src/dev-extension.ts
+// src/setup/dev-extension.ts
 import { createHash } from "node:crypto";
 import { existsSync, mkdirSync, readFileSync, renameSync, rmSync, writeFileSync } from "node:fs";
 import path2 from "node:path";
@@ -268,7 +268,7 @@ function unzip(zip) {
   return entries;
 }
 
-// src/relay-config.ts
+// src/relay/config.ts
 import fs2 from "node:fs";
 import path3 from "node:path";
 var relayConfigPath = (root = dataRoot()) => path3.join(root, "config.json");