@opencode/browse 0.0.6 → 0.0.7

package/dist/main-605j7tjk.mjs

@@ -1,1410 +0,0 @@
-import {
-  unpackedExtensionId,
-  extensionReconnectAlarmPeriodMs,
-  extensionProtocolAdvice,
-  parseJsonObject
-} from "./main-3gthmkzw.mjs";
-import {
-  relayAuthorization
-} from "./main-yv64m9we.mjs";
-import {
-  opencodeBrowserBuildId2
-} from "./main-ry14nc9q.mjs";
-import {
-  compiledBinary,
-  scriptEntry,
-  cliCommand,
-  installCommand,
-  npmRuntime
-} from "./main-3cza6vx1.mjs";
-
-// src/relay/helpers.ts
-import { Option, Predicate, Schema as Schema3 } from "effect";
-
-// 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,
-  createdAt: Schema.String,
-  updatedAt: Schema.String,
-  connected: Schema.Boolean,
-  pageUrl: Schema.NullOr(Schema.String),
-  stateKeys: Schema.Array(Schema.String),
-  readOnly: Schema.optionalKey(Schema.Boolean),
-  allowedOrigins: Schema.optionalKey(Schema.Array(Schema.String)),
-  browser: Schema.optionalKey(Schema.String)
-});
-var ExecuteSessionSummary = SessionSummary.pipe(Schema.fieldsAssign({
-  created: Schema.optionalKey(Schema.Boolean)
-}));
-var SessionContainer = Schema.Struct({
-  session: SessionSummary
-});
-var SessionsContainer = Schema.Struct({
-  sessions: Schema.Array(SessionSummary)
-});
-var SessionStopReport = Schema.Struct({
-  execute: Schema.Boolean,
-  handoff: Schema.Boolean,
-  forced: Schema.Boolean
-});
-var SessionDeleted = Schema.Struct({
-  deleted: Schema.Boolean,
-  id: Schema.String,
-  stopped: Schema.optionalKey(SessionStopReport)
-});
-var SessionResetResponse = Schema.Struct({
-  session: SessionSummary,
-  stopped: Schema.optionalKey(SessionStopReport)
-});
-var TargetSelection = Schema.Struct({
-  urlIncludes: Schema.optionalKey(Schema.NonEmptyString),
-  index: Schema.optionalKey(Schema.Int.check(Schema.isGreaterThanOrEqualTo(0)))
-}).check(Schema.makeFilter((selection) => {
-  const hasUrl = selection.urlIncludes !== undefined;
-  const hasIndex = selection.index !== undefined;
-  return hasUrl !== hasIndex ? undefined : "targetSelection must contain exactly one of urlIncludes or index";
-}));
-var ExecuteRequest = Schema.Struct({
-  sessionId: Schema.optionalKey(Schema.String),
-  code: Schema.String,
-  createIfMissing: Schema.Boolean,
-  browser: Schema.optionalKey(Schema.String),
-  removeAfterExecute: Schema.optionalKey(Schema.Boolean),
-  timeoutMs: Schema.optionalKey(Schema.Int.check(Schema.isGreaterThanOrEqualTo(0))),
-  targetSelection: Schema.optionalKey(TargetSelection)
-});
-var SessionAdoptRequest = Schema.Struct({
-  sessionId: Schema.optionalKey(Schema.String),
-  createIfMissing: Schema.Boolean,
-  targetSelection: Schema.optionalKey(TargetSelection),
-  tabId: Schema.optionalKey(Schema.Int)
-});
-var SessionNewRequest = Schema.Struct({
-  id: Schema.optionalKey(Schema.String),
-  readOnly: Schema.optionalKey(Schema.Boolean),
-  allowedOrigins: Schema.optionalKey(Schema.Array(Schema.String)),
-  browser: Schema.optionalKey(Schema.String)
-});
-var SessionEnsureRequest = Schema.Struct({
-  id: Schema.NonEmptyString,
-  readOnly: Schema.optionalKey(Schema.Boolean)
-});
-var SessionIdRequest = Schema.Struct({
-  id: Schema.String
-});
-var SessionAllowlistRequest = Schema.Struct({
-  id: Schema.String,
-  allowedOrigins: Schema.Array(Schema.String)
-});
-var SessionAdoptResponse = Schema.Struct({
-  session: ExecuteSessionSummary,
-  adoptedUrl: Schema.String,
-  adoptedTargetId: Schema.String
-});
-var ExecuteLogLocation = Schema.Struct({
-  url: Schema.String,
-  lineNumber: Schema.Number,
-  columnNumber: Schema.Number
-});
-var ExecuteLogEntry = Schema.Struct({
-  source: Schema.Literals(["script", "page"]),
-  type: Schema.String,
-  text: Schema.String,
-  location: Schema.optionalKey(ExecuteLogLocation),
-  repeatCount: Schema.optionalKey(Schema.Number)
-});
-var ExecuteLogSummary = Schema.Struct({
-  totalCount: Schema.Number,
-  returnedCount: Schema.Number,
-  repeatedCount: Schema.Number,
-  omittedCount: Schema.Number
-});
-var ExecuteAftermath = Schema.Struct({
-  startUrl: Schema.NullOr(Schema.String),
-  endUrl: Schema.NullOr(Schema.String),
-  navigations: Schema.Array(Schema.String),
-  consoleErrorCount: Schema.Number,
-  pageErrorCount: Schema.Number,
-  handoffs: Schema.Number,
-  challenge: Schema.optionalKey(Schema.Struct({
-    vendor: Schema.String,
-    kind: Schema.Literals(["non-interactive", "interactive", "block"]),
-    status: Schema.Literals(["cleared", "blocked"]),
-    signal: Schema.String,
-    url: Schema.String,
-    waitedMs: Schema.Number,
-    recommendation: Schema.Literals(["continue", "handoff", "stop"])
-  }))
-});
-var ExecuteMedia = Schema.Struct({
-  type: Schema.Literal("image"),
-  mimeType: Schema.String,
-  data: Schema.String,
-  size: Schema.Number
-});
-var ExecuteResponse = Schema.Struct({
-  text: Schema.String,
-  value: Schema.optionalKey(Schema.Unknown),
-  media: Schema.optionalKey(Schema.Array(ExecuteMedia)),
-  isError: Schema.Boolean,
-  logs: Schema.Array(ExecuteLogEntry),
-  logSummary: Schema.optionalKey(ExecuteLogSummary),
-  warnings: Schema.optionalKey(Schema.Array(Schema.String)),
-  diagnostic: Schema.optionalKey(Schema.String),
-  aftermath: Schema.optionalKey(ExecuteAftermath),
-  session: ExecuteSessionSummary
-});
-var AuthenticatedJsonMethod = Schema.Literals(["GET", "POST", "PUT", "PATCH", "DELETE"]);
-var AuthenticatedJsonRequest = Schema.Struct({
-  sessionId: Schema.NonEmptyString,
-  origin: Schema.NonEmptyString,
-  startUrl: Schema.optionalKey(Schema.NonEmptyString),
-  method: AuthenticatedJsonMethod,
-  path: Schema.NonEmptyString,
-  headers: Schema.optionalKey(Schema.Record(Schema.String, Schema.String)),
-  body: Schema.optionalKey(Schema.Json),
-  sensitive: Schema.optionalKey(Schema.Boolean),
-  handoffOnAuthFailure: Schema.optionalKey(Schema.Boolean),
-  handoffMessage: Schema.optionalKey(Schema.String),
-  timeoutMs: Schema.optionalKey(Schema.Int.check(Schema.isBetween({ minimum: 1, maximum: 120000 }))),
-  maxResponseBytes: Schema.optionalKey(Schema.Int.check(Schema.isBetween({ minimum: 1, maximum: 1e7 })))
-});
-var AuthenticatedJsonOutcome = Schema.TaggedUnion({
-  Success: {
-    status: Schema.Int,
-    value: Schema.Json
-  },
-  OriginMismatch: {
-    expectedOrigin: Schema.String,
-    actualOrigin: Schema.String
-  },
-  RequestFailed: {
-    outcome: Schema.Literals(["not-sent", "unknown"])
-  },
-  HttpError: {
-    status: Schema.Int
-  },
-  ResponseTooLarge: {
-    status: Schema.Int,
-    maxResponseBytes: Schema.Int
-  },
-  InvalidJson: {
-    status: Schema.Int
-  },
-  SensitiveCaptureActive: {}
-});
-var TargetSummary = Schema.Struct({
-  id: Schema.String,
-  type: Schema.String,
-  title: Schema.String,
-  url: Schema.String,
-  tabId: Schema.optionalKey(Schema.Number),
-  sessionId: Schema.optionalKey(Schema.String),
-  opencodeBrowserSessionId: Schema.optionalKey(Schema.String),
-  owner: Schema.optionalKey(Schema.Literals(["relay", "user"])),
-  crashed: Schema.optionalKey(Schema.Boolean),
-  protectedUi: Schema.optionalKey(Schema.Boolean)
-});
-var TargetSummaries = Schema.Array(TargetSummary);
-var ConnectedBrowser = Schema.Struct({
-  id: Schema.String,
-  name: Schema.String,
-  default: Schema.Boolean,
-  connected: Schema.Boolean,
-  version: Schema.NullOr(Schema.String),
-  tabs: Schema.Int.check(Schema.isGreaterThanOrEqualTo(0))
-});
-var ExtensionStatus = Schema.Struct({
-  connected: Schema.Boolean,
-  pairingState: Schema.optionalKey(Schema.Literals(["connected", "incompatible", "refused", "unpaired", "paired-offline", "not-seen"])),
-  nextStep: Schema.optionalKey(Schema.String),
-  version: Schema.NullOr(Schema.String),
-  build: Schema.optionalKey(Schema.NullOr(Schema.String)),
-  origin: Schema.optionalKey(Schema.NullOr(Schema.String)),
-  protocolVersion: Schema.optionalKey(Schema.NullOr(Schema.Number)),
-  protocolCompatible: Schema.optionalKey(Schema.NullOr(Schema.Boolean)),
-  protocolLegacy: Schema.optionalKey(Schema.NullOr(Schema.Boolean)),
-  browsers: Schema.optionalKey(Schema.Array(ConnectedBrowser)),
-  rejectedConnections: Schema.optionalKey(Schema.Int.check(Schema.isGreaterThanOrEqualTo(0))),
-  pairingFailures: Schema.optionalKey(Schema.Int.check(Schema.isGreaterThanOrEqualTo(0))),
-  processFaults: Schema.optionalKey(Schema.Struct({
-    suppressed: Schema.Int.check(Schema.isGreaterThanOrEqualTo(0)),
-    lastAt: Schema.optionalKey(Schema.String),
-    lastMessage: Schema.optionalKey(Schema.String)
-  })),
-  activeTargets: Schema.Number,
-  childTargets: Schema.optionalKey(Schema.Number),
-  cdpClients: Schema.optionalKey(Schema.Number),
-  sessions: Schema.optionalKey(Schema.Array(SessionSummary)),
-  targets: Schema.optionalKey(TargetSummaries)
-});
-var RelayVersion = Schema.Struct({
-  version: Schema.String,
-  buildId: Schema.optionalKey(Schema.String),
-  instanceId: Schema.optionalKey(Schema.String),
-  startedAt: Schema.optionalKey(Schema.String),
-  pid: Schema.optionalKey(Schema.Number),
-  managed: Schema.optionalKey(Schema.Boolean),
-  shutdownProtocol: Schema.optionalKey(Schema.Literal(2))
-});
-var RelayIdentity = Schema.String.check(Schema.isPattern(/^[A-Za-z0-9][A-Za-z0-9_-]{0,127}(?![\s\S])/));
-var RelayBuildId = Schema.String.check(Schema.isPattern(/^[A-Za-z0-9][A-Za-z0-9._:+-]{0,255}(?![\s\S])/));
-var RelayShutdownRequest = Schema.Struct({
-  instanceId: RelayIdentity,
-  requestId: RelayIdentity,
-  reason: Schema.Literal("explicit-restart"),
-  client: Schema.Struct({
-    kind: Schema.Literals(["cli", "mcp", "sdk"]),
-    instanceId: RelayIdentity,
-    buildId: RelayBuildId
-  }),
-  force: Schema.optionalKey(Schema.Boolean)
-});
-var RelayShutdownResponse = Schema.Struct({
-  stopping: Schema.Literal(true)
-});
-var NetworkContentMode = Schema.Literals(["omit", "embed"]);
-var NetworkStartRequest = Schema.Struct({
-  sessionId: Schema.NonEmptyString,
-  urlFilter: Schema.optionalKey(Schema.String),
-  resourceTypes: Schema.optionalKey(Schema.Array(Schema.NonEmptyString).check(Schema.isMaxLength(50))),
-  content: Schema.optionalKey(NetworkContentMode),
-  maxBodyBytes: Schema.optionalKey(Schema.Int.check(Schema.isBetween({ minimum: 1, maximum: 1e7 }))),
-  maxTotalBodyBytes: Schema.optionalKey(Schema.Int.check(Schema.isBetween({ minimum: 1, maximum: 1e8 }))),
-  maxEntries: Schema.optionalKey(Schema.Int.check(Schema.isBetween({ minimum: 1, maximum: 1e4 }))),
-  maxDurationMs: Schema.optionalKey(Schema.Int.check(Schema.isBetween({ minimum: 1, maximum: 86400000 })))
-});
-var NetworkSessionRequest = Schema.Struct({ sessionId: Schema.NonEmptyString });
-var NetworkStopRequest = NetworkSessionRequest.pipe(Schema.fieldsAssign({
-  outputPath: Schema.optionalKey(Schema.String),
-  secrets: Schema.optionalKey(Schema.NonEmptyString)
-}));
-var NetworkStatusResponse = Schema.Struct({
-  active: Schema.Boolean,
-  startedAt: Schema.optionalKey(Schema.String),
-  entryCount: Schema.Number,
-  responseCount: Schema.Number,
-  failureCount: Schema.Number,
-  capturedBodyBytes: Schema.Number,
-  truncatedBodyCount: Schema.Number,
-  droppedEntryCount: Schema.Number,
-  urlFilter: Schema.optionalKey(Schema.String),
-  resourceTypes: Schema.optionalKey(Schema.Array(Schema.String)),
-  content: Schema.optionalKey(NetworkContentMode),
-  secrets: Schema.optionalKey(Schema.String),
-  endsAt: Schema.optionalKey(Schema.String),
-  ended: Schema.optionalKey(Schema.String)
-});
-var AuthProfileSlotSummary = Schema.Struct({
-  ref: Schema.String,
-  sources: Schema.Array(Schema.String),
-  expiresAt: Schema.optionalKey(Schema.String),
-  expired: Schema.Boolean
-});
-var AuthProfileSummary = Schema.Struct({
-  name: Schema.String,
-  createdAt: Schema.String,
-  updatedAt: Schema.String,
-  slotCount: Schema.Number,
-  slots: Schema.Array(AuthProfileSlotSummary)
-});
-var NetworkEndpointDigest = Schema.Struct({
-  method: Schema.String,
-  url: Schema.String,
-  status: Schema.optionalKey(Schema.Number),
-  count: Schema.Number,
-  requestHeaders: Schema.optionalKey(Schema.Array(Schema.String)),
-  requestKeys: Schema.optionalKey(Schema.Array(Schema.String)),
-  responseKeys: Schema.optionalKey(Schema.Array(Schema.String))
-});
-var NetworkStopResponse = NetworkStatusResponse.pipe(Schema.fieldsAssign({
-  active: Schema.Literal(false),
-  stoppedAt: Schema.String,
-  outputPath: Schema.optionalKey(Schema.String),
-  authProfile: Schema.optionalKey(AuthProfileSummary),
-  updatedSecretRefs: Schema.Array(Schema.String),
-  observedSecretRefs: Schema.Array(Schema.String),
-  endpoints: Schema.optionalKey(Schema.Array(NetworkEndpointDigest))
-}));
-var NetworkCancelResponse = Schema.Struct({ cancelled: Schema.Boolean });
-var AuthProfileRequest = Schema.Struct({ name: Schema.NonEmptyString });
-var AuthRefreshRequest = Schema.Struct({
-  sessionId: Schema.NonEmptyString,
-  name: Schema.NonEmptyString,
-  urlFilter: Schema.optionalKey(Schema.String),
-  timeoutMs: Schema.optionalKey(Schema.Int.check(Schema.isGreaterThan(0)))
-});
-var AuthRunRequest = Schema.Struct({
-  name: Schema.NonEmptyString,
-  command: Schema.NonEmptyString,
-  args: Schema.optionalKey(Schema.Array(Schema.String)),
-  cwd: Schema.optionalKey(Schema.String),
-  timeoutMs: Schema.optionalKey(Schema.Int.check(Schema.isGreaterThan(0)))
-});
-var AuthRunResponse = Schema.Struct({
-  exitCode: Schema.Number,
-  signal: Schema.NullOr(Schema.String),
-  stdout: Schema.String,
-  stderr: Schema.String,
-  stdoutTruncated: Schema.Boolean,
-  stderrTruncated: Schema.Boolean,
-  durationMs: Schema.Number
-});
-var RecordingMode = Schema.Literals(["tab-capture", "cdp"]);
-var RecordingRequestedMode = Schema.Literals(["auto", "tab-capture", "cdp"]);
-var RecordingFrameRate = Schema.Number.check(Schema.isInt(), Schema.isBetween({ minimum: 1, maximum: 60 }));
-var RecordingQuality = Schema.Struct({
-  width: Schema.Number,
-  height: Schema.Number,
-  frameRate: Schema.Number,
-  sourceFrameCount: Schema.Number,
-  encodedSourceFrameCount: Schema.Number,
-  coalescedFrameCount: Schema.Number,
-  droppedFrameCount: Schema.Number,
-  achievedSourceFrameRate: Schema.Number,
-  achievedEncodedSourceFrameRate: Schema.Number,
-  screenshotFallback: Schema.Boolean,
-  sourceWidth: Schema.optionalKey(Schema.Number),
-  sourceHeight: Schema.optionalKey(Schema.Number)
-});
-var RecordingTargetRequest = Schema.Struct({
-  sessionId: Schema.optionalKey(Schema.String),
-  tabId: Schema.optionalKey(Schema.Number)
-});
-var RecordingStartRequest = RecordingTargetRequest.pipe(Schema.fieldsAssign({
-  outputPath: Schema.String,
-  mode: Schema.optionalKey(RecordingRequestedMode),
-  audio: Schema.optionalKey(Schema.Boolean),
-  frameRate: Schema.optionalKey(RecordingFrameRate),
-  videoBitsPerSecond: Schema.optionalKey(Schema.Number),
-  audioBitsPerSecond: Schema.optionalKey(Schema.Number),
-  maxDurationMs: Schema.optionalKey(Schema.Number),
-  cursor: Schema.optionalKey(Schema.Boolean)
-}));
-var RecordingArtifactType = Schema.Literals(["webm", "mp4"]);
-var RecordingStartResponse = Schema.Struct({
-  success: Schema.Boolean,
-  tabId: Schema.optionalKey(Schema.Number),
-  startedAt: Schema.optionalKey(Schema.Number),
-  path: Schema.optionalKey(Schema.String),
-  mimeType: Schema.optionalKey(Schema.String),
-  mode: Schema.optionalKey(RecordingMode),
-  artifactType: Schema.optionalKey(RecordingArtifactType),
-  frameRate: Schema.optionalKey(Schema.Number),
-  error: Schema.optionalKey(Schema.String)
-});
-var RecordingStopResponse = Schema.Struct({
-  success: Schema.Boolean,
-  tabId: Schema.optionalKey(Schema.Number),
-  duration: Schema.optionalKey(Schema.Number),
-  path: Schema.optionalKey(Schema.String),
-  size: Schema.optionalKey(Schema.Number),
-  mode: Schema.optionalKey(RecordingMode),
-  artifactType: Schema.optionalKey(RecordingArtifactType),
-  frameCount: Schema.optionalKey(Schema.Number),
-  quality: Schema.optionalKey(RecordingQuality),
-  error: Schema.optionalKey(Schema.String)
-});
-var RecordingStatusResponse = Schema.Struct({
-  isRecording: Schema.Boolean,
-  tabId: Schema.optionalKey(Schema.Number),
-  startedAt: Schema.optionalKey(Schema.Number),
-  path: Schema.optionalKey(Schema.String),
-  size: Schema.optionalKey(Schema.Number),
-  mode: Schema.optionalKey(RecordingMode),
-  artifactType: Schema.optionalKey(RecordingArtifactType),
-  frameCount: Schema.optionalKey(Schema.Number),
-  quality: Schema.optionalKey(RecordingQuality)
-});
-var TabsCleanupResponse = Schema.Struct({
-  closed: Schema.Array(Schema.Struct({ tabId: Schema.Number, title: Schema.String, idleMinutes: Schema.Number }))
-});
-var SettingValue = Schema.Union([Schema.String, Schema.Number]);
-var SettingReport = Schema.Struct({
-  value: SettingValue,
-  effective: SettingValue,
-  allowed: Schema.Array(SettingValue),
-  description: Schema.String,
-  overriddenBy: Schema.optionalKey(Schema.String)
-});
-var SettingsGetResponse = Schema.Struct({
-  settings: Schema.Record(Schema.String, SettingReport),
-  note: Schema.String
-});
-var SettingsSetResponse = Schema.Struct({
-  changed: Schema.Array(Schema.Struct({ key: Schema.String, from: SettingValue, to: SettingValue })),
-  unchanged: Schema.Array(Schema.String),
-  overridden: Schema.Array(Schema.Struct({ key: Schema.String, requested: SettingValue, variable: Schema.String, effective: SettingValue })),
-  settings: Schema.Record(Schema.String, SettingReport),
-  message: Schema.String
-});
-var RecordingCancelResponse = Schema.Struct({
-  success: Schema.Boolean,
-  error: Schema.optionalKey(Schema.String)
-});
-var FlightRecorderStartRequest = RecordingTargetRequest.pipe(Schema.fieldsAssign({
-  retentionMs: Schema.optionalKey(Schema.Number.check(Schema.isInt(), Schema.isBetween({ minimum: 1000, maximum: 120000 }))),
-  frameRate: Schema.optionalKey(RecordingFrameRate),
-  cursor: Schema.optionalKey(Schema.Boolean)
-}));
-var FlightRecorderStatusResponse = Schema.Struct({
-  active: Schema.Boolean,
-  tabId: Schema.optionalKey(Schema.Number),
-  sessionId: Schema.optionalKey(Schema.String),
-  startedAt: Schema.optionalKey(Schema.Number),
-  retentionMs: Schema.optionalKey(Schema.Number),
-  retainedDurationMs: Schema.optionalKey(Schema.Number),
-  frameRate: Schema.optionalKey(Schema.Number),
-  bufferedFrames: Schema.optionalKey(Schema.Number),
-  bufferedBytes: Schema.optionalKey(Schema.Number),
-  sourceFrameCount: Schema.optionalKey(Schema.Number),
-  droppedFrameCount: Schema.optionalKey(Schema.Number),
-  saving: Schema.optionalKey(Schema.Boolean)
-});
-var FlightRecorderSaveRequest = RecordingTargetRequest.pipe(Schema.fieldsAssign({
-  outputPath: Schema.String,
-  durationMs: Schema.optionalKey(Schema.Number.check(Schema.isInt(), Schema.isGreaterThan(0)))
-}));
-var FlightRecorderSaveResponse = Schema.Struct({
-  path: Schema.String,
-  durationMs: Schema.Number,
-  frameCount: Schema.Number,
-  sourceFrameCount: Schema.Number,
-  droppedFrameCount: Schema.Number
-});
-var FlightRecorderCancelResponse = Schema.Struct({ cancelled: Schema.Boolean });
-var RelayErrorCode = Schema.Literals([
-  "browser-unavailable",
-  "invalid-request",
-  "unauthorized",
-  "relay-starting",
-  "relay-busy",
-  "auth-profile-not-found",
-  "capture-conflict",
-  "session-already-exists",
-  "session-inactive",
-  "session-not-found",
-  "session-timeout",
-  "setup-failed",
-  "target-ambiguous",
-  "target-changed",
-  "target-not-found",
-  "target-owned",
-  "internal"
-]);
-var ErrorEnvelope = Schema.Struct({
-  error: Schema.String,
-  code: Schema.optionalKey(RelayErrorCode)
-});
-
-// src/relay/http.ts
-var maxCliBodyBytes = 1e6;
-
-class HttpRouteError2 extends Schema2.TaggedError()("HttpApi.HttpRouteError", { message: Schema2.String, status: Schema2.Number, code: RelayErrorCode }) {
-}
-function formatHostForUrl2(host) {
-  if (host.includes(":") && !host.startsWith("[")) {
-    return `[${host}]`;
-  }
-  return host;
-}
-function listenHttpServer2(options) {
-  return Effect.callback((resume) => {
-    const onError = (error) => {
-      resume(Effect.fail(error));
-    };
-    options.server.once("error", onError);
-    options.server.listen(options.port, options.host, () => {
-      options.server.off("error", onError);
-      resume(Effect.void);
-    });
-    return Effect.sync(() => {
-      options.server.off("error", onError);
-    });
-  });
-}
-function closeHttpServer2(server) {
-  if (!server.listening) {
-    return Effect.void;
-  }
-  return Effect.callback((resume) => {
-    server.close((error) => {
-      if (error) {
-        resume(Effect.fail(new Error("close http server", { cause: error })));
-        return;
-      }
-      resume(Effect.void);
-    });
-    return Effect.void;
-  });
-}
-function closeWebSocketServer2(server) {
-  return Effect.callback((resume) => {
-    server.close((error) => {
-      const nodeError = error;
-      if (nodeError?.code === "ERR_SERVER_NOT_RUNNING") {
-        resume(Effect.void);
-        return;
-      }
-      if (error) {
-        resume(Effect.fail(new Error("close websocket server", { cause: error })));
-        return;
-      }
-      resume(Effect.void);
-    });
-    return Effect.void;
-  });
-}
-function logCloseError2(message) {
-  return (effect) => {
-    return Effect.catch(effect, (error) => {
-      return Effect.sync(() => {
-        console.error(message, error);
-      });
-    });
-  };
-}
-function sendJson2(response, value, status = 200) {
-  response.writeHead(status, { "content-type": "application/json" });
-  response.end(JSON.stringify(value));
-}
-function readJsonBody2(request) {
-  const contentType = request.headers["content-type"];
-  const contentTypeValue = Array.isArray(contentType) ? contentType[0] : contentType;
-  if (!contentTypeValue?.toLowerCase().includes("application/json")) {
-    return Effect.fail(new HttpRouteError2({ message: "Content-Type must be application/json", status: 415, code: "invalid-request" }));
-  }
-  return Effect.callback((resume) => {
-    const chunks = [];
-    let totalBytes = 0;
-    let completed = false;
-    const onData = (chunk) => {
-      if (completed) {
-        return;
-      }
-      totalBytes += chunk.byteLength;
-      if (totalBytes > maxCliBodyBytes) {
-        completed = true;
-        request.destroy(new Error(`Request body exceeds ${maxCliBodyBytes} bytes`));
-        resume(Effect.fail(new HttpRouteError2({ message: `Request body exceeds ${maxCliBodyBytes} bytes`, status: 413, code: "invalid-request" })));
-        return;
-      }
-      chunks.push(chunk);
-    };
-    const onError = (error) => {
-      if (completed) {
-        return;
-      }
-      completed = true;
-      resume(Effect.fail(new Error("read request body", { cause: error })));
-    };
-    const onAbort = () => {
-      if (completed) {
-        return;
-      }
-      completed = true;
-      resume(Effect.fail(new Error("request body aborted")));
-    };
-    const onClose = () => {
-      if (completed || request.complete) {
-        return;
-      }
-      completed = true;
-      resume(Effect.fail(new Error("request closed before body completed")));
-    };
-    const onEnd = () => {
-      if (completed) {
-        return;
-      }
-      completed = true;
-      const text = Buffer.concat(chunks).toString("utf8");
-      if (!text.trim()) {
-        resume(Effect.succeed({}));
-        return;
-      }
-      try {
-        resume(Effect.succeed(parseJsonObject(text)));
-      } catch (error) {
-        resume(Effect.fail(new HttpRouteError2({ message: "Invalid JSON body", status: 400, code: "invalid-request" })));
-      }
-    };
-    request.on("data", onData);
-    request.on("error", onError);
-    request.on("aborted", onAbort);
-    request.on("close", onClose);
-    request.on("end", onEnd);
-    return Effect.sync(() => {
-      request.off("data", onData);
-      request.off("error", onError);
-      request.off("aborted", onAbort);
-      request.off("close", onClose);
-      request.off("end", onEnd);
-    });
-  });
-}
-
-// 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 = 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 = Schema3.decodeUnknownOption(RawTargetInfo);
-function optionalSessionId2(value) {
-  if (!Predicate.isString(value) || !value.trim()) {
-    return;
-  }
-  const id = value.trim();
-  if (!isValidSessionId2(id)) {
-    throw new HttpRouteError2({
-      message: "Session ids must use lowercase letters, numbers, and dashes, and be at most 63 characters",
-      status: 400,
-      code: "invalid-request"
-    });
-  }
-  return id;
-}
-function isValidSessionId2(id) {
-  if (id.length < 1 || id.length > 63 || id === "." || id === "..")
-    return false;
-  if (/[A-Z/\\:\0-\x1f\x7f]/.test(id))
-    return false;
-  return /^(?:[\p{Extended_Pictographic}\u200d\ufe0f]+\s*)?[a-z0-9][a-z0-9\p{Extended_Pictographic}\u200d\ufe0f\s_-]*$/u.test(id);
-}
-function requiredSessionId2(value) {
-  const id = optionalSessionId2(value);
-  if (!id) {
-    throw new HttpRouteError2({ message: "sessionId is required", status: 400, code: "invalid-request" });
-  }
-  return id;
-}
-function parseTargetSelection2(value) {
-  if (value === undefined) {
-    return;
-  }
-  if (!getObject2(value)) {
-    throw new HttpRouteError2({ message: "targetSelection must be an object", status: 400, code: "invalid-request" });
-  }
-  const decoded = decodeRawTargetSelection(value);
-  if (Option.isNone(decoded)) {
-    throw new HttpRouteError2({ message: "targetSelection.index must be a non-negative integer", status: 400, code: "invalid-request" });
-  }
-  const urlIncludes = decoded.value.urlIncludes ? decoded.value.urlIncludes : undefined;
-  const index = decoded.value.index;
-  if (urlIncludes && index !== undefined) {
-    throw new HttpRouteError2({ message: "Use only one target selector", status: 400, code: "invalid-request" });
-  }
-  return {
-    ...urlIncludes ? { urlIncludes } : {},
-    ...index !== undefined ? { index } : {}
-  };
-}
-function generateSessionId2(existing) {
-  const adjectives = ["amber", "brisk", "calm", "clever", "cosmic", "gentle", "lucky", "quiet", "rapid", "tidy"];
-  const nouns = ["badger", "comet", "falcon", "otter", "panda", "raven", "sparrow", "tiger", "walrus", "wombat"];
-  for (let attempt = 0;attempt < 100; attempt++) {
-    const adjective = adjectives[Math.floor(Math.random() * adjectives.length)] ?? "calm";
-    const noun = nouns[Math.floor(Math.random() * nouns.length)] ?? "otter";
-    const suffix = String(Math.floor(Math.random() * 1000)).padStart(3, "0");
-    const id = `${adjective}-${noun}-${suffix}`;
-    if (!existing.has(id)) {
-      return id;
-    }
-  }
-  return `session-${Date.now().toString(36)}`;
-}
-function sendCdpResponse2(socket, response) {
-  socket.send(JSON.stringify(response));
-}
-function sendCdpEvent2(socket, event) {
-  socket.send(JSON.stringify(event));
-}
-function getObject2(value) {
-  return Predicate.isObject(value) ? value : undefined;
-}
-function getString2(object, key) {
-  const value = object?.[key];
-  return Predicate.isString(value) ? value : undefined;
-}
-function getNumber2(object, key) {
-  const value = object?.[key];
-  return Predicate.isNumber(value) ? value : undefined;
-}
-function getIdText2(object, key) {
-  const value = object?.[key];
-  return Predicate.isNumber(value) || Predicate.isString(value) ? String(value) : undefined;
-}
-function headerValue2(value) {
-  if (!Predicate.isString(value) || !value)
-    return;
-  try {
-    return decodeURIComponent(value);
-  } catch {
-    return value;
-  }
-}
-function getTargetInfo2(value) {
-  return Option.match(decodeRawTargetInfo(value), {
-    onNone: () => {
-      return;
-    },
-    onSome: (info) => ({
-      targetId: info.targetId,
-      type: info.type,
-      title: info.title ?? info.url,
-      url: info.url,
-      attached: true,
-      canAccessOpener: info.canAccessOpener ?? false,
-      ...info.browserContextId === undefined ? {} : { browserContextId: info.browserContextId },
-      ...info.openerId === undefined ? {} : { openerId: info.openerId },
-      ...info.parentFrameId === undefined ? {} : { parentFrameId: info.parentFrameId }
-    })
-  });
-}
-function isRestrictedTarget2(targetInfo) {
-  if (targetInfo.type !== "page" && targetInfo.type !== "iframe" && targetInfo.type !== "worker") {
-    return true;
-  }
-  return isRestrictedUrl2(targetInfo.url);
-}
-var restrictedUrlPrefixes = ["chrome://", "chrome-extension://", "chrome-untrusted://", "devtools://", "edge://", "brave://"];
-function isRestrictedUrl2(url) {
-  if (!url) {
-    return false;
-  }
-  return restrictedUrlPrefixes.some((prefix) => url.startsWith(prefix));
-}
-async function dataUrlDocument2(url) {
-  const response = await fetch(url);
-  const type = (response.headers.get("content-type") ?? "text/plain").split(";")[0]?.trim().toLowerCase() ?? "text/plain";
-  if (type === "text/html" || type === "application/xhtml+xml")
-    return await response.text();
-  if (type.startsWith("text/") || type === "application/json" || type.endsWith("+json") || type === "application/javascript") {
-    const text = (await response.text()).replace(/[&<>]/g, (char) => ({ "&": "&amp;", "<": "&lt;", ">": "&gt;" })[char] ?? char);
-    return `<html><head><meta name="color-scheme" content="light dark"></head><body><pre style="word-wrap: break-word; white-space: pre-wrap;">${text}</pre></body></html>`;
-  }
-  if (type.startsWith("image/")) {
-    return `<html><body style="margin: 0; display: grid; place-items: center; min-height: 100vh;"><img src="${url.replace(/"/g, "%22")}"></body></html>`;
-  }
-  return;
-}
-
-// 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 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 Schema4.TaggedError()("RelayClient.RelayUnreachable", {
-  message: Schema4.String,
-  endpoint: Schema4.String,
-  path: Schema4.String,
-  cause: Schema4.Defect()
-}) {
-}
-
-class RelayRejected extends Schema4.TaggedError()("RelayClient.RelayRejected", {
-  message: Schema4.String,
-  status: Schema4.Number,
-  path: Schema4.String,
-  code: Schema4.optionalKey(RelayErrorCode)
-}) {
-}
-
-class RelayDecodeFailed extends Schema4.TaggedError()("RelayClient.RelayDecodeFailed", {
-  message: Schema4.String,
-  path: Schema4.String,
-  cause: Schema4.Defect()
-}) {
-}
-
-class RelayEncodeFailed extends Schema4.TaggedError()("RelayClient.RelayEncodeFailed", {
-  message: Schema4.String,
-  path: Schema4.String,
-  cause: Schema4.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 = 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}`,
-    cause
-  })));
-  const endpoint = options?.endpoint ?? endpointForPort(port);
-  const httpClient = yield* HttpClient.HttpClient;
-  const readBody = (response, path) => response.json.pipe(Effect2.mapError((cause) => new RelayDecodeFailed({
-    message: `Relay returned an unreadable response for ${path}`,
-    path,
-    cause
-  })));
-  const handleResponse = (response, path, schema) => readBody(response, path).pipe(Effect2.flatMap((body) => {
-    if (response.status < 200 || response.status >= 300) {
-      const envelope = decodeErrorEnvelope(body);
-      const message = Option2.isSome(envelope) ? envelope.value.error : Option2.getOrElse(Option2.map(decodeErrorMessage(body), (value) => value.error), () => `Relay responded with HTTP ${response.status} for ${path}`);
-      return Effect2.fail(new RelayRejected({
-        message,
-        status: response.status,
-        path,
-        ...Option2.isSome(envelope) && envelope.value.code ? { code: envelope.value.code } : {}
-      }));
-    }
-    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
-    })));
-  }));
-  const transportError = (path) => (cause) => new RelayUnreachable({
-    message: `browse relay is not reachable at ${endpoint}. Relay-backed CLI commands start it automatically; use \`${cliCommand("serve")}\` only for foreground debugging.`,
-    endpoint,
-    path,
-    cause
-  });
-  let authorization;
-  const authorize = (request) => {
-    try {
-      authorization ??= relayAuthorization();
-    } catch {
-      return request;
-    }
-    const authorized = HttpClientRequest.setHeader(request, "authorization", authorization);
-    return options?.clientPid === undefined ? authorized : HttpClientRequest.setHeader(authorized, "opencode-browser-client-pid", String(options.clientPid));
-  };
-  const getJson = (path, schema) => Effect2.suspend(() => httpClient.execute(authorize(HttpClientRequest.get(new URL(path, endpoint))))).pipe(Effect2.mapError(transportError(path)), Effect2.flatMap((response) => handleResponse(response, path, schema)));
-  const postJson = (path, body, schema) => HttpClientRequest.post(new URL(path, endpoint)).pipe(HttpClientRequest.bodyJson(body), Effect2.mapError((cause) => new RelayEncodeFailed({
-    message: `Could not encode relay request for ${path}`,
-    path,
-    cause
-  })), Effect2.flatMap((request) => httpClient.execute(authorize(request)).pipe(Effect2.mapError(transportError(path)), Effect2.flatMap((response) => handleResponse(response, path, schema)))));
-  const recordingTargetBody = (target) => ({
-    ...target.sessionId ? { sessionId: target.sessionId } : {},
-    ...target.tabId === undefined ? {} : { tabId: target.tabId }
-  });
-  const recordingTargetQuery = (target) => {
-    const searchParams = new URLSearchParams;
-    if (target.sessionId) {
-      searchParams.set("sessionId", target.sessionId);
-    }
-    if (target.tabId !== undefined) {
-      searchParams.set("tabId", String(target.tabId));
-    }
-    const text = searchParams.toString();
-    return text ? `?${text}` : "";
-  };
-  return Service.of({
-    endpoint,
-    version: getJson("/version", RelayVersion),
-    shutdown: (request) => postJson("/shutdown", { ...request }, RelayShutdownResponse),
-    extensionStatus: getJson("/extension/status", ExtensionStatus),
-    targets: getJson("/json/list", TargetSummaries),
-    sessions: getJson("/cli/sessions", SessionsContainer).pipe(Effect2.map((container) => container.sessions)),
-    sessionNew: (id, options) => postJson("/cli/session/new", {
-      ...id ? { id } : {},
-      ...options?.readOnly ? { readOnly: true } : {},
-      ...options?.allowedOrigins && options.allowedOrigins.length > 0 ? { allowedOrigins: [...options.allowedOrigins] } : {},
-      ...options?.browser ? { browser: options.browser } : {}
-    }, SessionContainer).pipe(Effect2.map((container) => container.session)),
-    sessionAllowlist: (id, allowedOrigins) => postJson("/cli/session/allowlist", { id, allowedOrigins: [...allowedOrigins] }, SessionContainer).pipe(Effect2.map((container) => container.session)),
-    sessionEnsure: (id, options) => postJson("/v1/sessions/ensure", {
-      id,
-      ...options?.readOnly === undefined ? {} : { readOnly: options.readOnly }
-    }, SessionContainer).pipe(Effect2.map((container) => container.session)),
-    sessionReset: (id) => postJson("/cli/session/reset", { id }, SessionResetResponse),
-    sessionAdopt: ({ sessionId, ...request }) => postJson("/cli/session/adopt", {
-      ...request,
-      ...sessionId ? { sessionId } : {}
-    }, SessionAdoptResponse),
-    sessionDelete: (id) => postJson("/cli/session/delete", { id }, SessionDeleted),
-    execute: ({ sessionId, ...request }) => postJson("/cli/execute", {
-      ...request,
-      ...sessionId ? { sessionId } : {}
-    }, ExecuteResponse),
-    authenticatedJson: (request) => postJson("/v1/authenticated-origin/json", { ...request }, AuthenticatedJsonOutcome),
-    networkStart: (request) => postJson("/network/start", { ...request }, NetworkStatusResponse),
-    networkStatus: (request) => postJson("/network/status", { ...request }, NetworkStatusResponse),
-    networkStop: (request) => postJson("/network/stop", { ...request }, NetworkStopResponse),
-    networkCancel: (request) => postJson("/network/cancel", { ...request }, NetworkCancelResponse),
-    authStatus: (request) => postJson("/auth/status", { ...request }, AuthProfileSummary),
-    authRefresh: (request) => postJson("/auth/refresh", { ...request }, NetworkStopResponse),
-    authRun: (request) => postJson("/auth/run", { ...request }, AuthRunResponse),
-    recordingStart: ({ sessionId, tabId, ...request }) => postJson("/recording/start", { ...recordingTargetBody({ sessionId, tabId }), ...request }, RecordingStartResponse),
-    recordingStop: (target) => postJson("/recording/stop", recordingTargetBody(target), RecordingStopResponse),
-    recordingStatus: (target) => getJson(`/recording/status${recordingTargetQuery(target)}`, RecordingStatusResponse),
-    recordingCancel: (target) => postJson("/recording/cancel", recordingTargetBody(target), RecordingCancelResponse),
-    tabsCleanup: (idleMinutes) => postJson("/tabs/cleanup", idleMinutes === undefined ? {} : { idleMinutes }, TabsCleanupResponse),
-    settingsGet: getJson("/settings", SettingsGetResponse),
-    settingsSet: (changes) => postJson("/settings", { set: changes }, SettingsSetResponse),
-    flightRecorderStart: ({ sessionId, tabId, ...request }) => postJson("/flight-recorder/start", { ...recordingTargetBody({ sessionId, tabId }), ...request }, FlightRecorderStatusResponse),
-    flightRecorderStatus: (target) => getJson(`/flight-recorder/status${recordingTargetQuery(target)}`, FlightRecorderStatusResponse),
-    flightRecorderSaveLast: ({ sessionId, tabId, ...request }) => postJson("/flight-recorder/save-last", { ...recordingTargetBody({ sessionId, tabId }), ...request }, FlightRecorderSaveResponse),
-    flightRecorderCancel: (target) => postJson("/flight-recorder/cancel", recordingTargetBody(target), FlightRecorderCancelResponse)
-  });
-});
-var layer = Layer.effect(Service, make());
-var layerFetch = layer.pipe(Layer.provide(NodeHttpClient.layerNodeHttp));
-function mcpClientPid() {
-  const shim = Number(process.env.OPENCODE_BROWSER_CLIENT_PID);
-  return Number.isSafeInteger(shim) && shim > 1 && shim === process.ppid ? shim : process.pid;
-}
-var layerFetchMcp = Layer.effect(Service, make({ clientPid: mcpClientPid() })).pipe(Layer.provide(NodeHttpClient.layerNodeHttp));
-
-// src/relay/lifecycle.ts
-var loadedCliEntrypoint = compiledBinary() ? process2.execPath : 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;
-}
-
-class RelayStillRunning extends Error {
-}
-
-class RelayStartFailed extends Schema5.TaggedError()("RelayLifecycle.RelayStartFailed", {
-  message: Schema5.String,
-  endpoint: Schema5.String,
-  cause: Schema5.Defect()
-}) {
-}
-
-class ExtensionDisconnected extends Schema5.TaggedError()("RelayLifecycle.ExtensionDisconnected", { message: Schema5.String, needsPairing: Schema5.optionalKey(Schema5.Boolean) }) {
-}
-
-class ExtensionProtocolIncompatible extends Schema5.TaggedError()("RelayLifecycle.ExtensionProtocolIncompatible", {
-  message: Schema5.String,
-  protocolVersion: Schema5.NullOr(Schema5.Number)
-}) {
-}
-function supersededRuntime() {
-  try {
-    const runtime = npmRuntime();
-    return runtime !== undefined && runtime.current.version !== runtime.version;
-  } catch {
-    return false;
-  }
-}
-function relayBuildProblem(version, buildId = opencodeBrowserBuildId2) {
-  if (!version.buildId) {
-    return `Running relay does not report a build id; use \`${cliCommand("relay restart")}\` for upgrade guidance (${buildId}).`;
-  }
-  if (version.buildId !== buildId) {
-    if (isNewerBuild(version.buildId, buildId)) {
-      return `Running relay build ${version.buildId} is newer than CLI build ${buildId}; refresh or restart this CLI or MCP client. Only use \`${cliCommand("relay restart")}\` from the current installation.`;
-    }
-    return `Running relay build ${version.buildId} does not match CLI build ${buildId}; run \`${cliCommand("relay restart")}\` when no agent is using the browser. This leaves browser tabs open but resets in-memory JavaScript state.`;
-  }
-  return;
-}
-var ensureRelay = Effect3.fn("RelayLifecycle.ensureRelay")(function* (options) {
-  const buildId = options.buildId ?? opencodeBrowserBuildId2;
-  const probe = options.relay.version;
-  const initial = yield* Effect3.result(probe);
-  if (Result.isSuccess(initial)) {
-    const buildProblem = relayBuildProblem(initial.success, buildId);
-    return {
-      version: initial.success,
-      started: false,
-      ...buildProblem ? { buildProblem } : {}
-    };
-  }
-  const relayWasAbsent = isRelayUnreachable(initial.failure);
-  if (!relayWasAbsent && !isRelayStarting(initial.failure)) {
-    return yield* initial.failure;
-  }
-  if (relayWasAbsent) {
-    const autoStart = yield* Config2.Boolean("OPENCODE_BROWSER_AUTOSTART").pipe(Config2.withDefault(true), Effect3.mapError((cause) => new Error("Invalid OPENCODE_BROWSER_AUTOSTART configuration", { cause })));
-    if (!autoStart) {
-      return yield* Effect3.fail(new Error(`Automatic relay startup is disabled; no relay is available at ${options.relay.endpoint}`));
-    }
-    if (!supersededRuntime())
-      yield* options.start ?? startManagedRelay();
-  }
-  const version = yield* waitForRelayReady(options);
-  const buildProblem = relayBuildProblem(version, buildId);
-  return { version, started: relayWasAbsent, ...buildProblem ? { buildProblem } : {} };
-});
-function waitForRelayReady(options) {
-  return options.relay.version.pipe(Effect3.retry({
-    times: options.retryTimes ?? 200,
-    schedule: Schedule.spaced(options.retryDelayMs ?? 50),
-    while: isRelayStartingOrUnreachable
-  }), Effect3.mapError((error) => isRelayStartingOrUnreachable(error) ? new RelayStartFailed({
-    message: `browse relay did not start at ${options.relay.endpoint}`,
-    endpoint: options.relay.endpoint,
-    cause: error
-  }) : error));
-}
-var restartRelay = Effect3.fn("RelayLifecycle.restartRelay")(function* (options) {
-  const buildId = options.buildId ?? opencodeBrowserBuildId2;
-  const initial = yield* Effect3.result(options.relay.version);
-  let original;
-  let replacement;
-  let restartRequestId;
-  if (Result.isSuccess(initial)) {
-    original = initial.success;
-  } else if (isRelayStarting(initial.failure)) {
-    original = yield* waitForRelayReady(options);
-  } else if (!isRelayUnreachable(initial.failure)) {
-    return yield* initial.failure;
-  }
-  if (original) {
-    if (original.managed !== true || !original.instanceId) {
-      return yield* Effect3.fail(new Error(`Cannot restart a foreground or unidentified relay. Stop it manually, then run \`${cliCommand("relay restart")}\`.`));
-    }
-    if (original.shutdownProtocol !== 2) {
-      return yield* Effect3.fail(new Error(`This legacy relay does not support safe shutdown protocol 2. Stop it manually once, then run \`${cliCommand("relay restart")}\` to upgrade; no shutdown request was sent.`));
-    }
-    if (!Number.isFinite(Date.parse(buildId)) || !original.buildId || !Number.isFinite(Date.parse(original.buildId))) {
-      return yield* Effect3.fail(new Error("Cannot explicitly replace a source or unorderable relay build. Stop it manually, then launch the intended build."));
-    }
-    if (!options.otherBuild && isNewerBuild(original.buildId, buildId)) {
-      return yield* Effect3.fail(new Error(`Refusing to downgrade relay build ${original.buildId} to ${buildId}; refresh or restart this CLI or MCP client.`));
-    }
-    const confirmed = yield* Effect3.result(options.relay.version);
-    if (Result.isFailure(confirmed)) {
-      if (!isRelayUnreachable(confirmed.failure))
-        return yield* confirmed.failure;
-    } else if (!isSameRelayInstance(original, confirmed.success)) {
-      replacement = confirmed.success;
-    } else {
-      if (confirmed.success.managed !== true || confirmed.success.shutdownProtocol !== 2 || confirmed.success.buildId !== original.buildId) {
-        return yield* Effect3.fail(new Error("Relay identity metadata changed during restart; no shutdown request was sent."));
-      }
-      const request = yield* RelayShutdownRequest.makeEffect({
-        instanceId: original.instanceId,
-        requestId: crypto2.randomUUID(),
-        reason: "explicit-restart",
-        client: { kind: options.clientKind ?? "sdk", instanceId: clientInstanceId, buildId },
-        ...options.force ? { force: true } : {}
-      });
-      const shutdown = yield* Effect3.result(options.relay.shutdown(request));
-      if (Result.isSuccess(shutdown)) {
-        restartRequestId = request.requestId;
-        if (options.onShutdownAccepted)
-          yield* options.onShutdownAccepted;
-      } else if (!isRelayUnreachable(shutdown.failure) && !isRelayInstanceChanged(shutdown.failure)) {
-        return yield* shutdown.failure;
-      }
-      replacement = yield* waitForRelayExitOrReplacement({ ...options, version: original });
-    }
-  }
-  const started = replacement === undefined;
-  if (started) {
-    yield* options.start ?? startManagedRelay(undefined, undefined, undefined, { ...restartRequestId ? { restartRequestId } : {} });
-    replacement = yield* waitForRelayReady(options);
-  }
-  if (!replacement || !replacement.instanceId || replacement.managed !== true || original && isSameRelayInstance(original, replacement)) {
-    return yield* Effect3.fail(new Error("Relay restart did not produce a new managed instance; no further shutdown was attempted."));
-  }
-  const buildProblem = options.otherBuild ? undefined : relayBuildProblem(replacement, buildId);
-  if (buildProblem)
-    return yield* Effect3.fail(new Error(`${buildProblem} A competing relay was left untouched.`));
-  return { version: replacement, started, waitForReconnect: true };
-});
-function waitForRelayExitOrReplacement(options) {
-  return options.relay.version.pipe(Effect3.flatMap((version) => isSameRelayInstance(options.version, version) ? Effect3.fail(new RelayStillRunning("browse relay is still draining; no replacement was started")) : Effect3.succeed(version)), Effect3.catch((error) => isRelayUnreachable(error) ? Effect3.succeed(undefined) : Effect3.fail(error)), Effect3.retry({
-    times: options.retryTimes ?? 200,
-    schedule: Schedule.spaced(options.retryDelayMs ?? 50),
-    while: (error) => error instanceof RelayStillRunning || isRelayStarting(error)
-  }));
-}
-function isSameRelayInstance(left, right) {
-  return left.instanceId !== undefined && left.instanceId === right.instanceId;
-}
-function isNewerBuild(current, running) {
-  if (!running)
-    return false;
-  const currentTime = Date.parse(current);
-  const runningTime = Date.parse(running);
-  return Number.isFinite(currentTime) && Number.isFinite(runningTime) && currentTime > runningTime;
-}
-function isRelayInstanceChanged(error) {
-  return error instanceof RelayRejected && error.status === 409 && error.code === "invalid-request";
-}
-var extensionReconnectWaitMs = extensionReconnectAlarmPeriodMs + 5000;
-var extensionReconnectProbeMs = 200;
-var ensureExtensionConnected = Effect3.fn("RelayLifecycle.ensureExtensionConnected")(function* (options) {
-  const check = options.relay.extensionStatus.pipe(Effect3.flatMap((status) => {
-    if (options.sessionId && status.sessions?.some((session) => session.id === options.sessionId && session.browser)) {
-      return Effect3.succeed(status);
-    }
-    if (status.protocolCompatible === false) {
-      return Effect3.fail(new ExtensionProtocolIncompatible({
-        message: status.nextStep ?? extensionProtocolAdvice(status.protocolVersion, { install: installCommand() }),
-        protocolVersion: status.protocolVersion ?? null
-      }));
-    }
-    return status.connected ? Effect3.succeed(status) : Effect3.fail(new ExtensionDisconnected({
-      message: status.nextStep ?? `browse extension is not connected. Open the browser with browse installed (\`${installCommand()}\`); it reconnects automatically after relay or browser startup.`,
-      needsPairing: status.pairingState === "refused" || status.pairingState === "unpaired"
-    }));
-  }));
-  if (!options.waitForReconnect) {
-    return yield* check;
-  }
-  let waitAnnounced = false;
-  return yield* check.pipe(Effect3.tapError((error) => {
-    if (waitAnnounced || !options.onWait || !(error instanceof ExtensionDisconnected))
-      return Effect3.void;
-    waitAnnounced = true;
-    return options.onWait;
-  }), Effect3.retry({
-    times: options.retryTimes ?? Math.ceil(extensionReconnectWaitMs / extensionReconnectProbeMs),
-    schedule: Schedule.spaced(options.retryDelayMs ?? extensionReconnectProbeMs),
-    while: (error) => error instanceof ExtensionDisconnected && !error.needsPairing || isRelayStartingOrUnreachable(error)
-  }));
-});
-function stoppedRelayStatus(endpoint) {
-  return { endpoint, relay: { running: false }, extension: null, sessions: [], targets: [] };
-}
-function statusCollections(status) {
-  return status.sessions && status.targets ? { sessions: status.sessions, targets: status.targets } : undefined;
-}
-function startManagedRelay(entrypoint = loadedCliEntrypoint, executable = process2.execPath, execArgv = process2.execArgv, options = {}) {
-  return Effect3.try({
-    try: () => {
-      if (!entrypoint) {
-        throw new Error("Cannot locate the opencode-browser CLI entrypoint");
-      }
-      const launch = managedRelayLaunch(entrypoint, executable, execArgv);
-      const { OPENCODE_BROWSER_RESTART_REQUEST_ID: _inheritedRestartRequestId, ...env } = relayEnvironment(process2.env);
-      const child = spawn(launch.executable, launch.args, {
-        detached: true,
-        stdio: "ignore",
-        env: { ...env, OPENCODE_BROWSER_MANAGED_RELAY: "1", ...options.restartRequestId ? { OPENCODE_BROWSER_RESTART_REQUEST_ID: options.restartRequestId } : {} }
-      });
-      child.unref();
-    },
-    catch: (cause) => cause instanceof Error ? cause : new Error("Failed to start browse relay", { cause })
-  });
-}
-var relayEnvironmentNames = new Set([
-  "PATH",
-  "HOME",
-  "USER",
-  "LOGNAME",
-  "SHELL",
-  "TMPDIR",
-  "TEMP",
-  "TMP",
-  "LANG",
-  "LANGUAGE",
-  "TZ",
-  "XDG_DATA_HOME",
-  "XDG_CONFIG_HOME",
-  "XDG_RUNTIME_DIR",
-  "DISPLAY",
-  "WAYLAND_DISPLAY",
-  "HTTP_PROXY",
-  "HTTPS_PROXY",
-  "NO_PROXY",
-  "ALL_PROXY",
-  "SSL_CERT_FILE",
-  "SSL_CERT_DIR",
-  "NODE_EXTRA_CA_CERTS",
-  "SYSTEMROOT",
-  "SYSTEMDRIVE",
-  "WINDIR",
-  "COMSPEC",
-  "PATHEXT",
-  "USERPROFILE",
-  "APPDATA",
-  "LOCALAPPDATA",
-  "PROGRAMDATA",
-  "PROGRAMFILES",
-  "PROGRAMFILES(X86)",
-  "HOMEDRIVE",
-  "HOMEPATH",
-  "USERNAME"
-]);
-var relayEnvironmentPrefixes = ["OPENCODE_BROWSER_", "LC_"];
-function relayEnvironment(env) {
-  return Object.fromEntries(Object.entries(env).filter(([name, value]) => {
-    if (value === undefined)
-      return false;
-    const upper = name.toUpperCase();
-    return relayEnvironmentNames.has(upper) || relayEnvironmentPrefixes.some((prefix) => upper.startsWith(prefix));
-  }));
-}
-function managedRelayLaunch(entrypoint = loadedCliEntrypoint, executable = process2.execPath, execArgv = process2.execArgv) {
-  if (!scriptEntry(entrypoint))
-    return { executable: entrypoint, args: ["serve"] };
-  return {
-    executable,
-    args: [...execArgv, managedRelayEntrypoint(entrypoint), "serve"]
-  };
-}
-function managedRelayEntrypoint(entrypoint) {
-  const name = path.basename(entrypoint);
-  if (name === "index.ts" || name === "opencode-browser-client.ts" || name === "cli.ts")
-    return path.join(path.dirname(entrypoint), "main.ts");
-  return entrypoint;
-}
-function isRelayUnreachable(error) {
-  return error instanceof RelayUnreachable;
-}
-function isRelayStarting(error) {
-  return error instanceof RelayRejected && error.code === "relay-starting";
-}
-function isRelayStartingOrUnreachable(error) {
-  return isRelayStarting(error) || isRelayUnreachable(error);
-}
-
-export { ExecuteRequest, SessionAdoptRequest, SessionNewRequest, SessionEnsureRequest, SessionIdRequest, SessionAllowlistRequest, AuthenticatedJsonRequest, AuthenticatedJsonOutcome, RelayShutdownRequest, NetworkStartRequest, NetworkSessionRequest, NetworkStopRequest, 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 };