diff --git a/packages/bot-cli/bin/bot.ts b/packages/bot-cli/bin/bot.ts
new file mode 100755
index 0000000..7bc2395
--- /dev/null
+++ b/packages/bot-cli/bin/bot.ts
@@ -0,0 +1,9 @@
+#!/usr/bin/env node
+
+/**
+ * CLI entry point
+ */
+
+import { program } from "../src/index.js";
+
+program.parse(process.argv);
diff --git a/packages/bot-cli/package.json b/packages/bot-cli/package.json
new file mode 100644
index 0000000..bc3c0fc
--- /dev/null
+++ b/packages/bot-cli/package.json
@@ -0,0 +1,61 @@
+{
+  "name": "@tego/bot-cli",
+  "version": "0.2.2",
+  "description": "CLI wrapper for @tego/botjs",
+  "type": "module",
+  "bin": {
+    "bot": "./dist/bin/bot.mjs"
+  },
+  "main": "./dist/src/index.js",
+  "types": "./dist/src/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/src/index.js",
+      "types": "./dist/src/index.d.ts"
+    }
+  },
+  "scripts": {
+    "build": "tsdown",
+    "dev": "tsdown --watch",
+    "gen:api": "tsx ./tools/gen-api.ts",
+    "gen:commands": "tsx ./tools/gen-commands.ts",
+    "gen": "pnpm gen:api && pnpm gen:commands",
+    "test": "vitest run",
+    "test:watch": "vitest"
+  },
+  "dependencies": {
+    "@tego/botjs": "workspace:*",
+    "commander": "^13.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "^24.5.2",
+    "ts-morph": "^27.0.0",
+    "tsdown": "^0.16.6",
+    "tsx": "^4.20.6",
+    "typescript": "^5.9.2",
+    "vitest": "^4.0.9"
+  },
+  "files": [
+    "dist",
+    "readme.md",
+    "package.json"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/tegojs/bot.git",
+    "directory": "packages/bot-cli"
+  },
+  "homepage": "https://github.com/tegojs/bot#readme",
+  "bugs": {
+    "url": "https://github.com/tegojs/bot/issues"
+  },
+  "license": "MIT",
+  "author": {
+    "name": "sealday",
+    "email": "sealday@gmail.com",
+    "url": "https://github.com/sealday"
+  },
+  "engines": {
+    "node": ">= 20"
+  }
+}
diff --git a/packages/bot-cli/readme.md b/packages/bot-cli/readme.md
new file mode 100644
index 0000000..7973c46
--- /dev/null
+++ b/packages/bot-cli/readme.md
@@ -0,0 +1,53 @@
+# @tego/bot-cli
+
+CLI wrapper for @tego/botjs.
+
+## Installation
+
+```bash
+# Install in the workspace
+pnpm install
+
+# Build the package
+pnpm --filter @tego/bot-cli build
+```
+
+## Usage
+
+### Generic invocation
+
+```bash
+bot call moveMouse --json '[100,200]'
+bot call mouseClick --json '["left", true]'
+bot call captureScreen --json '[]' --out screenshot.png
+```
+
+### Args input modes
+
+```bash
+bot call moveMouse --file args.json
+bot call moveMouse --stdin
+```
+
+### Dry-run validation
+
+```bash
+bot call moveMouse --json '[100,200]' --dry-run
+```
+
+### Doctor command
+
+```bash
+bot doctor
+bot doctor --json-output
+```
+
+## Output
+
+- Default output is human-readable.
+- Use `--json` to emit machine JSON output.
+- For Buffer results, use `--out` to write to file.
+
+## License
+
+MIT
diff --git a/packages/bot-cli/src/commands/call.ts b/packages/bot-cli/src/commands/call.ts
new file mode 100644
index 0000000..ba7f7be
--- /dev/null
+++ b/packages/bot-cli/src/commands/call.ts
@@ -0,0 +1,52 @@
+import * as fs from "node:fs/promises";
+import { stdin as stdinStream } from "node:process";
+import { invokeExport } from "./invoke.js";
+
+export interface CallOptions {
+  json?: string;
+  file?: string;
+  stdin?: boolean;
+  out?: string;
+  jsonOutput?: boolean;
+  validate?: boolean;
+  dryRun?: boolean;
+}
+
+async function readStdin(): Promise<string> {
+  const chunks: Buffer[] = [];
+  for await (const chunk of stdinStream) {
+    chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+  }
+  return Buffer.concat(chunks).toString("utf8");
+}
+
+async function loadArgs(options: CallOptions): Promise<unknown> {
+  if (options.json) {
+    return JSON.parse(options.json);
+  }
+  if (options.file) {
+    const contents = await fs.readFile(options.file, "utf8");
+    return JSON.parse(contents);
+  }
+  if (options.stdin) {
+    const contents = await readStdin();
+    return JSON.parse(contents);
+  }
+  return [];
+}
+
+export async function callCommand(
+  exportName: string,
+  options: CallOptions,
+): Promise<void> {
+  const args = await loadArgs(options);
+  const normalizedArgs = Array.isArray(args) ? args : [args];
+  if (options.dryRun) {
+    await invokeExport(exportName, normalizedArgs, {
+      ...options,
+      out: undefined,
+    });
+    return;
+  }
+  await invokeExport(exportName, normalizedArgs, options);
+}
diff --git a/packages/bot-cli/src/commands/doctor.test.ts b/packages/bot-cli/src/commands/doctor.test.ts
new file mode 100644
index 0000000..2668c16
--- /dev/null
+++ b/packages/bot-cli/src/commands/doctor.test.ts
@@ -0,0 +1,20 @@
+import { describe, expect, it, vi } from "vitest";
+import { doctorCommand } from "./doctor.js";
+
+describe("doctorCommand", () => {
+  it("prints messages for macOS", async () => {
+    const platformSpy = vi
+      .spyOn(process, "platform", "get")
+      .mockReturnValue("darwin");
+    const writeSpy = vi
+      .spyOn(process.stdout, "write")
+      .mockImplementation(() => true);
+
+    await doctorCommand(true);
+
+    const output = writeSpy.mock.calls.map((call) => call[0]).join("");
+    expect(output).toContain("Screen Recording");
+    platformSpy.mockRestore();
+    writeSpy.mockRestore();
+  });
+});
diff --git a/packages/bot-cli/src/commands/doctor.ts b/packages/bot-cli/src/commands/doctor.ts
new file mode 100644
index 0000000..aa01bbe
--- /dev/null
+++ b/packages/bot-cli/src/commands/doctor.ts
@@ -0,0 +1,40 @@
+import { platform } from "node:os";
+
+interface DoctorResult {
+  ok: boolean;
+  platform: string;
+  messages: string[];
+}
+
+export async function doctorCommand(jsonOutput: boolean): Promise<void> {
+  const result: DoctorResult = {
+    ok: true,
+    platform: platform(),
+    messages: [],
+  };
+
+  if (result.platform === "darwin") {
+    result.messages.push(
+      "macOS permissions: ensure Screen Recording access is granted (System Settings > Privacy & Security > Screen Recording).",
+    );
+  } else if (result.platform === "win32") {
+    result.messages.push(
+      "Windows: no additional permissions typically required.",
+    );
+  } else if (result.platform === "linux") {
+    result.messages.push(
+      "Linux: ensure a display server is available (X11/Wayland).",
+    );
+  } else {
+    result.messages.push(`Platform '${result.platform}' is untested.`);
+  }
+
+  if (jsonOutput) {
+    process.stdout.write(`${JSON.stringify(result)}\n`);
+    return;
+  }
+
+  for (const message of result.messages) {
+    process.stdout.write(`${message}\n`);
+  }
+}
diff --git a/packages/bot-cli/src/commands/invoke.ts b/packages/bot-cli/src/commands/invoke.ts
new file mode 100644
index 0000000..f79a9a3
--- /dev/null
+++ b/packages/bot-cli/src/commands/invoke.ts
@@ -0,0 +1,151 @@
+import * as fs from "node:fs/promises";
+import * as bot from "@tego/botjs";
+import { validateArgs } from "./validate.js";
+
+export interface InvokeOptions {
+  out?: string;
+  jsonOutput?: boolean;
+  validate?: boolean;
+  dryRun?: boolean;
+}
+
+function isBuffer(value: unknown): value is Buffer {
+  return Buffer.isBuffer(value);
+}
+
+function extractBufferField(
+  value: unknown,
+): { buffer: Buffer; remaining?: Record<string, unknown> } | null {
+  if (!value || typeof value !== "object") {
+    return null;
+  }
+  const record = value as Record<string, unknown>;
+  if (isBuffer(record.image)) {
+    const { image, ...rest } = record;
+    return { buffer: image, remaining: rest };
+  }
+  if (isBuffer(record.buffer)) {
+    const { buffer, ...rest } = record;
+    return { buffer, remaining: rest };
+  }
+  return null;
+}
+
+function isPromise<T>(value: T | Promise<T>): value is Promise<T> {
+  return Boolean(value) && typeof (value as Promise<T>).then === "function";
+}
+
+async function writeResult(
+  result: unknown,
+  options: InvokeOptions,
+): Promise<void> {
+  if (isBuffer(result)) {
+    if (!options.out) {
+      throw new Error("Buffer result requires --out <path> to write file.");
+    }
+    await fs.writeFile(options.out, result);
+    if (options.jsonOutput) {
+      process.stdout.write(
+        JSON.stringify({ out: options.out, bytes: result.length }),
+      );
+    } else {
+      process.stdout.write(`Wrote ${result.length} bytes to ${options.out}\n`);
+    }
+    return;
+  }
+
+  const extracted = extractBufferField(result);
+  if (options.out) {
+    if (!extracted) {
+      throw new Error(
+        "--out was provided but result did not contain a Buffer.",
+      );
+    }
+    await fs.writeFile(options.out, extracted.buffer);
+    if (options.jsonOutput) {
+      const payload = {
+        out: options.out,
+        bytes: extracted.buffer.length,
+        ...(extracted.remaining && Object.keys(extracted.remaining).length > 0
+          ? { result: extracted.remaining }
+          : {}),
+      };
+      process.stdout.write(`${JSON.stringify(payload)}\n`);
+    } else {
+      process.stdout.write(
+        `Wrote ${extracted.buffer.length} bytes to ${options.out}\n`,
+      );
+    }
+    return;
+  }
+
+  if (options.jsonOutput) {
+    process.stdout.write(`${JSON.stringify(result)}\n`);
+    return;
+  }
+
+  if (typeof result === "undefined") {
+    process.stdout.write("OK\n");
+    return;
+  }
+
+  if (typeof result === "string") {
+    process.stdout.write(`${result}\n`);
+    return;
+  }
+
+  process.stdout.write(`${JSON.stringify(result, null, 2)}\n`);
+}
+
+export async function invokeExport(
+  exportName: string,
+  args: unknown[],
+  options: InvokeOptions,
+): Promise<void> {
+  const fn = (bot as Record<string, unknown>)[exportName];
+  if (typeof fn !== "function") {
+    const names = Object.keys(bot).sort();
+    const matches = names.filter((name) =>
+      name.toLowerCase().includes(exportName.toLowerCase()),
+    );
+    const suffix =
+      matches.length > 0 ? `\nClosest matches: ${matches.join(", ")}` : "";
+    throw new Error(`Export '${exportName}' is not a function.${suffix}`);
+  }
+
+  const minArgs = fn.length;
+  const shouldValidate = options.validate !== false;
+  await validateArgs(exportName, args, shouldValidate);
+  if (
+    shouldValidate &&
+    args.length === 1 &&
+    args[0] &&
+    typeof args[0] === "object" &&
+    !Array.isArray(args[0]) &&
+    minArgs > 1
+  ) {
+    throw new Error(
+      `Argument for '${exportName}' should be an array when calling functions with ${minArgs} parameters.`,
+    );
+  }
+
+  if (options.dryRun) {
+    if (options.jsonOutput) {
+      process.stdout.write(
+        `${JSON.stringify({ ok: true, exportName, args, dryRun: true })}\n`,
+      );
+    } else {
+      process.stdout.write(`OK (dry-run): ${exportName}\n`);
+    }
+    return;
+  }
+
+  let result: unknown;
+  result = (fn as (...values: unknown[]) => unknown)(...args);
+
+  if (isPromise(result)) {
+    result = await result;
+  }
+
+  await writeResult(result, options);
+}
diff --git a/packages/bot-cli/src/commands/validate.ts b/packages/bot-cli/src/commands/validate.ts
new file mode 100644
index 0000000..a82a529
--- /dev/null
+++ b/packages/bot-cli/src/commands/validate.ts
@@ -0,0 +1,46 @@
+import { readFile } from "node:fs/promises";
+import { resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+
+export interface ApiSpec {
+  exports: Array<{
+    name: string;
+    kind: string;
+    params?: Array<{ name: string; optional?: boolean }>;
+  }>;
+}
+
+const scriptDir = resolve(dirname(fileURLToPath(import.meta.url)), "..");
+const apiPath = resolve(scriptDir, "../../botjs/generated/api.json");
+
+let cachedSpec: ApiSpec | null = null;
+
+async function loadApiSpec(): Promise<ApiSpec> {
+  if (cachedSpec) return cachedSpec;
+  const raw = await readFile(apiPath, "utf8");
+  cachedSpec = JSON.parse(raw) as ApiSpec;
+  return cachedSpec;
+}
+
+export async function validateArgs(
+  exportName: string,
+  args: unknown[],
+  validate: boolean,
+): Promise<void> {
+  if (!validate) return;
+  const spec = await loadApiSpec();
+  const entry = spec.exports.find((item) => item.name === exportName);
+  if (!entry || entry.kind !== "function") return;
+  const requiredCount = (entry.params ?? []).filter(
+    (param) => !param.optional,
+  ).length;
+  if (args.length < requiredCount) {
+    throw new Error(
+      `Expected at least ${requiredCount} argument(s) for '${exportName}', received ${args.length}.`,
+    );
+  }
+}
+
+function dirname(path: string): string {
+  return path.slice(0, Math.max(0, path.lastIndexOf("/")));
+}
diff --git a/packages/bot-cli/src/generated/commands.ts b/packages/bot-cli/src/generated/commands.ts
new file mode 100644
index 0000000..6ffccce
--- /dev/null
+++ b/packages/bot-cli/src/generated/commands.ts
@@ -0,0 +1,806 @@
+// Generated file. Do not edit manually.
+import type { Command } from "commander";
+import { invokeExport } from "../commands/invoke.js";
+
+const BOOL_TRUE = new Set(["true", "1", "yes", "y", "on"]);
+const BOOL_FALSE = new Set(["false", "0", "no", "n", "off"]);
+function parseArg(value: string): unknown {
+  try {
+    return JSON.parse(value);
+  } catch {
+    if (/^0x[0-9a-f]+$/i.test(value)) {
+      return Number.parseInt(value, 16);
+    }
+    const lower = value.toLowerCase();
+    if (BOOL_TRUE.has(lower)) return true;
+    if (BOOL_FALSE.has(lower)) return false;
+    if (/^-?\\d+(?:\\.\\d+)?$/.test(value)) {
+      return Number(value);
+    }
+    return value;
+  }
+}
+
+export function registerGeneratedCommands(program: Command): void {
+  program
+    .command("moveMouse")
+    .description("Call @tego/botjs moveMouse")
+    .argument("<x>", "x")
+    .argument("<y>", "y")
+    .option("--out <path>", "Write Buffer result to file")
+    .option("--json-output", "Emit result as JSON")
+    .option("--no-validate", "Disable arg shape validation")
+    .option("--dry-run", "Validate args without invoking")
+    .action(async (x, y, options) => {
+      const args = [x, y].map((value) => parseArg(String(value)));
+      await invokeExport("moveMouse", args, options);
+    });
+
+  program
+    .command("moveMouseSmooth")
+    .description("Call @tego/botjs moveMouseSmooth")
+    .argument("<x>", "x")
+    .argument("<y>", "y")
+    .argument("<speed>", "speed")
+    .option("--out <path>", "Write Buffer result to file")
+    .option("--json-output", "Emit result as JSON")
+    .option("--no-validate", "Disable arg shape validation")
+    .option("--dry-run", "Validate args without invoking")
+    .action(async (x, y, speed, options) => {
+      const args = [x, y, speed].map((value) => parseArg(String(value)));
+      await invokeExport("moveMouseSmooth", args, options);
+    });
+
+  program
+    .command("mouseClick")
+    .description("Call @tego/botjs mouseClick")
+    .argument("<button>", "button")
+    .argument("<double>", "double")
+    .option("--out <path>", "Write Buffer result to file")
+    .option("--json-output", "Emit result as JSON")
+    .option("--no-validate", "Disable arg shape validation")
+    .option("--dry-run", "Validate args without invoking")
+    .action(async (button, double, options) => {
+      const args = [button, double].map((value) => parseArg(String(value)));
+      await invokeExport("mouseClick", args, options);
+    });
+
+  program
+    .command("mouseToggle")
+    .description("Call @tego/botjs mouseToggle")
+    .argument("<down>", "down")
+    .argument("<button>", "button")
+    .option("--out <path>", "Write Buffer result to file")
+    .option("--json-output", "Emit result as JSON")
+    .option("--no-validate", "Disable arg shape validation")
+    .option("--dry-run", "Validate args without invoking")
+    .action(async (down, button, options) => {
+      const args = [down, button].map((value) => parseArg(String(value)));
+      await invokeExport("mouseToggle", args, options);
+    });
+
+  program
+    .command("dragMouse")
+    .description("Call @tego/botjs dragMouse")
+    .argument("<x>", "x")
+    .argument("<y>", "y")
+    .option("--out <path>", "Write Buffer result to file")
+    .option("--json-output", "Emit result as JSON")
+    .option("--no-validate", "Disable arg shape validation")
+    .option("--dry-run", "Validate args without invoking")
+    .action(async (x, y, options) => {
+      const args = [x, y].map((value) => parseArg(String(value)));
+      await invokeExport("dragMouse", args, options);
+    });
+
+  program
+    .command("scrollMouse")
+    .description("Call @tego/botjs scrollMouse")
+    .argument("<x>", "x")
+    .argument("<y>", "y")
+    .option("--out <path>", "Write Buffer result to file")
+    .option("--json-output", "Emit result as JSON")
+    .option("--no-validate", "Disable arg shape validation")
+    .option("--dry-run", "Validate args without invoking")
+    .action(async (x, y, options) => {
+      const args = [x, y].map((value) => parseArg(String(value)));
+      await invokeExport("scrollMouse", args, options);
+    });
+
+  program
+    .command("getMousePos")
+    .description("Call @tego/botjs getMousePos")
+    .option("--out <path>", "Write Buffer result to file")
+    .option("--json-output", "Emit result as JSON")
+    .option("--no-validate", "Disable arg shape validation")
+    .option("--dry-run", "Validate args without invoking")
+    .action(async (options) => {
+      const args: unknown[] = [];
+      await invokeExport("getMousePos", args, options);
+    });
+
+  program
+    .command("setMouseDelay")
+    .description("Call @tego/botjs setMouseDelay")
+    .argument("<delay>", "delay")
+    .option("--out <path>", "Write Buffer result to file")
+    .option("--json-output", "Emit result as JSON")
+    .option("--no-validate", "Disable arg shape validation")
+    .option("--dry-run", "Validate args without invoking")
+    .action(async (delay, options) => {
+      const args = [delay].map((value) => parseArg(String(value)));
+      await invokeExport("setMouseDelay", args, options);
+    });
+
+  program
+    .command("keyTap")
+    .description("Call @tego/botjs keyTap")
+    .argument("<key>", "key")
+    .argument("<modifier>", "modifier")
+    .option("--out <path>", "Write Buffer result to file")
+    .option("--json-output", "Emit result as JSON")
+    .option("--no-validate", "Disable arg shape validation")
+    .option("--dry-run", "Validate args without invoking")
+    .action(async (key, modifier, options) => {
+      const args = [key, modifier].map((value) => parseArg(String(value)));
+      await invokeExport("keyTap", args, options);
+    });
+
+  program
+    .command("keyToggle")
+    .description("Call @tego/botjs keyToggle")
+    .argument("<key>", "key")
+    .argument("<down>", "down")
+    .argument("<modifier>", "modifier")
+    .option("--out <path>", "Write Buffer result to file")
+    .option("--json-output", "Emit result as JSON")
+    .option("--no-validate", "Disable arg shape validation")
+    .option("--dry-run", "Validate args without invoking")
+    .action(async (key, down, modifier, options) => {
+      const args = [key, down, modifier].map((value) =>
+        parseArg(String(value)),
+      );
+      await invokeExport("keyToggle", args, options);
+    });
+
+  program
+    .command("typeString")
+    .description("Call @tego/botjs typeString")
+    .argument("<text>", "text")
+    .option("--out <path>", "Write Buffer result to file")
+    .option("--json-output", "Emit result as JSON")
+    .option("--no-validate", "Disable arg shape validation")
+    .option("--dry-run", "Validate args without invoking")
+    .action(async (text, options) => {
+      const args = [text].map((value) => parseArg(String(value)));
+      await invokeExport("typeString", args, options);
+    });
+
+  program
+    .command("typeStringDelayed")
+    .description("Call @tego/botjs typeStringDelayed")
+    .argument("<text>", "text")
+    .argument("<cpm>", "cpm")
+    .option("--out <path>", "Write Buffer result to file")
+    .option("--json-output", "Emit result as JSON")
+    .option("--no-validate", "Disable arg shape validation")
+    .option("--dry-run", "Validate args without invoking")
+    .action(async (text, cpm, options) => {
+      const args = [text, cpm].map((value) => parseArg(String(value)));
+      await invokeExport("typeStringDelayed", args, options);
+    });
+
+  program
+    .command("unicodeTap")
+    .description("Call @tego/botjs unicodeTap")
+    .argument("<codePoint>", "codePoint")
+    .option("--out <path>", "Write Buffer result to file")
+    .option("--json-output", "Emit result as JSON")
+    .option("--no-validate", "Disable arg shape validation")
+    .option("--dry-run", "Validate args without invoking")
+    .action(async (codePoint, options) => {
+      const args = [codePoint].map((value) => parseArg(String(value)));
+      await invokeExport("unicodeTap", args, options);
+    });
+
+  program
+    .command("setKeyboardDelay")
+    .description("Call @tego/botjs setKeyboardDelay")
+    .argument("<ms>", "ms")
+    .option("--out <path>", "Write Buffer result to file")
+    .option("--json-output", "Emit result as JSON")
+    .option("--no-validate", "Disable arg shape validation")
+    .option("--dry-run", "Validate args without invoking")
+    .action(async (ms, options) => {
+      const args = [ms].map((value) => parseArg(String(value)));
+      await invokeExport("setKeyboardDelay", args, options);
+    });
+
+  program
+    .command("bitmapColorAt")
+    .description("Call @tego/botjs bitmapColorAt")
+    .argument("<bitmap>", "bitmap")
+    .argument("<x>", "x")
+    .argument("<y>", "y")
+    .option("--out <path>", "Write Buffer result to file")
+    .option("--json-output", "Emit result as JSON")
+    .option("--no-validate", "Disable arg shape validation")
+    .option("--dry-run", "Validate args without invoking")
+    .action(async (bitmap, x, y, options) => {
+      const args = [bitmap, x, y].map((value) => parseArg(String(value)));
+      await invokeExport("bitmapColorAt", args, options);
+    });
+
+  program
+    .command("captureScreen")
+    .description("Call @tego/botjs captureScreen")
+    .option("--out <path>", "Write Buffer result to file")
+    .option("--json-output", "Emit result as JSON")
+    .option("--no-validate", "Disable arg shape validation")
+    .option("--dry-run", "Validate args without invoking")
+    .action(async (options) => {
+      const args: unknown[] = [];
+      await invokeExport("captureScreen", args, options);
+    });
+
+  program
+    .command("captureScreenRegion")
+    .description("Call @tego/botjs captureScreenRegion")
+    .argument("<x>", "x")
+    .argument("<y>", "y")
+    .argument("<width>", "width")
+    .argument("<height>", "height")
+    .option("--out <path>", "Write Buffer result to file")
+    .option("--json-output", "Emit result as JSON")
+    .option("--no-validate", "Disable arg shape validation")
+    .option("--dry-run", "Validate args without invoking")
+    .action(async (x, y, width, height, options) => {
+      const args = [x, y, width, height].map((value) =>
+        parseArg(String(value)),
+      );
+      await invokeExport("captureScreenRegion", args, options);
+    });
+
+  program
+    .command("getPixelColorHex")
+    .description("Call @tego/botjs getPixelColorHex")
+    .argument("<x>", "x")
+    .argument("<y>", "y")
+    .option("--out <path>", "Write Buffer result to file")
+    .option("--json-output", "Emit result as JSON")
+    .option("--no-validate", "Disable arg shape validation")
+    .option("--dry-run", "Validate args without invoking")
+    .action(async (x, y, options) => {
+      const args = [x, y].map((value) => parseArg(String(value)));
+      await invokeExport("getPixelColorHex", args, options);
+    });
+
+  program
+    .command("getScreen")
+    .description("Call @tego/botjs getScreen")
+    .option("--out <path>", "Write Buffer result to file")
+    .option("--json-output", "Emit result as JSON")
+    .option("--no-validate", "Disable arg shape validation")
+    .option("--dry-run", "Validate args without invoking")
+    .action(async (options) => {
+      const args: unknown[] = [];
+      await invokeExport("getScreen", args, options);
+    });
+
+  program
+    .command("getScreenSize")
+    .description("Call @tego/botjs getScreenSize")
+    .option("--out <path>", "Write Buffer result to file")
+    .option("--json-output", "Emit result as JSON")
+    .option("--no-validate", "Disable arg shape validation")
+    .option("--dry-run", "Validate args without invoking")
+    .action(async (options) => {
+      const args: unknown[] = [];
+      await invokeExport("getScreenSize", args, options);
+    });
+
+  program
+    .command("updateScreenMetrics")
+    .description("Call @tego/botjs updateScreenMetrics")
+    .option("--out <path>", "Write Buffer result to file")
+    .option("--json-output", "Emit result as JSON")
+    .option("--no-validate", "Disable arg shape validation")
+    .option("--dry-run", "Validate args without invoking")
+    .action(async (options) => {
+      const args: unknown[] = [];
+      await invokeExport("updateScreenMetrics", args, options);
+    });
+
+  program
+    .command("getClipboard")
+    .description("Call @tego/botjs getClipboard")
+    .option("--out <path>", "Write Buffer result to file")
+    .option("--json-output", "Emit result as JSON")
+    .option("--no-validate", "Disable arg shape validation")
+    .option("--dry-run", "Validate args without invoking")
+    .action(async (options) => {
+      const args: unknown[] = [];
+      await invokeExport("getClipboard", args, options);
+    });
+
+  program
+    .command("setClipboard")
+    .description("Call @tego/botjs setClipboard")
+    .argument("<text>", "text")
+    .option("--out <path>", "Write Buffer result to file")
+    .option("--json-output", "Emit result as JSON")
+    .option("--no-validate", "Disable arg shape validation")
+    .option("--dry-run", "Validate args without invoking")
+    .action(async (text, options) => {
+      const args = [text].map((value) => parseArg(String(value)));
+      await invokeExport("setClipboard", args, options);
+    });
+
+  program
+    .command("clearClipboard")
+    .description("Call @tego/botjs clearClipboard")
+    .option("--out <path>", "Write Buffer result to file")
+    .option("--json-output", "Emit result as JSON")
+    .option("--no-validate", "Disable arg shape validation")
+    .option("--dry-run", "Validate args without invoking")
+    .action(async (options) => {
+      const args: unknown[] = [];
+      await invokeExport("clearClipboard", args, options);
+    });
+
+  program
+    .command("getClipboardImage")
+    .description("Call @tego/botjs getClipboardImage")
+    .option("--out <path>", "Write Buffer result to file")
+    .option("--json-output", "Emit result as JSON")
+    .option("--no-validate", "Disable arg shape validation")
+    .option("--dry-run", "Validate args without invoking")
+    .action(async (options) => {
+      const args: unknown[] = [];
+      await invokeExport("getClipboardImage", args, options);
+    });
+
+  program
+    .command("setClipboardImage")
+    .description("Call @tego/botjs setClipboardImage")
+    .argument("<imageBuffer>", "imageBuffer")
+    .option("--out <path>", "Write Buffer result to file")
+    .option("--json-output", "Emit result as JSON")
+    .option("--no-validate", "Disable arg shape validation")
+    .option("--dry-run", "Validate args without invoking")
+    .action(async (imageBuffer, options) => {
+      const args = [imageBuffer].map((value) => parseArg(String(value)));
+      await invokeExport("setClipboardImage", args, options);
+    });
+
+  program
+    .command("getActiveWindow")
+    .description("Call @tego/botjs getActiveWindow")
+    .option("--out <path>", "Write Buffer result to file")
+    .option("--json-output", "Emit result as JSON")
+    .option("--no-validate", "Disable arg shape validation")
+    .option("--dry-run", "Validate args without invoking")
+    .action(async (options) => {
+      const args: unknown[] = [];
+      await invokeExport("getActiveWindow", args, options);
+    });
+
+  program
+    .command("getAllWindows")
+    .description("Call @tego/botjs getAllWindows")
+    .option("--out <path>", "Write Buffer result to file")
+    .option("--json-output", "Emit result as JSON")
+    .option("--no-validate", "Disable arg shape validation")
+    .option("--dry-run", "Validate args without invoking")
+    .action(async (options) => {
+      const args: unknown[] = [];
+      await invokeExport("getAllWindows", args, options);
+    });
+
+  program
+    .command("findWindowsByTitle")
+    .description("Call @tego/botjs findWindowsByTitle")
+    .argument("<title>", "title")
+    .option("--out <path>", "Write Buffer result to file")
+    .option("--json-output", "Emit result as JSON")
+    .option("--no-validate", "Disable arg shape validation")
+    .option("--dry-run", "Validate args without invoking")
+    .action(async (title, options) => {
+      const args = [title].map((value) => parseArg(String(value)));
+      await invokeExport("findWindowsByTitle", args, options);
+    });
+
+  program
+    .command("findWindowsByProcess")
+    .description("Call @tego/botjs findWindowsByProcess")
+    .argument("<processName>", "processName")
+    .option("--out <path>", "Write Buffer result to file")
+    .option("--json-output", "Emit result as JSON")
+    .option("--no-validate", "Disable arg shape validation")
+    .option("--dry-run", "Validate args without invoking")
+    .action(async (processName, options) => {
+      const args = [processName].map((value) => parseArg(String(value)));
+      await invokeExport("findWindowsByProcess", args, options);
+    });
+
+  program
+    .command("doubleClick")
+    .description("Call @tego/botjs doubleClick")
+    .argument("<x>", "x")
+    .argument("<y>", "y")
+    .option("--out <path>", "Write Buffer result to file")
+    .option("--json-output", "Emit result as JSON")
+    .option("--no-validate", "Disable arg shape validation")
+    .option("--dry-run", "Validate args without invoking")
+    .action(async (x, y, options) => {
+      const args = [x, y].map((value) => parseArg(String(value)));
+      await invokeExport("doubleClick", args, options);
+    });
+
+  program
+    .command("rightClick")
+    .description("Call @tego/botjs rightClick")
+    .argument("<x>", "x")
+    .argument("<y>", "y")
+    .option("--out <path>", "Write Buffer result to file")
+    .option("--json-output", "Emit result as JSON")
+    .option("--no-validate", "Disable arg shape validation")
+    .option("--dry-run", "Validate args without invoking")
+    .action(async (x, y, options) => {
+      const args = [x, y].map((value) => parseArg(String(value)));
+      await invokeExport("rightClick", args, options);
+    });
+
+  program
+    .command("middleClick")
+    .description("Call @tego/botjs middleClick")
+    .argument("<x>", "x")
+    .argument("<y>", "y")
+    .option("--out <path>", "Write Buffer result to file")
+    .option("--json-output", "Emit result as JSON")
+    .option("--no-validate", "Disable arg shape validation")
+    .option("--dry-run", "Validate args without invoking")
+    .action(async (x, y, options) => {
+      const args = [x, y].map((value) => parseArg(String(value)));
+      await invokeExport("middleClick", args, options);
+    });
+
+  program
+    .command("leftClick")
+    .description("Call @tego/botjs leftClick")
+    .argument("<x>", "x")
+    .argument("<y>", "y")
+    .option("--out <path>", "Write Buffer result to file")
+    .option("--json-output", "Emit result as JSON")
+    .option("--no-validate", "Disable arg shape validation")
+    .option("--dry-run", "Validate args without invoking")
+    .action(async (x, y, options) => {
+      const args = [x, y].map((value) => parseArg(String(value)));
+      await invokeExport("leftClick", args, options);
+    });
+
+  program
+    .command("mouseDown")
+    .description("Call @tego/botjs mouseDown")
+    .argument("<button>", "button")
+    .option("--out <path>", "Write Buffer result to file")
+    .option("--json-output", "Emit result as JSON")
+    .option("--no-validate", "Disable arg shape validation")
+    .option("--dry-run", "Validate args without invoking")
+    .action(async (button, options) => {
+      const args = [button].map((value) => parseArg(String(value)));
+      await invokeExport("mouseDown", args, options);
+    });
+
+  program
+    .command("mouseUp")
+    .description("Call @tego/botjs mouseUp")
+    .argument("<button>", "button")
+    .option("--out <path>", "Write Buffer result to file")
+    .option("--json-output", "Emit result as JSON")
+    .option("--no-validate", "Disable arg shape validation")
+    .option("--dry-run", "Validate args without invoking")
+    .action(async (button, options) => {
+      const args = [button].map((value) => parseArg(String(value)));
+      await invokeExport("mouseUp", args, options);
+    });
+
+  program
+    .command("captureAndCopy")
+    .description("Call @tego/botjs captureAndCopy")
+    .argument("<region>", "region")
+    .option("--out <path>", "Write Buffer result to file")
+    .option("--json-output", "Emit result as JSON")
+    .option("--no-validate", "Disable arg shape validation")
+    .option("--dry-run", "Validate args without invoking")
+    .action(async (region, options) => {
+      const args = [region].map((value) => parseArg(String(value)));
+      await invokeExport("captureAndCopy", args, options);
+    });
+
+  program
+    .command("captureAndSave")
+    .description("Call @tego/botjs captureAndSave")
+    .argument("<path>", "path")
+    .argument("<region>", "region")
+    .argument("<options>", "options")
+    .option("--out <path>", "Write Buffer result to file")
+    .option("--json-output", "Emit result as JSON")
+    .option("--no-validate", "Disable arg shape validation")
+    .option("--dry-run", "Validate args without invoking")
+    .action(async (path, region, optionsArg2, options) => {
+      const args = [path, region, optionsArg2].map((value) =>
+        parseArg(String(value)),
+      );
+      await invokeExport("captureAndSave", args, options);
+    });
+
+  program
+    .command("captureRegion")
+    .description("Call @tego/botjs captureRegion")
+    .argument("<x>", "x")
+    .argument("<y>", "y")
+    .argument("<width>", "width")
+    .argument("<height>", "height")
+    .option("--out <path>", "Write Buffer result to file")
+    .option("--json-output", "Emit result as JSON")
+    .option("--no-validate", "Disable arg shape validation")
+    .option("--dry-run", "Validate args without invoking")
+    .action(async (x, y, width, height, options) => {
+      const args = [x, y, width, height].map((value) =>
+        parseArg(String(value)),
+      );
+      await invokeExport("captureRegion", args, options);
+    });
+
+  program
+    .command("copyScreenshotToClipboard")
+    .description("Call @tego/botjs copyScreenshotToClipboard")
+    .argument("<result>", "result")
+    .option("--out <path>", "Write Buffer result to file")
+    .option("--json-output", "Emit result as JSON")
+    .option("--no-validate", "Disable arg shape validation")
+    .option("--dry-run", "Validate args without invoking")
+    .action(async (result, options) => {
+      const args = [result].map((value) => parseArg(String(value)));
+      await invokeExport("copyScreenshotToClipboard", args, options);
+    });
+
+  program
+    .command("getPixelColor")
+    .description("Call @tego/botjs getPixelColor")
+    .argument("<x>", "x")
+    .argument("<y>", "y")
+    .option("--out <path>", "Write Buffer result to file")
+    .option("--json-output", "Emit result as JSON")
+    .option("--no-validate", "Disable arg shape validation")
+    .option("--dry-run", "Validate args without invoking")
+    .action(async (x, y, options) => {
+      const args = [x, y].map((value) => parseArg(String(value)));
+      await invokeExport("getPixelColor", args, options);
+    });
+
+  program
+    .command("quickScreenshot")
+    .description("Call @tego/botjs quickScreenshot")
+    .option("--out <path>", "Write Buffer result to file")
+    .option("--json-output", "Emit result as JSON")
+    .option("--no-validate", "Disable arg shape validation")
+    .option("--dry-run", "Validate args without invoking")
+    .action(async (options) => {
+      const args: unknown[] = [];
+      await invokeExport("quickScreenshot", args, options);
+    });
+
+  program
+    .command("quickScreenshotRegion")
+    .description("Call @tego/botjs quickScreenshotRegion")
+    .argument("<region>", "region")
+    .option("--out <path>", "Write Buffer result to file")
+    .option("--json-output", "Emit result as JSON")
+    .option("--no-validate", "Disable arg shape validation")
+    .option("--dry-run", "Validate args without invoking")
+    .action(async (region, options) => {
+      const args = [region].map((value) => parseArg(String(value)));
+      await invokeExport("quickScreenshotRegion", args, options);
+    });
+
+  program
+    .command("saveScreenshotToFile")
+    .description("Call @tego/botjs saveScreenshotToFile")
+    .argument("<result>", "result")
+    .argument("<filePath>", "filePath")
+    .argument("<_options>", "_options")
+    .option("--out <path>", "Write Buffer result to file")
+    .option("--json-output", "Emit result as JSON")
+    .option("--no-validate", "Disable arg shape validation")
+    .option("--dry-run", "Validate args without invoking")
+    .action(async (result, filePath, _options, options) => {
+      const args = [result, filePath, _options].map((value) =>
+        parseArg(String(value)),
+      );
+      await invokeExport("saveScreenshotToFile", args, options);
+    });
+
+  program
+    .command("startInteractiveCapture")
+    .description("Call @tego/botjs startInteractiveCapture")
+    .argument("<_options>", "_options")
+    .option("--out <path>", "Write Buffer result to file")
+    .option("--json-output", "Emit result as JSON")
+    .option("--no-validate", "Disable arg shape validation")
+    .option("--dry-run", "Validate args without invoking")
+    .action(async (_options, options) => {
+      const args = [_options].map((value) => parseArg(String(value)));
+      await invokeExport("startInteractiveCapture", args, options);
+    });
+
+  program
+    .command("findAllInRegion")
+    .description("Call @tego/botjs findAllInRegion")
+    .argument("<template>", "template")
+    .argument("<x>", "x")
+    .argument("<y>", "y")
+    .argument("<width>", "width")
+    .argument("<height>", "height")
+    .argument("<config>", "config")
+    .option("--out <path>", "Write Buffer result to file")
+    .option("--json-output", "Emit result as JSON")
+    .option("--no-validate", "Disable arg shape validation")
+    .option("--dry-run", "Validate args without invoking")
+    .action(async (template, x, y, width, height, config, options) => {
+      const args = [template, x, y, width, height, config].map((value) =>
+        parseArg(String(value)),
+      );
+      await invokeExport("findAllInRegion", args, options);
+    });
+
+  program
+    .command("findAllOnScreen")
+    .description("Call @tego/botjs findAllOnScreen")
+    .argument("<template>", "template")
+    .argument("<config>", "config")
+    .option("--out <path>", "Write Buffer result to file")
+    .option("--json-output", "Emit result as JSON")
+    .option("--no-validate", "Disable arg shape validation")
+    .option("--dry-run", "Validate args without invoking")
+    .action(async (template, config, options) => {
+      const args = [template, config].map((value) => parseArg(String(value)));
+      await invokeExport("findAllOnScreen", args, options);
+    });
+
+  program
+    .command("findInRegion")
+    .description("Call @tego/botjs findInRegion")
+    .argument("<template>", "template")
+    .argument("<x>", "x")
+    .argument("<y>", "y")
+    .argument("<width>", "width")
+    .argument("<height>", "height")
+    .argument("<config>", "config")
+    .option("--out <path>", "Write Buffer result to file")
+    .option("--json-output", "Emit result as JSON")
+    .option("--no-validate", "Disable arg shape validation")
+    .option("--dry-run", "Validate args without invoking")
+    .action(async (template, x, y, width, height, config, options) => {
+      const args = [template, x, y, width, height, config].map((value) =>
+        parseArg(String(value)),
+      );
+      await invokeExport("findInRegion", args, options);
+    });
+
+  program
+    .command("findOnScreen")
+    .description("Call @tego/botjs findOnScreen")
+    .argument("<template>", "template")
+    .argument("<config>", "config")
+    .option("--out <path>", "Write Buffer result to file")
+    .option("--json-output", "Emit result as JSON")
+    .option("--no-validate", "Disable arg shape validation")
+    .option("--dry-run", "Validate args without invoking")
+    .action(async (template, config, options) => {
+      const args = [template, config].map((value) => parseArg(String(value)));
+      await invokeExport("findOnScreen", args, options);
+    });
+
+  program
+    .command("getMatchBounds")
+    .description("Call @tego/botjs getMatchBounds")
+    .argument("<match>", "match")
+    .option("--out <path>", "Write Buffer result to file")
+    .option("--json-output", "Emit result as JSON")
+    .option("--no-validate", "Disable arg shape validation")
+    .option("--dry-run", "Validate args without invoking")
+    .action(async (match, options) => {
+      const args = [match].map((value) => parseArg(String(value)));
+      await invokeExport("getMatchBounds", args, options);
+    });
+
+  program
+    .command("getMatchCenter")
+    .description("Call @tego/botjs getMatchCenter")
+    .argument("<match>", "match")
+    .option("--out <path>", "Write Buffer result to file")
+    .option("--json-output", "Emit result as JSON")
+    .option("--no-validate", "Disable arg shape validation")
+    .option("--dry-run", "Validate args without invoking")
+    .action(async (match, options) => {
+      const args = [match].map((value) => parseArg(String(value)));
+      await invokeExport("getMatchCenter", args, options);
+    });
+
+  program
+    .command("imageResource")
+    .description("Call @tego/botjs imageResource")
+    .argument("<path>", "path")
+    .option("--out <path>", "Write Buffer result to file")
+    .option("--json-output", "Emit result as JSON")
+    .option("--no-validate", "Disable arg shape validation")
+    .option("--dry-run", "Validate args without invoking")
+    .action(async (path, options) => {
+      const args = [path].map((value) => parseArg(String(value)));
+      await invokeExport("imageResource", args, options);
+    });
+
+  program
+    .command("imageResourceFromBuffer")
+    .description("Call @tego/botjs imageResourceFromBuffer")
+    .argument("<buffer>", "buffer")
+    .option("--out <path>", "Write Buffer result to file")
+    .option("--json-output", "Emit result as JSON")
+    .option("--no-validate", "Disable arg shape validation")
+    .option("--dry-run", "Validate args without invoking")
+    .action(async (buffer, options) => {
+      const args = [buffer].map((value) => parseArg(String(value)));
+      await invokeExport("imageResourceFromBuffer", args, options);
+    });
+
+  program
+    .command("imageResourceSync")
+    .description("Call @tego/botjs imageResourceSync")
+    .argument("<path>", "path")
+    .option("--out <path>", "Write Buffer result to file")
+    .option("--json-output", "Emit result as JSON")
+    .option("--no-validate", "Disable arg shape validation")
+    .option("--dry-run", "Validate args without invoking")
+    .action(async (path, options) => {
+      const args = [path].map((value) => parseArg(String(value)));
+      await invokeExport("imageResourceSync", args, options);
+    });
+
+  program
+    .command("waitFor")
+    .description("Call @tego/botjs waitFor")
+    .argument("<template>", "template")
+    .argument("<timeout>", "timeout")
+    .argument("<interval>", "interval")
+    .argument("<config>", "config")
+    .option("--out <path>", "Write Buffer result to file")
+    .option("--json-output", "Emit result as JSON")
+    .option("--no-validate", "Disable arg shape validation")
+    .option("--dry-run", "Validate args without invoking")
+    .action(async (template, timeout, interval, config, options) => {
+      const args = [template, timeout, interval, config].map((value) =>
+        parseArg(String(value)),
+      );
+      await invokeExport("waitFor", args, options);
+    });
+
+  program
+    .command("waitForGone")
+    .description("Call @tego/botjs waitForGone")
+    .argument("<template>", "template")
+    .argument("<timeout>", "timeout")
+    .argument("<interval>", "interval")
+    .argument("<config>", "config")
+    .option("--out <path>", "Write Buffer result to file")
+    .option("--json-output", "Emit result as JSON")
+    .option("--no-validate", "Disable arg shape validation")
+    .option("--dry-run", "Validate args without invoking")
+    .action(async (template, timeout, interval, config, options) => {
+      const args = [template, timeout, interval, config].map((value) =>
+        parseArg(String(value)),
+      );
+      await invokeExport("waitForGone", args, options);
+    });
+}
diff --git a/packages/bot-cli/src/index.ts b/packages/bot-cli/src/index.ts
new file mode 100644
index 0000000..557c28e
--- /dev/null
+++ b/packages/bot-cli/src/index.ts
@@ -0,0 +1,39 @@
+/**
+ * Main CLI module
+ */
+
+import { Command } from "commander";
+import { callCommand } from "./commands/call.js";
+import { doctorCommand } from "./commands/doctor.js";
+import { registerGeneratedCommands } from "./generated/commands.js";
+
+const program = new Command();
+
+program.name("bot").description("CLI wrapper for @tego/botjs").version("0.0.1");
+
+program
+  .command("call")
+  .description("Invoke a @tego/botjs export with JSON args")
+  .argument("<exportName>", "Exported function name")
+  .option("--json <json>", "Args as JSON array or object")
+  .option("--file <path>", "Read args JSON from file")
+  .option("--stdin", "Read args JSON from stdin")
+  .option("--out <path>", "Write Buffer result to file")
+  .option("--json-output", "Emit result as JSON")
+  .option("--no-validate", "Disable arg shape validation")
+  .option("--dry-run", "Validate args without invoking")
+  .action(async (exportName: string, options) => {
+    await callCommand(exportName, options);
+  });
+
+program
+  .command("doctor")
+  .description("Check system readiness for bot automation")
+  .option("--json-output", "Emit result as JSON")
+  .action(async (options) => {
+    await doctorCommand(Boolean(options.jsonOutput));
+  });
+
+registerGeneratedCommands(program);
+
+export { program };
diff --git a/packages/bot-cli/tests/call.test.ts b/packages/bot-cli/tests/call.test.ts
new file mode 100644
index 0000000..2446ccb
--- /dev/null
+++ b/packages/bot-cli/tests/call.test.ts
@@ -0,0 +1,34 @@
+import { describe, expect, it, vi } from "vitest";
+
+vi.mock("@tego/botjs", () => ({
+  moveMouse: () => undefined,
+  definitelyNotARealExport: undefined,
+}));
+
+// Minimal unit tests that avoid invoking real bot APIs.
+
+describe("callCommand", () => {
+  it("errors on unknown export", async () => {
+    const { callCommand } = await import("../src/commands/call.js");
+    await expect(callCommand("definitelyNotARealExport", {})).rejects.toThrow(
+      "not a function",
+    );
+  });
+
+  it("supports dry-run without invoking", async () => {
+    const { callCommand } = await import("../src/commands/call.js");
+    const writeSpy = vi
+      .spyOn(process.stdout, "write")
+      .mockImplementation(() => true);
+
+    await callCommand("moveMouse", {
+      json: "[1,2]",
+      dryRun: true,
+      jsonOutput: true,
+    });
+
+    const output = writeSpy.mock.calls.map((call) => call[0]).join("");
+    expect(output).toContain('"dryRun":true');
+    writeSpy.mockRestore();
+  });
+});
diff --git a/packages/bot-cli/tools/gen-api.ts b/packages/bot-cli/tools/gen-api.ts
new file mode 100644
index 0000000..c4171f6
--- /dev/null
+++ b/packages/bot-cli/tools/gen-api.ts
@@ -0,0 +1,267 @@
+import { mkdir, writeFile } from "node:fs/promises";
+import { dirname, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import {
+  type Symbol as MorphSymbol,
+  Project,
+  SyntaxKind,
+  type Type,
+} from "ts-morph";
+
+const scriptDir = dirname(fileURLToPath(import.meta.url));
+const repoRoot = resolve(scriptDir, "../../..");
+const botjsRoot = resolve(repoRoot, "packages/botjs");
+const entryFile = resolve(botjsRoot, "src/index.ts");
+const outputFile = resolve(botjsRoot, "generated/api.json");
+
+const project = new Project({
+  tsConfigFilePath: resolve(repoRoot, "tsconfig.base.json"),
+});
+
+project.addSourceFilesAtPaths(resolve(botjsRoot, "src/**/*.ts"));
+
+const source = project.getSourceFileOrThrow(entryFile);
+
+function getJsDocText(declaration: {
+  getJsDocs?: () => { getDescription: () => string }[];
+}) {
+  if (!declaration.getJsDocs) return undefined;
+  const docs = declaration.getJsDocs();
+  const description = docs
+    .map((doc) => doc.getDescription().trim())
+    .filter(Boolean)
+    .join("\n");
+  return description.length > 0 ? description : undefined;
+}
+
+function parseDefaultFromText(text?: string): string | undefined {
+  if (!text) return undefined;
+  const match =
+    text.match(/default:\s*([^\s,)\]]+)/i) ??
+    text.match(/default\s*=\s*([^\s,)\]]+)/i);
+  if (!match) return undefined;
+  return match[1]?.replace(/^['"]|['"]$/g, "");
+}
+
+function parseEnumFromText(text?: string): string[] | undefined {
+  if (!text) return undefined;
+  const values = new Set<string>();
+  for (const match of text.matchAll(/'([^']+)'/g)) {
+    values.add(match[1]);
+  }
+  for (const match of text.matchAll(/"([^"]+)"/g)) {
+    values.add(match[1]);
+  }
+  return values.size > 0 ? Array.from(values) : undefined;
+}
+
+function getLiteralUnionValues(
+  type: Type,
+): Array<string | number | boolean> | undefined {
+  const unionTypes = type.getUnionTypes();
+  if (unionTypes.length === 0) return undefined;
+  const values: Array<string | number | boolean> = [];
+  for (const unionType of unionTypes) {
+    if (unionType.isStringLiteral()) {
+      values.push(unionType.getLiteralValue() as string);
+    } else if (unionType.isNumberLiteral()) {
+      values.push(unionType.getLiteralValue() as number);
+    } else if (unionType.isBooleanLiteral()) {
+      values.push(unionType.getLiteralValue() as boolean);
+    }
+  }
+  return values.length > 0 ? values : undefined;
+}
+
+function parseParamTags(
+  declarations: MorphSymbol["getDeclarations"],
+): Map<string, string> {
+  const map = new Map<string, string>();
+  const decls = declarations();
+  for (const decl of decls) {
+    if (decl.getKind() !== SyntaxKind.FunctionDeclaration) continue;
+    const fnDecl = decl.asKindOrThrow(SyntaxKind.FunctionDeclaration);
+    for (const doc of fnDecl.getJsDocs()) {
+      for (const tag of doc.getTags()) {
+        if (tag.getTagName() !== "param") continue;
+        const rawText = tag.getText();
+        const cleaned = rawText.replace(/^\s*\*?\s*@param\s+/, "").trim();
+        const match = cleaned.match(/^(\[?\w+\]?)(?:\s+-\s+)?([\s\S]*)$/);
+        if (!match) continue;
+        const name = match[1].replace(/^\[/, "").replace(/\]$/, "");
+        const description = match[2]?.trim();
+        if (description) {
+          map.set(name, description);
+        }
+      }
+    }
+  }
+  return map;
+}
+
+function getReturnDocText(
+  declarations: MorphSymbol["getDeclarations"],
+): string | undefined {
+  const decls = declarations();
+  for (const decl of decls) {
+    if (decl.getKind() !== SyntaxKind.FunctionDeclaration) continue;
+    const fnDecl = decl.asKindOrThrow(SyntaxKind.FunctionDeclaration);
+    for (const doc of fnDecl.getJsDocs()) {
+      for (const tag of doc.getTags()) {
+        if (tag.getTagName() !== "returns" && tag.getTagName() !== "return")
+          continue;
+        const text = tag
+          .getText()
+          .replace(/^\s*\*?\s*@returns?\s+/, "")
+          .trim();
+        if (text.length > 0) {
+          return text;
+        }
+      }
+    }
+  }
+  return undefined;
+}
+
+function getSignatureParams(symbol: MorphSymbol) {
+  const declarations = symbol.getDeclarations();
+  const paramDocs = parseParamTags(symbol.getDeclarations.bind(symbol));
+  for (const decl of declarations) {
+    if (decl.getKind() === SyntaxKind.FunctionDeclaration) {
+      const fnDecl = decl.asKindOrThrow(SyntaxKind.FunctionDeclaration);
+      return fnDecl.getParameters().map((param) => {
+        const docText = paramDocs.get(param.getName());
+        const unionValues = getLiteralUnionValues(param.getType());
+        const docEnum = parseEnumFromText(docText);
+        const combinedEnum = unionValues ?? docEnum;
+        return {
+          name: param.getName(),
+          type: param.getType().getText(param),
+          optional: param.isOptional(),
+          default:
+            param.getInitializer()?.getText() ?? parseDefaultFromText(docText),
+          jsdoc: docText ?? getJsDocText(param),
+          enum: combinedEnum,
+        };
+      });
+    }
+  }
+  return [] as Array<{ name: string; type: string }>;
+}
+
+function getReturnType(symbol: MorphSymbol): string | null {
+  const declarations = symbol.getDeclarations();
+  for (const decl of declarations) {
+    if (decl.getKind() === SyntaxKind.FunctionDeclaration) {
+      const fnDecl = decl.asKindOrThrow(SyntaxKind.FunctionDeclaration);
+      return fnDecl.getReturnType().getText(fnDecl);
+    }
+  }
+  return null;
+}
+
+function isAsyncReturn(returnType: string | null): boolean {
+  if (!returnType) return false;
+  return returnType.startsWith("Promise<");
+}
+
+const exportSymbols = source.getExportSymbols();
+
+const exports = exportSymbols.map((symbol) => {
+  const name = symbol.getName();
+  const resolved = symbol.isAlias()
+    ? (symbol.getAliasedSymbol() ?? symbol)
+    : symbol;
+  const declarations = resolved.getDeclarations();
+  const isClass = declarations.some(
+    (decl) => decl.getKind() === SyntaxKind.ClassDeclaration,
+  );
+  const isFunction = declarations.some(
+    (decl) => decl.getKind() === SyntaxKind.FunctionDeclaration,
+  );
+  const isInterface = declarations.some(
+    (decl) => decl.getKind() === SyntaxKind.InterfaceDeclaration,
+  );
+  const isTypeAlias = declarations.some(
+    (decl) => decl.getKind() === SyntaxKind.TypeAliasDeclaration,
+  );
+  const isVariable = declarations.some(
+    (decl) => decl.getKind() === SyntaxKind.VariableDeclaration,
+  );
+  const sourceFile = declarations[0]?.getSourceFile().getBaseName();
+
+  if (isClass) {
+    return {
+      name,
+      kind: "class",
+      jsdoc:
+        declarations.length > 0 ? getJsDocText(declarations[0]) : undefined,
+      sourceFile,
+    };
+  }
+
+  if (isFunction) {
+    const params = getSignatureParams(resolved);
+    const returnType = getReturnType(resolved);
+    const jsdoc =
+      declarations.length > 0 ? getJsDocText(declarations[0]) : undefined;
+    const returnsDoc = getReturnDocText(
+      resolved.getDeclarations.bind(resolved),
+    );
+    return {
+      name,
+      kind: "function",
+      params,
+      returns: returnType ?? "unknown",
+      async: isAsyncReturn(returnType),
+      jsdoc,
+      returnsDoc,
+      sourceFile,
+    };
+  }
+
+  if (isInterface) {
+    return {
+      name,
+      kind: "interface",
+      sourceFile,
+    };
+  }
+
+  if (isTypeAlias) {
+    return {
+      name,
+      kind: "type",
+      sourceFile,
+    };
+  }
+
+  if (isVariable) {
+    const type = declarations[0]?.getType().getText(declarations[0]);
+    return {
+      name,
+      kind: "value",
+      type: type ?? "unknown",
+      jsdoc:
+        declarations.length > 0 ? getJsDocText(declarations[0]) : undefined,
+      sourceFile,
+    };
+  }
+
+  return {
+    name,
+    kind: "type",
+    sourceFile,
+  };
+});
+
+const payload = {
+  source: {
+    package: "@tego/botjs",
+    entrypoint: "src/index.ts",
+  },
+  exports,
+};
+
+await mkdir(dirname(outputFile), { recursive: true });
+await writeFile(outputFile, `${JSON.stringify(payload, null, 2)}\n`, "utf8");
diff --git a/packages/bot-cli/tools/gen-commands.ts b/packages/bot-cli/tools/gen-commands.ts
new file mode 100644
index 0000000..019d49a
--- /dev/null
+++ b/packages/bot-cli/tools/gen-commands.ts
@@ -0,0 +1,86 @@
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { dirname, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const scriptDir = dirname(fileURLToPath(import.meta.url));
+const repoRoot = resolve(scriptDir, "../../..");
+const botjsGenerated = resolve(repoRoot, "packages/botjs/generated/api.json");
+const outputFile = resolve(
+  repoRoot,
+  "packages/bot-cli/src/generated/commands.ts",
+);
+
+const payload = JSON.parse(await readFile(botjsGenerated, "utf8")) as {
+  exports: Array<{
+    name: string;
+    kind: string;
+    params?: Array<{ name: string; type: string }>;
+  }>;
+};
+
+const functions = payload.exports.filter((entry) => entry.kind === "function");
+
+const lines: string[] = [];
+lines.push("// Generated file. Do not edit manually.");
+lines.push('import { Command } from "commander";');
+lines.push('import { invokeExport } from "../commands/invoke.js";');
+lines.push("");
+lines.push('const BOOL_TRUE = new Set(["true", "1", "yes", "y", "on"]);');
+lines.push('const BOOL_FALSE = new Set(["false", "0", "no", "n", "off"]);');
+lines.push("function parseArg(value: string): unknown {");
+lines.push("  try {");
+lines.push("    return JSON.parse(value);");
+lines.push("  } catch {");
+lines.push("    if (/^0x[0-9a-f]+$/i.test(value)) {");
+lines.push("      return Number.parseInt(value, 16);");
+lines.push("    }");
+lines.push("    const lower = value.toLowerCase();");
+lines.push("    if (BOOL_TRUE.has(lower)) return true;");
+lines.push("    if (BOOL_FALSE.has(lower)) return false;");
+lines.push("    if (/^-?\\\\d+(?:\\\\.\\\\d+)?$/.test(value)) {");
+lines.push("      return Number(value);");
+lines.push("    }");
+lines.push("    return value;");
+lines.push("  }");
+lines.push("}");
+lines.push("");
+lines.push(
+  "export function registerGeneratedCommands(program: Command): void {",
+);
+
+for (const fn of functions) {
+  const params = fn.params ?? [];
+  const argList = params.map((param) => param.name);
+  const safeArgs = argList.map((name, index) => {
+    if (name === "options") return `optionsArg${index}`;
+    return name;
+  });
+  lines.push(`  program.command("${fn.name}")`);
+  lines.push(`    .description("Call @tego/botjs ${fn.name}")`);
+  for (const param of argList) {
+    lines.push(`    .argument("<${param}>", "${param}")`);
+  }
+  lines.push('    .option("--out <path>", "Write Buffer result to file")');
+  lines.push('    .option("--json-output", "Emit result as JSON")');
+  lines.push('    .option("--no-validate", "Disable arg shape validation")');
+  lines.push('    .option("--dry-run", "Validate args without invoking")');
+  lines.push(
+    `    .action(async (${safeArgs.join(", ")}${safeArgs.length > 0 ? ", " : ""}options) => {`,
+  );
+  if (safeArgs.length > 0) {
+    lines.push(
+      `      const args = [${safeArgs.join(", ")}].map((value) => parseArg(String(value)));`,
+    );
+  } else {
+    lines.push("      const args: unknown[] = [];");
+  }
+  lines.push(`      await invokeExport("${fn.name}", args, options);`);
+  lines.push("    });");
+  lines.push("");
+}
+
+lines.push("}");
+lines.push("");
+
+await mkdir(dirname(outputFile), { recursive: true });
+await writeFile(outputFile, `${lines.join("\n")}\n`, "utf8");
diff --git a/packages/bot-cli/tsconfig.json b/packages/bot-cli/tsconfig.json
new file mode 100644
index 0000000..0a96a25
--- /dev/null
+++ b/packages/bot-cli/tsconfig.json
@@ -0,0 +1,10 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "compilerOptions": {
+    "outDir": "./dist",
+    "rootDir": ".",
+    "types": ["node", "vitest/globals"]
+  },
+  "include": ["src/**/*", "bin/**/*", "tests/**/*"],
+  "exclude": ["node_modules", "dist"]
+}
diff --git a/packages/bot-cli/tsdown.config.ts b/packages/bot-cli/tsdown.config.ts
new file mode 100644
index 0000000..46a8f08
--- /dev/null
+++ b/packages/bot-cli/tsdown.config.ts
@@ -0,0 +1,12 @@
+import { defineConfig } from "tsdown";
+
+export default defineConfig({
+  entry: ["src/index.ts", "bin/bot.ts"],
+  format: ["esm"],
+  dts: true,
+  clean: true,
+  shims: true,
+  platform: "node",
+  target: "node18",
+  external: ["commander"],
+});
diff --git a/packages/bot-cli/vitest.config.ts b/packages/bot-cli/vitest.config.ts
new file mode 100644
index 0000000..4334476
--- /dev/null
+++ b/packages/bot-cli/vitest.config.ts
@@ -0,0 +1,14 @@
+import { resolve } from "node:path";
+import { defineConfig } from "vitest/config";
+
+export default defineConfig({
+  resolve: {
+    alias: {
+      "@tego/botjs": resolve(__dirname, "../botjs/src/index.ts"),
+    },
+  },
+  test: {
+    globals: true,
+    environment: "node",
+  },
+});
diff --git a/packages/botjs/generated/api.json b/packages/botjs/generated/api.json
new file mode 100644
index 0000000..2d3f6f6
--- /dev/null
+++ b/packages/botjs/generated/api.json
@@ -0,0 +1,1267 @@
+{
+  "source": {
+    "package": "@tego/botjs",
+    "entrypoint": "src/index.ts"
+  },
+  "exports": [
+    {
+      "name": "moveMouse",
+      "kind": "function",
+      "params": [
+        {
+          "name": "x",
+          "type": "number",
+          "optional": false,
+          "jsdoc": "X coordinate in pixels\n *"
+        },
+        {
+          "name": "y",
+          "type": "number",
+          "optional": false,
+          "jsdoc": "Y coordinate in pixels\n *\n *"
+        }
+      ],
+      "returns": "void",
+      "async": false,
+      "jsdoc": "Move the mouse cursor to the specified coordinates instantly",
+      "sourceFile": "index.ts"
+    },
+    {
+      "name": "moveMouseSmooth",
+      "kind": "function",
+      "params": [
+        {
+          "name": "x",
+          "type": "number",
+          "optional": false,
+          "jsdoc": "X coordinate in pixels\n *"
+        },
+        {
+          "name": "y",
+          "type": "number",
+          "optional": false,
+          "jsdoc": "Y coordinate in pixels\n *"
+        },
+        {
+          "name": "speed",
+          "type": "number | undefined",
+          "optional": true,
+          "default": "3.0",
+          "jsdoc": "Optional movement speed multiplier (default: 3.0, higher = faster)\n *\n *"
+        }
+      ],
+      "returns": "void",
+      "async": false,
+      "jsdoc": "Move the mouse cursor smoothly to the specified coordinates with easing animation",
+      "sourceFile": "index.ts"
+    },
+    {
+      "name": "mouseClick",
+      "kind": "function",
+      "params": [
+        {
+          "name": "button",
+          "type": "string | undefined",
+          "optional": true,
+          "default": "left",
+          "jsdoc": "Mouse button: \"left\", \"right\", or \"middle\" (default: \"left\")\n *",
+          "enum": ["left", "right", "middle"]
+        },
+        {
+          "name": "double",
+          "type": "boolean | undefined",
+          "optional": true,
+          "default": "false",
+          "jsdoc": "Whether to perform a double click (default: false)\n *\n *",
+          "enum": [null, null]
+        }
+      ],
+      "returns": "void",
+      "async": false,
+      "jsdoc": "Click the mouse button at the current cursor position",
+      "sourceFile": "index.ts"
+    },
+    {
+      "name": "mouseToggle",
+      "kind": "function",
+      "params": [
+        {
+          "name": "down",
+          "type": "string",
+          "optional": false,
+          "jsdoc": "\"down\" to press the button, \"up\" to release it\n *",
+          "enum": ["down", "up"]
+        },
+        {
+          "name": "button",
+          "type": "string | undefined",
+          "optional": true,
+          "default": "left",
+          "jsdoc": "Mouse button: \"left\", \"right\", or \"middle\" (default: \"left\")\n *\n *",
+          "enum": ["left", "right", "middle"]
+        }
+      ],
+      "returns": "void",
+      "async": false,
+      "jsdoc": "Toggle mouse button state (press down or release up)",
+      "sourceFile": "index.ts"
+    },
+    {
+      "name": "dragMouse",
+      "kind": "function",
+      "params": [
+        {
+          "name": "x",
+          "type": "number",
+          "optional": false,
+          "jsdoc": "Target X coordinate in pixels\n *"
+        },
+        {
+          "name": "y",
+          "type": "number",
+          "optional": false,
+          "jsdoc": "Target Y coordinate in pixels\n *\n *"
+        }
+      ],
+      "returns": "void",
+      "async": false,
+      "jsdoc": "Drag the mouse from current position to target coordinates",
+      "sourceFile": "index.ts"
+    },
+    {
+      "name": "scrollMouse",
+      "kind": "function",
+      "params": [
+        {
+          "name": "x",
+          "type": "number",
+          "optional": false,
+          "jsdoc": "Horizontal scroll amount (positive = right, negative = left)\n *"
+        },
+        {
+          "name": "y",
+          "type": "number",
+          "optional": false,
+          "jsdoc": "Vertical scroll amount (positive = down, negative = up)\n *\n *"
+        }
+      ],
+      "returns": "void",
+      "async": false,
+      "jsdoc": "Scroll the mouse wheel in horizontal and/or vertical directions",
+      "sourceFile": "index.ts"
+    },
+    {
+      "name": "getMousePos",
+      "kind": "function",
+      "params": [],
+      "returns": "bot.MousePositionResult",
+      "async": false,
+      "jsdoc": "Get the current mouse cursor position",
+      "returnsDoc": "Object containing x and y coordinates\n *\n *",
+      "sourceFile": "index.ts"
+    },
+    {
+      "name": "setMouseDelay",
+      "kind": "function",
+      "params": [
+        {
+          "name": "delay",
+          "type": "number",
+          "optional": false,
+          "jsdoc": "Delay in milliseconds (applied after each mouse operation)\n *\n *"
+        }
+      ],
+      "returns": "void",
+      "async": false,
+      "jsdoc": "Set the delay between mouse operations in milliseconds",
+      "sourceFile": "index.ts"
+    },
+    {
+      "name": "keyTap",
+      "kind": "function",
+      "params": [
+        {
+          "name": "key",
+          "type": "string",
+          "optional": false,
+          "jsdoc": "Key to tap (e.g., 'a', 'enter', 'escape', 'f1')\n *",
+          "enum": ["a", "enter", "escape", "f1"]
+        },
+        {
+          "name": "modifier",
+          "type": "string[] | undefined",
+          "optional": true,
+          "jsdoc": "Optional array of modifier keys: 'control', 'shift', 'alt', 'command'\n *\n *",
+          "enum": ["control", "shift", "alt", "command"]
+        }
+      ],
+      "returns": "void",
+      "async": false,
+      "jsdoc": "Tap a key (press and immediately release)",
+      "sourceFile": "index.ts"
+    },
+    {
+      "name": "keyToggle",
+      "kind": "function",
+      "params": [
+        {
+          "name": "key",
+          "type": "string",
+          "optional": false,
+          "jsdoc": "Key to toggle\n *"
+        },
+        {
+          "name": "down",
+          "type": "string",
+          "optional": false,
+          "jsdoc": "\"down\" to press, \"up\" to release\n *",
+          "enum": ["down", "up"]
+        },
+        {
+          "name": "modifier",
+          "type": "string[] | undefined",
+          "optional": true,
+          "jsdoc": "Optional array of modifier keys\n *\n *"
+        }
+      ],
+      "returns": "void",
+      "async": false,
+      "jsdoc": "Toggle a key state (press down or release up)",
+      "sourceFile": "index.ts"
+    },
+    {
+      "name": "typeString",
+      "kind": "function",
+      "params": [
+        {
+          "name": "text",
+          "type": "string",
+          "optional": false,
+          "jsdoc": "Text string to type\n *\n *"
+        }
+      ],
+      "returns": "void",
+      "async": false,
+      "jsdoc": "Type a string of text by simulating individual keystrokes",
+      "sourceFile": "index.ts"
+    },
+    {
+      "name": "typeStringDelayed",
+      "kind": "function",
+      "params": [
+        {
+          "name": "text",
+          "type": "string",
+          "optional": false,
+          "jsdoc": "Text string to type\n *"
+        },
+        {
+          "name": "cpm",
+          "type": "number",
+          "optional": false,
+          "jsdoc": "Characters per minute (typing speed)\n *\n *"
+        }
+      ],
+      "returns": "void",
+      "async": false,
+      "jsdoc": "Type a string with a specified delay between characters (simulates human typing speed)",
+      "sourceFile": "index.ts"
+    },
+    {
+      "name": "unicodeTap",
+      "kind": "function",
+      "params": [
+        {
+          "name": "codePoint",
+          "type": "number",
+          "optional": false,
+          "jsdoc": "Unicode code point (e.g., 0x1F600 for 😀)\n *\n *"
+        }
+      ],
+      "returns": "void",
+      "async": false,
+      "jsdoc": "Tap a Unicode character by its code point",
+      "sourceFile": "index.ts"
+    },
+    {
+      "name": "setKeyboardDelay",
+      "kind": "function",
+      "params": [
+        {
+          "name": "ms",
+          "type": "number",
+          "optional": false,
+          "jsdoc": "Delay in milliseconds\n *\n *"
+        }
+      ],
+      "returns": "void",
+      "async": false,
+      "jsdoc": "Set the delay between keyboard operations in milliseconds",
+      "sourceFile": "index.ts"
+    },
+    {
+      "name": "bitmapColorAt",
+      "kind": "function",
+      "params": [
+        {
+          "name": "bitmap",
+          "type": "bot.Bitmap",
+          "optional": false,
+          "jsdoc": "Bitmap object from screen capture\n *"
+        },
+        {
+          "name": "x",
+          "type": "number",
+          "optional": false,
+          "jsdoc": "X coordinate in the bitmap\n *"
+        },
+        {
+          "name": "y",
+          "type": "number",
+          "optional": false,
+          "jsdoc": "Y coordinate in the bitmap\n *"
+        }
+      ],
+      "returns": "string",
+      "async": false,
+      "jsdoc": "Get the color at specific coordinates in a bitmap",
+      "returnsDoc": "Hex color string (e.g., \"#FF0000\" for red)\n *\n *",
+      "sourceFile": "index.ts"
+    },
+    {
+      "name": "captureScreen",
+      "kind": "function",
+      "params": [],
+      "returns": "Promise<bot.ScreenCaptureResult>",
+      "async": true,
+      "jsdoc": "Capture the entire screen as a PNG image",
+      "returnsDoc": "Promise resolving to screen capture with PNG buffer\n *\n *",
+      "sourceFile": "index.ts"
+    },
+    {
+      "name": "captureScreenRegion",
+      "kind": "function",
+      "params": [
+        {
+          "name": "x",
+          "type": "number",
+          "optional": false,
+          "jsdoc": "X coordinate of the top-left corner\n *"
+        },
+        {
+          "name": "y",
+          "type": "number",
+          "optional": false,
+          "jsdoc": "Y coordinate of the top-left corner\n *"
+        },
+        {
+          "name": "width",
+          "type": "number",
+          "optional": false,
+          "jsdoc": "Width of the region in pixels\n *"
+        },
+        {
+          "name": "height",
+          "type": "number",
+          "optional": false,
+          "jsdoc": "Height of the region in pixels\n *"
+        }
+      ],
+      "returns": "Promise<bot.ScreenCaptureResult>",
+      "async": true,
+      "jsdoc": "Capture a specific region of the screen as a PNG image",
+      "returnsDoc": "Promise resolving to screen capture with PNG buffer\n *\n *",
+      "sourceFile": "index.ts"
+    },
+    {
+      "name": "getPixelColorHex",
+      "kind": "function",
+      "params": [
+        {
+          "name": "x",
+          "type": "number",
+          "optional": false,
+          "jsdoc": "X coordinate on screen\n *"
+        },
+        {
+          "name": "y",
+          "type": "number",
+          "optional": false,
+          "jsdoc": "Y coordinate on screen\n *"
+        }
+      ],
+      "returns": "Promise<string>",
+      "async": true,
+      "jsdoc": "Get the color of a pixel at specific screen coordinates",
+      "returnsDoc": "Promise resolving to hex color string (e.g., \"#FF0000\")\n *\n *",
+      "sourceFile": "index.ts"
+    },
+    {
+      "name": "getScreen",
+      "kind": "function",
+      "params": [],
+      "returns": "bot.Screen",
+      "async": false,
+      "jsdoc": "Get the global Screen instance for capture operations",
+      "returnsDoc": "Screen object\n *\n *",
+      "sourceFile": "index.ts"
+    },
+    {
+      "name": "getScreenSize",
+      "kind": "function",
+      "params": [],
+      "returns": "bot.ScreenSizeResult",
+      "async": false,
+      "jsdoc": "Get the dimensions of the primary screen",
+      "returnsDoc": "Object containing width and height in pixels\n *\n *",
+      "sourceFile": "index.ts"
+    },
+    {
+      "name": "updateScreenMetrics",
+      "kind": "function",
+      "params": [],
+      "returns": "void",
+      "async": false,
+      "jsdoc": "Update screen metrics (refresh monitor information)\nCall this after display configuration changes",
+      "sourceFile": "index.ts"
+    },
+    {
+      "name": "getClipboard",
+      "kind": "function",
+      "params": [],
+      "returns": "string",
+      "async": false,
+      "jsdoc": "Get text content from the system clipboard",
+      "returnsDoc": "Current clipboard text content\n *\n *",
+      "sourceFile": "index.ts"
+    },
+    {
+      "name": "setClipboard",
+      "kind": "function",
+      "params": [
+        {
+          "name": "text",
+          "type": "string",
+          "optional": false,
+          "jsdoc": "Text to copy to clipboard\n *\n *"
+        }
+      ],
+      "returns": "void",
+      "async": false,
+      "jsdoc": "Set text content to the system clipboard",
+      "sourceFile": "index.ts"
+    },
+    {
+      "name": "clearClipboard",
+      "kind": "function",
+      "params": [],
+      "returns": "void",
+      "async": false,
+      "jsdoc": "Clear the system clipboard contents",
+      "sourceFile": "index.ts"
+    },
+    {
+      "name": "getClipboardImage",
+      "kind": "function",
+      "params": [],
+      "returns": "Buffer<ArrayBufferLike>",
+      "async": false,
+      "jsdoc": "Get image from clipboard as a PNG-encoded buffer",
+      "returnsDoc": "PNG-encoded image buffer\n *\n *",
+      "sourceFile": "index.ts"
+    },
+    {
+      "name": "setClipboardImage",
+      "kind": "function",
+      "params": [
+        {
+          "name": "imageBuffer",
+          "type": "Buffer<ArrayBufferLike>",
+          "optional": false,
+          "jsdoc": "PNG-encoded image buffer\n *\n *"
+        }
+      ],
+      "returns": "void",
+      "async": false,
+      "jsdoc": "Set image to clipboard from a PNG-encoded buffer",
+      "sourceFile": "index.ts"
+    },
+    {
+      "name": "getActiveWindow",
+      "kind": "function",
+      "params": [],
+      "returns": "bot.WindowInfoResult",
+      "async": false,
+      "jsdoc": "Get information about the currently active (focused) window",
+      "returnsDoc": "WindowInfo object with title, process, position, and dimensions\n *\n *",
+      "sourceFile": "index.ts"
+    },
+    {
+      "name": "getAllWindows",
+      "kind": "function",
+      "params": [],
+      "returns": "bot.WindowInfoResult[]",
+      "async": false,
+      "jsdoc": "Get a list of all visible windows\n\n**Note:** Currently returns only the active window due to API limitations of the underlying library.\nFuture versions may support enumerating all windows.",
+      "returnsDoc": "Array of WindowInfo objects\n *\n *",
+      "sourceFile": "index.ts"
+    },
+    {
+      "name": "findWindowsByTitle",
+      "kind": "function",
+      "params": [
+        {
+          "name": "title",
+          "type": "string",
+          "optional": false,
+          "jsdoc": "Title text to search for (case-insensitive partial match)\n *"
+        }
+      ],
+      "returns": "bot.WindowInfoResult[]",
+      "async": false,
+      "jsdoc": "Find windows by title using case-insensitive partial matching\n\n**Note:** Currently searches only the active window due to API limitations of the underlying library.\nFuture versions may support searching all windows.",
+      "returnsDoc": "Array of matching WindowInfo objects\n *\n *",
+      "sourceFile": "index.ts"
+    },
+    {
+      "name": "findWindowsByProcess",
+      "kind": "function",
+      "params": [
+        {
+          "name": "processName",
+          "type": "string",
+          "optional": false,
+          "jsdoc": "Process name to search for (case-insensitive partial match)\n *"
+        }
+      ],
+      "returns": "bot.WindowInfoResult[]",
+      "async": false,
+      "jsdoc": "Find windows by process name using case-insensitive partial matching\n\n**Note:** Currently searches only the active window due to API limitations of the underlying library.\nFuture versions may support searching all windows.",
+      "returnsDoc": "Array of matching WindowInfo objects\n *\n *",
+      "sourceFile": "index.ts"
+    },
+    {
+      "name": "doubleClick",
+      "kind": "function",
+      "params": [
+        {
+          "name": "x",
+          "type": "number | undefined",
+          "optional": true,
+          "jsdoc": "Optional X coordinate to move to before double-clicking\n *"
+        },
+        {
+          "name": "y",
+          "type": "number | undefined",
+          "optional": true,
+          "jsdoc": "Optional Y coordinate to move to before double-clicking\n *\n *"
+        }
+      ],
+      "returns": "void",
+      "async": false,
+      "jsdoc": "Perform a double-click at the current mouse position or at specified coordinates",
+      "sourceFile": "index.ts"
+    },
+    {
+      "name": "rightClick",
+      "kind": "function",
+      "params": [
+        {
+          "name": "x",
+          "type": "number | undefined",
+          "optional": true,
+          "jsdoc": "Optional X coordinate to move to before right-clicking\n *"
+        },
+        {
+          "name": "y",
+          "type": "number | undefined",
+          "optional": true,
+          "jsdoc": "Optional Y coordinate to move to before right-clicking\n *\n *"
+        }
+      ],
+      "returns": "void",
+      "async": false,
+      "jsdoc": "Perform a right-click at the current mouse position or at specified coordinates",
+      "sourceFile": "index.ts"
+    },
+    {
+      "name": "middleClick",
+      "kind": "function",
+      "params": [
+        {
+          "name": "x",
+          "type": "number | undefined",
+          "optional": true,
+          "jsdoc": "Optional X coordinate to move to before middle-clicking\n *"
+        },
+        {
+          "name": "y",
+          "type": "number | undefined",
+          "optional": true,
+          "jsdoc": "Optional Y coordinate to move to before middle-clicking\n *\n *"
+        }
+      ],
+      "returns": "void",
+      "async": false,
+      "jsdoc": "Perform a middle-click at the current mouse position or at specified coordinates",
+      "sourceFile": "index.ts"
+    },
+    {
+      "name": "leftClick",
+      "kind": "function",
+      "params": [
+        {
+          "name": "x",
+          "type": "number | undefined",
+          "optional": true,
+          "jsdoc": "Optional X coordinate to move to before left-clicking\n *"
+        },
+        {
+          "name": "y",
+          "type": "number | undefined",
+          "optional": true,
+          "jsdoc": "Optional Y coordinate to move to before left-clicking\n *\n *"
+        }
+      ],
+      "returns": "void",
+      "async": false,
+      "jsdoc": "Perform a left-click at the current mouse position or at specified coordinates",
+      "sourceFile": "index.ts"
+    },
+    {
+      "name": "mouseDown",
+      "kind": "function",
+      "params": [
+        {
+          "name": "button",
+          "type": "\"left\" | \"right\" | \"middle\"",
+          "optional": true,
+          "default": "\"left\"",
+          "jsdoc": "Mouse button to hold: \"left\", \"right\", or \"middle\" (default: \"left\")\n *\n *",
+          "enum": ["left", "right", "middle"]
+        }
+      ],
+      "returns": "void",
+      "async": false,
+      "jsdoc": "Press and hold a mouse button down",
+      "sourceFile": "index.ts"
+    },
+    {
+      "name": "mouseUp",
+      "kind": "function",
+      "params": [
+        {
+          "name": "button",
+          "type": "\"left\" | \"right\" | \"middle\"",
+          "optional": true,
+          "default": "\"left\"",
+          "jsdoc": "Mouse button to release: \"left\", \"right\", or \"middle\" (default: \"left\")\n *\n *",
+          "enum": ["left", "right", "middle"]
+        }
+      ],
+      "returns": "void",
+      "async": false,
+      "jsdoc": "Release a held mouse button",
+      "sourceFile": "index.ts"
+    },
+    {
+      "name": "Bitmap",
+      "kind": "interface",
+      "sourceFile": "index.d.ts"
+    },
+    {
+      "name": "MousePosition",
+      "kind": "interface",
+      "sourceFile": "index.d.ts"
+    },
+    {
+      "name": "ScreenCapture",
+      "kind": "interface",
+      "sourceFile": "index.d.ts"
+    },
+    {
+      "name": "ScreenSize",
+      "kind": "interface",
+      "sourceFile": "index.d.ts"
+    },
+    {
+      "name": "WindowInfo",
+      "kind": "interface",
+      "sourceFile": "index.d.ts"
+    },
+    {
+      "name": "PixelColor",
+      "kind": "type",
+      "sourceFile": "index.ts"
+    },
+    {
+      "name": "Screen",
+      "kind": "value",
+      "type": "typeof bot.Screen",
+      "sourceFile": "index.ts"
+    },
+    {
+      "name": "ColorInfo",
+      "kind": "interface",
+      "sourceFile": "screenshot.ts"
+    },
+    {
+      "name": "ColorPickerOptions",
+      "kind": "interface",
+      "sourceFile": "screenshot.ts"
+    },
+    {
+      "name": "HslColor",
+      "kind": "interface",
+      "sourceFile": "screenshot.ts"
+    },
+    {
+      "name": "InteractiveCaptureOptions",
+      "kind": "interface",
+      "sourceFile": "screenshot.ts"
+    },
+    {
+      "name": "Position",
+      "kind": "interface",
+      "sourceFile": "screenshot.ts"
+    },
+    {
+      "name": "RgbaColor",
+      "kind": "interface",
+      "sourceFile": "screenshot.ts"
+    },
+    {
+      "name": "RgbColor",
+      "kind": "interface",
+      "sourceFile": "screenshot.ts"
+    },
+    {
+      "name": "SaveImageOptions",
+      "kind": "interface",
+      "sourceFile": "screenshot.ts"
+    },
+    {
+      "name": "ScreenRegion",
+      "kind": "interface",
+      "sourceFile": "screenshot.ts"
+    },
+    {
+      "name": "ScreenshotResult",
+      "kind": "interface",
+      "sourceFile": "screenshot.ts"
+    },
+    {
+      "name": "ScreenshotToolOptions",
+      "kind": "interface",
+      "sourceFile": "screenshot.ts"
+    },
+    {
+      "name": "captureAndCopy",
+      "kind": "function",
+      "params": [
+        {
+          "name": "region",
+          "type": "ScreenRegion | undefined",
+          "optional": true,
+          "jsdoc": "Optional region to capture\n *\n *"
+        }
+      ],
+      "returns": "Promise<void>",
+      "async": true,
+      "jsdoc": "Capture and copy to clipboard in one call",
+      "sourceFile": "screenshot.ts"
+    },
+    {
+      "name": "captureAndSave",
+      "kind": "function",
+      "params": [
+        {
+          "name": "path",
+          "type": "string",
+          "optional": false,
+          "jsdoc": "Output file path\n *"
+        },
+        {
+          "name": "region",
+          "type": "ScreenRegion | undefined",
+          "optional": true,
+          "jsdoc": "Optional region to capture\n *"
+        },
+        {
+          "name": "options",
+          "type": "SaveImageOptions | undefined",
+          "optional": true,
+          "jsdoc": "Save options\n *\n *"
+        }
+      ],
+      "returns": "Promise<void>",
+      "async": true,
+      "jsdoc": "Capture and save screenshot in one call",
+      "sourceFile": "screenshot.ts"
+    },
+    {
+      "name": "captureRegion",
+      "kind": "function",
+      "params": [
+        {
+          "name": "x",
+          "type": "number",
+          "optional": false,
+          "jsdoc": "X coordinate\n *"
+        },
+        {
+          "name": "y",
+          "type": "number",
+          "optional": false,
+          "jsdoc": "Y coordinate\n *"
+        },
+        {
+          "name": "width",
+          "type": "number",
+          "optional": false,
+          "jsdoc": "Width in pixels\n *"
+        },
+        {
+          "name": "height",
+          "type": "number",
+          "optional": false,
+          "jsdoc": "Height in pixels\n *"
+        }
+      ],
+      "returns": "Promise<ScreenshotResult>",
+      "async": true,
+      "jsdoc": "Capture region with simplified API",
+      "returnsDoc": "Screenshot result\n *\n *",
+      "sourceFile": "screenshot.ts"
+    },
+    {
+      "name": "copyScreenshotToClipboard",
+      "kind": "function",
+      "params": [
+        {
+          "name": "result",
+          "type": "ScreenshotResult",
+          "optional": false,
+          "jsdoc": "Screenshot result to copy\n *\n *"
+        }
+      ],
+      "returns": "Promise<void>",
+      "async": true,
+      "jsdoc": "Copy screenshot to clipboard",
+      "sourceFile": "screenshot.ts"
+    },
+    {
+      "name": "getPixelColor",
+      "kind": "function",
+      "params": [
+        {
+          "name": "x",
+          "type": "number",
+          "optional": false,
+          "jsdoc": "X coordinate\n *"
+        },
+        {
+          "name": "y",
+          "type": "number",
+          "optional": false,
+          "jsdoc": "Y coordinate\n *"
+        }
+      ],
+      "returns": "Promise<ColorInfo>",
+      "async": true,
+      "jsdoc": "Get pixel color at specific coordinates (shorthand)",
+      "returnsDoc": "Color information\n *\n *",
+      "sourceFile": "screenshot.ts"
+    },
+    {
+      "name": "quickScreenshot",
+      "kind": "function",
+      "params": [],
+      "returns": "Promise<ScreenshotResult>",
+      "async": true,
+      "jsdoc": "Quick screenshot of entire screen",
+      "returnsDoc": "Screenshot result\n *\n *",
+      "sourceFile": "screenshot.ts"
+    },
+    {
+      "name": "quickScreenshotRegion",
+      "kind": "function",
+      "params": [
+        {
+          "name": "region",
+          "type": "ScreenRegion",
+          "optional": false,
+          "jsdoc": "Region to capture\n *"
+        }
+      ],
+      "returns": "Promise<ScreenshotResult>",
+      "async": true,
+      "jsdoc": "Quick screenshot of specific region",
+      "returnsDoc": "Screenshot result\n *\n *",
+      "sourceFile": "screenshot.ts"
+    },
+    {
+      "name": "ScreenshotTool",
+      "kind": "class",
+      "jsdoc": "Advanced screenshot tool with interactive selection, color picking, and annotations",
+      "sourceFile": "screenshot.ts"
+    },
+    {
+      "name": "saveScreenshotToFile",
+      "kind": "function",
+      "params": [
+        {
+          "name": "result",
+          "type": "ScreenshotResult",
+          "optional": false,
+          "jsdoc": "Screenshot result to save\n *"
+        },
+        {
+          "name": "filePath",
+          "type": "string",
+          "optional": false,
+          "jsdoc": "File path (extension determines format)\n *\n *"
+        },
+        {
+          "name": "_options",
+          "type": "SaveImageOptions | undefined",
+          "optional": true
+        }
+      ],
+      "returns": "Promise<void>",
+      "async": true,
+      "jsdoc": "Save screenshot to file",
+      "sourceFile": "screenshot.ts"
+    },
+    {
+      "name": "startInteractiveCapture",
+      "kind": "function",
+      "params": [
+        {
+          "name": "_options",
+          "type": "InteractiveCaptureOptions | undefined",
+          "optional": true
+        }
+      ],
+      "returns": "Promise<ScreenshotResult>",
+      "async": true,
+      "jsdoc": "Start interactive screenshot capture\n\nNote: Interactive mode is not yet fully implemented.\nUse quickScreenshot() or quickScreenshotRegion() instead.",
+      "returnsDoc": "Screenshot result",
+      "sourceFile": "screenshot.ts"
+    },
+    {
+      "name": "ImageResource",
+      "kind": "interface",
+      "sourceFile": "image-match.ts"
+    },
+    {
+      "name": "MatchConfig",
+      "kind": "interface",
+      "sourceFile": "image-match.ts"
+    },
+    {
+      "name": "MatchResult",
+      "kind": "interface",
+      "sourceFile": "image-match.ts"
+    },
+    {
+      "name": "findAllInRegion",
+      "kind": "function",
+      "params": [
+        {
+          "name": "template",
+          "type": "ImageResource",
+          "optional": false,
+          "jsdoc": "ImageResource to search for\n *"
+        },
+        {
+          "name": "x",
+          "type": "number",
+          "optional": false,
+          "jsdoc": "X coordinate of search region\n *"
+        },
+        {
+          "name": "y",
+          "type": "number",
+          "optional": false,
+          "jsdoc": "Y coordinate of search region\n *"
+        },
+        {
+          "name": "width",
+          "type": "number",
+          "optional": false,
+          "jsdoc": "Width of search region\n *"
+        },
+        {
+          "name": "height",
+          "type": "number",
+          "optional": false,
+          "jsdoc": "Height of search region\n *"
+        },
+        {
+          "name": "config",
+          "type": "MatchConfig | undefined",
+          "optional": true,
+          "jsdoc": "Optional matching configuration\n *"
+        }
+      ],
+      "returns": "Promise<MatchResult[]>",
+      "async": true,
+      "jsdoc": "Find all matches of template image in a specific screen region",
+      "returnsDoc": "Promise resolving to array of MatchResults (coordinates are absolute screen coordinates)\n *\n *",
+      "sourceFile": "image-match.ts"
+    },
+    {
+      "name": "findAllOnScreen",
+      "kind": "function",
+      "params": [
+        {
+          "name": "template",
+          "type": "ImageResource",
+          "optional": false,
+          "jsdoc": "ImageResource to search for\n *"
+        },
+        {
+          "name": "config",
+          "type": "MatchConfig | undefined",
+          "optional": true,
+          "jsdoc": "Optional matching configuration\n *"
+        }
+      ],
+      "returns": "Promise<MatchResult[]>",
+      "async": true,
+      "jsdoc": "Find all matches of template image on screen",
+      "returnsDoc": "Promise resolving to array of MatchResults, sorted by confidence descending\n *\n *",
+      "sourceFile": "image-match.ts"
+    },
+    {
+      "name": "findInRegion",
+      "kind": "function",
+      "params": [
+        {
+          "name": "template",
+          "type": "ImageResource",
+          "optional": false,
+          "jsdoc": "ImageResource to search for\n *"
+        },
+        {
+          "name": "x",
+          "type": "number",
+          "optional": false,
+          "jsdoc": "X coordinate of search region\n *"
+        },
+        {
+          "name": "y",
+          "type": "number",
+          "optional": false,
+          "jsdoc": "Y coordinate of search region\n *"
+        },
+        {
+          "name": "width",
+          "type": "number",
+          "optional": false,
+          "jsdoc": "Width of search region\n *"
+        },
+        {
+          "name": "height",
+          "type": "number",
+          "optional": false,
+          "jsdoc": "Height of search region\n *"
+        },
+        {
+          "name": "config",
+          "type": "MatchConfig | undefined",
+          "optional": true,
+          "jsdoc": "Optional matching configuration\n *"
+        }
+      ],
+      "returns": "Promise<MatchResult | null>",
+      "async": true,
+      "jsdoc": "Find first match of template image in a specific screen region",
+      "returnsDoc": "Promise resolving to MatchResult or null (coordinates are absolute screen coordinates)\n *\n *",
+      "sourceFile": "image-match.ts"
+    },
+    {
+      "name": "findOnScreen",
+      "kind": "function",
+      "params": [
+        {
+          "name": "template",
+          "type": "ImageResource",
+          "optional": false,
+          "jsdoc": "ImageResource to search for\n *"
+        },
+        {
+          "name": "config",
+          "type": "MatchConfig | undefined",
+          "optional": true,
+          "jsdoc": "Optional matching configuration\n *"
+        }
+      ],
+      "returns": "Promise<MatchResult | null>",
+      "async": true,
+      "jsdoc": "Find first match of template image on screen",
+      "returnsDoc": "Promise resolving to MatchResult or null if not found\n *\n *",
+      "sourceFile": "image-match.ts"
+    },
+    {
+      "name": "getMatchBounds",
+      "kind": "function",
+      "params": [
+        {
+          "name": "match",
+          "type": "MatchResult",
+          "optional": false,
+          "jsdoc": "MatchResult to get bounds for\n *"
+        }
+      ],
+      "returns": "{ left: number; top: number; right: number; bottom: number; }",
+      "async": false,
+      "jsdoc": "Get the bounding rectangle of a match result",
+      "returnsDoc": "Object with left, top, right, bottom coordinates\n *\n *",
+      "sourceFile": "image-match.ts"
+    },
+    {
+      "name": "getMatchCenter",
+      "kind": "function",
+      "params": [
+        {
+          "name": "match",
+          "type": "MatchResult",
+          "optional": false,
+          "jsdoc": "MatchResult to calculate center for\n *"
+        }
+      ],
+      "returns": "{ x: number; y: number; }",
+      "async": false,
+      "jsdoc": "Get the center point of a match result",
+      "returnsDoc": "Object with x and y coordinates of the center\n *\n *",
+      "sourceFile": "image-match.ts"
+    },
+    {
+      "name": "imageResource",
+      "kind": "function",
+      "params": [
+        {
+          "name": "path",
+          "type": "string",
+          "optional": false,
+          "jsdoc": "Path to the image file (PNG, JPG, BMP, etc.)\n *"
+        }
+      ],
+      "returns": "Promise<ImageResource>",
+      "async": true,
+      "jsdoc": "Load an image from file for use as a template",
+      "returnsDoc": "Promise resolving to ImageResource\n *\n *",
+      "sourceFile": "image-match.ts"
+    },
+    {
+      "name": "imageResourceFromBuffer",
+      "kind": "function",
+      "params": [
+        {
+          "name": "buffer",
+          "type": "Buffer<ArrayBufferLike>",
+          "optional": false,
+          "jsdoc": "PNG, JPG, or other image format buffer\n *"
+        }
+      ],
+      "returns": "ImageResource",
+      "async": false,
+      "jsdoc": "Create an image resource from a Buffer",
+      "returnsDoc": "ImageResource\n *\n *",
+      "sourceFile": "image-match.ts"
+    },
+    {
+      "name": "imageResourceSync",
+      "kind": "function",
+      "params": [
+        {
+          "name": "path",
+          "type": "string",
+          "optional": false,
+          "jsdoc": "Path to the image file (PNG, JPG, BMP, etc.)\n *"
+        }
+      ],
+      "returns": "ImageResource",
+      "async": false,
+      "jsdoc": "Load an image synchronously from file for use as a template",
+      "returnsDoc": "ImageResource\n *\n *",
+      "sourceFile": "image-match.ts"
+    },
+    {
+      "name": "waitFor",
+      "kind": "function",
+      "params": [
+        {
+          "name": "template",
+          "type": "ImageResource",
+          "optional": false,
+          "jsdoc": "ImageResource to wait for\n *"
+        },
+        {
+          "name": "timeout",
+          "type": "number",
+          "optional": true,
+          "default": "10000",
+          "jsdoc": "Maximum time to wait in milliseconds (default: 10000)\n *"
+        },
+        {
+          "name": "interval",
+          "type": "number",
+          "optional": true,
+          "default": "500",
+          "jsdoc": "Time between checks in milliseconds (default: 500)\n *"
+        },
+        {
+          "name": "config",
+          "type": "MatchConfig | undefined",
+          "optional": true,
+          "jsdoc": "Optional matching configuration\n *"
+        }
+      ],
+      "returns": "Promise<MatchResult | null>",
+      "async": true,
+      "jsdoc": "Wait for a template image to appear on screen",
+      "returnsDoc": "Promise resolving to MatchResult when found, or null if timeout\n *\n *",
+      "sourceFile": "image-match.ts"
+    },
+    {
+      "name": "waitForGone",
+      "kind": "function",
+      "params": [
+        {
+          "name": "template",
+          "type": "ImageResource",
+          "optional": false,
+          "jsdoc": "ImageResource to wait for disappearance\n *"
+        },
+        {
+          "name": "timeout",
+          "type": "number",
+          "optional": true,
+          "default": "10000",
+          "jsdoc": "Maximum time to wait in milliseconds (default: 10000)\n *"
+        },
+        {
+          "name": "interval",
+          "type": "number",
+          "optional": true,
+          "default": "500",
+          "jsdoc": "Time between checks in milliseconds (default: 500)\n *"
+        },
+        {
+          "name": "config",
+          "type": "MatchConfig | undefined",
+          "optional": true,
+          "jsdoc": "Optional matching configuration\n *"
+        }
+      ],
+      "returns": "Promise<boolean>",
+      "async": true,
+      "jsdoc": "Wait for a template image to disappear from screen",
+      "returnsDoc": "Promise resolving to true if disappeared, false if timeout\n *\n *",
+      "sourceFile": "image-match.ts"
+    }
+  ]
+}
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index 4f410ac..91aaab1 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -198,6 +198,34 @@ importers:
         specifier: ^4.0.9
         version: 4.0.9(@types/debug@4.1.12)(@types/node@24.5.2)(jiti@2.6.1)(lightningcss@1.30.2)(sass@1.51.0)(tsx@4.20.6)(yaml@2.8.1)
 
+  packages/bot-cli:
+    dependencies:
+      '@tego/botjs':
+        specifier: workspace:*
+        version: link:../botjs
+      commander:
+        specifier: ^13.0.0
+        version: 13.1.0
+    devDependencies:
+      '@types/node':
+        specifier: ^24.5.2
+        version: 24.5.2
+      ts-morph:
+        specifier: ^27.0.0
+        version: 27.0.2
+      tsdown:
+        specifier: ^0.16.6
+        version: 0.16.6(typescript@5.9.2)
+      tsx:
+        specifier: ^4.20.6
+        version: 4.20.6
+      typescript:
+        specifier: ^5.9.2
+        version: 5.9.2
+      vitest:
+        specifier: ^4.0.9
+        version: 4.0.9(@types/debug@4.1.12)(@types/node@24.5.2)(jiti@2.6.1)(lightningcss@1.30.2)(sass@1.51.0)(tsx@4.20.6)(yaml@2.8.1)
+
   packages/botjs:
     dependencies:
       '@tego/bot':
@@ -1025,6 +1053,14 @@ packages:
       '@types/node':
         optional: true
 
+  '@isaacs/balanced-match@4.0.1':
+    resolution: {integrity: sha512-yzMTt9lEb8Gv7zRioUilSglI0c0smZ9k5D65677DLWLtWJaXIS3CqcGyUFByYKlnUj6TkjLVs54fBl6+TiGQDQ==}
+    engines: {node: 20 || >=22}
+
+  '@isaacs/brace-expansion@5.0.0':
+    resolution: {integrity: sha512-ZT55BDLV0yv0RBm2czMiZ+SqCGO7AvmOM3G/w2xhVPH+te0aKgFjmBvGlL1dH+ql2tgGO3MVrbb3jCKyvpgnxA==}
+    engines: {node: 20 || >=22}
+
   '@jridgewell/gen-mapping@0.3.13':
     resolution: {integrity: sha512-2kkt/7niJ6MgEPxF0bYdQ6etZaA+fQvDcLKckhy1yIQOzaoKjBBjSj63/aLVjYE3qhRt5dvM+uUyfCg6UKCBbA==}
 
@@ -2165,6 +2201,9 @@ packages:
   '@tauri-apps/plugin-opener@2.5.2':
     resolution: {integrity: sha512-ei/yRRoCklWHImwpCcDK3VhNXx+QXM9793aQ64YxpqVF0BDuuIlXhZgiAkc15wnPVav+IbkYhmDJIv5R326Mew==}
 
+  '@ts-morph/common@0.28.1':
+    resolution: {integrity: sha512-W74iWf7ILp1ZKNYXY5qbddNaml7e9Sedv5lvU1V8lftlitkc9Pq1A+jlH23ltDgWYeZFFEqGCD1Ies9hqu3O+g==}
+
   '@tweenjs/tween.js@25.0.0':
     resolution: {integrity: sha512-XKLA6syeBUaPzx4j3qwMqzzq+V4uo72BnlbOjmuljLrRqdsd3qnzvZZoxvMHZ23ndsRS4aufU6JOZYpCbU6T1A==}
 
@@ -2640,6 +2679,9 @@ packages:
     resolution: {integrity: sha512-eYm0QWBtUrBWZWG0d386OGAw16Z995PiOVo2B7bjWSbHedGl5e0ZWaq65kOGgUSNesEIDkB9ISbTg/JK9dhCZA==}
     engines: {node: '>=6'}
 
+  code-block-writer@13.0.3:
+    resolution: {integrity: sha512-Oofo0pq3IKnsFtuHqSF7TqBfr71aeyZDVJ0HpmqB7FBM2qEigL0iPONSCZSO9pE9dZTAxANe5XHG9Uy0YMv8cg==}
+
   color-convert@2.0.1:
     resolution: {integrity: sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==}
     engines: {node: '>=7.0.0'}
@@ -3146,9 +3188,6 @@ packages:
     resolution: {integrity: sha512-sTSfBjoXBp89JvIKIefqw7U2CCebsc74kiY6awiGogKtoSGbgjYE/G/+l9sF3MWFPNc9IcoOC4ODfKHfxFmp0g==}
     engines: {node: '>= 0.4'}
 
-  get-tsconfig@4.10.1:
-    resolution: {integrity: sha512-auHyJ4AgMz7vgS8Hp3N6HXSmlMdUyhSUrfBF16w153rxtLIEOE+HGqaBppczZvnHLqQJfiHotCYpNhl0lUROFQ==}
-
   get-tsconfig@4.13.0:
     resolution: {integrity: sha512-1VKTZJCwBrvbd+Wn3AOgQP/2Av+TfTCOlE4AcRJE72W1ksZXbAx8PPBR9RzgTeSPzlPMHrbANMH3LbltH73wxQ==}
 
@@ -3777,6 +3816,10 @@ packages:
     resolution: {integrity: sha512-VP79XUPxV2CigYP3jWwAUFSku2aKqBH7uTAapFWCBqutsbmDo96KY5o8uh6U+/YSIn5OxJnXp73beVkpqMIGhA==}
     engines: {node: '>=18'}
 
+  minimatch@10.1.1:
+    resolution: {integrity: sha512-enIvLvRAFZYXJzkCYG5RKmPfrFArdLv+R+lbQ53BmIMLIry74bjKzX6iHAm8WYamJkhSSEabrWN5D97XnKObjQ==}
+    engines: {node: 20 || >=22}
+
   minimatch@9.0.5:
     resolution: {integrity: sha512-G6T0ZX48xgozx7587koeX9Ys2NYy6Gmv//P89sEte9V9whIapMNF4idKxnW2QtCcLiTWlb/wfCabAtAFWhhBow==}
     engines: {node: '>=16 || 14 >=14.17'}
@@ -3917,6 +3960,9 @@ packages:
   parse5@6.0.1:
     resolution: {integrity: sha512-Ofn/CTFzRGTTxwpNEs9PP93gXShHcTq255nzRYSKe8AkVpZY7e1fpmTfOyoIvjP5HG7Z2ZM7VS9PPhQGW2pOpw==}
 
+  path-browserify@1.0.1:
+    resolution: {integrity: sha512-b7uo2UCUOYZcnF/3ID0lulOJi/bafxa1xPe7ZPsammBSpjSWQkjNxlt635YGS2MiR9GjvuXCtz2emr3jbsz98g==}
+
   path-data-parser@0.1.0:
     resolution: {integrity: sha512-NOnmBpt5Y2RWbuv0LMzsayp3lVylAHLPUTut412ZA3l+C4uw4ZVkQbjShYCQ8TCpUMdPapr4YjUqLYD6v68j+w==}
 
@@ -4357,6 +4403,9 @@ packages:
     resolution: {integrity: sha512-q5W7tVM71e2xjHZTlgfTDoPF/SmqKG5hddq9SzR49CH2hayqRKJtQ4mtRlSxKaJlR/+9rEM+mnBHf7I2/BQcpQ==}
     engines: {node: '>=6.10'}
 
+  ts-morph@27.0.2:
+    resolution: {integrity: sha512-fhUhgeljcrdZ+9DZND1De1029PrE+cMkIP7ooqkLRTrRLTqcki2AstsyJm0vRNbTbVCNJ0idGlbBrfqc7/nA8w==}
+
   tsdown@0.16.6:
     resolution: {integrity: sha512-g3xHEnGdfwJTlXhEkqww3Q/KlCfyNFw4rnzuQ9Gqw8T2xjDYrw94qmSw5wYYTAW5zV1sEfWDlfgxZo5mmtu0NQ==}
     engines: {node: '>=20.19.0'}
@@ -5555,6 +5604,12 @@ snapshots:
     optionalDependencies:
       '@types/node': 24.5.2
 
+  '@isaacs/balanced-match@4.0.1': {}
+
+  '@isaacs/brace-expansion@5.0.0':
+    dependencies:
+      '@isaacs/balanced-match': 4.0.1
+
   '@jridgewell/gen-mapping@0.3.13':
     dependencies:
       '@jridgewell/sourcemap-codec': 1.5.5
@@ -6440,6 +6495,12 @@ snapshots:
     dependencies:
       '@tauri-apps/api': 2.9.1
 
+  '@ts-morph/common@0.28.1':
+    dependencies:
+      minimatch: 10.1.1
+      path-browserify: 1.0.1
+      tinyglobby: 0.2.15
+
   '@tweenjs/tween.js@25.0.0': {}
 
   '@tybys/wasm-util@0.10.1':
@@ -6961,6 +7022,8 @@ snapshots:
 
   clsx@2.1.1: {}
 
+  code-block-writer@13.0.3: {}
+
   color-convert@2.0.1:
     dependencies:
       color-name: 1.1.4
@@ -7473,10 +7536,6 @@ snapshots:
       dunder-proto: 1.0.1
       es-object-atoms: 1.1.1
 
-  get-tsconfig@4.10.1:
-    dependencies:
-      resolve-pkg-maps: 1.0.0
-
   get-tsconfig@4.13.0:
     dependencies:
       resolve-pkg-maps: 1.0.0
@@ -8290,6 +8349,10 @@ snapshots:
 
   mimic-function@5.0.1: {}
 
+  minimatch@10.1.1:
+    dependencies:
+      '@isaacs/brace-expansion': 5.0.0
+
   minimatch@9.0.5:
     dependencies:
       brace-expansion: 2.0.2
@@ -8418,6 +8481,8 @@ snapshots:
 
   parse5@6.0.1: {}
 
+  path-browserify@1.0.1: {}
+
   path-data-parser@0.1.0: {}
 
   path-exists@5.0.0: {}
@@ -8867,6 +8932,11 @@ snapshots:
 
   ts-dedent@2.2.0: {}
 
+  ts-morph@27.0.2:
+    dependencies:
+      '@ts-morph/common': 0.28.1
+      code-block-writer: 13.0.3
+
   tsdown@0.16.6(typescript@5.9.2):
     dependencies:
       ansis: 4.2.0
@@ -8898,7 +8968,7 @@ snapshots:
   tsx@4.20.6:
     dependencies:
       esbuild: 0.25.12
-      get-tsconfig: 4.10.1
+      get-tsconfig: 4.13.0
     optionalDependencies:
       fsevents: 2.3.3