@kortix/agent-tunnel 0.1.4 → 0.12.8

package/src/client/cli.ts

@@ -1,115 +1,72 @@
 /**
- * Agent Tunnel CLI — interact with the user's local machine via Agent Tunnel.
+ * Agent Tunnel CLI: filesystem, shell, and CUA Driver-backed computer control.
  *
  * Usage: agent-tunnel-cli <command> [args as JSON]
- *
- * Commands:
- *   status                                          — list all tunnel connections
- *   fs_read   '{"path":"/Users/me/file.txt"}'       — read a file
- *   fs_write  '{"path":"/tmp/out.txt","content":"hello"}' — write a file
- *   fs_list   '{"path":"/Users/me"}'                — list directory
- *   shell     '{"command":"git","args":["status"]}'  — run a command
- *   screenshot                                       — take a screenshot
- *   click     '{"x":100,"y":200}'                    — click at coordinates
- *   mouse_move '{"x":100,"y":200}'                   — move mouse
- *   mouse_drag '{"fromX":0,"fromY":0,"toX":100,"toY":100}' — drag
- *   mouse_scroll '{"x":500,"y":500,"deltaY":3}'     — scroll
- *   type      '{"text":"hello world"}'               — type text
- *   key       '{"keys":["cmd","s"]}'                 — press key combo
- *   window_list                                      — list windows
- *   window_focus '{"windowId":123}'                  — focus a window
- *   app_launch '{"app":"Safari"}'                    — launch app
- *   app_quit  '{"app":"Safari"}'                     — quit app
- *   clipboard_read                                   — read clipboard
- *   clipboard_write '{"text":"copied"}'              — write clipboard
- *   screen_info                                      — get screen resolution
- *   cursor_image                                     — screenshot around cursor
- *   ax_tree   '{"pid":1234}'                         — accessibility tree
- *   ax_action '{"elementId":"0.3.1","action":"AXPress"}' — perform AX action
- *   ax_set_value '{"elementId":"0.3.1","value":"hello"}' — set element value
- *   ax_focus  '{"elementId":"0.3.1"}'                — focus element
- *   ax_search '{"query":"Submit"}'                   — search AX tree
  */
 
-import { writeFileSync, mkdirSync, readFileSync } from "fs";
-import { join } from "path";
-import { tmpdir } from "os";
-import { randomBytes } from "crypto";
-import { TunnelClient, TunnelClientError } from "./tunnel-client";
-import type { AXElement } from "./tunnel-client";
+import { readFileSync } from 'fs';
+import { TunnelClient, TunnelClientError } from './tunnel-client';
 
-// ── Env resolution (s6 → process.env) ─────────────────────────────────────
+const S6_ENV_DIR = process.env.S6_ENV_DIR || '/run/s6/container_environment';
+const FALLBACK_API_URL = 'http://localhost:8008';
 
-const S6_ENV_DIR = process.env.S6_ENV_DIR || "/run/s6/container_environment";
+const ALL_COMMANDS = [
+  'status',
+  'fs_read',
+  'fs_write',
+  'fs_list',
+  'shell',
+  'cua_ensure',
+  'cua_start_daemon',
+  'cua_status',
+  'cua_version',
+  'cua_list_tools',
+  'cua_describe',
+  'cua_call',
+  'cua_list_apps',
+  'cua_list_windows',
+  'cua_get_window_state',
+  'cua_click',
+  'cua_type_text',
+  'cua_hotkey',
+];
 
 function getEnv(key: string): string | undefined {
   try {
-    const val = readFileSync(`${S6_ENV_DIR}/${key}`, "utf-8").trim();
-    if (val) return val;
+    const value = readFileSync(`${S6_ENV_DIR}/${key}`, 'utf-8').trim();
+    if (value) return value;
   } catch {}
   return process.env[key];
 }
 
-// ── Client setup ──────────────────────────────────────────────────────────
-
-const FALLBACK_API_URL = "http://localhost:8008";
-
 function getApiBase(): string {
-  const raw = getEnv("TUNNEL_API_URL") || FALLBACK_API_URL;
-  const url = raw.startsWith("http") ? raw : FALLBACK_API_URL;
-  // Strip /v1/router suffix — TUNNEL_API_URL sometimes includes the router path
-  // but the CLI appends its own /v1/tunnel path.
-  return url.replace(/\/+$/, "").replace(/\/v1\/router\/?$/, "");
+  const raw = getEnv('TUNNEL_API_URL') || FALLBACK_API_URL;
+  const url = raw.startsWith('http') ? raw : FALLBACK_API_URL;
+  return url.replace(/\/+$/, '').replace(/\/v1\/router\/?$/, '');
 }
 
 const client = new TunnelClient({
   apiUrl: `${getApiBase()}/v1/tunnel`,
-  token: getEnv("TUNNEL_TOKEN") || "",
-  tunnelId: getEnv("TUNNEL_ID"),
+  token: getEnv('TUNNEL_TOKEN') || '',
+  tunnelId: getEnv('TUNNEL_ID'),
 });
 
-// ── Helpers ───────────────────────────────────────────────────────────────
-
 function out(data: unknown): void {
   console.log(JSON.stringify(data, null, 2));
 }
 
-function saveImage(base64: string, format: string): string {
-  const ext = format === "jpeg" || format === "jpg" ? "jpg" : "png";
-  const dir = join(tmpdir(), "tunnel-screenshots");
-  mkdirSync(dir, { recursive: true });
-  const path = join(
-    dir,
-    `screenshot-${randomBytes(4).toString("hex")}.${ext}`
-  );
-  writeFileSync(path, Buffer.from(base64, "base64"));
-  return path;
-}
-
-function formatAXTree(el: AXElement, indent = 0): string {
-  const pad = "  ".repeat(indent);
-  const parts: string[] = [];
-
-  const label = el.title || el.value || el.description || "(unnamed)";
-  const flags: string[] = [];
-  if (!el.enabled) flags.push("disabled");
-  if (el.focused) flags.push("focused");
-  if (el.actions.length > 0) flags.push(`actions: ${el.actions.join(",")}`);
-  const flagStr = flags.length > 0 ? ` [${flags.join(", ")}]` : "";
-
-  parts.push(`${pad}[${el.role}] ${label} (id: ${el.id})${flagStr}`);
-
-  for (const child of el.children) {
-    parts.push(formatAXTree(child, indent + 1));
-  }
-
-  return parts.join("\n");
+function fail(message: string): void {
+  out({ success: false, error: message });
+  process.exitCode = 1;
 }
 
 async function rpcSafe(
   method: string,
-  params: Record<string, unknown> = {}
-): Promise<{ result: unknown; permissionRequired: false } | { result: null; permissionRequired: true; requestId: string; message: string }> {
+  params: Record<string, unknown> = {},
+): Promise<
+  | { result: unknown; permissionRequired: false }
+  | { result: null; permissionRequired: true; requestId: string; message: string }
+> {
   try {
     const result = await client.rpc(method, params);
     return { result, permissionRequired: false };
@@ -118,45 +75,36 @@ async function rpcSafe(
       return {
         result: null,
         permissionRequired: true,
-        requestId: err.requestId || "unknown",
-        message: `Permission required. A permission request (${err.requestId}) has been sent to the user for approval. The user needs to approve this request before you can access their local machine. Please inform the user and try again after they approve.`,
+        requestId: err.requestId || 'unknown',
+        message: `Permission required. A permission request (${err.requestId}) has been sent to the user for approval.`,
       };
     }
     throw err;
   }
 }
 
-// Wrapper: call rpcSafe, handle permission, return result or null
-async function call(
-  method: string,
-  params: Record<string, unknown> = {}
-): Promise<unknown | null> {
-  const r = await rpcSafe(method, params);
-  if (r.permissionRequired) {
+async function call(method: string, params: Record<string, unknown> = {}): Promise<unknown | null> {
+  const response = await rpcSafe(method, params);
+  if (response.permissionRequired) {
     out({
       success: false,
       permissionRequired: true,
-      requestId: r.requestId,
-      message: r.message,
+      requestId: response.requestId,
+      message: response.message,
     });
     return null;
   }
-  return r.result;
+  return response.result;
 }
 
-// ── Commands ──────────────────────────────────────────────────────────────
-
 async function status() {
-  const connections = (await client.getConnections()) as Array<
-    Record<string, unknown>
-  >;
+  const connections = (await client.getConnections()) as Array<Record<string, unknown>>;
 
   if (connections.length === 0) {
     return out({
       success: true,
       connections: [],
-      message:
-        "No tunnel connections found. The user needs to set up Agent Tunnel first.",
+      message: 'No tunnel connections found. The user needs to set up Agent Tunnel first.',
     });
   }
 
@@ -164,9 +112,9 @@ async function status() {
   const mapped = connections.map((data) => {
     if (data.isLive) hasOnline = true;
     return {
-      name: data.name || "Unnamed",
+      name: data.name || 'Unnamed',
       tunnelId: data.tunnelId,
-      status: data.isLive ? "ONLINE" : "OFFLINE",
+      status: data.isLive ? 'ONLINE' : 'OFFLINE',
       capabilities: (data.capabilities as string[]) || [],
       machineInfo: data.machineInfo || {},
     };
@@ -178,30 +126,25 @@ async function status() {
     hasOnline,
     message: hasOnline
       ? undefined
-      : "No tunnel is currently online. Ask the user to run `npx @kortix/agent-tunnel connect` on their local machine.",
+      : 'No tunnel is currently online. Ask the user to run `npx --yes @kortix/agent-tunnel@latest connect` on their local machine.',
   });
 }
 
 async function fsRead(args: Record<string, unknown>) {
-  const result = await call("fs.read", {
+  const result = await call('fs.read', {
     path: args.path,
-    encoding: (args.encoding as string) || "utf-8",
+    encoding: (args.encoding as string) || 'utf-8',
   });
   if (result === null) return;
   const data = result as Record<string, unknown>;
-  out({
-    success: true,
-    path: data.path || args.path,
-    size: data.size,
-    content: data.content,
-  });
+  out({ success: true, path: data.path || args.path, size: data.size, content: data.content });
 }
 
 async function fsWrite(args: Record<string, unknown>) {
-  const result = await call("fs.write", {
+  const result = await call('fs.write', {
     path: args.path,
     content: args.content,
-    encoding: (args.encoding as string) || "utf-8",
+    encoding: (args.encoding as string) || 'utf-8',
   });
   if (result === null) return;
   const data = result as Record<string, unknown>;
@@ -209,30 +152,17 @@ async function fsWrite(args: Record<string, unknown>) {
 }
 
 async function fsList(args: Record<string, unknown>) {
-  const result = await call("fs.list", {
+  const result = await call('fs.list', {
     path: args.path,
     recursive: args.recursive || false,
   });
   if (result === null) return;
-  const data = result as {
-    entries: Array<{
-      name: string;
-      path: string;
-      isDirectory: boolean;
-      isFile: boolean;
-    }>;
-    count: number;
-  };
-  out({
-    success: true,
-    path: args.path,
-    count: data.count,
-    entries: data.entries,
-  });
+  const data = result as { entries: unknown[]; count: number };
+  out({ success: true, path: args.path, count: data.count, entries: data.entries });
 }
 
 async function shell(args: Record<string, unknown>) {
-  const result = await call("shell.exec", {
+  const result = await call('shell.exec', {
     command: args.command,
     args: (args.args as string[]) || [],
     cwd: args.cwd,
@@ -258,456 +188,103 @@ async function shell(args: Record<string, unknown>) {
   });
 }
 
-async function screenshot(args: Record<string, unknown>) {
-  const params: Record<string, unknown> = {};
-  if (
-    args.x !== undefined &&
-    args.y !== undefined &&
-    args.width !== undefined &&
-    args.height !== undefined
-  ) {
-    params.region = {
-      x: args.x,
-      y: args.y,
-      width: args.width,
-      height: args.height,
-    };
-  }
-  if (args.windowId !== undefined) params.windowId = args.windowId;
-
-  const result = await call("desktop.screenshot", params);
-  if (result === null) return;
-  const data = result as {
-    image: string;
-    width: number;
-    height: number;
-    format?: string;
-  };
-  const format = data.format || "png";
-  const sizeKB = Math.round((data.image.length * 0.75) / 1024);
-  const path = saveImage(data.image, format);
-  out({
-    success: true,
-    path,
-    width: data.width,
-    height: data.height,
-    format,
-    sizeKB,
-    message: `Screenshot saved: ${path} (${data.width}x${data.height} ${format.toUpperCase()}, ${sizeKB}KB). Use the Read tool to view.`,
-  });
-}
-
-async function click(args: Record<string, unknown>) {
-  const result = await call("desktop.mouse.click", {
-    x: args.x,
-    y: args.y,
-    button: args.button,
-    clicks: args.clicks,
-    modifiers: args.modifiers,
-  });
-  if (result === null) return;
-  out({
-    success: true,
-    x: args.x,
-    y: args.y,
-    button: args.button || "left",
-    clicks: args.clicks || 1,
-  });
-}
-
-async function mouseMove(args: Record<string, unknown>) {
-  const result = await call("desktop.mouse.move", { x: args.x, y: args.y });
-  if (result === null) return;
-  out({ success: true, x: args.x, y: args.y });
-}
-
-async function mouseDrag(args: Record<string, unknown>) {
-  const result = await call("desktop.mouse.drag", {
-    fromX: args.fromX,
-    fromY: args.fromY,
-    toX: args.toX,
-    toY: args.toY,
-    button: args.button,
-  });
-  if (result === null) return;
-  out({
-    success: true,
-    fromX: args.fromX,
-    fromY: args.fromY,
-    toX: args.toX,
-    toY: args.toY,
-  });
-}
-
-async function mouseScroll(args: Record<string, unknown>) {
-  const result = await call("desktop.mouse.scroll", {
-    x: args.x,
-    y: args.y,
-    deltaX: args.deltaX,
-    deltaY: args.deltaY,
-  });
-  if (result === null) return;
-  out({
-    success: true,
-    x: args.x,
-    y: args.y,
-    deltaX: args.deltaX || 0,
-    deltaY: args.deltaY || 0,
-  });
-}
-
-async function typeText(args: Record<string, unknown>) {
-  const result = await call("desktop.keyboard.type", {
-    text: args.text,
-    delay: args.delay,
-  });
-  if (result === null) return;
-  out({ success: true, chars: (args.text as string).length });
-}
-
-async function pressKey(args: Record<string, unknown>) {
-  const result = await call("desktop.keyboard.key", { keys: args.keys });
-  if (result === null) return;
-  out({ success: true, keys: args.keys });
-}
-
-async function windowList() {
-  const result = await call("desktop.window.list", {});
-  if (result === null) return;
-  const data = result as {
-    windows: Array<{
-      id: number;
-      app: string;
-      title: string;
-      bounds: { x: number; y: number; width: number; height: number };
-      minimized: boolean;
-    }>;
-  };
-  out({ success: true, windows: data.windows });
-}
-
-async function windowFocus(args: Record<string, unknown>) {
-  const result = await call("desktop.window.focus", {
-    windowId: args.windowId,
-  });
-  if (result === null) return;
-  out({ success: true, windowId: args.windowId });
-}
-
-async function appLaunch(args: Record<string, unknown>) {
-  const result = await call("desktop.app.launch", { app: args.app });
-  if (result === null) return;
-  out({ success: true, app: args.app });
-}
-
-async function appQuit(args: Record<string, unknown>) {
-  const result = await call("desktop.app.quit", { app: args.app });
-  if (result === null) return;
-  out({ success: true, app: args.app });
-}
-
-async function clipboardRead() {
-  const result = await call("desktop.clipboard.read", {});
-  if (result === null) return;
-  const data = result as { text: string };
-  out({ success: true, text: data.text || "" });
-}
-
-async function clipboardWrite(args: Record<string, unknown>) {
-  const result = await call("desktop.clipboard.write", { text: args.text });
-  if (result === null) return;
-  out({ success: true, chars: (args.text as string).length });
-}
-
-async function screenInfo() {
-  const result = await call("desktop.screen.info", {});
-  if (result === null) return;
-  const data = result as {
-    width: number;
-    height: number;
-    scaleFactor: number;
-  };
-  out({ success: true, ...data });
-}
-
-async function cursorImage(args: Record<string, unknown>) {
-  const result = await call("desktop.cursor.image", { radius: args.radius });
-  if (result === null) return;
-  const data = result as {
-    image: string;
-    width: number;
-    height: number;
-    format?: string;
-  };
-  const format = data.format || "png";
-  const sizeKB = Math.round((data.image.length * 0.75) / 1024);
-  const path = saveImage(data.image, format);
-  out({
-    success: true,
-    path,
-    width: data.width,
-    height: data.height,
-    format,
-    sizeKB,
-    message: `Cursor area saved: ${path} (${data.width}x${data.height}). Use the Read tool to view.`,
-  });
-}
-
-async function axTree(args: Record<string, unknown>) {
-  const params: Record<string, unknown> = {};
-  if (args.pid !== undefined) params.pid = args.pid;
-  if (args.maxDepth !== undefined) params.maxDepth = args.maxDepth;
-  if (args.roles !== undefined) params.roles = args.roles;
-
-  const result = await call("desktop.ax.tree", params);
+async function cuaRpc(method: string, args: Record<string, unknown> = {}) {
+  const result = await call(method, args);
   if (result === null) return;
-  const data = result as { root: AXElement; elementCount: number };
-  if (!data.root)
-    return out({
-      success: true,
-      tree: null,
-      message: "No accessibility tree available",
-    });
-
-  out({
-    success: true,
-    elementCount: data.elementCount,
-    tree: formatAXTree(data.root),
-  });
-}
-
-async function axAction(args: Record<string, unknown>) {
-  const result = await call("desktop.ax.action", {
-    elementId: args.elementId,
-    action: args.action,
-    pid: args.pid,
-  });
-  if (result === null) return;
-  const data = result as {
-    ok: boolean;
-    action: string;
-    elementId: string;
-    before: { focused: boolean; value: string };
-    after: { focused: boolean; value: string };
-    stateChanged: boolean;
-    role: string;
-    title: string;
-  };
-  out({
-    success: data.ok,
-    action: data.action,
-    elementId: data.elementId,
-    role: data.role,
-    title: data.title,
-    stateChanged: data.stateChanged,
-    before: data.before,
-    after: data.after,
-  });
+  out({ success: true, result });
 }
 
-async function axSetValue(args: Record<string, unknown>) {
-  const result = await call("desktop.ax.set_value", {
-    elementId: args.elementId,
-    value: args.value,
-    pid: args.pid,
-  });
-  if (result === null) return;
-  const data = result as {
-    ok: boolean;
-    elementId: string;
-    requestedValue: string;
-    actualValue: string;
-    error?: string;
-  };
-  out({
-    success: data.ok,
-    elementId: data.elementId,
-    requestedValue: data.requestedValue,
-    actualValue: data.actualValue,
-    error: data.error,
-  });
-}
+async function cuaCall(args: Record<string, unknown>) {
+  const tool = args.tool as string;
+  if (!tool) return fail('tool is required');
 
-async function axFocus(args: Record<string, unknown>) {
-  const result = await call("desktop.ax.focus", {
-    elementId: args.elementId,
-    pid: args.pid,
+  const result = await call('desktop.cua.call', {
+    tool,
+    args: (args.args || {}) as Record<string, unknown>,
   });
   if (result === null) return;
-  const data = result as {
-    ok: boolean;
-    elementId: string;
-    role: string;
-    title: string;
-    before: { focused: boolean };
-    after: { focused: boolean };
-    error?: string;
-  };
-  out({
-    success: data.ok,
-    elementId: data.elementId,
-    role: data.role,
-    title: data.title,
-    before: data.before,
-    after: data.after,
-    error: data.error,
-  });
+  out({ success: true, tool, result });
 }
 
-async function axSearch(args: Record<string, unknown>) {
-  const params: Record<string, unknown> = { query: args.query };
-  if (args.role !== undefined) params.role = args.role;
-  if (args.pid !== undefined) params.pid = args.pid;
-  if (args.maxResults !== undefined) params.maxResults = args.maxResults;
-
-  const result = await call("desktop.ax.search", params);
-  if (result === null) return;
-  const data = result as { elements: AXElement[] };
-
-  if (!data.elements || data.elements.length === 0) {
-    return out({
-      success: true,
-      query: args.query,
-      elements: [],
-      message: `No elements found matching "${args.query}"`,
-    });
-  }
-
-  const elements = data.elements.map((el) => ({
-    id: el.id,
-    role: el.role,
-    title: el.title || el.value || el.description || "(unnamed)",
-    bounds: el.bounds,
-    enabled: el.enabled,
-    focused: el.focused,
-    actions: el.actions,
-  }));
-
-  out({ success: true, query: args.query, count: elements.length, elements });
+async function cuaDescribe(args: Record<string, unknown>) {
+  const tool = args.tool as string;
+  if (!tool) return fail('tool is required');
+  await cuaRpc('desktop.cua.describe', { tool });
 }
 
-// ── Dispatch ──────────────────────────────────────────────────────────────
-
-const ALL_COMMANDS = [
-  "status",
-  "fs_read",
-  "fs_write",
-  "fs_list",
-  "shell",
-  "screenshot",
-  "click",
-  "mouse_move",
-  "mouse_drag",
-  "mouse_scroll",
-  "type",
-  "key",
-  "window_list",
-  "window_focus",
-  "app_launch",
-  "app_quit",
-  "clipboard_read",
-  "clipboard_write",
-  "screen_info",
-  "cursor_image",
-  "ax_tree",
-  "ax_action",
-  "ax_set_value",
-  "ax_focus",
-  "ax_search",
-];
-
 const [cmd, rawArgs] = process.argv.slice(2);
 
 if (!cmd) {
-  console.error(
-    `Usage: agent-tunnel-cli <command> [args as JSON]\n\nAvailable: ${ALL_COMMANDS.join(" | ")}`
-  );
+  console.error(`Usage: agent-tunnel-cli <command> [args as JSON]\n\nAvailable: ${ALL_COMMANDS.join(' | ')}`);
   process.exit(1);
 }
 
-const args = rawArgs ? JSON.parse(rawArgs) : {};
+let args: Record<string, unknown> = {};
+try {
+  args = rawArgs ? JSON.parse(rawArgs) : {};
+} catch (err) {
+  fail(err instanceof Error ? err.message : String(err));
+  process.exit(1);
+}
 
 try {
   switch (cmd) {
-    case "status":
+    case 'status':
       await status();
       break;
-    case "fs_read":
+    case 'fs_read':
       await fsRead(args);
       break;
-    case "fs_write":
+    case 'fs_write':
       await fsWrite(args);
       break;
-    case "fs_list":
+    case 'fs_list':
       await fsList(args);
       break;
-    case "shell":
+    case 'shell':
       await shell(args);
       break;
-    case "screenshot":
-      await screenshot(args);
-      break;
-    case "click":
-      await click(args);
-      break;
-    case "mouse_move":
-      await mouseMove(args);
-      break;
-    case "mouse_drag":
-      await mouseDrag(args);
-      break;
-    case "mouse_scroll":
-      await mouseScroll(args);
-      break;
-    case "type":
-      await typeText(args);
-      break;
-    case "key":
-      await pressKey(args);
-      break;
-    case "window_list":
-      await windowList();
+    case 'cua_ensure':
+      await cuaRpc('desktop.cua.ensure');
       break;
-    case "window_focus":
-      await windowFocus(args);
+    case 'cua_start_daemon':
+      await cuaRpc('desktop.cua.start_daemon');
       break;
-    case "app_launch":
-      await appLaunch(args);
+    case 'cua_status':
+      await cuaRpc('desktop.cua.status');
       break;
-    case "app_quit":
-      await appQuit(args);
+    case 'cua_version':
+      await cuaRpc('desktop.cua.version');
       break;
-    case "clipboard_read":
-      await clipboardRead();
+    case 'cua_list_tools':
+      await cuaRpc('desktop.cua.list_tools');
       break;
-    case "clipboard_write":
-      await clipboardWrite(args);
+    case 'cua_describe':
+      await cuaDescribe(args);
       break;
-    case "screen_info":
-      await screenInfo();
+    case 'cua_call':
+      await cuaCall(args);
       break;
-    case "cursor_image":
-      await cursorImage(args);
+    case 'cua_list_apps':
+      await cuaRpc('desktop.cua.list_apps', args);
       break;
-    case "ax_tree":
-      await axTree(args);
+    case 'cua_list_windows':
+      await cuaRpc('desktop.cua.list_windows', args);
       break;
-    case "ax_action":
-      await axAction(args);
+    case 'cua_get_window_state':
+      await cuaRpc('desktop.cua.get_window_state', args);
       break;
-    case "ax_set_value":
-      await axSetValue(args);
+    case 'cua_click':
+      await cuaRpc('desktop.cua.click', args);
       break;
-    case "ax_focus":
-      await axFocus(args);
+    case 'cua_type_text':
+      await cuaRpc('desktop.cua.type_text', args);
       break;
-    case "ax_search":
-      await axSearch(args);
+    case 'cua_hotkey':
+      await cuaRpc('desktop.cua.hotkey', args);
       break;
     default:
-      console.error(
-        `Unknown command: ${cmd}\n\nAvailable: ${ALL_COMMANDS.join(" | ")}`
-      );
+      console.error(`Unknown command: ${cmd}\n\nAvailable: ${ALL_COMMANDS.join(' | ')}`);
       process.exit(1);
   }
 } catch (err) {