@btraut/browser-bridge 0.1.0

package/dist/index.js

@@ -0,0 +1,2087 @@
+#!/usr/bin/env node
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// packages/cli/src/index.ts
+var import_commander = require("commander");
+
+// packages/shared/src/errors.ts
+var import_zod = require("zod");
+var ErrorCodeSchema = import_zod.z.enum([
+  "UNKNOWN",
+  "INVALID_ARGUMENT",
+  "NOT_FOUND",
+  "ALREADY_EXISTS",
+  "FAILED_PRECONDITION",
+  "UNAUTHORIZED",
+  "FORBIDDEN",
+  "CONFLICT",
+  "TIMEOUT",
+  "CANCELLED",
+  "UNAVAILABLE",
+  "RATE_LIMITED",
+  "NOT_IMPLEMENTED",
+  "INTERNAL",
+  "SESSION_NOT_FOUND",
+  "SESSION_CLOSED",
+  "SESSION_BROKEN",
+  "DRIVE_UNAVAILABLE",
+  "INSPECT_UNAVAILABLE",
+  "EXTENSION_DISCONNECTED",
+  "DEBUGGER_IN_USE",
+  "ATTACH_DENIED",
+  "TAB_NOT_FOUND",
+  "NOT_SUPPORTED",
+  "LOCATOR_NOT_FOUND",
+  "NAVIGATION_FAILED",
+  "EVALUATION_FAILED",
+  "ARTIFACT_IO_ERROR"
+]);
+var ErrorInfoSchema = import_zod.z.object({
+  code: ErrorCodeSchema,
+  message: import_zod.z.string(),
+  retryable: import_zod.z.boolean(),
+  details: import_zod.z.record(import_zod.z.string(), import_zod.z.unknown()).optional()
+});
+var ErrorEnvelopeSchema = import_zod.z.object({
+  ok: import_zod.z.literal(false),
+  error: ErrorInfoSchema
+});
+var successEnvelopeSchema = (result) => import_zod.z.object({
+  ok: import_zod.z.literal(true),
+  result
+});
+var apiEnvelopeSchema = (result) => import_zod.z.union([successEnvelopeSchema(result), ErrorEnvelopeSchema]);
+
+// packages/shared/src/schemas.ts
+var import_zod2 = require("zod");
+var LocatorRoleSchema = import_zod2.z.object({
+  name: import_zod2.z.string(),
+  value: import_zod2.z.string().optional()
+});
+var LocatorSchema = import_zod2.z.object({
+  ref: import_zod2.z.string().min(1).optional(),
+  testid: import_zod2.z.string().min(1).optional(),
+  css: import_zod2.z.string().min(1).optional(),
+  text: import_zod2.z.string().min(1).optional(),
+  role: LocatorRoleSchema.optional()
+}).refine(
+  (value) => Boolean(
+    value.ref || value.testid || value.css || value.text || value.role
+  ),
+  {
+    message: "Locator must include at least one selector."
+  }
+);
+var OpResultSchema = import_zod2.z.object({
+  ok: import_zod2.z.literal(true),
+  message: import_zod2.z.string().optional(),
+  warnings: import_zod2.z.array(import_zod2.z.string()).optional()
+});
+var SessionStateSchema = import_zod2.z.enum([
+  "INIT",
+  "DRIVE_READY",
+  "INSPECT_READY",
+  "READY",
+  "DEGRADED_DRIVE",
+  "DEGRADED_INSPECT",
+  "BROKEN",
+  "CLOSED"
+]);
+var SessionInfoSchema = import_zod2.z.object({
+  session_id: import_zod2.z.string(),
+  state: SessionStateSchema,
+  created_at: import_zod2.z.string().datetime().optional()
+});
+var SessionPlaneStatusSchema = import_zod2.z.object({
+  connected: import_zod2.z.boolean(),
+  last_seen_at: import_zod2.z.string().datetime().optional(),
+  error: ErrorInfoSchema.optional()
+});
+var SessionStatusSchema = import_zod2.z.object({
+  session_id: import_zod2.z.string(),
+  state: SessionStateSchema,
+  drive: SessionPlaneStatusSchema.optional(),
+  inspect: SessionPlaneStatusSchema.optional(),
+  updated_at: import_zod2.z.string().datetime().optional()
+});
+var RecoverResultSchema = import_zod2.z.object({
+  session_id: import_zod2.z.string(),
+  recovered: import_zod2.z.boolean(),
+  state: SessionStateSchema,
+  message: import_zod2.z.string().optional()
+});
+var DiagnosticCheckSchema = import_zod2.z.object({
+  name: import_zod2.z.string(),
+  ok: import_zod2.z.boolean(),
+  message: import_zod2.z.string().optional(),
+  details: import_zod2.z.record(import_zod2.z.string(), import_zod2.z.unknown()).optional()
+});
+var DiagnosticReportSchema = import_zod2.z.object({
+  ok: import_zod2.z.boolean(),
+  session_id: import_zod2.z.string().optional(),
+  checks: import_zod2.z.array(DiagnosticCheckSchema).optional(),
+  extension: import_zod2.z.object({
+    connected: import_zod2.z.boolean().optional(),
+    version: import_zod2.z.string().optional(),
+    last_seen_at: import_zod2.z.string().datetime().optional()
+  }).optional(),
+  debugger: import_zod2.z.object({
+    attached: import_zod2.z.boolean().optional(),
+    idle_timeout_ms: import_zod2.z.number().finite().optional(),
+    console_buffer_size: import_zod2.z.number().finite().optional(),
+    network_buffer_size: import_zod2.z.number().finite().optional(),
+    last_error: ErrorInfoSchema.optional()
+  }).optional(),
+  artifacts: import_zod2.z.object({
+    root_dir: import_zod2.z.string().optional()
+  }).optional(),
+  recovery: import_zod2.z.object({
+    last_attempt: import_zod2.z.object({
+      session_id: import_zod2.z.string(),
+      recovered: import_zod2.z.boolean(),
+      state: SessionStateSchema,
+      message: import_zod2.z.string().optional(),
+      at: import_zod2.z.string()
+    }).optional(),
+    attempts: import_zod2.z.array(
+      import_zod2.z.object({
+        session_id: import_zod2.z.string(),
+        recovered: import_zod2.z.boolean(),
+        state: SessionStateSchema,
+        message: import_zod2.z.string().optional(),
+        at: import_zod2.z.string()
+      })
+    ).optional(),
+    success_count: import_zod2.z.number().finite().optional(),
+    failure_count: import_zod2.z.number().finite().optional(),
+    success_rate: import_zod2.z.number().finite().optional(),
+    recent_failure_count: import_zod2.z.number().finite().optional(),
+    loop_detected: import_zod2.z.boolean().optional()
+  }).optional(),
+  warnings: import_zod2.z.array(import_zod2.z.string()).optional(),
+  notes: import_zod2.z.array(import_zod2.z.string()).optional()
+});
+var SessionIdSchema = import_zod2.z.object({
+  session_id: import_zod2.z.string().min(1)
+});
+var SessionCreateInputSchema = import_zod2.z.object({}).strict().default({});
+var SessionCreateOutputSchema = SessionInfoSchema;
+var SessionStatusInputSchema = SessionIdSchema;
+var SessionStatusOutputSchema = SessionStatusSchema;
+var SessionRecoverInputSchema = SessionIdSchema;
+var SessionRecoverOutputSchema = RecoverResultSchema;
+var SessionCloseInputSchema = SessionIdSchema;
+var SessionCloseOutputSchema = import_zod2.z.object({
+  ok: import_zod2.z.boolean()
+});
+var DriveWaitConditionSchema = import_zod2.z.object({
+  kind: import_zod2.z.enum(["locator_visible", "text_present", "url_matches"]),
+  value: import_zod2.z.string().min(1)
+});
+var DriveNavigateInputSchema = import_zod2.z.object({
+  session_id: import_zod2.z.string().min(1),
+  url: import_zod2.z.string().min(1),
+  tab_id: import_zod2.z.number().finite().optional(),
+  wait: import_zod2.z.enum(["none", "domcontentloaded"]).default("domcontentloaded")
+});
+var DriveNavigateOutputSchema = OpResultSchema;
+var DriveGoBackInputSchema = import_zod2.z.object({
+  session_id: import_zod2.z.string().min(1),
+  tab_id: import_zod2.z.number().finite().optional()
+});
+var DriveGoBackOutputSchema = OpResultSchema;
+var DriveGoForwardInputSchema = import_zod2.z.object({
+  session_id: import_zod2.z.string().min(1),
+  tab_id: import_zod2.z.number().finite().optional()
+});
+var DriveGoForwardOutputSchema = OpResultSchema;
+var DriveBackInputSchema = DriveGoBackInputSchema;
+var DriveBackOutputSchema = OpResultSchema;
+var DriveForwardInputSchema = DriveGoForwardInputSchema;
+var DriveForwardOutputSchema = OpResultSchema;
+var DriveClickInputSchema = import_zod2.z.object({
+  session_id: import_zod2.z.string().min(1),
+  locator: LocatorSchema,
+  tab_id: import_zod2.z.number().finite().optional(),
+  click_count: import_zod2.z.number().finite().optional()
+});
+var DriveClickOutputSchema = OpResultSchema;
+var DriveHoverInputSchema = import_zod2.z.object({
+  session_id: import_zod2.z.string().min(1),
+  locator: LocatorSchema,
+  delay_ms: import_zod2.z.number().min(0).max(1e4).optional(),
+  tab_id: import_zod2.z.number().finite().optional()
+});
+var DriveHoverOutputSchema = import_zod2.z.object({
+  format: import_zod2.z.literal("html"),
+  snapshot: import_zod2.z.string()
+});
+var DriveSelectInputSchema = import_zod2.z.object({
+  session_id: import_zod2.z.string().min(1),
+  locator: LocatorSchema,
+  value: import_zod2.z.string().min(1).optional(),
+  text: import_zod2.z.string().min(1).optional(),
+  index: import_zod2.z.number().int().min(0).optional(),
+  tab_id: import_zod2.z.number().finite().optional()
+}).refine((value) => value.value || value.text || value.index !== void 0, {
+  message: "Either value, text, or index must be provided.",
+  path: ["select"]
+});
+var DriveSelectOutputSchema = OpResultSchema;
+var DriveTypeInputSchema = import_zod2.z.object({
+  session_id: import_zod2.z.string().min(1),
+  locator: LocatorSchema.optional(),
+  text: import_zod2.z.string().min(1),
+  tab_id: import_zod2.z.number().finite().optional(),
+  clear: import_zod2.z.boolean().default(false),
+  submit: import_zod2.z.boolean().default(false)
+});
+var DriveTypeOutputSchema = OpResultSchema;
+var DriveFillFormFieldSchema = import_zod2.z.object({
+  selector: import_zod2.z.string().min(1).optional(),
+  locator: LocatorSchema.optional(),
+  value: import_zod2.z.union([import_zod2.z.string(), import_zod2.z.boolean()]),
+  type: import_zod2.z.enum(["auto", "text", "select", "checkbox", "radio", "contentEditable"]).default("auto"),
+  submit: import_zod2.z.boolean().default(false)
+}).refine((value) => Boolean(value.selector || value.locator), {
+  message: "fill_form field requires selector or locator.",
+  path: ["selector"]
+});
+var DriveFillFormInputSchema = import_zod2.z.object({
+  session_id: import_zod2.z.string().min(1),
+  fields: import_zod2.z.array(DriveFillFormFieldSchema).min(1),
+  tab_id: import_zod2.z.number().finite().optional()
+});
+var DriveFillFormOutputSchema = import_zod2.z.object({
+  filled: import_zod2.z.number().finite(),
+  attempted: import_zod2.z.number().finite(),
+  errors: import_zod2.z.array(import_zod2.z.string()).optional()
+});
+var DriveDragInputSchema = import_zod2.z.object({
+  session_id: import_zod2.z.string().min(1),
+  from: LocatorSchema,
+  to: LocatorSchema,
+  steps: import_zod2.z.number().min(1).max(50).default(12),
+  tab_id: import_zod2.z.number().finite().optional()
+});
+var DriveDragOutputSchema = OpResultSchema;
+var DriveHandleDialogInputSchema = import_zod2.z.object({
+  session_id: import_zod2.z.string().min(1),
+  action: import_zod2.z.enum(["accept", "dismiss"]),
+  promptText: import_zod2.z.string().optional(),
+  tab_id: import_zod2.z.number().finite().optional()
+});
+var DriveHandleDialogOutputSchema = OpResultSchema;
+var DialogAcceptInputSchema = SessionIdSchema.extend({
+  promptText: import_zod2.z.string().optional(),
+  tab_id: import_zod2.z.number().finite().optional()
+});
+var DialogAcceptOutputSchema = OpResultSchema;
+var DialogDismissInputSchema = SessionIdSchema.extend({
+  tab_id: import_zod2.z.number().finite().optional()
+});
+var DialogDismissOutputSchema = OpResultSchema;
+var DriveKeyModifiersSchema = import_zod2.z.object({
+  ctrl: import_zod2.z.boolean().optional(),
+  alt: import_zod2.z.boolean().optional(),
+  shift: import_zod2.z.boolean().optional(),
+  meta: import_zod2.z.boolean().optional()
+});
+var DriveKeyPressInputSchema = import_zod2.z.object({
+  session_id: import_zod2.z.string().min(1),
+  key: import_zod2.z.string().min(1),
+  modifiers: DriveKeyModifiersSchema.optional(),
+  tab_id: import_zod2.z.number().finite().optional()
+});
+var DriveKeyPressOutputSchema = OpResultSchema;
+var DriveKeyModifierSchema = import_zod2.z.enum(["ctrl", "alt", "shift", "meta"]);
+var DriveKeyInputSchema = import_zod2.z.object({
+  session_id: import_zod2.z.string().min(1),
+  key: import_zod2.z.string().min(1),
+  modifiers: import_zod2.z.array(DriveKeyModifierSchema).optional(),
+  repeat: import_zod2.z.number().int().min(1).max(50).optional(),
+  tab_id: import_zod2.z.number().finite().optional()
+});
+var DriveKeyOutputSchema = OpResultSchema;
+var DriveScrollInputSchema = import_zod2.z.object({
+  session_id: import_zod2.z.string().min(1),
+  delta_x: import_zod2.z.number().finite().optional(),
+  delta_y: import_zod2.z.number().finite().optional(),
+  top: import_zod2.z.number().finite().optional(),
+  left: import_zod2.z.number().finite().optional(),
+  behavior: import_zod2.z.enum(["auto", "smooth"]).optional(),
+  tab_id: import_zod2.z.number().finite().optional()
+}).refine(
+  (value) => value.delta_x !== void 0 || value.delta_y !== void 0 || value.top !== void 0 || value.left !== void 0,
+  {
+    message: "scroll requires delta_x/delta_y or top/left.",
+    path: ["scroll"]
+  }
+);
+var DriveScrollOutputSchema = OpResultSchema;
+var DriveWaitForInputSchema = import_zod2.z.object({
+  session_id: import_zod2.z.string().min(1),
+  condition: DriveWaitConditionSchema,
+  timeout_ms: import_zod2.z.number().finite().optional(),
+  tab_id: import_zod2.z.number().finite().optional()
+});
+var DriveWaitForOutputSchema = OpResultSchema;
+var DriveTabInfoSchema = import_zod2.z.object({
+  tab_id: import_zod2.z.number().finite(),
+  window_id: import_zod2.z.number().finite(),
+  url: import_zod2.z.string().min(1),
+  title: import_zod2.z.string(),
+  active: import_zod2.z.boolean().optional(),
+  last_active_at: import_zod2.z.string().datetime().optional()
+});
+var DriveTabListInputSchema = SessionIdSchema;
+var DriveTabListOutputSchema = import_zod2.z.object({
+  tabs: import_zod2.z.array(DriveTabInfoSchema)
+});
+var DriveTabActivateInputSchema = import_zod2.z.object({
+  session_id: import_zod2.z.string().min(1),
+  tab_id: import_zod2.z.number().finite()
+});
+var DriveTabActivateOutputSchema = OpResultSchema;
+var DriveTabCloseInputSchema = import_zod2.z.object({
+  session_id: import_zod2.z.string().min(1),
+  tab_id: import_zod2.z.number().finite()
+});
+var DriveTabCloseOutputSchema = OpResultSchema;
+var InspectDomFormatSchema = import_zod2.z.enum(["ax", "html"]);
+var InspectConsistencySchema = import_zod2.z.enum(["best_effort", "quiesce"]);
+var TargetHintSchema = import_zod2.z.object({
+  url: import_zod2.z.string().min(1).optional(),
+  title: import_zod2.z.string().min(1).optional(),
+  last_active_at: import_zod2.z.string().optional(),
+  lastActiveAt: import_zod2.z.string().optional()
+});
+var FormFieldInfoSchema = import_zod2.z.object({
+  name: import_zod2.z.string(),
+  type: import_zod2.z.string(),
+  value: import_zod2.z.string(),
+  options: import_zod2.z.array(import_zod2.z.string()).optional()
+});
+var FormInfoSchema = import_zod2.z.object({
+  selector: import_zod2.z.string(),
+  action: import_zod2.z.string().optional(),
+  method: import_zod2.z.string().optional(),
+  fields: import_zod2.z.array(FormFieldInfoSchema)
+});
+var StorageEntrySchema = import_zod2.z.object({
+  key: import_zod2.z.string(),
+  value: import_zod2.z.string()
+});
+var PageStateSchema = import_zod2.z.object({
+  forms: import_zod2.z.array(FormInfoSchema),
+  localStorage: import_zod2.z.array(StorageEntrySchema),
+  sessionStorage: import_zod2.z.array(StorageEntrySchema),
+  cookies: import_zod2.z.array(StorageEntrySchema),
+  warnings: import_zod2.z.array(import_zod2.z.string()).optional()
+});
+var DomSnapshotSchema = import_zod2.z.object({
+  format: InspectDomFormatSchema,
+  snapshot: import_zod2.z.unknown()
+}).passthrough();
+var InspectDomSnapshotInputSchema = import_zod2.z.object({
+  session_id: import_zod2.z.string().min(1),
+  format: InspectDomFormatSchema.default("ax"),
+  consistency: InspectConsistencySchema.default("best_effort"),
+  interactive: import_zod2.z.boolean().default(false),
+  compact: import_zod2.z.boolean().default(false),
+  selector: import_zod2.z.string().min(1).optional(),
+  target: TargetHintSchema.optional()
+});
+var InspectDomSnapshotOutputSchema = DomSnapshotSchema;
+var DomDiffResultSchema = import_zod2.z.object({
+  added: import_zod2.z.array(import_zod2.z.string()),
+  removed: import_zod2.z.array(import_zod2.z.string()),
+  changed: import_zod2.z.array(import_zod2.z.string()),
+  summary: import_zod2.z.string()
+});
+var InspectDomDiffInputSchema = SessionIdSchema;
+var InspectDomDiffOutputSchema = DomDiffResultSchema;
+var InspectFindRoleInputSchema = SessionIdSchema.extend({
+  kind: import_zod2.z.literal("role"),
+  role: import_zod2.z.string().min(1),
+  name: import_zod2.z.string().min(1).optional(),
+  target: TargetHintSchema.optional()
+});
+var InspectFindTextInputSchema = SessionIdSchema.extend({
+  kind: import_zod2.z.literal("text"),
+  text: import_zod2.z.string().min(1),
+  target: TargetHintSchema.optional()
+});
+var InspectFindLabelInputSchema = SessionIdSchema.extend({
+  kind: import_zod2.z.literal("label"),
+  label: import_zod2.z.string().min(1),
+  target: TargetHintSchema.optional()
+});
+var InspectFindInputSchema = import_zod2.z.discriminatedUnion("kind", [
+  InspectFindRoleInputSchema,
+  InspectFindTextInputSchema,
+  InspectFindLabelInputSchema
+]);
+var InspectFindMatchSchema = import_zod2.z.object({
+  ref: import_zod2.z.string(),
+  role: import_zod2.z.string().optional(),
+  name: import_zod2.z.string().optional()
+});
+var InspectFindOutputSchema = import_zod2.z.object({
+  matches: import_zod2.z.array(InspectFindMatchSchema),
+  warnings: import_zod2.z.array(import_zod2.z.string()).optional()
+});
+var InspectPageStateInputSchema = SessionIdSchema.extend({
+  target: TargetHintSchema.optional()
+});
+var InspectPageStateOutputSchema = PageStateSchema;
+var InspectExtractContentFormatSchema = import_zod2.z.enum([
+  "markdown",
+  "text",
+  "article_json"
+]);
+var InspectExtractContentInputSchema = SessionIdSchema.extend({
+  format: InspectExtractContentFormatSchema.default("markdown"),
+  include_metadata: import_zod2.z.boolean().default(true),
+  target: TargetHintSchema.optional()
+});
+var InspectExtractContentOutputSchema = import_zod2.z.object({
+  content: import_zod2.z.string(),
+  title: import_zod2.z.string().optional(),
+  byline: import_zod2.z.string().optional(),
+  excerpt: import_zod2.z.string().optional(),
+  siteName: import_zod2.z.string().optional(),
+  warnings: import_zod2.z.array(import_zod2.z.string()).optional()
+});
+var InspectConsoleListInputSchema = SessionIdSchema.extend({
+  target: TargetHintSchema.optional()
+});
+var ConsoleSourceLocationSchema = import_zod2.z.object({
+  url: import_zod2.z.string().optional(),
+  // 1-based line/column for human readability.
+  line: import_zod2.z.number().int().positive().optional(),
+  column: import_zod2.z.number().int().positive().optional()
+}).passthrough();
+var ConsoleStackFrameSchema = import_zod2.z.object({
+  functionName: import_zod2.z.string().optional(),
+  url: import_zod2.z.string().optional(),
+  // 1-based line/column for human readability.
+  line: import_zod2.z.number().int().positive().optional(),
+  column: import_zod2.z.number().int().positive().optional()
+}).passthrough();
+var ConsoleRemoteObjectSchema = import_zod2.z.object({
+  type: import_zod2.z.string().optional(),
+  subtype: import_zod2.z.string().optional(),
+  description: import_zod2.z.string().optional(),
+  value: import_zod2.z.unknown().optional(),
+  unserializableValue: import_zod2.z.string().optional()
+}).passthrough();
+var ConsoleEntrySchema = import_zod2.z.object({
+  level: import_zod2.z.string().optional(),
+  text: import_zod2.z.string().optional(),
+  timestamp: import_zod2.z.string().datetime().optional(),
+  source: ConsoleSourceLocationSchema.optional(),
+  stack: import_zod2.z.array(ConsoleStackFrameSchema).optional(),
+  exception: ConsoleRemoteObjectSchema.optional(),
+  args: import_zod2.z.array(ConsoleRemoteObjectSchema).optional()
+}).passthrough();
+var ConsoleListSchema = import_zod2.z.object({
+  entries: import_zod2.z.array(ConsoleEntrySchema)
+}).passthrough();
+var InspectConsoleListOutputSchema = ConsoleListSchema;
+var ArtifactInfoSchema = import_zod2.z.object({
+  artifact_id: import_zod2.z.string(),
+  path: import_zod2.z.string(),
+  mime: import_zod2.z.string()
+});
+var InspectNetworkHarInputSchema = SessionIdSchema.extend({
+  target: TargetHintSchema.optional()
+});
+var InspectNetworkHarOutputSchema = ArtifactInfoSchema;
+var InspectEvaluateInputSchema = import_zod2.z.object({
+  session_id: import_zod2.z.string().min(1),
+  expression: import_zod2.z.string().min(1).optional(),
+  target: TargetHintSchema.optional()
+});
+var EvaluateResultSchema = import_zod2.z.object({
+  value: import_zod2.z.unknown().optional(),
+  exception: import_zod2.z.unknown().optional()
+}).passthrough();
+var InspectEvaluateOutputSchema = EvaluateResultSchema;
+var InspectPerformanceMetricsInputSchema = SessionIdSchema.extend({
+  target: TargetHintSchema.optional()
+});
+var PerformanceMetricSchema = import_zod2.z.object({
+  name: import_zod2.z.string(),
+  value: import_zod2.z.number().finite()
+}).passthrough();
+var PerformanceMetricsSchema = import_zod2.z.object({
+  metrics: import_zod2.z.array(PerformanceMetricSchema)
+}).passthrough();
+var InspectPerformanceMetricsOutputSchema = PerformanceMetricsSchema;
+var ArtifactsScreenshotInputSchema = import_zod2.z.object({
+  session_id: import_zod2.z.string().min(1),
+  target: import_zod2.z.enum(["viewport", "full"]).default("viewport"),
+  fullPage: import_zod2.z.boolean().default(false),
+  format: import_zod2.z.enum(["png", "jpeg", "webp"]).default("png"),
+  quality: import_zod2.z.number().min(0).max(100).optional()
+});
+var ArtifactsScreenshotOutputSchema = ArtifactInfoSchema;
+var DiagnosticsDoctorInputSchema = import_zod2.z.object({
+  session_id: import_zod2.z.string().min(1).optional()
+});
+var DiagnosticsDoctorOutputSchema = DiagnosticReportSchema;
+
+// packages/cli/src/cli-output.ts
+var import_zod3 = require("zod");
+var CliError = class extends Error {
+  constructor(info) {
+    super(info.message);
+    this.info = info;
+  }
+};
+var parseInput = (schema, payload) => {
+  const result = schema.safeParse(payload);
+  if (result.success) {
+    return result.data;
+  }
+  const [issue] = result.error.issues;
+  throw new CliError({
+    code: "INVALID_ARGUMENT",
+    message: issue?.message ?? "Invalid input.",
+    retryable: false,
+    details: { issues: result.error.issues }
+  });
+};
+var outputEnvelope = (envelope2, options) => {
+  if (options.json) {
+    console.log(JSON.stringify(envelope2, null, 2));
+    return;
+  }
+  if (envelope2.ok) {
+    if (typeof envelope2.result === "string") {
+      console.log(envelope2.result);
+      return;
+    }
+    console.log(JSON.stringify(envelope2.result, null, 2));
+    return;
+  }
+  console.error(`${envelope2.error.code}: ${envelope2.error.message}`);
+  if (envelope2.error.details) {
+    console.error(JSON.stringify(envelope2.error.details, null, 2));
+  }
+};
+var toErrorInfo = (error) => {
+  if (error instanceof CliError) {
+    return error.info;
+  }
+  if (error instanceof import_zod3.ZodError) {
+    const [issue] = error.issues;
+    return {
+      code: "INVALID_ARGUMENT",
+      message: issue?.message ?? "Invalid input.",
+      retryable: false,
+      details: { issues: error.issues }
+    };
+  }
+  if (error instanceof Error) {
+    return {
+      code: "INTERNAL",
+      message: error.message,
+      retryable: false
+    };
+  }
+  return {
+    code: "INTERNAL",
+    message: "Unknown error.",
+    retryable: false
+  };
+};
+var outputError = (error, options) => {
+  const info = toErrorInfo(error);
+  const envelope2 = { ok: false, error: info };
+  if (options.json) {
+    console.log(JSON.stringify(envelope2, null, 2));
+    return;
+  }
+  console.error(`${info.code}: ${info.message}`);
+  if (info.details) {
+    console.error(JSON.stringify(info.details, null, 2));
+  }
+};
+
+// packages/cli/src/core-client.ts
+var import_node_child_process = require("node:child_process");
+var import_node_path = require("node:path");
+var import_promises = require("node:timers/promises");
+var DEFAULT_HOST = "127.0.0.1";
+var DEFAULT_PORT = 3210;
+var DEFAULT_TIMEOUT_MS = 4e3;
+var HEALTH_RETRY_MS = 250;
+var HEALTH_ATTEMPTS = 20;
+var resolveHost = (host) => {
+  const candidate = host?.trim() || process.env.BROWSER_BRIDGE_CORE_HOST || process.env.BROWSER_VISION_CORE_HOST;
+  if (candidate && candidate.length > 0) {
+    return candidate;
+  }
+  return DEFAULT_HOST;
+};
+var resolvePort = (port) => {
+  const candidate = port ?? (process.env.BROWSER_BRIDGE_CORE_PORT ? Number.parseInt(process.env.BROWSER_BRIDGE_CORE_PORT, 10) : process.env.BROWSER_VISION_CORE_PORT ? Number.parseInt(process.env.BROWSER_VISION_CORE_PORT, 10) : void 0);
+  if (candidate === void 0 || candidate === null) {
+    return DEFAULT_PORT;
+  }
+  const parsed = typeof candidate === "number" ? candidate : Number.parseInt(candidate, 10);
+  if (!Number.isFinite(parsed) || parsed <= 0) {
+    throw new Error(`Invalid port: ${String(candidate)}`);
+  }
+  return parsed;
+};
+var resolveTimeoutMs = (timeoutMs) => {
+  const candidate = timeoutMs ?? (process.env.BROWSER_BRIDGE_CORE_TIMEOUT_MS ? Number.parseInt(process.env.BROWSER_BRIDGE_CORE_TIMEOUT_MS, 10) : process.env.BROWSER_VISION_CORE_TIMEOUT_MS ? Number.parseInt(process.env.BROWSER_VISION_CORE_TIMEOUT_MS, 10) : void 0);
+  if (candidate === void 0 || candidate === null) {
+    return DEFAULT_TIMEOUT_MS;
+  }
+  const parsed = typeof candidate === "number" ? candidate : Number(candidate);
+  if (!Number.isFinite(parsed) || parsed <= 0) {
+    throw new Error(`Invalid timeoutMs: ${String(candidate)}`);
+  }
+  return Math.floor(parsed);
+};
+var normalizePath = (path2) => path2.startsWith("/") ? path2 : `/${path2}`;
+var createCoreClient = (options = {}) => {
+  const host = resolveHost(options.host);
+  const port = resolvePort(options.port);
+  const baseUrl = `http://${host}:${port}`;
+  const timeoutMs = resolveTimeoutMs(options.timeoutMs);
+  const fetchImpl = options.fetchImpl ?? fetch;
+  const spawnImpl = options.spawnImpl ?? import_node_child_process.spawn;
+  const ensureDaemon = options.ensureDaemon ?? true;
+  const requestJson = async (method, path2, body) => {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), timeoutMs);
+    try {
+      const response = await fetchImpl(`${baseUrl}${normalizePath(path2)}`, {
+        method,
+        headers: {
+          "content-type": "application/json"
+        },
+        body: body === void 0 ? void 0 : JSON.stringify(body),
+        signal: controller.signal
+      });
+      const raw = await response.text();
+      if (!raw) {
+        throw new Error(`Empty response from Core (${response.status}).`);
+      }
+      try {
+        return JSON.parse(raw);
+      } catch (error) {
+        const message = error instanceof Error ? error.message : "Unknown JSON parse error";
+        throw new Error(`Failed to parse Core response: ${message}`);
+      }
+    } finally {
+      clearTimeout(timeout);
+    }
+  };
+  const checkHealth = async () => {
+    try {
+      const controller = new AbortController();
+      const timeout = setTimeout(() => controller.abort(), timeoutMs);
+      try {
+        const response = await fetchImpl(`${baseUrl}/health`, {
+          method: "GET",
+          signal: controller.signal
+        });
+        if (!response.ok) {
+          return false;
+        }
+        const data = await response.json().catch(() => null);
+        return Boolean(data?.ok);
+      } finally {
+        clearTimeout(timeout);
+      }
+    } catch {
+      return false;
+    }
+  };
+  const spawnDaemon = () => {
+    const coreEntry = (0, import_node_path.resolve)(__dirname, "api.js");
+    const script = `const { startCoreServer } = require(${JSON.stringify(
+      coreEntry
+    )});
+startCoreServer({ host: ${JSON.stringify(
+      host
+    )}, port: ${port} })
+  .catch((err) => { console.error(err); process.exit(1); });`;
+    const child = spawnImpl(process.execPath, ["-e", script], {
+      detached: true,
+      stdio: "ignore",
+      env: {
+        ...process.env,
+        BROWSER_BRIDGE_CORE_HOST: host,
+        BROWSER_BRIDGE_CORE_PORT: String(port),
+        BROWSER_VISION_CORE_HOST: host,
+        BROWSER_VISION_CORE_PORT: String(port)
+      }
+    });
+    child.unref();
+  };
+  const ensureCoreRunning = async () => {
+    if (await checkHealth()) {
+      return;
+    }
+    spawnDaemon();
+    for (let attempt = 0; attempt < HEALTH_ATTEMPTS; attempt += 1) {
+      await (0, import_promises.setTimeout)(HEALTH_RETRY_MS);
+      if (await checkHealth()) {
+        return;
+      }
+    }
+    throw new Error(`Core daemon failed to start on ${host}:${port}.`);
+  };
+  let ensurePromise = null;
+  const ensureReady = async () => {
+    if (!ensureDaemon) {
+      return;
+    }
+    if (!ensurePromise) {
+      ensurePromise = ensureCoreRunning();
+    }
+    await ensurePromise;
+  };
+  const post = async (path2, body) => {
+    await ensureReady();
+    return requestJson("POST", path2, body);
+  };
+  return { baseUrl, ensureReady, post };
+};
+
+// packages/cli/src/cli-runtime.ts
+var getRootCommand = (command) => {
+  let current = command;
+  while (current.parent) {
+    current = current.parent;
+  }
+  return current;
+};
+var getGlobalOptions = (command) => {
+  const root = getRootCommand(command);
+  return root.opts();
+};
+var createClientFromCommand = (command) => {
+  const options = getGlobalOptions(command);
+  return createCoreClient({
+    host: options.host,
+    port: options.port,
+    ensureDaemon: options.daemon !== false
+  });
+};
+var runCommand = async (command, work) => {
+  const options = getGlobalOptions(command);
+  const client = createClientFromCommand(command);
+  try {
+    const envelope2 = await work(client, options);
+    outputEnvelope(envelope2, { json: Boolean(options.json) });
+    if (!envelope2.ok) {
+      process.exitCode = 1;
+    }
+  } catch (error) {
+    outputError(error, { json: Boolean(options.json) });
+    process.exitCode = 1;
+  }
+};
+var runLocal = async (command, work) => {
+  const options = getGlobalOptions(command);
+  try {
+    const envelope2 = await work(options);
+    outputEnvelope(envelope2, { json: Boolean(options.json) });
+    if (!envelope2.ok) {
+      process.exitCode = 1;
+    }
+  } catch (error) {
+    outputError(error, { json: Boolean(options.json) });
+    process.exitCode = 1;
+  }
+};
+
+// packages/cli/src/commands/artifacts.ts
+var parseNumber = (value) => {
+  if (value === void 0 || value === null || value === "") {
+    return void 0;
+  }
+  const parsed = Number(value);
+  return Number.isFinite(parsed) ? parsed : Number.NaN;
+};
+var registerArtifactsCommands = (program2) => {
+  const artifacts = program2.command("artifacts").description("Artifact commands");
+  artifacts.command("screenshot").description("Request a screenshot artifact").requiredOption("--session-id <id>", "Session identifier").option("--target <target>", "Screenshot target (viewport, full)").option("--full-page", "Capture full page (alias for --target full)").option("--format <format>", "Screenshot format (png, jpeg, webp)").option("--quality <quality>", "Screenshot quality (0-100) for jpeg/webp").action(async (options, command) => {
+    await runCommand(command, (client) => {
+      const payload = parseInput(ArtifactsScreenshotInputSchema, {
+        session_id: options.sessionId,
+        target: options.target,
+        fullPage: Boolean(options.fullPage),
+        format: options.format,
+        quality: parseNumber(options.quality)
+      });
+      return client.post("/artifacts/screenshot", payload);
+    });
+  });
+};
+
+// packages/cli/src/commands/dialog.ts
+var parseNumber2 = (value) => {
+  if (value === void 0 || value === null || value === "") {
+    return void 0;
+  }
+  const parsed = Number(value);
+  return Number.isFinite(parsed) ? parsed : Number.NaN;
+};
+var registerDialogCommands = (program2) => {
+  const dialog = program2.command("dialog").description("Dialog commands");
+  dialog.command("accept").description("Accept a JavaScript dialog").requiredOption("--session-id <id>", "Session identifier").option("--prompt-text <text>", "Prompt text for prompt() dialogs").option("--tab-id <id>", "Tab identifier").action(async (options, command) => {
+    await runCommand(command, (client) => {
+      const payload = parseInput(DialogAcceptInputSchema, {
+        session_id: options.sessionId,
+        promptText: options.promptText,
+        tab_id: parseNumber2(options.tabId)
+      });
+      return client.post("/dialog/accept", payload);
+    });
+  });
+  dialog.command("dismiss").description("Dismiss a JavaScript dialog").requiredOption("--session-id <id>", "Session identifier").option("--tab-id <id>", "Tab identifier").action(async (options, command) => {
+    await runCommand(command, (client) => {
+      const payload = parseInput(DialogDismissInputSchema, {
+        session_id: options.sessionId,
+        tab_id: parseNumber2(options.tabId)
+      });
+      return client.post("/dialog/dismiss", payload);
+    });
+  });
+};
+
+// packages/cli/src/commands/diagnostics.ts
+var registerDiagnosticsCommands = (program2) => {
+  const diagnostics = program2.command("diagnostics").description("Diagnostics commands");
+  diagnostics.command("doctor").description("Run diagnostics").option("--session-id <id>", "Session identifier").action(async (options, command) => {
+    await runCommand(command, (client) => {
+      const payload = parseInput(DiagnosticsDoctorInputSchema, {
+        session_id: options.sessionId
+      });
+      return client.post("/diagnostics/doctor", payload);
+    });
+  });
+};
+
+// packages/cli/src/locator.ts
+var buildLocator = (options) => {
+  const locator = {};
+  if (options.locatorRef) {
+    locator.ref = options.locatorRef;
+  }
+  if (options.locatorTestid) {
+    locator.testid = options.locatorTestid;
+  }
+  if (options.locatorCss) {
+    locator.css = options.locatorCss;
+  }
+  if (options.locatorText) {
+    locator.text = options.locatorText;
+  }
+  if (options.locatorRoleValue && !options.locatorRole) {
+    throw new CliError({
+      code: "INVALID_ARGUMENT",
+      message: "locator-role-value requires locator-role to be set.",
+      retryable: false,
+      details: { field: "locator.role.value" }
+    });
+  }
+  if (options.locatorRole) {
+    locator.role = {
+      name: options.locatorRole,
+      ...options.locatorRoleValue ? { value: options.locatorRoleValue } : {}
+    };
+  }
+  if (!locator.ref && !locator.testid && !locator.css && !locator.text && !locator.role) {
+    return void 0;
+  }
+  return locator;
+};
+var requireLocator = (options) => {
+  const locator = buildLocator(options);
+  if (!locator) {
+    throw new CliError({
+      code: "INVALID_ARGUMENT",
+      message: "Locator must include at least one selector.",
+      retryable: false,
+      details: { field: "locator" }
+    });
+  }
+  return locator;
+};
+
+// packages/cli/src/commands/drive.ts
+var parseNumber3 = (value) => {
+  if (value === void 0 || value === null || value === "") {
+    return void 0;
+  }
+  const parsed = Number(value);
+  return Number.isFinite(parsed) ? parsed : Number.NaN;
+};
+var parseJson = (value, label) => {
+  try {
+    return JSON.parse(value);
+  } catch {
+    throw new Error(`${label} must be valid JSON.`);
+  }
+};
+var registerDriveCommands = (program2) => {
+  const drive = program2.command("drive").description("Drive commands");
+  drive.command("navigate").description("Navigate to a URL").requiredOption("--session-id <id>", "Session identifier").requiredOption("--url <url>", "URL to navigate to").option("--tab-id <id>", "Tab identifier (defaults to active tab)").option("--wait <mode>", "Wait mode (none, domcontentloaded)").action(async (options, command) => {
+    await runCommand(command, (client) => {
+      const payload = parseInput(DriveNavigateInputSchema, {
+        session_id: options.sessionId,
+        url: options.url,
+        tab_id: parseNumber3(options.tabId),
+        wait: options.wait
+      });
+      return client.post("/drive/navigate", payload);
+    });
+  });
+  drive.command("go-back").description("Go back in browser history").requiredOption("--session-id <id>", "Session identifier").option("--tab-id <id>", "Tab identifier").action(async (options, command) => {
+    await runCommand(command, (client) => {
+      const payload = parseInput(DriveGoBackInputSchema, {
+        session_id: options.sessionId,
+        tab_id: parseNumber3(options.tabId)
+      });
+      return client.post("/drive/go_back", payload);
+    });
+  });
+  drive.command("back").description("Go back in browser history").requiredOption("--session-id <id>", "Session identifier").option("--tab-id <id>", "Tab identifier").action(async (options, command) => {
+    await runCommand(command, (client) => {
+      const payload = parseInput(DriveBackInputSchema, {
+        session_id: options.sessionId,
+        tab_id: parseNumber3(options.tabId)
+      });
+      return client.post("/drive/back", payload);
+    });
+  });
+  drive.command("go-forward").description("Go forward in browser history").requiredOption("--session-id <id>", "Session identifier").option("--tab-id <id>", "Tab identifier").action(async (options, command) => {
+    await runCommand(command, (client) => {
+      const payload = parseInput(DriveGoForwardInputSchema, {
+        session_id: options.sessionId,
+        tab_id: parseNumber3(options.tabId)
+      });
+      return client.post("/drive/go_forward", payload);
+    });
+  });
+  drive.command("forward").description("Go forward in browser history").requiredOption("--session-id <id>", "Session identifier").option("--tab-id <id>", "Tab identifier").action(async (options, command) => {
+    await runCommand(command, (client) => {
+      const payload = parseInput(DriveForwardInputSchema, {
+        session_id: options.sessionId,
+        tab_id: parseNumber3(options.tabId)
+      });
+      return client.post("/drive/forward", payload);
+    });
+  });
+  drive.command("click").description("Click an element").requiredOption("--session-id <id>", "Session identifier").option("--tab-id <id>", "Tab identifier").option("--locator-ref <ref>", "Locator ref (e.g., @e1)").option("--locator-testid <id>", "Locator test id").option("--locator-css <selector>", "Locator CSS selector").option("--locator-text <text>", "Locator text").option("--locator-role <role>", "Locator role name").option("--locator-role-value <value>", "Locator role value").option("--click-count <count>", "Click count").action(async (options, command) => {
+    await runCommand(command, (client) => {
+      const locator = requireLocator({
+        locatorRef: options.locatorRef,
+        locatorTestid: options.locatorTestid,
+        locatorCss: options.locatorCss,
+        locatorText: options.locatorText,
+        locatorRole: options.locatorRole,
+        locatorRoleValue: options.locatorRoleValue
+      });
+      const payload = parseInput(DriveClickInputSchema, {
+        session_id: options.sessionId,
+        locator,
+        tab_id: parseNumber3(options.tabId),
+        click_count: parseNumber3(options.clickCount)
+      });
+      return client.post("/drive/click", payload);
+    });
+  });
+  drive.command("hover").description("Hover over an element").requiredOption("--session-id <id>", "Session identifier").option("--tab-id <id>", "Tab identifier").option("--locator-ref <ref>", "Locator ref (e.g., @e1)").option("--locator-testid <id>", "Locator test id").option("--locator-css <selector>", "Locator CSS selector").option("--locator-text <text>", "Locator text").option("--locator-role <role>", "Locator role name").option("--locator-role-value <value>", "Locator role value").option("--delay-ms <ms>", "Delay after hover in milliseconds").action(async (options, command) => {
+    await runCommand(command, (client) => {
+      const locator = requireLocator({
+        locatorRef: options.locatorRef,
+        locatorTestid: options.locatorTestid,
+        locatorCss: options.locatorCss,
+        locatorText: options.locatorText,
+        locatorRole: options.locatorRole,
+        locatorRoleValue: options.locatorRoleValue
+      });
+      const payload = parseInput(DriveHoverInputSchema, {
+        session_id: options.sessionId,
+        locator,
+        delay_ms: parseNumber3(options.delayMs),
+        tab_id: parseNumber3(options.tabId)
+      });
+      return client.post("/drive/hover", payload);
+    });
+  });
+  drive.command("select").description("Select an option in a dropdown").requiredOption("--session-id <id>", "Session identifier").option("--tab-id <id>", "Tab identifier").option("--locator-ref <ref>", "Locator ref (e.g., @e1)").option("--locator-testid <id>", "Locator test id").option("--locator-css <selector>", "Locator CSS selector").option("--locator-text <text>", "Locator text").option("--locator-role <role>", "Locator role name").option("--locator-role-value <value>", "Locator role value").option("--value <value>", "Option value attribute").option("--text <text>", "Option visible text").option("--index <index>", "Option index (0-based)").action(async (options, command) => {
+    await runCommand(command, (client) => {
+      const locator = requireLocator({
+        locatorRef: options.locatorRef,
+        locatorTestid: options.locatorTestid,
+        locatorCss: options.locatorCss,
+        locatorText: options.locatorText,
+        locatorRole: options.locatorRole,
+        locatorRoleValue: options.locatorRoleValue
+      });
+      const payload = parseInput(DriveSelectInputSchema, {
+        session_id: options.sessionId,
+        locator,
+        value: options.value,
+        text: options.text,
+        index: parseNumber3(options.index),
+        tab_id: parseNumber3(options.tabId)
+      });
+      return client.post("/drive/select", payload);
+    });
+  });
+  drive.command("type").description("Type into a field").requiredOption("--session-id <id>", "Session identifier").requiredOption("--text <text>", "Text to enter").option("--tab-id <id>", "Tab identifier").option("--locator-ref <ref>", "Locator ref (e.g., @e1)").option("--locator-testid <id>", "Locator test id").option("--locator-css <selector>", "Locator CSS selector").option("--locator-text <text>", "Locator text").option("--locator-role <role>", "Locator role name").option("--locator-role-value <value>", "Locator role value").option("--clear", "Clear input before typing").option("--submit", "Submit after typing").action(async (options, command) => {
+    await runCommand(command, (client) => {
+      const locator = buildLocator({
+        locatorRef: options.locatorRef,
+        locatorTestid: options.locatorTestid,
+        locatorCss: options.locatorCss,
+        locatorText: options.locatorText,
+        locatorRole: options.locatorRole,
+        locatorRoleValue: options.locatorRoleValue
+      });
+      const payload = parseInput(DriveTypeInputSchema, {
+        session_id: options.sessionId,
+        locator,
+        text: options.text,
+        tab_id: parseNumber3(options.tabId),
+        clear: Boolean(options.clear),
+        submit: Boolean(options.submit)
+      });
+      return client.post("/drive/type", payload);
+    });
+  });
+  drive.command("fill-form").description("Fill multiple form fields").requiredOption("--session-id <id>", "Session identifier").requiredOption("--fields <json>", "JSON array of fields to fill").option("--tab-id <id>", "Tab identifier").action(async (options, command) => {
+    await runCommand(command, (client) => {
+      const fields = parseJson(options.fields, "fields");
+      const payload = parseInput(DriveFillFormInputSchema, {
+        session_id: options.sessionId,
+        fields,
+        tab_id: parseNumber3(options.tabId)
+      });
+      return client.post("/drive/fill_form", payload);
+    });
+  });
+  drive.command("drag").description("Drag an element to a target").requiredOption("--session-id <id>", "Session identifier").option("--from-locator-ref <ref>", "Source locator ref (e.g., @e1)").option("--from-locator-testid <id>", "Source locator test id").option("--from-locator-css <selector>", "Source locator CSS selector").option("--from-locator-text <text>", "Source locator text").option("--from-locator-role <role>", "Source locator role name").option("--from-locator-role-value <value>", "Source locator role value").option("--to-locator-ref <ref>", "Target locator ref (e.g., @e1)").option("--to-locator-testid <id>", "Target locator test id").option("--to-locator-css <selector>", "Target locator CSS selector").option("--to-locator-text <text>", "Target locator text").option("--to-locator-role <role>", "Target locator role name").option("--to-locator-role-value <value>", "Target locator role value").option("--steps <steps>", "Number of drag steps").option("--tab-id <id>", "Tab identifier").action(async (options, command) => {
+    await runCommand(command, (client) => {
+      const from = requireLocator({
+        locatorRef: options.fromLocatorRef,
+        locatorTestid: options.fromLocatorTestid,
+        locatorCss: options.fromLocatorCss,
+        locatorText: options.fromLocatorText,
+        locatorRole: options.fromLocatorRole,
+        locatorRoleValue: options.fromLocatorRoleValue
+      });
+      const to = requireLocator({
+        locatorRef: options.toLocatorRef,
+        locatorTestid: options.toLocatorTestid,
+        locatorCss: options.toLocatorCss,
+        locatorText: options.toLocatorText,
+        locatorRole: options.toLocatorRole,
+        locatorRoleValue: options.toLocatorRoleValue
+      });
+      const payload = parseInput(DriveDragInputSchema, {
+        session_id: options.sessionId,
+        from,
+        to,
+        steps: parseNumber3(options.steps),
+        tab_id: parseNumber3(options.tabId)
+      });
+      return client.post("/drive/drag", payload);
+    });
+  });
+  drive.command("handle-dialog").description("Handle a JavaScript dialog").requiredOption("--session-id <id>", "Session identifier").requiredOption("--action <action>", "Dialog action (accept, dismiss)").option("--prompt-text <text>", "Prompt text for prompt() dialogs").option("--tab-id <id>", "Tab identifier").action(async (options, command) => {
+    await runCommand(command, (client) => {
+      const payload = parseInput(DriveHandleDialogInputSchema, {
+        session_id: options.sessionId,
+        action: options.action,
+        promptText: options.promptText,
+        tab_id: parseNumber3(options.tabId)
+      });
+      return client.post("/drive/handle_dialog", payload);
+    });
+  });
+  drive.command("key-press").description("Press a keyboard key").requiredOption("--session-id <id>", "Session identifier").requiredOption("--key <key>", "Key to press (e.g. Enter, ArrowDown)").option("--ctrl", "Hold control modifier").option("--alt", "Hold alt modifier").option("--shift", "Hold shift modifier").option("--meta", "Hold meta modifier").option("--tab-id <id>", "Tab identifier").action(async (options, command) => {
+    await runCommand(command, (client) => {
+      const payload = parseInput(DriveKeyPressInputSchema, {
+        session_id: options.sessionId,
+        key: options.key,
+        modifiers: {
+          ctrl: Boolean(options.ctrl),
+          alt: Boolean(options.alt),
+          shift: Boolean(options.shift),
+          meta: Boolean(options.meta)
+        },
+        tab_id: parseNumber3(options.tabId)
+      });
+      return client.post("/drive/key_press", payload);
+    });
+  });
+  drive.command("key").description("Press a keyboard key with modifiers").requiredOption("--session-id <id>", "Session identifier").requiredOption("--key <key>", "Key to press (e.g. Enter, ArrowDown)").option(
+    "--modifier <modifier>",
+    "Modifier key (ctrl, alt, shift, meta)",
+    (value, previous) => [...previous ?? [], value],
+    []
+  ).option("--repeat <count>", "Number of times to press").option("--tab-id <id>", "Tab identifier").action(async (options, command) => {
+    await runCommand(command, (client) => {
+      const payload = parseInput(DriveKeyInputSchema, {
+        session_id: options.sessionId,
+        key: options.key,
+        modifiers: options.modifier,
+        repeat: parseNumber3(options.repeat),
+        tab_id: parseNumber3(options.tabId)
+      });
+      return client.post("/drive/key", payload);
+    });
+  });
+  drive.command("scroll").description("Scroll the page").requiredOption("--session-id <id>", "Session identifier").option("--delta-x <px>", "Scroll delta X").option("--delta-y <px>", "Scroll delta Y").option("--top <px>", "Scroll top position").option("--left <px>", "Scroll left position").option("--behavior <mode>", "Scroll behavior (auto, smooth)").option("--tab-id <id>", "Tab identifier").action(async (options, command) => {
+    await runCommand(command, (client) => {
+      const payload = parseInput(DriveScrollInputSchema, {
+        session_id: options.sessionId,
+        delta_x: parseNumber3(options.deltaX),
+        delta_y: parseNumber3(options.deltaY),
+        top: parseNumber3(options.top),
+        left: parseNumber3(options.left),
+        behavior: options.behavior,
+        tab_id: parseNumber3(options.tabId)
+      });
+      return client.post("/drive/scroll", payload);
+    });
+  });
+  drive.command("wait-for").description("Wait for a condition").requiredOption("--session-id <id>", "Session identifier").option("--tab-id <id>", "Tab identifier").requiredOption(
+    "--kind <kind>",
+    "Condition kind (locator_visible, text_present, url_matches)"
+  ).requiredOption("--value <value>", "Condition value").option("--timeout-ms <ms>", "Timeout in milliseconds").action(async (options, command) => {
+    await runCommand(command, (client) => {
+      const payload = parseInput(DriveWaitForInputSchema, {
+        session_id: options.sessionId,
+        condition: {
+          kind: options.kind,
+          value: options.value
+        },
+        timeout_ms: parseNumber3(options.timeoutMs),
+        tab_id: parseNumber3(options.tabId)
+      });
+      return client.post("/drive/wait_for", payload);
+    });
+  });
+  drive.command("tab-list").description("List browser tabs").requiredOption("--session-id <id>", "Session identifier").action(async (options, command) => {
+    await runCommand(command, (client) => {
+      const payload = parseInput(DriveTabListInputSchema, {
+        session_id: options.sessionId
+      });
+      return client.post("/drive/tab_list", payload);
+    });
+  });
+  drive.command("tab-activate").description("Activate a tab").requiredOption("--session-id <id>", "Session identifier").requiredOption("--tab-id <id>", "Tab identifier").action(async (options, command) => {
+    await runCommand(command, (client) => {
+      const payload = parseInput(DriveTabActivateInputSchema, {
+        session_id: options.sessionId,
+        tab_id: parseNumber3(options.tabId)
+      });
+      return client.post("/drive/tab_activate", payload);
+    });
+  });
+  drive.command("tab-close").description("Close a tab").requiredOption("--session-id <id>", "Session identifier").requiredOption("--tab-id <id>", "Tab identifier").action(async (options, command) => {
+    await runCommand(command, (client) => {
+      const payload = parseInput(DriveTabCloseInputSchema, {
+        session_id: options.sessionId,
+        tab_id: parseNumber3(options.tabId)
+      });
+      return client.post("/drive/tab_close", payload);
+    });
+  });
+};
+
+// packages/cli/src/commands/inspect.ts
+var registerInspectCommands = (program2) => {
+  const inspect = program2.command("inspect").description("Inspect commands");
+  inspect.command("dom-snapshot").description("Fetch a DOM snapshot").requiredOption("--session-id <id>", "Session identifier").option("--format <format>", "Snapshot format (ax, html)").option("--consistency <mode>", "Consistency mode (best_effort, quiesce)").option("-i, --interactive", "Only include interactive elements").option("-c, --compact", "Remove empty/decorative nodes").option("-s, --selector <selector>", "Limit snapshot to selector").action(async (options, command) => {
+    await runCommand(command, (client) => {
+      const payload = parseInput(InspectDomSnapshotInputSchema, {
+        session_id: options.sessionId,
+        format: options.format,
+        consistency: options.consistency,
+        interactive: options.interactive,
+        compact: options.compact,
+        selector: options.selector
+      });
+      return client.post("/inspect/dom_snapshot", payload);
+    });
+  });
+  inspect.command("dom-diff").description("Compare recent DOM snapshots").requiredOption("--session-id <id>", "Session identifier").action(async (options, command) => {
+    await runCommand(command, (client) => {
+      const payload = parseInput(InspectDomDiffInputSchema, {
+        session_id: options.sessionId
+      });
+      return client.post("/inspect/dom_diff", payload);
+    });
+  });
+  inspect.command("find").description("Find elements and return refs").requiredOption("--session-id <id>", "Session identifier").argument("<kind>", "Find kind (role, text, label)").argument("<value>", "Role name or text to match").option("--name <name>", "Accessible name to match (role only)").action(async (kind, value, options, command) => {
+    await runCommand(command, (client) => {
+      const normalizedKind = String(kind ?? "").toLowerCase();
+      let payload;
+      if (normalizedKind === "role") {
+        payload = {
+          session_id: options.sessionId,
+          kind: "role",
+          role: value,
+          name: options.name
+        };
+      } else if (normalizedKind === "text") {
+        payload = {
+          session_id: options.sessionId,
+          kind: "text",
+          text: value
+        };
+      } else if (normalizedKind === "label") {
+        payload = {
+          session_id: options.sessionId,
+          kind: "label",
+          label: value
+        };
+      } else {
+        throw new CliError({
+          code: "INVALID_ARGUMENT",
+          message: "kind must be role, text, or label.",
+          retryable: false,
+          details: { field: "kind" }
+        });
+      }
+      const parsed = parseInput(InspectFindInputSchema, payload);
+      return client.post("/inspect/find", parsed);
+    });
+  });
+  inspect.command("extract-content").description("Extract main content from the page").requiredOption("--session-id <id>", "Session identifier").option("--format <format>", "Output format (markdown, text, article_json)").option("--include-metadata", "Include article metadata").option("--no-include-metadata", "Exclude article metadata").action(async (options, command) => {
+    await runCommand(command, (client) => {
+      const payload = parseInput(InspectExtractContentInputSchema, {
+        session_id: options.sessionId,
+        format: options.format,
+        include_metadata: options.includeMetadata
+      });
+      return client.post("/inspect/extract_content", payload);
+    });
+  });
+  inspect.command("page-state").description("Capture form, storage, and cookie state").requiredOption("--session-id <id>", "Session identifier").action(async (options, command) => {
+    await runCommand(command, (client) => {
+      const payload = parseInput(InspectPageStateInputSchema, {
+        session_id: options.sessionId
+      });
+      return client.post("/inspect/page_state", payload);
+    });
+  });
+  inspect.command("console-list").description("Fetch console entries").requiredOption("--session-id <id>", "Session identifier").action(async (options, command) => {
+    await runCommand(command, (client) => {
+      const payload = parseInput(InspectConsoleListInputSchema, {
+        session_id: options.sessionId
+      });
+      return client.post("/inspect/console_list", payload);
+    });
+  });
+  inspect.command("network-har").description("Fetch network HAR").requiredOption("--session-id <id>", "Session identifier").action(async (options, command) => {
+    await runCommand(command, (client) => {
+      const payload = parseInput(InspectNetworkHarInputSchema, {
+        session_id: options.sessionId
+      });
+      return client.post("/inspect/network_har", payload);
+    });
+  });
+  inspect.command("evaluate").description("Evaluate a JavaScript expression").requiredOption("--session-id <id>", "Session identifier").option("--expression <expr>", "Expression to evaluate").action(async (options, command) => {
+    await runCommand(command, (client) => {
+      const payload = parseInput(InspectEvaluateInputSchema, {
+        session_id: options.sessionId,
+        expression: options.expression
+      });
+      return client.post("/inspect/evaluate", payload);
+    });
+  });
+  inspect.command("performance-metrics").description("Fetch performance metrics").requiredOption("--session-id <id>", "Session identifier").action(async (options, command) => {
+    await runCommand(command, (client) => {
+      const payload = parseInput(InspectPerformanceMetricsInputSchema, {
+        session_id: options.sessionId
+      });
+      return client.post("/inspect/performance_metrics", payload);
+    });
+  });
+};
+
+// packages/mcp-adapter/src/core-client.ts
+var DEFAULT_HOST2 = "127.0.0.1";
+var DEFAULT_PORT2 = 3210;
+var DEFAULT_TIMEOUT_MS2 = 4e3;
+var resolveHost2 = (host) => {
+  const candidate = host?.trim() || process.env.BROWSER_BRIDGE_CORE_HOST || process.env.BROWSER_VISION_CORE_HOST;
+  if (candidate && candidate.length > 0) {
+    return candidate;
+  }
+  return DEFAULT_HOST2;
+};
+var resolvePort2 = (port) => {
+  const candidate = port ?? (process.env.BROWSER_BRIDGE_CORE_PORT ? Number.parseInt(process.env.BROWSER_BRIDGE_CORE_PORT, 10) : process.env.BROWSER_VISION_CORE_PORT ? Number.parseInt(process.env.BROWSER_VISION_CORE_PORT, 10) : void 0);
+  if (candidate === void 0 || candidate === null) {
+    return DEFAULT_PORT2;
+  }
+  const parsed = typeof candidate === "number" ? candidate : Number.parseInt(candidate, 10);
+  if (!Number.isFinite(parsed) || parsed <= 0) {
+    throw new Error(`Invalid port: ${String(candidate)}`);
+  }
+  return parsed;
+};
+var normalizePath2 = (path2) => path2.startsWith("/") ? path2 : `/${path2}`;
+var createCoreClient2 = (options = {}) => {
+  const host = resolveHost2(options.host);
+  const port = resolvePort2(options.port);
+  const baseUrl = `http://${host}:${port}`;
+  const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS2;
+  const fetchImpl = options.fetchImpl ?? fetch;
+  const requestJson = async (path2, body) => {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), timeoutMs);
+    try {
+      const response = await fetchImpl(`${baseUrl}${normalizePath2(path2)}`, {
+        method: "POST",
+        headers: {
+          "content-type": "application/json"
+        },
+        body: body === void 0 ? void 0 : JSON.stringify(body),
+        signal: controller.signal
+      });
+      const raw = await response.text();
+      if (!raw) {
+        throw new Error(`Empty response from Core (${response.status}).`);
+      }
+      try {
+        return JSON.parse(raw);
+      } catch (error) {
+        const message = error instanceof Error ? error.message : "Unknown JSON parse error";
+        throw new Error(`Failed to parse Core response: ${message}`);
+      }
+    } finally {
+      clearTimeout(timeout);
+    }
+  };
+  const post = async (path2, body) => {
+    return requestJson(path2, body);
+  };
+  return { baseUrl, post };
+};
+
+// packages/mcp-adapter/src/tools.ts
+var toToolResult = (payload) => {
+  const content = [{ type: "text", text: JSON.stringify(payload) }];
+  if (payload && typeof payload === "object") {
+    return {
+      content,
+      structuredContent: payload
+    };
+  }
+  return { content };
+};
+var toInternalErrorEnvelope = (error) => ({
+  ok: false,
+  error: {
+    code: "INTERNAL",
+    message: error instanceof Error ? error.message : "Unknown error.",
+    retryable: false
+  }
+});
+var envelope = (schema) => apiEnvelopeSchema(schema);
+var TOOL_DEFINITIONS = [
+  {
+    name: "session.create",
+    config: {
+      title: "Session Create",
+      description: "Create a new browser session.",
+      inputSchema: SessionCreateInputSchema,
+      outputSchema: envelope(SessionCreateOutputSchema),
+      corePath: "/session/create"
+    }
+  },
+  {
+    name: "session.status",
+    config: {
+      title: "Session Status",
+      description: "Fetch session status.",
+      inputSchema: SessionStatusInputSchema,
+      outputSchema: envelope(SessionStatusOutputSchema),
+      corePath: "/session/status"
+    }
+  },
+  {
+    name: "session.recover",
+    config: {
+      title: "Session Recover",
+      description: "Recover a session after errors.",
+      inputSchema: SessionRecoverInputSchema,
+      outputSchema: envelope(SessionRecoverOutputSchema),
+      corePath: "/session/recover"
+    }
+  },
+  {
+    name: "session.close",
+    config: {
+      title: "Session Close",
+      description: "Close a session.",
+      inputSchema: SessionCloseInputSchema,
+      outputSchema: envelope(SessionCloseOutputSchema),
+      corePath: "/session/close"
+    }
+  },
+  {
+    name: "drive.navigate",
+    config: {
+      title: "Drive Navigate",
+      description: "Navigate to a URL.",
+      inputSchema: DriveNavigateInputSchema,
+      outputSchema: envelope(DriveNavigateOutputSchema),
+      corePath: "/drive/navigate"
+    }
+  },
+  {
+    name: "drive.go_back",
+    config: {
+      title: "Drive Go Back",
+      description: "Go back in browser history.",
+      inputSchema: DriveGoBackInputSchema,
+      outputSchema: envelope(DriveGoBackOutputSchema),
+      corePath: "/drive/go_back"
+    }
+  },
+  {
+    name: "drive.go_forward",
+    config: {
+      title: "Drive Go Forward",
+      description: "Go forward in browser history.",
+      inputSchema: DriveGoForwardInputSchema,
+      outputSchema: envelope(DriveGoForwardOutputSchema),
+      corePath: "/drive/go_forward"
+    }
+  },
+  {
+    name: "drive.back",
+    config: {
+      title: "Drive Back",
+      description: "Go back in browser history.",
+      inputSchema: DriveBackInputSchema,
+      outputSchema: envelope(DriveBackOutputSchema),
+      corePath: "/drive/back"
+    }
+  },
+  {
+    name: "drive.forward",
+    config: {
+      title: "Drive Forward",
+      description: "Go forward in browser history.",
+      inputSchema: DriveForwardInputSchema,
+      outputSchema: envelope(DriveForwardOutputSchema),
+      corePath: "/drive/forward"
+    }
+  },
+  {
+    name: "drive.click",
+    config: {
+      title: "Drive Click",
+      description: "Click an element.",
+      inputSchema: DriveClickInputSchema,
+      outputSchema: envelope(DriveClickOutputSchema),
+      corePath: "/drive/click"
+    }
+  },
+  {
+    name: "drive.hover",
+    config: {
+      title: "Drive Hover",
+      description: "Hover over an element.",
+      inputSchema: DriveHoverInputSchema,
+      outputSchema: envelope(DriveHoverOutputSchema),
+      corePath: "/drive/hover"
+    }
+  },
+  {
+    name: "drive.select",
+    config: {
+      title: "Drive Select",
+      description: "Select an option in a dropdown.",
+      inputSchema: DriveSelectInputSchema,
+      outputSchema: envelope(DriveSelectOutputSchema),
+      corePath: "/drive/select"
+    }
+  },
+  {
+    name: "drive.type",
+    config: {
+      title: "Drive Type",
+      description: "Type into an element.",
+      inputSchema: DriveTypeInputSchema,
+      outputSchema: envelope(DriveTypeOutputSchema),
+      corePath: "/drive/type"
+    }
+  },
+  {
+    name: "drive.fill_form",
+    config: {
+      title: "Drive Fill Form",
+      description: "Fill multiple form fields.",
+      inputSchema: DriveFillFormInputSchema,
+      outputSchema: envelope(DriveFillFormOutputSchema),
+      corePath: "/drive/fill_form"
+    }
+  },
+  {
+    name: "drive.drag",
+    config: {
+      title: "Drive Drag",
+      description: "Drag an element to a target.",
+      inputSchema: DriveDragInputSchema,
+      outputSchema: envelope(DriveDragOutputSchema),
+      corePath: "/drive/drag"
+    }
+  },
+  {
+    name: "drive.handle_dialog",
+    config: {
+      title: "Drive Handle Dialog",
+      description: "Handle a JavaScript dialog.",
+      inputSchema: DriveHandleDialogInputSchema,
+      outputSchema: envelope(DriveHandleDialogOutputSchema),
+      corePath: "/drive/handle_dialog"
+    }
+  },
+  {
+    name: "dialog.accept",
+    config: {
+      title: "Dialog Accept",
+      description: "Accept a JavaScript dialog.",
+      inputSchema: DialogAcceptInputSchema,
+      outputSchema: envelope(DialogAcceptOutputSchema),
+      corePath: "/dialog/accept"
+    }
+  },
+  {
+    name: "dialog.dismiss",
+    config: {
+      title: "Dialog Dismiss",
+      description: "Dismiss a JavaScript dialog.",
+      inputSchema: DialogDismissInputSchema,
+      outputSchema: envelope(DialogDismissOutputSchema),
+      corePath: "/dialog/dismiss"
+    }
+  },
+  {
+    name: "drive.key",
+    config: {
+      title: "Drive Key",
+      description: "Press a keyboard key.",
+      inputSchema: DriveKeyInputSchema,
+      outputSchema: envelope(DriveKeyOutputSchema),
+      corePath: "/drive/key"
+    }
+  },
+  {
+    name: "drive.key_press",
+    config: {
+      title: "Drive Key Press",
+      description: "Press a key on the active element.",
+      inputSchema: DriveKeyPressInputSchema,
+      outputSchema: envelope(DriveKeyPressOutputSchema),
+      corePath: "/drive/key_press"
+    }
+  },
+  {
+    name: "drive.scroll",
+    config: {
+      title: "Drive Scroll",
+      description: "Scroll the active tab.",
+      inputSchema: DriveScrollInputSchema,
+      outputSchema: envelope(DriveScrollOutputSchema),
+      corePath: "/drive/scroll"
+    }
+  },
+  {
+    name: "drive.wait_for",
+    config: {
+      title: "Drive Wait For",
+      description: "Wait for a drive condition.",
+      inputSchema: DriveWaitForInputSchema,
+      outputSchema: envelope(DriveWaitForOutputSchema),
+      corePath: "/drive/wait_for"
+    }
+  },
+  {
+    name: "drive.tab_list",
+    config: {
+      title: "Drive Tab List",
+      description: "List browser tabs.",
+      inputSchema: DriveTabListInputSchema,
+      outputSchema: envelope(DriveTabListOutputSchema),
+      corePath: "/drive/tab_list"
+    }
+  },
+  {
+    name: "drive.tab_activate",
+    config: {
+      title: "Drive Tab Activate",
+      description: "Activate a browser tab.",
+      inputSchema: DriveTabActivateInputSchema,
+      outputSchema: envelope(DriveTabActivateOutputSchema),
+      corePath: "/drive/tab_activate"
+    }
+  },
+  {
+    name: "drive.tab_close",
+    config: {
+      title: "Drive Tab Close",
+      description: "Close a browser tab.",
+      inputSchema: DriveTabCloseInputSchema,
+      outputSchema: envelope(DriveTabCloseOutputSchema),
+      corePath: "/drive/tab_close"
+    }
+  },
+  {
+    name: "inspect.dom_snapshot",
+    config: {
+      title: "Inspect DOM Snapshot",
+      description: "Capture a DOM snapshot.",
+      inputSchema: InspectDomSnapshotInputSchema,
+      outputSchema: envelope(InspectDomSnapshotOutputSchema),
+      corePath: "/inspect/dom_snapshot"
+    }
+  },
+  {
+    name: "inspect.dom_diff",
+    config: {
+      title: "Inspect DOM Diff",
+      description: "Compare recent DOM snapshots.",
+      inputSchema: InspectDomDiffInputSchema,
+      outputSchema: envelope(InspectDomDiffOutputSchema),
+      corePath: "/inspect/dom_diff"
+    }
+  },
+  {
+    name: "inspect.find",
+    config: {
+      title: "Inspect Find",
+      description: "Find elements in the accessibility tree and return refs.",
+      inputSchema: InspectFindInputSchema,
+      outputSchema: envelope(InspectFindOutputSchema),
+      corePath: "/inspect/find"
+    }
+  },
+  {
+    name: "inspect.extract_content",
+    config: {
+      title: "Inspect Extract Content",
+      description: "Extract main content as markdown or text.",
+      inputSchema: InspectExtractContentInputSchema,
+      outputSchema: envelope(InspectExtractContentOutputSchema),
+      corePath: "/inspect/extract_content"
+    }
+  },
+  {
+    name: "inspect.page_state",
+    config: {
+      title: "Inspect Page State",
+      description: "Capture form, storage, and cookie state.",
+      inputSchema: InspectPageStateInputSchema,
+      outputSchema: envelope(InspectPageStateOutputSchema),
+      corePath: "/inspect/page_state"
+    }
+  },
+  {
+    name: "inspect.console_list",
+    config: {
+      title: "Inspect Console List",
+      description: "List console entries.",
+      inputSchema: InspectConsoleListInputSchema,
+      outputSchema: envelope(InspectConsoleListOutputSchema),
+      corePath: "/inspect/console_list"
+    }
+  },
+  {
+    name: "inspect.network_har",
+    config: {
+      title: "Inspect Network HAR",
+      description: "Capture network HAR data.",
+      inputSchema: InspectNetworkHarInputSchema,
+      outputSchema: envelope(InspectNetworkHarOutputSchema),
+      corePath: "/inspect/network_har"
+    }
+  },
+  {
+    name: "inspect.evaluate",
+    config: {
+      title: "Inspect Evaluate",
+      description: "Evaluate an expression in the target.",
+      inputSchema: InspectEvaluateInputSchema,
+      outputSchema: envelope(InspectEvaluateOutputSchema),
+      corePath: "/inspect/evaluate"
+    }
+  },
+  {
+    name: "inspect.performance_metrics",
+    config: {
+      title: "Inspect Performance Metrics",
+      description: "Collect performance metrics.",
+      inputSchema: InspectPerformanceMetricsInputSchema,
+      outputSchema: envelope(InspectPerformanceMetricsOutputSchema),
+      corePath: "/inspect/performance_metrics"
+    }
+  },
+  {
+    name: "artifacts.screenshot",
+    config: {
+      title: "Artifacts Screenshot",
+      description: "Capture a screenshot artifact.",
+      inputSchema: ArtifactsScreenshotInputSchema,
+      outputSchema: envelope(ArtifactsScreenshotOutputSchema),
+      corePath: "/artifacts/screenshot"
+    }
+  },
+  {
+    name: "diagnostics.doctor",
+    config: {
+      title: "Diagnostics Doctor",
+      description: "Run diagnostics checks.",
+      inputSchema: DiagnosticsDoctorInputSchema,
+      outputSchema: envelope(DiagnosticsDoctorOutputSchema),
+      corePath: "/diagnostics/doctor"
+    }
+  }
+];
+var createToolHandler = (client, corePath) => {
+  return (async (args, _extra) => {
+    void _extra;
+    try {
+      const envelopeResult = await client.post(corePath, args);
+      return toToolResult(envelopeResult);
+    } catch (error) {
+      const parsed = ErrorEnvelopeSchema.safeParse(error);
+      if (parsed.success) {
+        return toToolResult(parsed.data);
+      }
+      return toToolResult(toInternalErrorEnvelope(error));
+    }
+  });
+};
+var registerBrowserBridgeTools = (server, client) => {
+  for (const tool of TOOL_DEFINITIONS) {
+    server.registerTool(
+      tool.name,
+      {
+        title: tool.config.title,
+        description: tool.config.description,
+        inputSchema: tool.config.inputSchema,
+        outputSchema: tool.config.outputSchema
+      },
+      createToolHandler(client, tool.config.corePath)
+    );
+  }
+};
+
+// packages/mcp-adapter/src/server.ts
+var import_mcp = require("@modelcontextprotocol/sdk/server/mcp.js");
+var import_stdio = require("@modelcontextprotocol/sdk/server/stdio.js");
+var DEFAULT_SERVER_NAME = "browser-bridge";
+var DEFAULT_SERVER_VERSION = "0.0.0";
+var createMcpServer = (options = {}) => {
+  const server = new import_mcp.McpServer({
+    name: options.name ?? DEFAULT_SERVER_NAME,
+    version: options.version ?? DEFAULT_SERVER_VERSION
+  });
+  const client = options.coreClient ?? createCoreClient2(options);
+  registerBrowserBridgeTools(server, client);
+  return { server, client };
+};
+var startMcpServer = async (options = {}) => {
+  const handle = createMcpServer(options);
+  const transport = new import_stdio.StdioServerTransport();
+  await handle.server.connect(transport);
+  return { ...handle, transport };
+};
+
+// packages/cli/src/commands/mcp.ts
+var registerMcpCommand = (program2) => {
+  program2.command("mcp").description("Run the MCP server over stdio").option("--name <name>", "MCP server name").option("--version <version>", "MCP server version").action(async (options, command) => {
+    const globals = getGlobalOptions(command);
+    const coreClient = createCoreClient({
+      host: globals.host,
+      port: globals.port,
+      ensureDaemon: globals.daemon !== false
+    });
+    try {
+      await startMcpServer({
+        name: options.name,
+        version: options.version,
+        coreClient
+      });
+    } catch (error) {
+      console.error(error);
+      process.exitCode = 1;
+    }
+  });
+};
+
+// packages/core/src/server.ts
+var import_express2 = __toESM(require("express"));
+
+// packages/core/src/routes/session.ts
+var import_express = require("express");
+
+// packages/core/src/inspect.ts
+var import_readability = require("@mozilla/readability");
+var import_jsdom = require("jsdom");
+var import_turndown = __toESM(require("turndown"));
+
+// packages/core/src/artifacts.ts
+var import_promises2 = require("node:fs/promises");
+var import_node_os = __toESM(require("node:os"));
+var import_node_path2 = __toESM(require("node:path"));
+var ARTIFACTS_DIR_NAME = "browser-agent";
+var resolveTempRoot = () => process.env.TMPDIR || process.env.TEMP || process.env.TMP || import_node_os.default.tmpdir();
+var getArtifactRootDir = (sessionId) => import_node_path2.default.join(resolveTempRoot(), ARTIFACTS_DIR_NAME, sessionId);
+var ensureArtifactRootDir = async (sessionId) => {
+  const rootDir = getArtifactRootDir(sessionId);
+  await (0, import_promises2.mkdir)(rootDir, { recursive: true });
+  return rootDir;
+};
+
+// packages/core/src/extension-bridge.ts
+var import_ws = require("ws");
+
+// packages/core/src/drive.ts
+var DriveMutex = class {
+  constructor() {
+    this.tail = Promise.resolve();
+  }
+  async runExclusive(work) {
+    const result = this.tail.then(work, work);
+    this.tail = result.then(
+      () => void 0,
+      () => void 0
+    );
+    return await result;
+  }
+};
+var driveMutex = new DriveMutex();
+
+// packages/core/src/page-state-script.ts
+var PAGE_STATE_SCRIPT = [
+  "(() => {",
+  "  const escape = (value) => {",
+  "    if (typeof CSS !== 'undefined' && typeof CSS.escape === 'function') {",
+  "      return CSS.escape(value);",
+  "    }",
+  `    return String(value).replace(/["'\\\\]/g, '\\\\$&');`,
+  "  };",
+  "  const truncate = (value, max) => {",
+  "    const text = String(value ?? '');",
+  "    return text.length > max ? text.slice(0, max) : text;",
+  "  };",
+  "  const selectorFor = (element) => {",
+  "    if (element.id) {",
+  "      return `#${escape(element.id)}`;",
+  "    }",
+  "    const name = element.getAttribute('name');",
+  "    if (name) {",
+  '      return `${element.tagName.toLowerCase()}[name="${escape(name)}"]`;',
+  "    }",
+  "    const parts = [];",
+  "    let node = element;",
+  "    while (node && node.nodeType === 1 && parts.length < 4) {",
+  "      let part = node.tagName.toLowerCase();",
+  "      const parent = node.parentElement;",
+  "      if (parent) {",
+  "        const siblings = Array.from(parent.children).filter(",
+  "          (child) => child.tagName === node.tagName",
+  "        );",
+  "        if (siblings.length > 1) {",
+  "          part += `:nth-of-type(${siblings.indexOf(node) + 1})`;",
+  "        }",
+  "      }",
+  "      parts.unshift(part);",
+  "      node = parent;",
+  "    }",
+  "    return parts.join('>');",
+  "  };",
+  "  const readStorage = (storage, limit) => {",
+  "    try {",
+  "      return Object.keys(storage)",
+  "        .slice(0, limit)",
+  "        .map((key) => ({",
+  "          key,",
+  "          value: truncate(storage.getItem(key), 500),",
+  "        }));",
+  "    } catch {",
+  "      return [];",
+  "    }",
+  "  };",
+  "  const forms = Array.from(document.querySelectorAll('form')).map((form) => {",
+  "    const fields = Array.from(form.elements)",
+  "      .filter((element) => element && element.tagName)",
+  "      .map((element) => {",
+  "        const tag = element.tagName.toLowerCase();",
+  "        const type = 'type' in element && element.type ? element.type : tag;",
+  "        const name = element.name || element.getAttribute('name') || element.id || '';",
+  "        let value = '';",
+  "        let options;",
+  "        if (tag === 'select') {",
+  "          const select = element;",
+  "          value = select.value ?? '';",
+  "          options = Array.from(select.options).map((option) => option.text);",
+  "        } else if (tag === 'input' && element.type === 'password') {",
+  "          value = '[redacted]';",
+  "        } else if (tag === 'input' || tag === 'textarea') {",
+  "          value = element.value ?? '';",
+  "        } else if (element.isContentEditable) {",
+  "          value = element.textContent ?? '';",
+  "        } else if ('value' in element) {",
+  "          value = element.value ?? '';",
+  "        }",
+  "        return {",
+  "          name,",
+  "          type,",
+  "          value: truncate(value, 500),",
+  "          ...(options ? { options } : {}),",
+  "        };",
+  "      });",
+  "    return {",
+  "      selector: selectorFor(form),",
+  "      action: form.getAttribute('action') || undefined,",
+  "      method: form.getAttribute('method') || undefined,",
+  "      fields,",
+  "    };",
+  "  });",
+  "  const localStorage = readStorage(window.localStorage, 100);",
+  "  const sessionStorage = readStorage(window.sessionStorage, 100);",
+  "  const cookies = (document.cookie ? document.cookie.split(';') : [])",
+  "    .map((entry) => entry.trim())",
+  "    .filter((entry) => entry.length > 0)",
+  "    .slice(0, 50)",
+  "    .map((entry) => {",
+  "      const [key, ...rest] = entry.split('=');",
+  "      return { key, value: truncate(rest.join('='), 500) };",
+  "    });",
+  "  return { forms, localStorage, sessionStorage, cookies };",
+  "})()"
+].join("\n");
+
+// packages/cli/src/open-path.ts
+var import_node_child_process2 = require("node:child_process");
+var openPath = async (target) => {
+  const platform = process.platform;
+  if (platform === "darwin") {
+    const child2 = (0, import_node_child_process2.spawn)("open", [target], { detached: true, stdio: "ignore" });
+    child2.unref();
+    return;
+  }
+  if (platform === "win32") {
+    const child2 = (0, import_node_child_process2.spawn)("cmd", ["/c", "start", "", target], {
+      detached: true,
+      stdio: "ignore"
+    });
+    child2.unref();
+    return;
+  }
+  const child = (0, import_node_child_process2.spawn)("xdg-open", [target], {
+    detached: true,
+    stdio: "ignore"
+  });
+  child.unref();
+};
+
+// packages/cli/src/commands/open-artifacts.ts
+var registerOpenArtifactsCommand = (program2) => {
+  program2.command("open-artifacts").description("Open the artifact folder for a session").requiredOption("--session-id <id>", "Session identifier").action(async (options, command) => {
+    await runLocal(command, async () => {
+      const payload = parseInput(SessionIdSchema, {
+        session_id: options.sessionId
+      });
+      const rootDir = await ensureArtifactRootDir(payload.session_id);
+      await openPath(rootDir);
+      return { ok: true, result: { path: rootDir, opened: true } };
+    });
+  });
+};
+
+// packages/cli/src/commands/session.ts
+var registerSessionCommands = (program2) => {
+  const session = program2.command("session").description("Manage Core sessions");
+  session.command("create").description("Create a new session").action(async (options, command) => {
+    await runCommand(command, (client) => {
+      const payload = parseInput(SessionCreateInputSchema, {});
+      return client.post("/session/create", payload);
+    });
+  });
+  session.command("status").description("Get session status").requiredOption("--session-id <id>", "Session identifier").action(async (options, command) => {
+    await runCommand(command, (client) => {
+      const payload = parseInput(SessionStatusInputSchema, {
+        session_id: options.sessionId
+      });
+      return client.post("/session/status", payload);
+    });
+  });
+  session.command("recover").description("Attempt to recover a session").requiredOption("--session-id <id>", "Session identifier").action(async (options, command) => {
+    await runCommand(command, (client) => {
+      const payload = parseInput(SessionRecoverInputSchema, {
+        session_id: options.sessionId
+      });
+      return client.post("/session/recover", payload);
+    });
+  });
+  session.command("close").description("Close a session").requiredOption("--session-id <id>", "Session identifier").action(async (options, command) => {
+    await runCommand(command, (client) => {
+      const payload = parseInput(SessionCloseInputSchema, {
+        session_id: options.sessionId
+      });
+      return client.post("/session/close", payload);
+    });
+  });
+};
+
+// packages/cli/src/index.ts
+var program = new import_commander.Command();
+program.name("browser-bridge").description("Browser Bridge CLI").option("--host <host>", "Core host (default: 127.0.0.1)").option("--port <port>", "Core port (default: 3210)").option("--json", "Output JSON").option("--no-daemon", "Disable auto-starting Core");
+registerSessionCommands(program);
+registerDriveCommands(program);
+registerInspectCommands(program);
+registerArtifactsCommands(program);
+registerDiagnosticsCommands(program);
+registerDialogCommands(program);
+registerOpenArtifactsCommand(program);
+registerMcpCommand(program);
+void program.parseAsync(process.argv);
+//# sourceMappingURL=index.js.map