@crewhaus/tool-mouse-keyboard 0.1.4 → 0.1.5

package/dist/index.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Catalog R4 `tool-mouse-keyboard` — Section 25 BROW.
+ *
+ * Wraps `computer-use-driver` mouse + keyboard methods 1:1 as
+ * registered tools. ALL FOUR are `destructive: true` so the §3
+ * permission-engine refuses to grant `allow` in default mode without
+ * an explicit `alwaysAllow` rule. The smoke's permission-floor probe
+ * exercises this path: same spec WITHOUT alwaysAllow rules → denial
+ * cites the destructive flag + missing rule.
+ *
+ * Tools:
+ *   - `Click(x, y, button?)` — `left | right | middle` click.
+ *   - `Type(text)`           — typed input.
+ *   - `Key(combo)`           — special-key combos ("Enter", "Tab", "Control+a").
+ *   - `Scroll(dx, dy)`       — wheel scroll in pixels.
+ */
+import type { Driver } from "@crewhaus/computer-use-driver";
+import { CrewhausError } from "@crewhaus/errors";
+import type { RegisteredTool } from "@crewhaus/tool-catalog";
+export declare class MouseKeyboardError extends CrewhausError {
+    readonly name = "MouseKeyboardError";
+    constructor(message: string, cause?: unknown);
+}
+export type CreateMouseKeyboardToolsOptions = {
+    readonly driver: Driver;
+};
+export declare function createClickTool(opts: CreateMouseKeyboardToolsOptions): RegisteredTool;
+export declare function createTypeTool(opts: CreateMouseKeyboardToolsOptions): RegisteredTool;
+export declare function createKeyTool(opts: CreateMouseKeyboardToolsOptions): RegisteredTool;
+export declare function createScrollTool(opts: CreateMouseKeyboardToolsOptions): RegisteredTool;
+export declare function createAllMouseKeyboardTools(opts: CreateMouseKeyboardToolsOptions): {
+    click: RegisteredTool;
+    type: RegisteredTool;
+    key: RegisteredTool;
+    scroll: RegisteredTool;
+};

package/dist/index.js

@@ -0,0 +1,120 @@
+import { CrewhausError } from "@crewhaus/errors";
+import { buildTool } from "@crewhaus/tool-builder";
+import { z } from "zod";
+export class MouseKeyboardError extends CrewhausError {
+    name = "MouseKeyboardError";
+    constructor(message, cause) {
+        super("tool", message, cause);
+    }
+}
+const clickSchema = z
+    .object({
+    x: z.number().int().min(0),
+    y: z.number().int().min(0),
+    button: z.enum(["left", "right", "middle"]).optional(),
+})
+    .strict();
+const typeSchema = z.object({ text: z.string() }).strict();
+const keySchema = z
+    .object({
+    combo: z
+        .string()
+        .min(1)
+        .describe("Single key or combo, e.g. 'Enter', 'Tab', 'Control+a'. Uses Playwright's key naming."),
+})
+    .strict();
+const scrollSchema = z
+    .object({
+    dx: z.number().int(),
+    dy: z.number().int(),
+})
+    .strict();
+export function createClickTool(opts) {
+    return buildTool({
+        name: "Click",
+        description: "Click at viewport pixel coordinates (x, y). Defaults to left button. Use FindElement(description) to get coordinates from a natural-language target. DESTRUCTIVE: requires explicit alwaysAllow rule.",
+        inputSchema: clickSchema,
+        readOnly: false,
+        destructive: true,
+        concurrencySafe: false,
+        classifyOutput: false,
+        execute: async (input) => {
+            const button = input.button ?? "left";
+            try {
+                await opts.driver.click(input.x, input.y, button);
+            }
+            catch (err) {
+                return `[Click error] ${err.message ?? String(err)}`;
+            }
+            return `Clicked ${button} at (${input.x}, ${input.y}).`;
+        },
+    });
+}
+export function createTypeTool(opts) {
+    return buildTool({
+        name: "Type",
+        description: "Type text at the focused input. Click an input first to focus it. DESTRUCTIVE: requires explicit alwaysAllow rule.",
+        inputSchema: typeSchema,
+        readOnly: false,
+        destructive: true,
+        concurrencySafe: false,
+        classifyOutput: false,
+        execute: async (input) => {
+            try {
+                await opts.driver.type(input.text);
+            }
+            catch (err) {
+                return `[Type error] ${err.message ?? String(err)}`;
+            }
+            return `Typed ${input.text.length} chars.`;
+        },
+    });
+}
+export function createKeyTool(opts) {
+    return buildTool({
+        name: "Key",
+        description: "Press a single key or combo (e.g. 'Enter', 'Tab', 'Control+a'). Uses Playwright's key naming. DESTRUCTIVE: requires explicit alwaysAllow rule.",
+        inputSchema: keySchema,
+        readOnly: false,
+        destructive: true,
+        concurrencySafe: false,
+        classifyOutput: false,
+        execute: async (input) => {
+            try {
+                await opts.driver.key(input.combo);
+            }
+            catch (err) {
+                return `[Key error] ${err.message ?? String(err)}`;
+            }
+            return `Pressed ${input.combo}.`;
+        },
+    });
+}
+export function createScrollTool(opts) {
+    return buildTool({
+        name: "Scroll",
+        description: "Scroll by pixel deltas. Positive dy scrolls down. DESTRUCTIVE: requires explicit alwaysAllow rule.",
+        inputSchema: scrollSchema,
+        readOnly: false,
+        destructive: true,
+        concurrencySafe: false,
+        classifyOutput: false,
+        execute: async (input) => {
+            try {
+                await opts.driver.scroll(input.dx, input.dy);
+            }
+            catch (err) {
+                return `[Scroll error] ${err.message ?? String(err)}`;
+            }
+            return `Scrolled (${input.dx}, ${input.dy}).`;
+        },
+    });
+}
+export function createAllMouseKeyboardTools(opts) {
+    return {
+        click: createClickTool(opts),
+        type: createTypeTool(opts),
+        key: createKeyTool(opts),
+        scroll: createScrollTool(opts),
+    };
+}

package/package.json

@@ -1,21 +1,24 @@
 {
   "name": "@crewhaus/tool-mouse-keyboard",
-  "version": "0.1.4",
+  "version": "0.1.5",
   "type": "module",
   "description": "Click / Type / Key / Scroll tools — destructive: true (Section 25 BROW)",
-  "main": "src/index.ts",
-  "types": "src/index.ts",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
   "exports": {
-    ".": "./src/index.ts"
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
   },
   "scripts": {
     "test": "bun test src"
   },
   "dependencies": {
-    "@crewhaus/computer-use-driver": "0.1.4",
-    "@crewhaus/errors": "0.1.4",
-    "@crewhaus/tool-builder": "0.1.4",
-    "@crewhaus/tool-catalog": "0.1.4",
+    "@crewhaus/computer-use-driver": "0.1.5",
+    "@crewhaus/errors": "0.1.5",
+    "@crewhaus/tool-builder": "0.1.5",
+    "@crewhaus/tool-catalog": "0.1.5",
     "zod": "^3.23.8"
   },
   "license": "Apache-2.0",
@@ -36,5 +39,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "files": ["src", "README.md", "LICENSE", "NOTICE"]
+  "files": ["dist", "README.md", "LICENSE", "NOTICE"]
 }

package/src/index.test.ts

@@ -1,210 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import type { Driver } from "@crewhaus/computer-use-driver";
-import {
-  MouseKeyboardError,
-  createAllMouseKeyboardTools,
-  createClickTool,
-  createKeyTool,
-  createScrollTool,
-  createTypeTool,
-} from "./index.js";
-
-function recordingDriver(): { driver: Driver; calls: string[] } {
-  const calls: string[] = [];
-  const driver: Driver = {
-    backend: "chromium",
-    async connect() {},
-    async goto() {},
-    async screenshot() {
-      return new Uint8Array();
-    },
-    async click(x, y, button = "left") {
-      calls.push(`click ${button} ${x} ${y}`);
-    },
-    async type(text) {
-      calls.push(`type ${text}`);
-    },
-    async key(combo) {
-      calls.push(`key ${combo}`);
-    },
-    async scroll(dx, dy) {
-      calls.push(`scroll ${dx} ${dy}`);
-    },
-    async getViewport() {
-      return { width: 800, height: 600, devicePixelRatio: 1 };
-    },
-    async disconnect() {},
-  };
-  return { driver, calls };
-}
-
-// A driver whose single named method rejects; all others are inert no-ops.
-// Lets each tool's error-catch branch be exercised in isolation.
-function throwingDriver(method: "click" | "type" | "key" | "scroll", message: string): Driver {
-  const base: Driver = {
-    backend: "chromium",
-    async connect() {},
-    async goto() {},
-    async screenshot() {
-      return new Uint8Array();
-    },
-    async click() {},
-    async type() {},
-    async key() {},
-    async scroll() {},
-    async getViewport() {
-      return { width: 0, height: 0, devicePixelRatio: 1 };
-    },
-    async disconnect() {},
-  };
-  return {
-    ...base,
-    [method]: async () => {
-      throw new Error(message);
-    },
-  };
-}
-
-describe("Mouse + keyboard tools (T1 wrapping)", () => {
-  test("Click forwards (x, y, button) to driver.click", async () => {
-    const { driver, calls } = recordingDriver();
-    const tool = createClickTool({ driver });
-    const r = await tool.execute({ x: 100, y: 200, button: "left" }, {});
-    expect(calls).toEqual(["click left 100 200"]);
-    expect(typeof r === "string" && r.includes("Clicked left at (100, 200)")).toBe(true);
-  });
-
-  test("Click default button is left", async () => {
-    const { driver, calls } = recordingDriver();
-    const tool = createClickTool({ driver });
-    await tool.execute({ x: 1, y: 2 }, {});
-    expect(calls).toEqual(["click left 1 2"]);
-  });
-
-  test("Type forwards text", async () => {
-    const { driver, calls } = recordingDriver();
-    const tool = createTypeTool({ driver });
-    await tool.execute({ text: "hello" }, {});
-    expect(calls).toEqual(["type hello"]);
-  });
-
-  test("Key forwards combo", async () => {
-    const { driver, calls } = recordingDriver();
-    const tool = createKeyTool({ driver });
-    await tool.execute({ combo: "Enter" }, {});
-    expect(calls).toEqual(["key Enter"]);
-  });
-
-  test("Scroll forwards dx/dy", async () => {
-    const { driver, calls } = recordingDriver();
-    const tool = createScrollTool({ driver });
-    await tool.execute({ dx: 0, dy: 100 }, {});
-    expect(calls).toEqual(["scroll 0 100"]);
-  });
-
-  test("All four tools are destructive: true (T8 — permission floor)", () => {
-    const { driver } = recordingDriver();
-    const tools = createAllMouseKeyboardTools({ driver });
-    expect(tools.click.destructive).toBe(true);
-    expect(tools.type.destructive).toBe(true);
-    expect(tools.key.destructive).toBe(true);
-    expect(tools.scroll.destructive).toBe(true);
-  });
-
-  test("createAllMouseKeyboardTools returns the four named tools", () => {
-    const { driver } = recordingDriver();
-    const tools = createAllMouseKeyboardTools({ driver });
-    expect(tools.click.name).toBe("Click");
-    expect(tools.type.name).toBe("Type");
-    expect(tools.key.name).toBe("Key");
-    expect(tools.scroll.name).toBe("Scroll");
-  });
-
-  test("driver errors are surfaced as tool result strings (not thrown)", async () => {
-    const driver: Driver = {
-      backend: "chromium",
-      async connect() {},
-      async goto() {},
-      async screenshot() {
-        return new Uint8Array();
-      },
-      async click() {
-        throw new Error("driver explosion");
-      },
-      async type() {},
-      async key() {},
-      async scroll() {},
-      async getViewport() {
-        return { width: 0, height: 0, devicePixelRatio: 1 };
-      },
-      async disconnect() {},
-    };
-    const tool = createClickTool({ driver });
-    const r = await tool.execute({ x: 1, y: 1 }, {});
-    expect(typeof r === "string" && r.includes("[Click error]")).toBe(true);
-  });
-
-  test("Type driver errors are surfaced as a [Type error] result string", async () => {
-    const driver = throwingDriver("type", "type blew up");
-    const tool = createTypeTool({ driver });
-    const r = await tool.execute({ text: "hi" }, {});
-    expect(typeof r === "string" && r.includes("[Type error] type blew up")).toBe(true);
-  });
-
-  test("Key driver errors are surfaced as a [Key error] result string", async () => {
-    const driver = throwingDriver("key", "key blew up");
-    const tool = createKeyTool({ driver });
-    const r = await tool.execute({ combo: "Enter" }, {});
-    expect(typeof r === "string" && r.includes("[Key error] key blew up")).toBe(true);
-  });
-
-  test("Scroll driver errors are surfaced as a [Scroll error] result string", async () => {
-    const driver = throwingDriver("scroll", "scroll blew up");
-    const tool = createScrollTool({ driver });
-    const r = await tool.execute({ dx: 0, dy: 10 }, {});
-    expect(typeof r === "string" && r.includes("[Scroll error] scroll blew up")).toBe(true);
-  });
-
-  test("non-Error throw still yields a result string (String(err) fallback)", async () => {
-    // err.message is undefined → falls through to String(err).
-    const driver: Driver = {
-      backend: "chromium",
-      async connect() {},
-      async goto() {},
-      async screenshot() {
-        return new Uint8Array();
-      },
-      async click() {
-        throw "raw string failure";
-      },
-      async type() {},
-      async key() {},
-      async scroll() {},
-      async getViewport() {
-        return { width: 0, height: 0, devicePixelRatio: 1 };
-      },
-      async disconnect() {},
-    };
-    const tool = createClickTool({ driver });
-    const r = await tool.execute({ x: 1, y: 1 }, {});
-    expect(typeof r === "string" && r.includes("[Click error] raw string failure")).toBe(true);
-  });
-});
-
-describe("MouseKeyboardError", () => {
-  test("constructs with the 'tool' error code and a stable name", () => {
-    const err = new MouseKeyboardError("input device unavailable");
-    expect(err).toBeInstanceOf(Error);
-    expect(err.name).toBe("MouseKeyboardError");
-    expect(err.message).toBe("input device unavailable");
-    expect(err.code).toBe("tool");
-    expect(err.cause).toBeUndefined();
-  });
-
-  test("threads an underlying cause through to the base error", () => {
-    const root = new Error("driver socket closed");
-    const err = new MouseKeyboardError("scroll failed", root);
-    expect(err.cause).toBe(root);
-    expect(err.code).toBe("tool");
-  });
-});

package/src/index.ts

@@ -1,159 +0,0 @@
-/**
- * Catalog R4 `tool-mouse-keyboard` — Section 25 BROW.
- *
- * Wraps `computer-use-driver` mouse + keyboard methods 1:1 as
- * registered tools. ALL FOUR are `destructive: true` so the §3
- * permission-engine refuses to grant `allow` in default mode without
- * an explicit `alwaysAllow` rule. The smoke's permission-floor probe
- * exercises this path: same spec WITHOUT alwaysAllow rules → denial
- * cites the destructive flag + missing rule.
- *
- * Tools:
- *   - `Click(x, y, button?)` — `left | right | middle` click.
- *   - `Type(text)`           — typed input.
- *   - `Key(combo)`           — special-key combos ("Enter", "Tab", "Control+a").
- *   - `Scroll(dx, dy)`       — wheel scroll in pixels.
- */
-import type { Driver, MouseButton } from "@crewhaus/computer-use-driver";
-import { CrewhausError } from "@crewhaus/errors";
-import { buildTool } from "@crewhaus/tool-builder";
-import type { RegisteredTool } from "@crewhaus/tool-catalog";
-import { z } from "zod";
-
-export class MouseKeyboardError extends CrewhausError {
-  override readonly name = "MouseKeyboardError";
-  constructor(message: string, cause?: unknown) {
-    super("tool", message, cause);
-  }
-}
-
-export type CreateMouseKeyboardToolsOptions = {
-  readonly driver: Driver;
-};
-
-const clickSchema = z
-  .object({
-    x: z.number().int().min(0),
-    y: z.number().int().min(0),
-    button: z.enum(["left", "right", "middle"]).optional(),
-  })
-  .strict();
-
-const typeSchema = z.object({ text: z.string() }).strict();
-
-const keySchema = z
-  .object({
-    combo: z
-      .string()
-      .min(1)
-      .describe(
-        "Single key or combo, e.g. 'Enter', 'Tab', 'Control+a'. Uses Playwright's key naming.",
-      ),
-  })
-  .strict();
-
-const scrollSchema = z
-  .object({
-    dx: z.number().int(),
-    dy: z.number().int(),
-  })
-  .strict();
-
-export function createClickTool(opts: CreateMouseKeyboardToolsOptions): RegisteredTool {
-  return buildTool({
-    name: "Click",
-    description:
-      "Click at viewport pixel coordinates (x, y). Defaults to left button. Use FindElement(description) to get coordinates from a natural-language target. DESTRUCTIVE: requires explicit alwaysAllow rule.",
-    inputSchema: clickSchema,
-    readOnly: false,
-    destructive: true,
-    concurrencySafe: false,
-    classifyOutput: false,
-    execute: async (input) => {
-      const button: MouseButton = input.button ?? "left";
-      try {
-        await opts.driver.click(input.x, input.y, button);
-      } catch (err) {
-        return `[Click error] ${(err as Error).message ?? String(err)}`;
-      }
-      return `Clicked ${button} at (${input.x}, ${input.y}).`;
-    },
-  });
-}
-
-export function createTypeTool(opts: CreateMouseKeyboardToolsOptions): RegisteredTool {
-  return buildTool({
-    name: "Type",
-    description:
-      "Type text at the focused input. Click an input first to focus it. DESTRUCTIVE: requires explicit alwaysAllow rule.",
-    inputSchema: typeSchema,
-    readOnly: false,
-    destructive: true,
-    concurrencySafe: false,
-    classifyOutput: false,
-    execute: async (input) => {
-      try {
-        await opts.driver.type(input.text);
-      } catch (err) {
-        return `[Type error] ${(err as Error).message ?? String(err)}`;
-      }
-      return `Typed ${input.text.length} chars.`;
-    },
-  });
-}
-
-export function createKeyTool(opts: CreateMouseKeyboardToolsOptions): RegisteredTool {
-  return buildTool({
-    name: "Key",
-    description:
-      "Press a single key or combo (e.g. 'Enter', 'Tab', 'Control+a'). Uses Playwright's key naming. DESTRUCTIVE: requires explicit alwaysAllow rule.",
-    inputSchema: keySchema,
-    readOnly: false,
-    destructive: true,
-    concurrencySafe: false,
-    classifyOutput: false,
-    execute: async (input) => {
-      try {
-        await opts.driver.key(input.combo);
-      } catch (err) {
-        return `[Key error] ${(err as Error).message ?? String(err)}`;
-      }
-      return `Pressed ${input.combo}.`;
-    },
-  });
-}
-
-export function createScrollTool(opts: CreateMouseKeyboardToolsOptions): RegisteredTool {
-  return buildTool({
-    name: "Scroll",
-    description:
-      "Scroll by pixel deltas. Positive dy scrolls down. DESTRUCTIVE: requires explicit alwaysAllow rule.",
-    inputSchema: scrollSchema,
-    readOnly: false,
-    destructive: true,
-    concurrencySafe: false,
-    classifyOutput: false,
-    execute: async (input) => {
-      try {
-        await opts.driver.scroll(input.dx, input.dy);
-      } catch (err) {
-        return `[Scroll error] ${(err as Error).message ?? String(err)}`;
-      }
-      return `Scrolled (${input.dx}, ${input.dy}).`;
-    },
-  });
-}
-
-export function createAllMouseKeyboardTools(opts: CreateMouseKeyboardToolsOptions): {
-  click: RegisteredTool;
-  type: RegisteredTool;
-  key: RegisteredTool;
-  scroll: RegisteredTool;
-} {
-  return {
-    click: createClickTool(opts),
-    type: createTypeTool(opts),
-    key: createKeyTool(opts),
-    scroll: createScrollTool(opts),
-  };
-}