chromeflow 0.8.0 → 0.9.9

package/dist/tools/flow.js

@@ -1,436 +0,0 @@
-import { z } from "zod";
-function registerFlowTools(server, bridge) {
-  server.tool(
-    "scroll_page",
-    "Scroll the page or the focused panel up or down. Use this when the target location is unknown. If you know which field or element you need, use scroll_to_element instead \u2014 it scrolls precisely without guessing. After scrolling, call get_page_text to read the new content \u2014 NEVER call take_screenshot after scrolling.",
-    {
-      direction: z.enum(["down", "up"]).describe("Scroll direction"),
-      amount: z.number().optional().describe("Pixels to scroll (default 400)")
-    },
-    async ({ direction, amount = 400 }) => {
-      await bridge.request({ type: "scroll_page", direction, amount });
-      return { content: [{ type: "text", text: `Scrolled ${direction} ${amount}px.` }] };
-    }
-  );
-  server.tool(
-    "click_element",
-    `Click a button, link, or interactive element on the page by its visible text or aria-label.
-Use this whenever Claude can press a button without needing user input \u2014 e.g. "Save", "Continue", "Create product", "Add pricing", "Confirm", "Next".
-After clicking, use get_page_text to check the result \u2014 only use take_screenshot if you need pixel positions.
-Do NOT use for: elements that require the user to make a personal choice, consent to terms, or enter sensitive data.
-When multiple elements share the same label (e.g. many "Remove" buttons), use nth to target a specific one (1 = first/topmost, 2 = second, etc.).
-
-Verifying the click took effect: on React-heavy sites the synthetic click sometimes returns success but the handler never ran. Pass an "until" condition that should hold AFTER the click \u2014 click_element will then poll for it and return success only if the page actually changed:
-- until_selector: a CSS selector that should appear (e.g. ".success-toast", "#confirm-modal")
-- until_url_contains: a substring that should appear in the URL (e.g. "/listing-published")
-- until_text_contains: a substring that should appear anywhere in page text (e.g. "Listing created")
-If the until-condition is not met within until_timeout_ms (default 5000ms), click_element returns success=false with a clear message so the caller can retry or take a different path.`,
-    {
-      textHint: z.string().describe(
-        "The visible label of the button or link (e.g. 'Save product', 'Continue', 'Add a product', 'Create')"
-      ),
-      nth: z.number().int().min(1).optional().describe("Which match to click when multiple elements share the same label (1 = first/topmost, default 1)"),
-      until_selector: z.string().optional().describe('Wait until this CSS selector appears on the page after the click (e.g. ".success-toast"). Returns success=false if it does not appear within until_timeout_ms.'),
-      until_url_contains: z.string().optional().describe('Wait until the URL contains this substring after the click (e.g. "/checkout/complete"). Returns success=false if it does not.'),
-      until_text_contains: z.string().optional().describe('Wait until the visible page text contains this substring after the click (e.g. "Listing published"). Returns success=false if it does not.'),
-      until_timeout_ms: z.number().int().min(500).optional().describe("How long to wait for the until-condition, in milliseconds (default 5000). Only used if one of until_* is set.")
-    },
-    async ({ textHint, nth, until_selector, until_url_contains, until_text_contains, until_timeout_ms }) => {
-      const wsTimeout = Math.max(3e4, (until_timeout_ms ?? 0) + 1e4);
-      let response;
-      try {
-        response = await bridge.request(
-          { type: "click_element", textHint, nth, until_selector, until_url_contains, until_text_contains, until_timeout_ms },
-          wsTimeout
-        );
-      } catch (err) {
-        const errMsg = err instanceof Error ? err.message : String(err);
-        if (errMsg.includes("timed out")) {
-          return {
-            content: [
-              {
-                type: "text",
-                text: `Could not confirm click on "${textHint}": ${errMsg}. The click MAY have already fired \u2014 the page just took longer than ${wsTimeout}ms to respond. Verify with get_page_text or wait_for_selector before retrying. Re-clicking can toggle the wrong way on React-controlled radios.`
-              }
-            ]
-          };
-        }
-        return {
-          content: [
-            { type: "text", text: `Could not click "${textHint}": ${errMsg}` }
-          ]
-        };
-      }
-      const r = response;
-      if (!r.success) {
-        return {
-          content: [
-            {
-              type: "text",
-              text: `Could not click "${textHint}": ${r.message}`
-            }
-          ]
-        };
-      }
-      return {
-        content: [{ type: "text", text: r.message }]
-      };
-    }
-  );
-  server.tool(
-    "wait_for_click",
-    `Wait for the user to click (or interact with) the currently highlighted element, then return.
-Use this after highlighting a step so the flow advances automatically without the user returning to the chat.
-After this resolves, highlight the next step immediately.
-If the click causes page navigation, this resolves when the new page finishes loading.`,
-    {
-      timeout: z.number().optional().describe("Max seconds to wait for the click (default 120)")
-    },
-    async ({ timeout = 120 }) => {
-      const response = await bridge.request({
-        type: "start_click_watch",
-        timeout: timeout * 1e3
-      });
-      if (response.type === "navigation_complete") {
-        return {
-          content: [
-            {
-              type: "text",
-              text: `User clicked. Page navigated to: ${response.url}`
-            }
-          ]
-        };
-      }
-      return {
-        content: [{ type: "text", text: "User clicked the highlighted element." }]
-      };
-    }
-  );
-  server.tool(
-    "wait_for_selector",
-    `Wait for a CSS selector to appear on the page. Use this instead of polling with take_screenshot.
-Examples: wait for a build to finish, a success/error message to appear, a modal to open.
-After it resolves, use get_page_text to read the result rather than taking a screenshot.
-For long-running server-side processes (e.g. a query job that may take minutes), set poll_interval
-to 15 seconds so the page is checked gently rather than hammered every 500ms.
-
-Pierces open shadow roots automatically \u2014 selectors for elements inside web components
-(Outlier task UI, Lit/Stencil widgets) match without needing a shadow-DOM-aware caller.
-
-Pass \`shadow_root: true\` when the matched element is itself a shadow host whose tree
-hasn't attached yet \u2014 common after SPA route transitions where the host element appears
-seconds before its shadow content hydrates. Without this, wait_for_selector("the-host")
-resolves on the empty host and the next execute_script(host.shadowRoot) returns null.`,
-    {
-      selector: z.string().describe(
-        `CSS selector to wait for (e.g. '.deploy-ready', '[data-status="error"]', '.toast-error')`
-      ),
-      timeout: z.number().optional().describe("Max seconds to wait (default 30)"),
-      poll_interval: z.number().optional().describe(
-        "How often to check for the selector, in seconds (default 0.5). Set to 15 when waiting for a slow server-side process."
-      ),
-      shadow_root: z.boolean().optional().describe(
-        "If true, also require the matched element to have an attached shadowRoot (not null). Use after SPA navigations where the shadow host appears before its tree hydrates. Default false."
-      )
-    },
-    async ({ selector, timeout = 30, poll_interval, shadow_root }) => {
-      const timeoutMs = timeout * 1e3;
-      const pollMs = poll_interval ? poll_interval * 1e3 : void 0;
-      await bridge.request(
-        { type: "wait_for_selector", selector, timeout: timeoutMs, refresh: pollMs, shadow_root },
-        timeoutMs + 5e3
-      );
-      const suffix = shadow_root ? " (with attached shadowRoot)" : "";
-      return {
-        content: [{ type: "text", text: `Selector "${selector}" found on page${suffix}.` }]
-      };
-    }
-  );
-  server.tool(
-    "wait_for_change",
-    `Block until the element matching \`selector\` mutates, then return its text content.
-Uses a MutationObserver \u2014 no polling, no screenshots. Ideal after an action where you expect
-a specific UI region to update: click Save, then wait_for_change(".toast") to capture the
-confirmation. wait_for_change(".chat-messages") after sending a message to get the reply.
-
-The element must exist at call time (use wait_for_selector first if needed). After the first
-mutation fires, waits a brief settle window (default 150ms) for the update to batch, then
-returns the element's current text with secrets redacted.
-
-Only observes changes within the matched element's subtree. Mutations in deeper shadow roots
-or in sibling elements are not detected. For form inputs whose \`value\` changes without a
-DOM mutation, this won't fire \u2014 use execute_script to read the value directly.`,
-    {
-      selector: z.string().describe(
-        `CSS selector of the element whose changes you want to observe (e.g. '.toast', '.chat-messages', '[role="alert"]')`
-      ),
-      timeout: z.number().optional().describe("Max seconds to wait for a mutation (default 30)"),
-      settle: z.number().optional().describe(
-        "Milliseconds to wait AFTER the first mutation for subsequent mutations to batch (default 150). Increase to 500-1000 if the page renders in multiple rapid steps."
-      )
-    },
-    async ({ selector, timeout = 30, settle }) => {
-      const timeoutMs = timeout * 1e3;
-      const settleMs = settle ?? 150;
-      const response = await bridge.request(
-        { type: "wait_for_change", selector, timeout: timeoutMs, settle: settleMs },
-        timeoutMs + 5e3
-      );
-      const r = response;
-      if (!r.ok) {
-        return { content: [{ type: "text", text: r.message ?? `wait_for_change timed out on "${selector}"` }] };
-      }
-      const preview = (r.text ?? "").slice(0, 5e3);
-      return {
-        content: [
-          {
-            type: "text",
-            text: `Element "${selector}" changed.
-
-${preview}`
-          }
-        ]
-      };
-    }
-  );
-  server.tool(
-    "scroll_to_element",
-    `Scroll an element into view by CSS selector or label/text match.
-Use this instead of guessing scroll amounts when you know which field or section you need to reach.
-Examples: scroll_to_element("#submit-btn"), scroll_to_element("Billing address"), scroll_to_element(".cm-editor")`,
-    {
-      query: z.string().describe("CSS selector (e.g. '#my-input', '.section-header') or visible text / label to search for")
-    },
-    async ({ query }) => {
-      const response = await bridge.request({ type: "scroll_to_element", query });
-      const msg = response.message ?? `Scrolled to element matching "${query}".`;
-      return { content: [{ type: "text", text: msg }] };
-    }
-  );
-  server.tool(
-    "find_text",
-    `Search the page for text and get back actionable matches without dumping the whole DOM. Use this instead of get_page_text when you only need to know "is X on the page?" or "where is the Save button?".
-
-For each match, returns the surrounding context, the nearest meaningful element (button/link/heading/role/label/etc.), a best-effort CSS selector, and a clickable flag. If a match is clickable, pipe the matched text into click_element to act on it.
-
-Use when:
-- Checking whether a toast / error message / heading appeared after an action
-- Locating one of multiple buttons by text
-- Finding all instances of a phrase to count or inspect them
-
-Do NOT use for: reading large blocks of body text \u2014 use get_page_text(selector=...) for that. find_text returns one short snippet per match, not the full content.
-
-Pierces open shadow roots. Pass frame="iframe.selector" to search inside a same-origin iframe.`,
-    {
-      query: z.string().describe(
-        "Text to search for. Substring match by default; pass regex=true to interpret as a case-insensitive regex."
-      ),
-      max: z.number().int().min(1).optional().describe("Maximum matches to return (default 10). total_matches is reported even when truncated."),
-      scope_selector: z.string().optional().describe('Limit search to descendants of this CSS selector (e.g. ".main-panel", "#dialog"). Default searches the whole body.'),
-      regex: z.boolean().optional().describe("Treat query as a regex (case-insensitive). Default false."),
-      visible_only: z.boolean().optional().describe("Skip matches inside display:none / visibility:hidden / aria-hidden=true ancestors. Default true."),
-      context_chars: z.number().int().min(0).optional().describe("Characters of surrounding context to include before/after each match. Default 60."),
-      frame: z.string().optional().describe('Same-origin iframe CSS selector (e.g. "iframe.editor") to search inside. Cross-origin iframes are not supported.')
-    },
-    async ({ query, max, scope_selector, regex, visible_only, context_chars, frame }) => {
-      const response = await bridge.request({
-        type: "find_text",
-        query,
-        max,
-        scope_selector,
-        regex,
-        visible_only,
-        context_chars,
-        frame
-      });
-      const r = response;
-      if (r.frame_error) {
-        return { content: [{ type: "text", text: r.frame_error }] };
-      }
-      if (r.scope_missed) {
-        return {
-          content: [
-            { type: "text", text: `Scope selector "${scope_selector}" did not match any element \u2014 no search performed.` }
-          ]
-        };
-      }
-      if (r.matches.length === 0) {
-        return {
-          content: [
-            { type: "text", text: `No matches found for "${query}".` }
-          ]
-        };
-      }
-      const lines = r.matches.map((m, i) => {
-        const role = m.role ? `, role=${m.role}` : "";
-        const click = m.clickable ? " \u2014 clickable" : "";
-        const pos = m.position ? ` at (${m.position.x}, ${m.position.y}, ${m.position.width}\xD7${m.position.height})` : "";
-        return `  ${i + 1}. [${m.tag}${role}]${click}${pos} \u2014 selector: ${m.selector}
-     "${m.text}"
-     context: ${m.context}`;
-      });
-      const header = r.truncated ? `Found ${r.matches.length} of ${r.total_matches} matches for "${query}":` : `Found ${r.matches.length} match${r.matches.length === 1 ? "" : "es"} for "${query}":`;
-      return {
-        content: [{ type: "text", text: `${header}
-${lines.join("\n")}` }]
-      };
-    }
-  );
-  server.tool(
-    "find_input",
-    `Locate form inputs whose label / placeholder / aria-label / name / id matches a hint, returning the top N with their section heading. Use this instead of get_form_fields when you only need a couple of fields \u2014 it's the targeted lookup, not the full inventory.
-
-Match strength is reported as match_kind: aria-eq / placeholder-eq / label-text-eq / name-eq / id-eq are exact matches; *-includes are partial matches; fuzzy-text-walk is the lowest-confidence fallback.
-
-Returned labels are designed to be piped straight into fill_input(label, value), which uses the same fuzzy ranks to find the same field again. No CSS selector is returned \u2014 fill_input matches by label text, not by selector.
-
-Use when:
-- "Is the Email field on this page?"
-- "Find the price input below the fold"
-- "Which input has placeholder 'you@example.com'?"
-
-Do NOT use for: filling fields (use fill_input / fill_form). For the full form inventory (every field including hidden ones), use get_form_fields.
-
-Pierces open shadow roots. Pass frame="iframe.selector" to search inside a same-origin iframe. Pass exact=true to refuse fuzzy text-walk and *-includes matches when the hint is short and could collide with neighbours.`,
-    {
-      query: z.string().describe(
-        "Hint to match against the field's label, placeholder, aria-label, name, or id (e.g. 'Email', 'price', 'Card number')"
-      ),
-      type_filter: z.string().optional().describe(
-        'Restrict to a specific input type \u2014 "email", "checkbox", "file", "textarea", "select", "number", etc. Default "any".'
-      ),
-      max: z.number().int().min(1).optional().describe("Maximum fields to return (default 5). total_matches is reported even when truncated."),
-      exact: z.boolean().optional().describe(
-        "If true, return only exact equality matches (aria-eq / placeholder-eq / label-text-eq / name-eq / id-eq). Skips fuzzy text-walk and *-includes. Default false."
-      ),
-      frame: z.string().optional().describe("Same-origin iframe CSS selector to search inside. Cross-origin iframes are not supported.")
-    },
-    async ({ query, type_filter, max, exact, frame }) => {
-      const response = await bridge.request({
-        type: "find_input",
-        query,
-        type_filter,
-        max,
-        exact,
-        frame
-      });
-      const r = response;
-      if (r.frame_error) {
-        return { content: [{ type: "text", text: r.frame_error }] };
-      }
-      if (r.fields.length === 0) {
-        return {
-          content: [{ type: "text", text: `No input fields found matching "${query}".` }]
-        };
-      }
-      const lines = r.fields.map((f, i) => {
-        const placeholderPart = f.placeholder ? ` placeholder="${f.placeholder}"` : "";
-        const valuePart = f.value ? ` value="${f.value}"` : "";
-        const underPart = f.under ? ` [under: "${f.under}"]` : "";
-        const posPart = f.position ? ` at y=${f.position.y}` : "";
-        return `  ${i + 1}. "${f.label}" type=${f.type}${placeholderPart}${valuePart}${underPart} \u2014 match: ${f.match_kind}${posPart}`;
-      });
-      const header = r.truncated ? `Found ${r.fields.length} of ${r.total_matches} input(s) for "${query}":` : `Found ${r.fields.length} input${r.fields.length === 1 ? "" : "s"} for "${query}":`;
-      return {
-        content: [{ type: "text", text: `${header}
-${lines.join("\n")}
-
-To fill: fill_input("${r.fields[0].label}", "<value>")` }]
-      };
-    }
-  );
-  server.tool(
-    "wait_for_text",
-    `Wait for text to appear in the DOM. Complement to wait_for_selector for the case where you only know the message text \u2014 no selector required. Uses a MutationObserver under the hood, no polling.
-
-Resolves on the first match (or if the text is already present). Returns the elapsed time, the matched text, and the surrounding context.
-
-Use when:
-- "Click Save, then wait for 'Saved successfully' to show"
-- "Wait until the deploy log says 'Build complete'"
-- Any case where the post-action signal is a phrase, not a known selector
-
-Do NOT use for: waiting on a known CSS selector (use wait_for_selector \u2014 slightly cheaper).
-
-Pierces open shadow roots. Pass frame="iframe.selector" to wait for text inside a same-origin iframe.`,
-    {
-      query: z.string().describe("Text to wait for (substring by default; pass regex=true for a regex)"),
-      timeout_ms: z.number().int().min(100).optional().describe("Maximum milliseconds to wait (default 10000)"),
-      scope_selector: z.string().optional().describe("Limit the observation to a CSS selector's subtree (e.g. '.toast-region')"),
-      regex: z.boolean().optional().describe("Treat query as a regex (case-insensitive). Default false."),
-      frame: z.string().optional().describe("Same-origin iframe CSS selector to wait inside. Cross-origin iframes are not supported.")
-    },
-    async ({ query, timeout_ms, scope_selector, regex, frame }) => {
-      const wsTimeout = Math.max(15e3, (timeout_ms ?? 1e4) + 5e3);
-      const response = await bridge.request(
-        {
-          type: "wait_for_text",
-          query,
-          timeout_ms,
-          scope_selector,
-          regex,
-          frame
-        },
-        wsTimeout
-      );
-      const r = response;
-      if (r.frame_error) {
-        return { content: [{ type: "text", text: r.frame_error }] };
-      }
-      if (!r.found) {
-        return {
-          content: [
-            { type: "text", text: `Timed out after ${r.elapsed_ms}ms waiting for "${query}".` }
-          ]
-        };
-      }
-      const ctx = r.context ? `
-context: ${r.context}` : "";
-      const sel = r.selector ? `
-selector: ${r.selector}` : "";
-      return {
-        content: [
-          {
-            type: "text",
-            text: `Found "${r.text}" after ${r.elapsed_ms}ms.${sel}${ctx}`
-          }
-        ]
-      };
-    }
-  );
-  server.tool(
-    "fill_form",
-    `Fill multiple form fields in a single call by targeting each field by its label text.
-Use this instead of calling fill_input repeatedly \u2014 it fills all fields in one round trip and returns a per-field success report.
-Ideal for forms with many textareas or inputs where each fill would otherwise require a separate tool call.
-fields is an array of {label, value} pairs. label should match the field's visible label, placeholder, or aria-label.
-
-Each per-field result includes the matched element description (e.g. \`<input name="title" id="..." placeholder="...">\`) so Claude can spot when fill_form picked the wrong field.
-
-Pass \`exact: true\` for forms with short generic labels (like "Rate" or "Amount") that may collide with similarly-labeled neighbours \u2014 fields without an exact aria-label/placeholder/name/id/label-text match will return success=false instead of silently filling the wrong field.`,
-    {
-      fields: z.array(
-        z.object({
-          label: z.string().describe("Visible label, placeholder, or aria-label of the field"),
-          value: z.string().describe("Value to fill in")
-        })
-      ).describe("List of fields to fill"),
-      exact: z.boolean().optional().describe("If true, refuse fuzzy text-walk matches for every field. Default false.")
-    },
-    async ({ fields, exact }) => {
-      const response = await bridge.request({ type: "fill_form", fields, exact });
-      const r = response;
-      const lines = r.results.map((f) => `${f.success ? "\u2713" : "\u2717"} "${f.label}": ${f.message}`);
-      return {
-        content: [{
-          type: "text",
-          text: `Filled ${r.succeeded}/${r.total} fields:
-${lines.join("\n")}`
-        }]
-      };
-    }
-  );
-}
-export {
-  registerFlowTools
-};

package/dist/tools/highlight.js

@@ -1,70 +0,0 @@
-import { z } from "zod";
-function registerHighlightTools(server, bridge) {
-  server.tool(
-    "find_and_highlight",
-    "Find an element on the page by its visible text and highlight it with an instructional callout. Try this before using highlight_region. Returns whether the element was found.",
-    {
-      text: z.string().describe(
-        "Visible text of the element or text near it (e.g. 'API Keys', 'Create account')"
-      ),
-      message: z.string().describe(
-        "Instruction to show the user in the callout (e.g. 'Click here to create your API key'). When the user needs to type something, use a short instruction like 'Type this in the field:' and pass the text as valueToType."
-      ),
-      valueToType: z.string().optional().describe(
-        "Only use when the user must personally type the value (password, email, personal data). Do NOT use when Claude will auto-fill after the click \u2014 in that case, omit this and use message: 'Click here \u2014 I'll fill it in'."
-      )
-    },
-    async ({ text, message, valueToType }) => {
-      const response = await bridge.request({
-        type: "find_highlight",
-        text,
-        message,
-        valueToType
-      });
-      if (response.type !== "find_highlight_response") {
-        throw new Error("Unexpected response from extension");
-      }
-      return {
-        content: [
-          {
-            type: "text",
-            text: response.found ? `Element containing "${text}" highlighted.` : `Element containing "${text}" not found. Try get_elements() to get exact DOM coordinates, or take_screenshot() only if you need to see the visual layout.`
-          }
-        ]
-      };
-    }
-  );
-  server.tool(
-    "highlight_region",
-    `Highlight a region on the page with an instructional callout.
-Prefer passing a CSS selector \u2014 the extension will find the element, scroll it into view, and highlight its exact bounds automatically. This is more robust than pixel coordinates, which go stale if the user scrolls.
-Only pass x/y/width/height when you have no selector and already have fresh coordinates from get_elements.`,
-    {
-      selector: z.string().optional().describe("CSS selector of the element to highlight (e.g. '#upload-zone', '.drop-area'). Preferred over raw coordinates."),
-      x: z.number().optional().describe("Left edge in CSS pixels \u2014 only needed if no selector"),
-      y: z.number().optional().describe("Top edge in CSS pixels \u2014 only needed if no selector"),
-      width: z.number().optional().describe("Width in CSS pixels \u2014 only needed if no selector"),
-      height: z.number().optional().describe("Height in CSS pixels \u2014 only needed if no selector"),
-      message: z.string().describe(
-        "Instruction to show the user in the callout. When the user needs to type something, use a short instruction like 'Type this in the field:' and pass the text as valueToType."
-      ),
-      valueToType: z.string().optional().describe(
-        `Only use when the user must personally type the value (password, email, personal data). Do NOT use when Claude will auto-fill after the click \u2014 in that case, omit this and use message: "Click here \u2014 I'll fill it in".`
-      )
-    },
-    async ({ selector, x, y, width, height, message, valueToType }) => {
-      await bridge.request({ type: "highlight_region", selector, x, y, width, height, message, valueToType });
-      return {
-        content: [
-          {
-            type: "text",
-            text: selector ? `Highlighted element matching "${selector}".` : `Region highlighted at (${x ?? 0}, ${y ?? 0}) ${width ?? 0}\xD7${height ?? 0}.`
-          }
-        ]
-      };
-    }
-  );
-}
-export {
-  registerHighlightTools
-};

package/dist/ws-bridge.js

@@ -1,116 +0,0 @@
-import { WebSocketServer, WebSocket } from "ws";
-import path from "path";
-const WS_PORT_BASE = 7878;
-const WS_PORT_MAX = 7888;
-const REQUEST_TIMEOUT_MS = 3e4;
-class WsBridge {
-  wss;
-  client = null;
-  pending = /* @__PURE__ */ new Map();
-  port = WS_PORT_BASE;
-  constructor() {
-    this.bind(WS_PORT_BASE);
-  }
-  bind(tryPort) {
-    if (tryPort > WS_PORT_MAX) {
-      console.error(
-        `[chromeflow] All ports ${WS_PORT_BASE}-${WS_PORT_MAX} are in use. Cannot start MCP server.`
-      );
-      return;
-    }
-    const wss = new WebSocketServer({ port: tryPort });
-    wss.on("error", (err) => {
-      if (err.code === "EADDRINUSE") {
-        console.error(`[chromeflow] Port ${tryPort} in use, trying ${tryPort + 1}...`);
-        this.bind(tryPort + 1);
-      } else {
-        console.error("[chromeflow] WS server error:", err);
-      }
-    });
-    wss.on("listening", () => {
-      this.wss = wss;
-      this.port = tryPort;
-      console.error(`[chromeflow] WS bridge listening on ws://localhost:${tryPort}`);
-    });
-    wss.on("connection", (ws) => {
-      if (this.client) {
-        this.client.terminate();
-      }
-      this.client = ws;
-      console.error("[chromeflow] Extension connected");
-      ws.on("message", (data) => {
-        let msg;
-        try {
-          msg = JSON.parse(data.toString());
-        } catch {
-          return;
-        }
-        if (msg.type === "ready") {
-          console.error("[chromeflow] Extension ready");
-          const cwd = process.cwd();
-          ws.send(JSON.stringify({
-            type: "identity",
-            cwd,
-            label: path.basename(cwd),
-            port: this.port
-          }));
-          return;
-        }
-        const pending = this.pending.get(msg.requestId);
-        if (pending) {
-          clearTimeout(pending.timer);
-          this.pending.delete(msg.requestId);
-          if (msg.type === "error") {
-            pending.reject(new Error(msg.message));
-          } else {
-            pending.resolve(msg);
-          }
-        }
-      });
-      ws.on("close", () => {
-        console.error("[chromeflow] Extension disconnected");
-        this.client = null;
-        for (const [id, pending] of this.pending) {
-          clearTimeout(pending.timer);
-          pending.reject(new Error(
-            "Chrome extension disconnected. Reload the chromeflow extension in Chrome and try again."
-          ));
-          this.pending.delete(id);
-        }
-      });
-    });
-  }
-  isConnected() {
-    return this.client !== null && this.client.readyState === WebSocket.OPEN;
-  }
-  /** Send a message and wait for a response from the extension. */
-  request(message, timeoutMs = REQUEST_TIMEOUT_MS) {
-    if (!this.isConnected()) {
-      return Promise.reject(
-        new Error(
-          "Chromeflow extension is not connected. Open Chrome and ensure the extension is installed."
-        )
-      );
-    }
-    const requestId = crypto.randomUUID();
-    return new Promise((resolve, reject) => {
-      const timer = setTimeout(() => {
-        this.pending.delete(requestId);
-        reject(new Error(`Request timed out after ${timeoutMs}ms`));
-      }, timeoutMs);
-      this.pending.set(requestId, { resolve, reject, timer });
-      this.client.send(JSON.stringify({ ...message, requestId }));
-    });
-  }
-  /** Send a fire-and-forget message (no response expected). */
-  send(message) {
-    if (!this.isConnected()) {
-      throw new Error("Chromeflow extension is not connected.");
-    }
-    const requestId = crypto.randomUUID();
-    this.client.send(JSON.stringify({ ...message, requestId }));
-  }
-}
-export {
-  WsBridge
-};