@crewhaus/computer-use-driver 0.1.4 → 0.1.6

package/src/backends/backends.test.ts

@@ -1,396 +0,0 @@
-/**
- * Section 30 — host + remote driver contract tests.
- */
-import { describe, expect, test } from "bun:test";
-import { ComputerUseDriverError, type Viewport } from "../index";
-import { type HostExecutor, createHostDriver } from "./host";
-import { type PuppeteerCoreLike, createRemoteDriver } from "./remote";
-
-describe("host driver — Section 30", () => {
-  test("disabled flag → throws on construction", () => {
-    expect(() => createHostDriver({ enabled: false, executor: {} as never })).toThrow(
-      ComputerUseDriverError,
-    );
-  });
-
-  test("connect + every operation delegates to the executor", async () => {
-    const calls: string[] = [];
-    const viewport: Viewport = { width: 1920, height: 1080, devicePixelRatio: 1 };
-    let closed = false;
-    const executor: HostExecutor = {
-      async click(x, y, button) {
-        calls.push(`click ${x},${y} ${button}`);
-      },
-      async type(text) {
-        calls.push(`type ${text}`);
-      },
-      async key(combo) {
-        calls.push(`key ${combo}`);
-      },
-      async scroll(x, y, dx, dy) {
-        calls.push(`scroll ${x},${y} ${dx},${dy}`);
-      },
-      async screenshot() {
-        calls.push("screenshot");
-        // "iVBORw0KGgo=" decodes to the PNG magic bytes (0x89 0x50 0x4E 0x47 ...).
-        return { pngBase64: "iVBORw0KGgo=", viewport };
-      },
-      async close() {
-        closed = true;
-      },
-    };
-    const driver = createHostDriver({ enabled: true, executor });
-    await driver.connect();
-    await driver.click(100, 200, "left");
-    const shot = await driver.screenshot();
-    expect(shot).toBeInstanceOf(Uint8Array);
-    expect(shot[0]).toBe(0x89);
-    expect(shot[1]).toBe(0x50);
-    await driver.type("hello");
-    await driver.key("cmd+space");
-    await driver.scroll(5, 6);
-    const vp = await driver.getViewport();
-    expect(vp).toEqual(viewport);
-    await driver.disconnect();
-    expect(closed).toBe(true);
-    expect(calls).toEqual([
-      "click 100,200 left",
-      "screenshot",
-      "type hello",
-      "key cmd+space",
-      "scroll 0,0 5,6",
-      "screenshot", // getViewport screenshots to read the viewport
-    ]);
-  });
-
-  test("click defaults to the left button when none is given", async () => {
-    const calls: string[] = [];
-    const executor: HostExecutor = {
-      async click(x, y, button) {
-        calls.push(`click ${x},${y} ${button}`);
-      },
-      async type() {},
-      async key() {},
-      async scroll() {},
-      async screenshot() {
-        return { pngBase64: "", viewport: { width: 0, height: 0, devicePixelRatio: 1 } };
-      },
-    };
-    const driver = createHostDriver({ enabled: true, executor });
-    await driver.connect();
-    await driver.click(7, 8);
-    expect(calls).toEqual(["click 7,8 left"]);
-  });
-
-  test("disconnect tolerates an executor without a close() method", async () => {
-    const executor: HostExecutor = {
-      async click() {},
-      async type() {},
-      async key() {},
-      async scroll() {},
-      async screenshot() {
-        return { pngBase64: "", viewport: { width: 0, height: 0, devicePixelRatio: 1 } };
-      },
-      // no close — optional-chaining must not throw
-    };
-    const driver = createHostDriver({ enabled: true, executor });
-    await driver.connect();
-    await expect(driver.disconnect()).resolves.toBeUndefined();
-    // After disconnect, guarded operations throw again.
-    await expect(driver.screenshot()).rejects.toBeInstanceOf(ComputerUseDriverError);
-  });
-
-  test("type / key / getViewport reject before connect", async () => {
-    const executor: HostExecutor = {
-      async click() {},
-      async type() {},
-      async key() {},
-      async scroll() {},
-      async screenshot() {
-        return { pngBase64: "", viewport: { width: 0, height: 0, devicePixelRatio: 1 } };
-      },
-    };
-    const driver = createHostDriver({ enabled: true, executor });
-    await expect(driver.type("x")).rejects.toBeInstanceOf(ComputerUseDriverError);
-    await expect(driver.key("Enter")).rejects.toBeInstanceOf(ComputerUseDriverError);
-    await expect(driver.scroll(0, 0)).rejects.toBeInstanceOf(ComputerUseDriverError);
-    await expect(driver.getViewport()).rejects.toBeInstanceOf(ComputerUseDriverError);
-    await expect(driver.screenshot()).rejects.toBeInstanceOf(ComputerUseDriverError);
-  });
-
-  test("scroll delegates to executor with zero anchor", async () => {
-    const calls: string[] = [];
-    const executor: HostExecutor = {
-      async click() {},
-      async type() {},
-      async key() {},
-      async scroll(x, y, dx, dy) {
-        calls.push(`scroll ${x},${y} ${dx},${dy}`);
-      },
-      async screenshot() {
-        return {
-          pngBase64: "",
-          viewport: { width: 0, height: 0, devicePixelRatio: 1 },
-        };
-      },
-    };
-    const driver = createHostDriver({ enabled: true, executor });
-    await driver.connect();
-    await driver.scroll(10, 20);
-    expect(calls).toEqual(["scroll 0,0 10,20"]);
-  });
-
-  test("operations before connect throw", async () => {
-    const executor = {
-      async click() {},
-      async type() {},
-      async key() {},
-      async scroll() {},
-      async screenshot() {
-        return {
-          pngBase64: "",
-          viewport: { width: 0, height: 0, devicePixelRatio: 1 },
-        };
-      },
-    } as HostExecutor;
-    const driver = createHostDriver({ enabled: true, executor });
-    await expect(driver.click(0, 0)).rejects.toBeInstanceOf(ComputerUseDriverError);
-  });
-
-  test("goto throws — host backend cannot navigate URLs", async () => {
-    const driver = createHostDriver({
-      enabled: true,
-      executor: {
-        async screenshot() {
-          return {
-            pngBase64: "",
-            viewport: { width: 0, height: 0, devicePixelRatio: 1 },
-          };
-        },
-      } as HostExecutor,
-    });
-    await driver.connect();
-    await expect(driver.goto("https://x.com")).rejects.toBeInstanceOf(ComputerUseDriverError);
-  });
-});
-
-describe("remote driver — Section 30", () => {
-  test("missing url throws on construction", () => {
-    expect(() => createRemoteDriver({ url: "" })).toThrow(ComputerUseDriverError);
-  });
-
-  test("connect without _puppeteer throws with install hint", async () => {
-    const driver = createRemoteDriver({ url: "ws://test" });
-    await expect(driver.connect()).rejects.toThrow(/puppeteer-core/);
-  });
-
-  test("connect + screenshot + click delegate to puppeteer-core stub", async () => {
-    const ops: string[] = [];
-    const stubPage = {
-      async goto(url: string) {
-        ops.push(`goto ${url}`);
-      },
-      async screenshot() {
-        ops.push("screenshot");
-        return Buffer.from("png-data");
-      },
-      mouse: {
-        async click(x: number, y: number, opts?: { button?: string }) {
-          ops.push(`click ${x},${y} ${opts?.button}`);
-        },
-      },
-      keyboard: {
-        async type(text: string) {
-          ops.push(`type ${text}`);
-        },
-        async press(key: string) {
-          ops.push(`press ${key}`);
-        },
-      },
-      async evaluate<T>(_fn: () => T) {
-        return undefined as unknown as T;
-      },
-      async close() {
-        ops.push("close-page");
-      },
-    };
-    const stubBrowser = {
-      async newPage() {
-        return stubPage;
-      },
-      async close() {
-        ops.push("close-browser");
-      },
-    };
-    const stubPuppeteer: PuppeteerCoreLike = {
-      async connect(_opts) {
-        ops.push("connect");
-        return stubBrowser as never;
-      },
-    };
-    const driver = createRemoteDriver({ url: "ws://test", _puppeteer: stubPuppeteer });
-    await driver.connect();
-    await driver.goto("https://x.com");
-    await driver.click(50, 60, "right");
-    await driver.disconnect();
-    expect(ops).toContain("connect");
-    expect(ops).toContain("goto https://x.com");
-    expect(ops).toContain("click 50,60 right");
-    expect(ops).toContain("close-browser");
-  });
-
-  /** Build a fully-stubbed puppeteer-core whose page records into `ops`. */
-  function makeStub(ops: string[], opts?: { screenshotAsString?: boolean }) {
-    const page = {
-      async goto(url: string) {
-        ops.push(`goto ${url}`);
-      },
-      async screenshot(_o?: { encoding?: "base64" }) {
-        ops.push("screenshot");
-        // "aGk=" is base64 for "hi"; cover both the string and Buffer arms.
-        return opts?.screenshotAsString ? "aGk=" : Buffer.from("hi");
-      },
-      mouse: {
-        async click(x: number, y: number, o?: { button?: string }) {
-          ops.push(`click ${x},${y} ${o?.button}`);
-        },
-      },
-      keyboard: {
-        async type(text: string) {
-          ops.push(`type ${text}`);
-        },
-        async press(key: string) {
-          ops.push(`press ${key}`);
-        },
-      },
-      // The real driver casts the page and calls evaluate(fn, arg). Run the fn
-      // against a stub global exposing scrollBy so the closure body executes.
-      async evaluate(fn: (d: { dx: number; dy: number }) => void, arg: { dx: number; dy: number }) {
-        const g = globalThis as Record<string, unknown>;
-        const prev = g["scrollBy"];
-        g["scrollBy"] = (dx: number, dy: number) => {
-          ops.push(`scrollBy ${dx},${dy}`);
-        };
-        try {
-          fn(arg);
-        } finally {
-          g["scrollBy"] = prev;
-        }
-      },
-      async close() {
-        ops.push("close-page");
-      },
-    };
-    const browser = {
-      async newPage() {
-        return page;
-      },
-      async close() {
-        ops.push("close-browser");
-      },
-    };
-    const puppeteer: PuppeteerCoreLike = {
-      async connect(_o) {
-        return browser as never;
-      },
-    };
-    return { puppeteer, page, browser };
-  }
-
-  test("screenshot decodes a base64 string from puppeteer", async () => {
-    const ops: string[] = [];
-    const { puppeteer } = makeStub(ops, { screenshotAsString: true });
-    const driver = createRemoteDriver({ url: "ws://t", _puppeteer: puppeteer });
-    await driver.connect();
-    const png = await driver.screenshot();
-    expect(png).toBeInstanceOf(Uint8Array);
-    expect(Buffer.from(png).toString()).toBe("hi");
-  });
-
-  test("screenshot re-encodes a Buffer from puppeteer", async () => {
-    const ops: string[] = [];
-    const { puppeteer } = makeStub(ops, { screenshotAsString: false });
-    const driver = createRemoteDriver({ url: "ws://t", _puppeteer: puppeteer });
-    await driver.connect();
-    const png = await driver.screenshot();
-    expect(Buffer.from(png).toString()).toBe("hi");
-  });
-
-  test("type / key / scroll delegate through puppeteer", async () => {
-    const ops: string[] = [];
-    const { puppeteer } = makeStub(ops);
-    const driver = createRemoteDriver({ url: "ws://t", _puppeteer: puppeteer });
-    await driver.connect();
-    await driver.type("hello");
-    await driver.key("Enter");
-    await driver.scroll(11, 22);
-    expect(ops).toContain("type hello");
-    expect(ops).toContain("press Enter");
-    // The scroll closure runs in the (stubbed) page context and calls scrollBy.
-    expect(ops).toContain("scrollBy 11,22");
-  });
-
-  test("click defaults to the left button when none is given", async () => {
-    const ops: string[] = [];
-    const { puppeteer } = makeStub(ops);
-    const driver = createRemoteDriver({ url: "ws://t", _puppeteer: puppeteer });
-    await driver.connect();
-    await driver.click(1, 2);
-    expect(ops).toContain("click 1,2 left");
-  });
-
-  test("getViewport returns the override when provided", async () => {
-    const ops: string[] = [];
-    const { puppeteer } = makeStub(ops);
-    const viewport: Viewport = { width: 640, height: 480, devicePixelRatio: 2 };
-    const driver = createRemoteDriver({ url: "ws://t", viewport, _puppeteer: puppeteer });
-    await driver.connect();
-    expect(await driver.getViewport()).toEqual(viewport);
-  });
-
-  test("getViewport falls back to 1280x800 when no override", async () => {
-    const ops: string[] = [];
-    const { puppeteer } = makeStub(ops);
-    const driver = createRemoteDriver({ url: "ws://t", _puppeteer: puppeteer });
-    await driver.connect();
-    expect(await driver.getViewport()).toEqual({ width: 1280, height: 800, devicePixelRatio: 1 });
-  });
-
-  test("operations before connect throw 'not connected'", async () => {
-    const driver = createRemoteDriver({ url: "ws://t", _puppeteer: makeStub([]).puppeteer });
-    await expect(driver.goto("https://x.com")).rejects.toThrow(/not connected/);
-    await expect(driver.screenshot()).rejects.toThrow(/not connected/);
-    await expect(driver.click(0, 0)).rejects.toThrow(/not connected/);
-    await expect(driver.type("x")).rejects.toThrow(/not connected/);
-    await expect(driver.key("Enter")).rejects.toThrow(/not connected/);
-    await expect(driver.scroll(0, 0)).rejects.toThrow(/not connected/);
-  });
-
-  test("disconnect closes page then browser and resets state", async () => {
-    const ops: string[] = [];
-    const { puppeteer } = makeStub(ops);
-    const driver = createRemoteDriver({ url: "ws://t", _puppeteer: puppeteer });
-    await driver.connect();
-    await driver.disconnect();
-    expect(ops).toContain("close-page");
-    expect(ops).toContain("close-browser");
-    // After disconnect the page handle is cleared → operations throw again.
-    await expect(driver.click(0, 0)).rejects.toThrow(/not connected/);
-  });
-
-  test("disconnect swallows close() failures (best-effort)", async () => {
-    const ops: string[] = [];
-    const { puppeteer, page } = makeStub(ops);
-    page.close = async () => {
-      throw new Error("page close failed");
-    };
-    const driver = createRemoteDriver({ url: "ws://t", _puppeteer: puppeteer });
-    await driver.connect();
-    await expect(driver.disconnect()).resolves.toBeUndefined();
-  });
-
-  test("disconnect before connect is a no-op (no page / browser handles)", async () => {
-    const driver = createRemoteDriver({ url: "ws://t", _puppeteer: makeStub([]).puppeteer });
-    await expect(driver.disconnect()).resolves.toBeUndefined();
-  });
-});

package/src/backends/host.ts

@@ -1,96 +0,0 @@
-/**
- * Section 30 — host backend for `computer-use-driver`. Drives the
- * dev's actual desktop via the OS-level computer-use surface (macOS
- * Quartz / Linux X11+xdotool / Windows SendInput). Production
- * deployments use this for cross-app workflows that no browser can
- * reach (Maps, Notes, Photos, Finder, native System Settings).
- *
- * **Safety gate:** the constructor refuses to return a working driver
- * unless `CREWHAUS_BROW_HOST_ENABLED=1` is set in the environment. The
- * goal is fail-loud ergonomics: deployment errors that try to use the
- * host backend without explicit opt-in should immediately surface
- * rather than silently driving the dev's machine.
- *
- * The OS-level command dispatch is delegated to a caller-supplied
- * `HostExecutor` so tests + the smoke harness can stub the surface.
- * In production, codegen wires a thin wrapper that shells out to
- * `xdotool` (Linux), `cliclick` (macOS), or PowerShell (Windows).
- */
-import { ComputerUseDriverError, type Driver, type Viewport } from "../index";
-
-export type HostExecutor = {
-  /** Click at absolute screen coordinates. Button: "left" | "right" | "middle". */
-  click(x: number, y: number, button: string): Promise<void>;
-  /** Type a string at the current focus. */
-  type(text: string): Promise<void>;
-  /** Press a single key (or modifier+key, e.g. "cmd+space"). */
-  key(combo: string): Promise<void>;
-  /** Scroll at absolute screen coordinates. */
-  scroll(x: number, y: number, deltaX: number, deltaY: number): Promise<void>;
-  /** Capture a PNG screenshot of the entire screen, returning base64. */
-  screenshot(): Promise<{ pngBase64: string; viewport: Viewport }>;
-  /** Disconnect / clean up any handles. */
-  close?(): Promise<void>;
-};
-
-export type HostBackendOptions = {
-  /** Required to pass; otherwise the constructor throws. */
-  readonly enabled: boolean;
-  /** Test injection (or production OS shim). */
-  readonly executor: HostExecutor;
-};
-
-export function createHostDriver(opts: HostBackendOptions): Driver {
-  if (!opts.enabled) {
-    throw new ComputerUseDriverError(
-      "host backend disabled. Set CREWHAUS_BROW_HOST_ENABLED=1 to opt in (this drives the actual desktop — never enable in smoke tests).",
-    );
-  }
-  let connected = false;
-  return {
-    backend: "host",
-    async connect(): Promise<void> {
-      connected = true;
-    },
-    async goto(_url: string): Promise<void> {
-      // The host backend doesn't navigate URLs — callers should open
-      // a browser app first via the OS shell. We surface this as a
-      // soft-fail since some workflows want goto to be a no-op.
-      throw new ComputerUseDriverError(
-        "host backend cannot navigate URLs directly — open a browser via OS shell first",
-      );
-    },
-    async screenshot(): Promise<Uint8Array> {
-      if (!connected) throw new ComputerUseDriverError("host driver not connected");
-      const { pngBase64 } = await opts.executor.screenshot();
-      return Buffer.from(pngBase64, "base64");
-    },
-    async click(x: number, y: number, button = "left"): Promise<void> {
-      if (!connected) throw new ComputerUseDriverError("host driver not connected");
-      await opts.executor.click(x, y, button);
-    },
-    async type(text: string): Promise<void> {
-      if (!connected) throw new ComputerUseDriverError("host driver not connected");
-      await opts.executor.type(text);
-    },
-    async key(combo: string): Promise<void> {
-      if (!connected) throw new ComputerUseDriverError("host driver not connected");
-      await opts.executor.key(combo);
-    },
-    async scroll(dx: number, dy: number): Promise<void> {
-      if (!connected) throw new ComputerUseDriverError("host driver not connected");
-      // Driver.scroll has no cursor coords; pass (0, 0) for the executor's
-      // anchor and let the host shim scroll at the focused window's origin.
-      await opts.executor.scroll(0, 0, dx, dy);
-    },
-    async getViewport(): Promise<Viewport> {
-      if (!connected) throw new ComputerUseDriverError("host driver not connected");
-      const shot = await opts.executor.screenshot();
-      return shot.viewport;
-    },
-    async disconnect(): Promise<void> {
-      connected = false;
-      await opts.executor.close?.();
-    },
-  };
-}

package/src/backends/remote.ts

@@ -1,127 +0,0 @@
-/**
- * Section 30 — remote backend for `computer-use-driver`. Connects to a
- * remote chromium instance over Chrome DevTools Protocol (browserless.io,
- * BrowserBase, self-hosted DevTools). Same `Driver` surface as the
- * Playwright-backed `chromium` backend; the difference is the connection
- * layer.
- *
- * Production deployments install `puppeteer-core` and pass it as
- * `_puppeteer`. Without it, the constructor returns a driver whose
- * `connect()` throws a clear diagnostic — matching the SQS / Vapi
- * pattern of "abstraction always builds; deployment-time SDK presence
- * gates the operation".
- */
-import { ComputerUseDriverError, type Driver, type Viewport } from "../index";
-
-export type RemoteBackendOptions = {
-  /** Browserless / BrowserBase WebSocket endpoint. */
-  readonly url: string;
-  /** Optional viewport override; defaults to 1280×800. */
-  readonly viewport?: Viewport;
-  /**
-   * Test / production injection: `puppeteer-core` `import` namespace.
-   * When undefined, the driver throws at `connect()` with a hint to
-   * install puppeteer-core.
-   */
-  readonly _puppeteer?: PuppeteerCoreLike;
-};
-
-export type PuppeteerCoreLike = {
-  connect(opts: { browserWSEndpoint: string }): Promise<{
-    newPage(): Promise<{
-      goto(url: string): Promise<void>;
-      screenshot(opts?: { encoding?: "base64" }): Promise<string | Buffer>;
-      mouse: {
-        click(x: number, y: number, opts?: { button?: string }): Promise<void>;
-      };
-      keyboard: {
-        type(text: string): Promise<void>;
-        press(key: string): Promise<void>;
-      };
-      evaluate<T>(fn: () => T): Promise<T>;
-      close(): Promise<void>;
-    }>;
-    close(): Promise<void>;
-  }>;
-};
-
-export function createRemoteDriver(opts: RemoteBackendOptions): Driver {
-  if (!opts.url) throw new ComputerUseDriverError("remote backend requires url");
-  let browser: Awaited<ReturnType<NonNullable<typeof opts._puppeteer>["connect"]>> | undefined;
-  let page: Awaited<ReturnType<NonNullable<typeof browser>["newPage"]>> | undefined;
-  let connected = false;
-
-  function ensure(): NonNullable<typeof page> {
-    if (!page) throw new ComputerUseDriverError("remote driver not connected");
-    return page;
-  }
-
-  return {
-    backend: "remote",
-    async connect(): Promise<void> {
-      const pup = opts._puppeteer;
-      if (!pup) {
-        throw new ComputerUseDriverError(
-          "remote backend requires `puppeteer-core` to be installed and passed as `_puppeteer`. e.g. `import * as pc from 'puppeteer-core'; createDriver({ backend: 'remote', url, _puppeteer: pc })`.",
-        );
-      }
-      browser = await pup.connect({ browserWSEndpoint: opts.url });
-      page = await browser.newPage();
-      connected = true;
-    },
-    async goto(url: string): Promise<void> {
-      await ensure().goto(url);
-    },
-    async screenshot(): Promise<Uint8Array> {
-      const buffer = await ensure().screenshot({ encoding: "base64" });
-      const pngBase64 = typeof buffer === "string" ? buffer : buffer.toString("base64");
-      return Buffer.from(pngBase64, "base64");
-    },
-    async click(x: number, y: number, button = "left"): Promise<void> {
-      await ensure().mouse.click(x, y, { button });
-    },
-    async type(text: string): Promise<void> {
-      await ensure().keyboard.type(text);
-    },
-    async key(combo: string): Promise<void> {
-      await ensure().keyboard.press(combo);
-    },
-    async scroll(dx: number, dy: number): Promise<void> {
-      // Puppeteer doesn't expose mouse.wheel directly; dispatch from the
-      // page context where `window` is defined. The eval-with-args shape
-      // isn't on the local PuppeteerCoreLike type; cast to puppeteer's
-      // actual surface to call it.
-      const pageWithArgs = ensure() as unknown as {
-        evaluate(
-          fn: (d: { dx: number; dy: number }) => void,
-          arg: { dx: number; dy: number },
-        ): Promise<void>;
-      };
-      await pageWithArgs.evaluate(
-        (d: { dx: number; dy: number }) => {
-          (globalThis as unknown as { scrollBy: (dx: number, dy: number) => void }).scrollBy(
-            d.dx,
-            d.dy,
-          );
-        },
-        { dx, dy },
-      );
-    },
-    async getViewport(): Promise<Viewport> {
-      const v = opts.viewport;
-      if (v !== undefined) return v;
-      return { width: 1280, height: 800, devicePixelRatio: 1 };
-    },
-    async disconnect(): Promise<void> {
-      try {
-        if (page) await page.close();
-        if (browser) await browser.close();
-      } catch {
-        /* best-effort */
-      }
-      connected = false;
-      page = undefined;
-      browser = undefined;
-    },
-  };
-}

package/src/chromium-import-fail.test.ts

@@ -1,39 +0,0 @@
-/**
- * Catalog R18 — covers the chromium driver's `loadPlaywright` failure path
- * (the catch arm that rethrows a `ComputerUseDriverError` with an install
- * hint when `import("playwright")` rejects).
- *
- * The failing import is injected via the `_importPlaywright` seam instead of
- * `mock.module("playwright", throwingFactory)`: bun's `mock.module` is
- * process-global, and once "playwright" has been successfully imported
- * anywhere in the test process (chromium.test.ts imports it as a fake), a
- * *throwing* factory is evaluated eagerly and blows up at registration time.
- * Because `bun test` runs every file in one process in nondeterministic
- * order, the module-mock approach worked or exploded depending on which file
- * ran first; the seam is order-independent.
- */
-import { expect, test } from "bun:test";
-import { ComputerUseDriverError, createDriver } from "./index.js";
-
-// Rejects the way a missing optional peer dep does, exercising the same
-// catch arm in `loadPlaywright` as a genuine import failure.
-const failingImport = () => Promise.reject(new Error("Cannot find module 'playwright'"));
-
-test("connect surfaces a clean diagnostic when playwright import fails", async () => {
-  const d = createDriver({ backend: "chromium", _importPlaywright: failingImport });
-  await expect(d.connect()).rejects.toThrow(/Playwright not installed/);
-});
-
-test("the import error is preserved as the error cause", async () => {
-  const d = createDriver({ backend: "chromium", _importPlaywright: failingImport });
-  try {
-    await d.connect();
-    throw new Error("should have thrown");
-  } catch (err) {
-    expect(err).toBeInstanceOf(ComputerUseDriverError);
-    // `cause` is the standard Error.cause carrying the original import error.
-    const cause = (err as { cause?: unknown }).cause;
-    expect(cause).toBeInstanceOf(Error);
-    expect((cause as Error).message).toContain("Cannot find module");
-  }
-});