@kortix/agent-tunnel 0.1.3 → 0.12.7

package/dist/client-cli.js

@@ -1,14 +1,20 @@
 #!/usr/bin/env node
-import "./chunk-7N7GSU6K.js";
 
 // src/client/cli.ts
-import { writeFileSync, mkdirSync, readFileSync } from "fs";
-import { join } from "path";
-import { tmpdir } from "os";
-import { randomBytes } from "crypto";
+import { readFileSync } from "fs";
 
 // src/client/tunnel-client.ts
-var TunnelClientError = class extends Error {
+function trimTrailingSlashes(value) {
+  let end = value.length;
+  while (end > 0 && value.charCodeAt(end - 1) === 47)
+    end -= 1;
+  return value.slice(0, end);
+}
+
+class TunnelClientError extends Error {
+  code;
+  requestId;
+  isPermissionRequest;
   constructor(code, message, requestId, isPermissionRequest = false) {
     super(message);
     this.code = code;
@@ -16,8 +22,9 @@ var TunnelClientError = class extends Error {
     this.isPermissionRequest = isPermissionRequest;
     this.name = "TunnelClientError";
   }
-};
-var TunnelClient = class {
+}
+
+class TunnelClient {
   apiUrl;
   token;
   explicitTunnelId;
@@ -26,15 +33,20 @@ var TunnelClient = class {
   cacheTtlMs;
   fs;
   shell;
-  desktop;
+  cua;
   constructor(config) {
-    this.apiUrl = config.apiUrl.replace(/\/+$/, "");
+    const apiUrl = new URL(config.apiUrl);
+    const loopback = apiUrl.hostname === "localhost" || apiUrl.hostname === "127.0.0.1" || apiUrl.hostname === "[::1]" || apiUrl.hostname === "::1";
+    if (apiUrl.protocol !== "https:" && !(apiUrl.protocol === "http:" && loopback)) {
+      throw new Error("Remote tunnel API URLs must use https");
+    }
+    this.apiUrl = trimTrailingSlashes(apiUrl.toString());
     this.token = config.token;
     this.explicitTunnelId = config.tunnelId;
     this.cacheTtlMs = config.cacheTtlMs ?? 1e4;
     this.fs = new FsNamespace(this);
     this.shell = new ShellNamespace(this);
-    this.desktop = new DesktopNamespace(this);
+    this.cua = new CuaNamespace(this);
   }
   async rpc(method, params = {}) {
     const tunnelId = await this.resolveTunnelId();
@@ -48,13 +60,9 @@ var TunnelClient = class {
     });
     const data = await res.json();
     if (!res.ok) {
-      if (res.status === 404) this.cachedTunnelId = null;
-      throw new TunnelClientError(
-        data.code ?? -1,
-        data.error ?? `HTTP ${res.status}`,
-        data.requestId,
-        res.status === 403 && !!data.requestId
-      );
+      if (res.status === 404)
+        this.cachedTunnelId = null;
+      throw new TunnelClientError(data.code ?? -1, data.error ?? `HTTP ${res.status}`, data.requestId, res.status === 403 && !!data.requestId);
     }
     return data.result;
   }
@@ -80,7 +88,8 @@ var TunnelClient = class {
     return await res.json();
   }
   async resolveTunnelId() {
-    if (this.explicitTunnelId) return this.explicitTunnelId;
+    if (this.explicitTunnelId)
+      return this.explicitTunnelId;
     if (this.cachedTunnelId && Date.now() - this.cacheTimestamp < this.cacheTtlMs) {
       return this.cachedTunnelId;
     }
@@ -92,27 +101,24 @@ var TunnelClient = class {
     if (res.ok) {
       const connections = await res.json();
       const online = connections.find((c) => c.isLive);
-      if (online) {
-        this.cachedTunnelId = online.tunnelId;
-        this.cacheTimestamp = Date.now();
-        return online.tunnelId;
-      }
-      if (connections.length > 0) {
-        this.cachedTunnelId = connections[0].tunnelId;
+      const chosen = online ?? connections[0];
+      if (chosen) {
+        this.cachedTunnelId = chosen.tunnelId;
         this.cacheTimestamp = Date.now();
-        return connections[0].tunnelId;
+        return chosen.tunnelId;
       }
     }
     this.cachedTunnelId = null;
-    throw new TunnelClientError(
-      -1,
-      "No tunnel connection found. The user needs to set up Agent Tunnel first:\n1. Create a tunnel connection\n2. Run `npx @kortix/agent-tunnel connect` on their local machine"
-    );
+    throw new TunnelClientError(-1, `No tunnel connection found. The user needs to set up Agent Tunnel first:
+` + `1. Create a tunnel connection
+` + "2. Connect the local machine from the Kortix desktop app or run the tunnel connect command");
   }
-};
-var FsNamespace = class {
-  constructor(client2) {
-    this.client = client2;
+}
+
+class FsNamespace {
+  client;
+  constructor(client) {
+    this.client = client;
   }
   async read(path, encoding = "utf-8") {
     return await this.client.rpc("fs.read", { path, encoding });
@@ -129,101 +135,104 @@ var FsNamespace = class {
   async delete(path) {
     return await this.client.rpc("fs.delete", { path });
   }
-};
-var ShellNamespace = class {
-  constructor(client2) {
-    this.client = client2;
+}
+
+class ShellNamespace {
+  client;
+  constructor(client) {
+    this.client = client;
   }
-  async exec(command, args2 = [], options) {
+  async exec(command, args = [], options) {
     return await this.client.rpc("shell.exec", {
       command,
-      args: args2,
+      args,
       cwd: options?.cwd,
       timeout: options?.timeout
     });
   }
-};
-var DesktopNamespace = class {
-  constructor(client2) {
-    this.client = client2;
-  }
-  async screenshot(params) {
-    return await this.client.rpc("desktop.screenshot", params ?? {});
-  }
-  async click(params) {
-    return this.client.rpc("desktop.mouse.click", params);
-  }
-  async type(text, delay) {
-    return this.client.rpc("desktop.keyboard.type", { text, delay });
-  }
-  async key(keys) {
-    return this.client.rpc("desktop.keyboard.key", { keys });
-  }
-  async mouseMove(x, y) {
-    return this.client.rpc("desktop.mouse.move", { x, y });
-  }
-  async mouseDrag(fromX, fromY, toX, toY, button) {
-    return this.client.rpc("desktop.mouse.drag", { fromX, fromY, toX, toY, button });
-  }
-  async mouseScroll(x, y, deltaX, deltaY) {
-    return this.client.rpc("desktop.mouse.scroll", { x, y, deltaX, deltaY });
+}
+
+class CuaNamespace {
+  client;
+  constructor(client) {
+    this.client = client;
   }
-  async windowList() {
-    return await this.client.rpc("desktop.window.list", {});
+  async ensure() {
+    return await this.client.rpc("desktop.cua.ensure", {});
   }
-  async windowFocus(windowId) {
-    return this.client.rpc("desktop.window.focus", { windowId });
+  async startDaemon() {
+    return await this.client.rpc("desktop.cua.start_daemon", {});
   }
-  async appLaunch(app) {
-    return this.client.rpc("desktop.app.launch", { app });
+  async status() {
+    return await this.client.rpc("desktop.cua.status", {});
   }
-  async appQuit(app) {
-    return this.client.rpc("desktop.app.quit", { app });
+  async version() {
+    return await this.client.rpc("desktop.cua.version", {});
   }
-  async clipboardRead() {
-    return await this.client.rpc("desktop.clipboard.read", {});
+  async listTools() {
+    return await this.client.rpc("desktop.cua.list_tools", {});
   }
-  async clipboardWrite(text) {
-    return this.client.rpc("desktop.clipboard.write", { text });
+  async describe(tool) {
+    return await this.client.rpc("desktop.cua.describe", { tool });
   }
-  async screenInfo() {
-    return await this.client.rpc("desktop.screen.info", {});
+  async call(tool, args = {}) {
+    return this.client.rpc("desktop.cua.call", { tool, args });
   }
-  async cursorImage(radius) {
-    return await this.client.rpc("desktop.cursor.image", { radius });
+  async listApps() {
+    return this.client.rpc("desktop.cua.list_apps", {});
   }
-  async axTree(params) {
-    return await this.client.rpc("desktop.ax.tree", params ?? {});
+  async listWindows(params) {
+    return this.client.rpc("desktop.cua.list_windows", params ?? {});
   }
-  async axAction(elementId, action, pid) {
-    return await this.client.rpc("desktop.ax.action", { elementId, action, pid });
+  async getWindowState(params) {
+    return this.client.rpc("desktop.cua.get_window_state", params);
   }
-  async axSetValue(elementId, value, pid) {
-    return await this.client.rpc("desktop.ax.set_value", { elementId, value, pid });
+  async click(params) {
+    return this.client.rpc("desktop.cua.click", params);
   }
-  async axFocus(elementId, pid) {
-    return await this.client.rpc("desktop.ax.focus", { elementId, pid });
+  async typeText(params) {
+    return this.client.rpc("desktop.cua.type_text", params);
   }
-  async axSearch(query, params) {
-    return await this.client.rpc("desktop.ax.search", { query, ...params });
+  async hotkey(params) {
+    return this.client.rpc("desktop.cua.hotkey", params);
   }
-};
+}
 
 // src/client/cli.ts
 var S6_ENV_DIR = process.env.S6_ENV_DIR || "/run/s6/container_environment";
+var FALLBACK_API_URL = "http://localhost:8008";
+var 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) {
   try {
-    const val = readFileSync(`${S6_ENV_DIR}/${key}`, "utf-8").trim();
-    if (val) return val;
-  } catch {
-  }
+    const value = readFileSync(`${S6_ENV_DIR}/${key}`, "utf-8").trim();
+    if (value)
+      return value;
+  } catch {}
   return process.env[key];
 }
-var FALLBACK_API_URL = "http://localhost:8008";
 function getApiBase() {
   const raw = getEnv("TUNNEL_API_URL") || FALLBACK_API_URL;
   const url = raw.startsWith("http") ? raw : FALLBACK_API_URL;
-  return url.replace(/\/+$/, "");
+  return url.replace(/\/+$/, "").replace(/\/v1\/router\/?$/, "");
 }
 var client = new TunnelClient({
   apiUrl: `${getApiBase()}/v1/tunnel`,
@@ -233,31 +242,9 @@ var client = new TunnelClient({
 function out(data) {
   console.log(JSON.stringify(data, null, 2));
 }
-function saveImage(base64, format) {
-  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, indent = 0) {
-  const pad = "  ".repeat(indent);
-  const parts = [];
-  const label = el.title || el.value || el.description || "(unnamed)";
-  const flags = [];
-  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) {
+  out({ success: false, error: message });
+  process.exitCode = 1;
 }
 async function rpcSafe(method, params = {}) {
   try {
@@ -269,24 +256,24 @@ async function rpcSafe(method, params = {}) {
         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.`
+        message: `Permission required. A permission request (${err.requestId}) has been sent to the user for approval.`
       };
     }
     throw err;
   }
 }
 async function call(method, params = {}) {
-  const r = await rpcSafe(method, params);
-  if (r.permissionRequired) {
+  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;
 }
 async function status() {
   const connections = await client.getConnections();
@@ -299,7 +286,8 @@ async function status() {
   }
   let hasOnline = false;
   const mapped = connections.map((data) => {
-    if (data.isLive) hasOnline = true;
+    if (data.isLive)
+      hasOnline = true;
     return {
       name: data.name || "Unnamed",
       tunnelId: data.tunnelId,
@@ -312,55 +300,49 @@ async function status() {
     success: true,
     connections: mapped,
     hasOnline,
-    message: hasOnline ? void 0 : "No tunnel is currently online. Ask the user to run `npx @kortix/agent-tunnel connect` on their local machine."
+    message: hasOnline ? undefined : "No tunnel is currently online. Ask the user to run `npx --yes @kortix/agent-tunnel@latest connect` on their local machine."
   });
 }
-async function fsRead(args2) {
+async function fsRead(args) {
   const result = await call("fs.read", {
-    path: args2.path,
-    encoding: args2.encoding || "utf-8"
+    path: args.path,
+    encoding: args.encoding || "utf-8"
   });
-  if (result === null) return;
+  if (result === null)
+    return;
   const data = result;
-  out({
-    success: true,
-    path: data.path || args2.path,
-    size: data.size,
-    content: data.content
-  });
+  out({ success: true, path: data.path || args.path, size: data.size, content: data.content });
 }
-async function fsWrite(args2) {
+async function fsWrite(args) {
   const result = await call("fs.write", {
-    path: args2.path,
-    content: args2.content,
-    encoding: args2.encoding || "utf-8"
+    path: args.path,
+    content: args.content,
+    encoding: args.encoding || "utf-8"
   });
-  if (result === null) return;
+  if (result === null)
+    return;
   const data = result;
   out({ success: true, path: data.path, size: data.size });
 }
-async function fsList(args2) {
+async function fsList(args) {
   const result = await call("fs.list", {
-    path: args2.path,
-    recursive: args2.recursive || false
+    path: args.path,
+    recursive: args.recursive || false
   });
-  if (result === null) return;
+  if (result === null)
+    return;
   const data = result;
-  out({
-    success: true,
-    path: args2.path,
-    count: data.count,
-    entries: data.entries
-  });
+  out({ success: true, path: args.path, count: data.count, entries: data.entries });
 }
-async function shell(args2) {
+async function shell(args) {
   const result = await call("shell.exec", {
-    command: args2.command,
-    args: args2.args || [],
-    cwd: args2.cwd,
-    timeout: args2.timeout
+    command: args.command,
+    args: args.args || [],
+    cwd: args.cwd,
+    timeout: args.timeout
   });
-  if (result === null) return;
+  if (result === null)
+    return;
   const data = result;
   out({
     success: data.exitCode === 0,
@@ -372,294 +354,44 @@ async function shell(args2) {
     stderrTruncated: data.stderrTruncated
   });
 }
-async function screenshot(args2) {
-  const params = {};
-  if (args2.x !== void 0 && args2.y !== void 0 && args2.width !== void 0 && args2.height !== void 0) {
-    params.region = {
-      x: args2.x,
-      y: args2.y,
-      width: args2.width,
-      height: args2.height
-    };
-  }
-  if (args2.windowId !== void 0) params.windowId = args2.windowId;
-  const result = await call("desktop.screenshot", params);
-  if (result === null) return;
-  const data = result;
-  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(args2) {
-  const result = await call("desktop.mouse.click", {
-    x: args2.x,
-    y: args2.y,
-    button: args2.button,
-    clicks: args2.clicks,
-    modifiers: args2.modifiers
-  });
-  if (result === null) return;
-  out({
-    success: true,
-    x: args2.x,
-    y: args2.y,
-    button: args2.button || "left",
-    clicks: args2.clicks || 1
-  });
-}
-async function mouseMove(args2) {
-  const result = await call("desktop.mouse.move", { x: args2.x, y: args2.y });
-  if (result === null) return;
-  out({ success: true, x: args2.x, y: args2.y });
-}
-async function mouseDrag(args2) {
-  const result = await call("desktop.mouse.drag", {
-    fromX: args2.fromX,
-    fromY: args2.fromY,
-    toX: args2.toX,
-    toY: args2.toY,
-    button: args2.button
-  });
-  if (result === null) return;
-  out({
-    success: true,
-    fromX: args2.fromX,
-    fromY: args2.fromY,
-    toX: args2.toX,
-    toY: args2.toY
-  });
-}
-async function mouseScroll(args2) {
-  const result = await call("desktop.mouse.scroll", {
-    x: args2.x,
-    y: args2.y,
-    deltaX: args2.deltaX,
-    deltaY: args2.deltaY
-  });
-  if (result === null) return;
-  out({
-    success: true,
-    x: args2.x,
-    y: args2.y,
-    deltaX: args2.deltaX || 0,
-    deltaY: args2.deltaY || 0
-  });
-}
-async function typeText(args2) {
-  const result = await call("desktop.keyboard.type", {
-    text: args2.text,
-    delay: args2.delay
+async function cuaRpc(method, args = {}) {
+  const result = await call(method, args);
+  if (result === null)
+    return;
+  out({ success: true, result });
+}
+async function cuaCall(args) {
+  const tool = args.tool;
+  if (!tool)
+    return fail("tool is required");
+  const result = await call("desktop.cua.call", {
+    tool,
+    args: args.args || {}
   });
-  if (result === null) return;
-  out({ success: true, chars: args2.text.length });
+  if (result === null)
+    return;
+  out({ success: true, tool, result });
 }
-async function pressKey(args2) {
-  const result = await call("desktop.keyboard.key", { keys: args2.keys });
-  if (result === null) return;
-  out({ success: true, keys: args2.keys });
+async function cuaDescribe(args) {
+  const tool = args.tool;
+  if (!tool)
+    return fail("tool is required");
+  await cuaRpc("desktop.cua.describe", { tool });
 }
-async function windowList() {
-  const result = await call("desktop.window.list", {});
-  if (result === null) return;
-  const data = result;
-  out({ success: true, windows: data.windows });
-}
-async function windowFocus(args2) {
-  const result = await call("desktop.window.focus", {
-    windowId: args2.windowId
-  });
-  if (result === null) return;
-  out({ success: true, windowId: args2.windowId });
-}
-async function appLaunch(args2) {
-  const result = await call("desktop.app.launch", { app: args2.app });
-  if (result === null) return;
-  out({ success: true, app: args2.app });
-}
-async function appQuit(args2) {
-  const result = await call("desktop.app.quit", { app: args2.app });
-  if (result === null) return;
-  out({ success: true, app: args2.app });
-}
-async function clipboardRead() {
-  const result = await call("desktop.clipboard.read", {});
-  if (result === null) return;
-  const data = result;
-  out({ success: true, text: data.text || "" });
-}
-async function clipboardWrite(args2) {
-  const result = await call("desktop.clipboard.write", { text: args2.text });
-  if (result === null) return;
-  out({ success: true, chars: args2.text.length });
-}
-async function screenInfo() {
-  const result = await call("desktop.screen.info", {});
-  if (result === null) return;
-  const data = result;
-  out({ success: true, ...data });
-}
-async function cursorImage(args2) {
-  const result = await call("desktop.cursor.image", { radius: args2.radius });
-  if (result === null) return;
-  const data = result;
-  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(args2) {
-  const params = {};
-  if (args2.pid !== void 0) params.pid = args2.pid;
-  if (args2.maxDepth !== void 0) params.maxDepth = args2.maxDepth;
-  if (args2.roles !== void 0) params.roles = args2.roles;
-  const result = await call("desktop.ax.tree", params);
-  if (result === null) return;
-  const data = result;
-  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(args2) {
-  const result = await call("desktop.ax.action", {
-    elementId: args2.elementId,
-    action: args2.action,
-    pid: args2.pid
-  });
-  if (result === null) return;
-  const data = result;
-  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
-  });
-}
-async function axSetValue(args2) {
-  const result = await call("desktop.ax.set_value", {
-    elementId: args2.elementId,
-    value: args2.value,
-    pid: args2.pid
-  });
-  if (result === null) return;
-  const data = result;
-  out({
-    success: data.ok,
-    elementId: data.elementId,
-    requestedValue: data.requestedValue,
-    actualValue: data.actualValue,
-    error: data.error
-  });
-}
-async function axFocus(args2) {
-  const result = await call("desktop.ax.focus", {
-    elementId: args2.elementId,
-    pid: args2.pid
-  });
-  if (result === null) return;
-  const data = result;
-  out({
-    success: data.ok,
-    elementId: data.elementId,
-    role: data.role,
-    title: data.title,
-    before: data.before,
-    after: data.after,
-    error: data.error
-  });
-}
-async function axSearch(args2) {
-  const params = { query: args2.query };
-  if (args2.role !== void 0) params.role = args2.role;
-  if (args2.pid !== void 0) params.pid = args2.pid;
-  if (args2.maxResults !== void 0) params.maxResults = args2.maxResults;
-  const result = await call("desktop.ax.search", params);
-  if (result === null) return;
-  const data = result;
-  if (!data.elements || data.elements.length === 0) {
-    return out({
-      success: true,
-      query: args2.query,
-      elements: [],
-      message: `No elements found matching "${args2.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: args2.query, count: elements.length, elements });
-}
-var 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"
-];
 var [cmd, rawArgs] = process.argv.slice(2);
 if (!cmd) {
-  console.error(
-    `Usage: agent-tunnel-cli <command> [args as JSON]
+  console.error(`Usage: agent-tunnel-cli <command> [args as JSON]
 
-Available: ${ALL_COMMANDS.join(" | ")}`
-  );
+Available: ${ALL_COMMANDS.join(" | ")}`);
+  process.exit(1);
+}
+var args = {};
+try {
+  args = rawArgs ? JSON.parse(rawArgs) : {};
+} catch (err) {
+  fail(err instanceof Error ? err.message : String(err));
   process.exit(1);
 }
-var args = rawArgs ? JSON.parse(rawArgs) : {};
 try {
   switch (cmd) {
     case "status":
@@ -677,72 +409,49 @@ try {
     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}
+      console.error(`Unknown command: ${cmd}
 
-Available: ${ALL_COMMANDS.join(" | ")}`
-      );
+Available: ${ALL_COMMANDS.join(" | ")}`);
       process.exit(1);
   }
 } catch (err) {