@vm0/cli 9.100.2 → 9.101.0

package/zero.js

@@ -36,6 +36,7 @@ import {
   getAskUserAnswer,
   getAuthMethodsForType,
   getBaseUrl,
+  getComputerUseHost,
   getConnectorDerivedNames,
   getConnectorFirewall,
   getConnectorTypeForSecretName,
@@ -87,6 +88,7 @@ import {
   promptPassword,
   promptSelect,
   promptText,
+  registerComputerUseHost,
   removeZeroOrgMember,
   renderRunCreated,
   requestDeveloperSupportConsent,
@@ -103,6 +105,7 @@ import {
   setZeroVariable,
   submitDeveloperSupport,
   switchZeroOrg,
+  unregisterComputerUseHost,
   updateSkill,
   updateZeroAgent,
   updateZeroAgentInstructions,
@@ -111,10 +114,10 @@ import {
   updateZeroUserPreferences,
   upsertZeroOrgModelProvider,
   withErrorHandler
-} from "./chunk-7RQXNUYT.js";
+} from "./chunk-X2L3TKWA.js";
 
 // src/zero.ts
-import { Command as Command74 } from "commander";
+import { Command as Command77 } from "commander";
 
 // src/commands/zero/org/index.ts
 import { Command as Command23 } from "commander";
@@ -4683,6 +4686,967 @@ Notes:
   )
 );
 
+// src/commands/zero/computer-use/index.ts
+import { Command as Command76 } from "commander";
+
+// src/commands/zero/computer-use/host.ts
+import { Command as Command74 } from "commander";
+import chalk57 from "chalk";
+
+// src/lib/computer-use/desktop-server.ts
+import {
+  createServer as createServer2
+} from "http";
+import { createServer as createNetServer } from "net";
+
+// src/lib/computer-use/screencapture.ts
+import { execFile } from "child_process";
+import { readFile, unlink } from "fs/promises";
+import { randomUUID } from "crypto";
+import { join as join3 } from "path";
+import { tmpdir } from "os";
+import { promisify } from "util";
+var execFileAsync = promisify(execFile);
+async function captureScreenshot() {
+  const tmpPath = join3(tmpdir(), `vm0-screenshot-${randomUUID()}.jpg`);
+  try {
+    await execFileAsync("screencapture", ["-x", "-t", "jpg", tmpPath]);
+    const buffer = await readFile(tmpPath);
+    const info = await getScreenInfo();
+    return {
+      image: buffer.toString("base64"),
+      width: info.width,
+      height: info.height,
+      scaleFactor: info.scaleFactor,
+      format: "jpg"
+    };
+  } finally {
+    await unlink(tmpPath).catch(() => {
+    });
+  }
+}
+async function captureRegionScreenshot(region) {
+  const tmpPath = join3(tmpdir(), `vm0-zoom-${randomUUID()}.jpg`);
+  try {
+    const regionArg = `${region.x},${region.y},${region.width},${region.height}`;
+    await execFileAsync("screencapture", [
+      "-x",
+      "-t",
+      "jpg",
+      "-R",
+      regionArg,
+      tmpPath
+    ]);
+    const buffer = await readFile(tmpPath);
+    return {
+      image: buffer.toString("base64"),
+      width: region.width,
+      height: region.height,
+      scaleFactor: 1,
+      format: "jpg"
+    };
+  } finally {
+    await unlink(tmpPath).catch(() => {
+    });
+  }
+}
+async function getScreenInfo() {
+  const { stdout } = await execFileAsync("system_profiler", [
+    "SPDisplaysDataType",
+    "-json"
+  ]);
+  const data = JSON.parse(stdout);
+  const displays = data.SPDisplaysDataType ?? [];
+  for (const gpu of displays) {
+    const screens = gpu.spdisplays_ndrvs ?? [];
+    for (const screen of screens) {
+      const pixelStr = screen._spdisplays_pixels;
+      if (pixelStr) {
+        const match = pixelStr.match(/(\d+)\s*x\s*(\d+)/);
+        if (match?.[1] && match[2]) {
+          const width = parseInt(match[1], 10);
+          const height = parseInt(match[2], 10);
+          const resStr = screen._spdisplays_resolution ?? screen.spdisplays_resolution ?? "";
+          const isRetina = /retina/i.test(resStr);
+          const scaleFactor = isRetina ? 2 : 1;
+          return { width, height, scaleFactor };
+        }
+      }
+    }
+  }
+  return { width: 1920, height: 1080, scaleFactor: 1 };
+}
+
+// src/lib/computer-use/cliclick.ts
+import { execFile as execFile2 } from "child_process";
+import { promisify as promisify2 } from "util";
+import { setTimeout as sleep } from "timers/promises";
+var execFileAsync2 = promisify2(execFile2);
+async function leftClickDrag(startX, startY, endX, endY) {
+  await execFileAsync2("cliclick", [
+    `dd:${startX},${startY}`,
+    `du:${endX},${endY}`
+  ]);
+}
+async function leftMouseDown(x, y) {
+  await execFileAsync2("cliclick", [`dd:${x},${y}`]);
+}
+async function leftMouseUp(x, y) {
+  await execFileAsync2("cliclick", [`du:${x},${y}`]);
+}
+var ACTION_COMMANDS = {
+  left_click: "c",
+  right_click: "rc",
+  middle_click: "mc",
+  double_click: "dc",
+  triple_click: "tc",
+  move: "m"
+};
+var VALID_ACTIONS = new Set(Object.keys(ACTION_COMMANDS));
+async function checkCliclickInstalled() {
+  try {
+    await execFileAsync2("which", ["cliclick"]);
+  } catch {
+    throw new Error("cliclick not found. Install with: brew install cliclick");
+  }
+}
+async function executeMouseAction(action, x, y) {
+  await checkCliclickInstalled();
+  const prefix = ACTION_COMMANDS[action];
+  await execFileAsync2("cliclick", [`${prefix}:${x},${y}`]);
+}
+async function getCursorPosition() {
+  await checkCliclickInstalled();
+  const { stdout } = await execFileAsync2("cliclick", ["p"]);
+  const parts = stdout.trim().split(",");
+  const xStr = parts[0];
+  const yStr = parts[1];
+  if (parts.length !== 2 || xStr === void 0 || yStr === void 0) {
+    throw new Error(`Unexpected cliclick output: ${stdout.trim()}`);
+  }
+  const x = parseInt(xStr, 10);
+  const y = parseInt(yStr, 10);
+  if (Number.isNaN(x) || Number.isNaN(y)) {
+    throw new Error(`Failed to parse cursor position: ${stdout.trim()}`);
+  }
+  return { x, y };
+}
+var VALID_SPECIAL_KEYS = /* @__PURE__ */ new Set([
+  "cmd",
+  "ctrl",
+  "alt",
+  "shift",
+  "fn",
+  "arrow-up",
+  "arrow-down",
+  "arrow-left",
+  "arrow-right",
+  "tab",
+  "esc",
+  "space",
+  "delete",
+  "return",
+  "enter",
+  "home",
+  "end",
+  "page-up",
+  "page-down",
+  ...Array.from({ length: 19 }, (_, i) => {
+    return `f${i + 1}`;
+  })
+]);
+function isValidKeyName(key) {
+  return VALID_SPECIAL_KEYS.has(key) || key.length === 1;
+}
+function parseKeyCombo(keys) {
+  const parts = keys.split("+");
+  if (parts.length === 0 || parts.some((p) => {
+    return p === "";
+  })) {
+    throw new Error(`Invalid key combo: "${keys}"`);
+  }
+  const mainKey = parts[parts.length - 1];
+  const modifiers = parts.slice(0, -1);
+  for (const key of parts) {
+    if (!isValidKeyName(key)) {
+      throw new Error(
+        `Unknown key: "${key}". Valid keys: single characters, or special keys like cmd, ctrl, alt, shift, tab, esc, return, arrow-up, f1-f19, etc.`
+      );
+    }
+  }
+  return { modifiers, mainKey };
+}
+async function pressKey(keys) {
+  const { modifiers, mainKey } = parseKeyCombo(keys);
+  if (modifiers.length === 0) {
+    await execFileAsync2("cliclick", [`kp:${mainKey}`]);
+    return;
+  }
+  const args = [];
+  for (const mod of modifiers) {
+    args.push(`kd:${mod}`);
+  }
+  args.push(`kp:${mainKey}`);
+  for (let i = modifiers.length - 1; i >= 0; i--) {
+    args.push(`ku:${modifiers[i]}`);
+  }
+  await execFileAsync2("cliclick", args);
+}
+async function holdKey(keys, durationMs) {
+  const { modifiers, mainKey } = parseKeyCombo(keys);
+  const allKeys = [...modifiers, mainKey];
+  const downArgs = allKeys.map((k) => {
+    return `kd:${k}`;
+  });
+  const upArgs = [...allKeys].reverse().map((k) => {
+    return `ku:${k}`;
+  });
+  await execFileAsync2("cliclick", downArgs);
+  await sleep(durationMs);
+  await execFileAsync2("cliclick", upArgs);
+}
+async function typeText(text) {
+  await execFileAsync2("cliclick", [`t:${text}`]);
+}
+
+// src/lib/computer-use/scroll.ts
+import { execFile as execFile3 } from "child_process";
+import { promisify as promisify3 } from "util";
+var execFileAsync3 = promisify3(execFile3);
+var DEFAULT_SCROLL_AMOUNT = 3;
+async function scroll(x, y, direction, amount = DEFAULT_SCROLL_AMOUNT) {
+  await execFileAsync3("cliclick", [`m:${x},${y}`]);
+  let dy = 0;
+  let dx = 0;
+  switch (direction) {
+    case "up":
+      dy = amount;
+      break;
+    case "down":
+      dy = -amount;
+      break;
+    case "left":
+      dx = amount;
+      break;
+    case "right":
+      dx = -amount;
+      break;
+  }
+  const script = [
+    "ObjC.import('CoreGraphics');",
+    `var e = $.CGEventCreateScrollWheelEvent(null, 0, 2, ${dy}, ${dx});`,
+    "$.CGEventPost($.kCGHIDEventTap, e);"
+  ].join(" ");
+  await execFileAsync3("osascript", ["-l", "JavaScript", "-e", script]);
+}
+
+// src/lib/computer-use/clipboard.ts
+import { execFile as execFile4, spawn as spawn2 } from "child_process";
+import { promisify as promisify4 } from "util";
+var execFileAsync4 = promisify4(execFile4);
+async function readClipboard() {
+  const { stdout } = await execFileAsync4("pbpaste");
+  return stdout;
+}
+async function writeClipboard(text) {
+  return new Promise((resolve, reject) => {
+    const proc = spawn2("pbcopy", { stdio: ["pipe", "ignore", "ignore"] });
+    proc.on("error", reject);
+    proc.on("close", (code) => {
+      if (code === 0) {
+        resolve();
+      } else {
+        reject(new Error(`pbcopy exited with code ${code}`));
+      }
+    });
+    proc.stdin.end(text);
+  });
+}
+
+// src/lib/computer-use/application.ts
+import { execFile as execFile5 } from "child_process";
+import { promisify as promisify5 } from "util";
+var execFileAsync5 = promisify5(execFile5);
+async function openApplication(nameOrBundleId) {
+  const isBundleId = nameOrBundleId.includes(".");
+  const flag = isBundleId ? "-b" : "-a";
+  await execFileAsync5("open", [flag, nameOrBundleId]);
+}
+
+// src/lib/computer-use/desktop-server.ts
+function readBody(req) {
+  return new Promise((resolve, reject) => {
+    const chunks = [];
+    req.on("data", (chunk) => {
+      chunks.push(chunk);
+    });
+    req.on("end", () => {
+      resolve(Buffer.concat(chunks).toString());
+    });
+    req.on("error", reject);
+  });
+}
+async function handleZoom(searchParams, res) {
+  const x = Number(searchParams.get("x"));
+  const y = Number(searchParams.get("y"));
+  const width = Number(searchParams.get("width"));
+  const height = Number(searchParams.get("height"));
+  if ([x, y, width, height].some((v) => {
+    return !Number.isFinite(v);
+  })) {
+    res.writeHead(400, { "Content-Type": "text/plain" });
+    res.end(
+      "Missing or invalid query parameters: x, y, width, height are required numbers"
+    );
+    return;
+  }
+  if (width <= 0 || height <= 0) {
+    res.writeHead(400, { "Content-Type": "text/plain" });
+    res.end("width and height must be positive");
+    return;
+  }
+  if (x < 0 || y < 0) {
+    res.writeHead(400, { "Content-Type": "text/plain" });
+    res.end("x and y must be non-negative");
+    return;
+  }
+  const info = await getScreenInfo();
+  if (x + width > info.width || y + height > info.height) {
+    res.writeHead(400, { "Content-Type": "text/plain" });
+    res.end(`Region exceeds screen bounds (${info.width}x${info.height})`);
+    return;
+  }
+  const result = await captureRegionScreenshot({ x, y, width, height });
+  res.writeHead(200, { "Content-Type": "application/json" });
+  res.end(JSON.stringify(result));
+}
+function parseJsonBody(req) {
+  return new Promise((resolve, reject) => {
+    const chunks = [];
+    let size = 0;
+    req.on("data", (chunk) => {
+      size += chunk.length;
+      if (size > 1024) {
+        reject(new Error("Request body too large"));
+        req.destroy();
+        return;
+      }
+      chunks.push(chunk);
+    });
+    req.on("end", () => {
+      try {
+        resolve(JSON.parse(Buffer.concat(chunks).toString()));
+      } catch {
+        reject(new Error("Invalid JSON body"));
+      }
+    });
+    req.on("error", reject);
+  });
+}
+async function handleMouseRequest(req, res) {
+  const body = await parseJsonBody(req);
+  if (typeof body !== "object" || body === null || !("action" in body)) {
+    res.writeHead(400, { "Content-Type": "text/plain" });
+    res.end("Missing required fields: action, x, y");
+    return;
+  }
+  const { action } = body;
+  if (typeof action !== "string") {
+    res.writeHead(400, { "Content-Type": "text/plain" });
+    res.end("Invalid action");
+    return;
+  }
+  if (VALID_ACTIONS.has(action)) {
+    if (!("x" in body) || !("y" in body)) {
+      res.writeHead(400, { "Content-Type": "text/plain" });
+      res.end("Missing required fields: action, x, y");
+      return;
+    }
+    const { x, y } = body;
+    if (typeof x !== "number" || typeof y !== "number" || !Number.isFinite(x) || !Number.isFinite(y)) {
+      res.writeHead(400, { "Content-Type": "text/plain" });
+      res.end("Coordinates x and y must be finite numbers");
+      return;
+    }
+    const info = await getScreenInfo();
+    const maxX = Math.floor(info.width / info.scaleFactor);
+    const maxY = Math.floor(info.height / info.scaleFactor);
+    if (x < 0 || x >= maxX || y < 0 || y >= maxY) {
+      res.writeHead(400, { "Content-Type": "text/plain" });
+      res.end(
+        `Coordinates out of bounds. Screen size: ${maxX}x${maxY} (points)`
+      );
+      return;
+    }
+    await executeMouseAction(action, x, y);
+    res.writeHead(200, { "Content-Type": "application/json" });
+    res.end(JSON.stringify({ ok: true }));
+    return;
+  }
+  const typedBody = body;
+  switch (typedBody.action) {
+    case "left_click_drag":
+      await leftClickDrag(
+        typedBody.startX,
+        typedBody.startY,
+        typedBody.endX,
+        typedBody.endY
+      );
+      break;
+    case "left_mouse_down":
+      await leftMouseDown(typedBody.x, typedBody.y);
+      break;
+    case "left_mouse_up":
+      await leftMouseUp(typedBody.x, typedBody.y);
+      break;
+    case "scroll":
+      await scroll(
+        typedBody.x,
+        typedBody.y,
+        typedBody.direction,
+        typedBody.amount
+      );
+      break;
+    default:
+      res.writeHead(400, { "Content-Type": "text/plain" });
+      res.end(
+        `Unknown mouse action: ${body.action}`
+      );
+      return;
+  }
+  res.writeHead(200, { "Content-Type": "application/json" });
+  res.end(JSON.stringify({ ok: true }));
+}
+async function handleKeyboard(req, res) {
+  const raw = await readBody(req);
+  const body = JSON.parse(raw);
+  switch (body.action) {
+    case "key":
+      await pressKey(body.keys);
+      break;
+    case "hold_key":
+      if (typeof body.durationMs !== "number" || !Number.isFinite(body.durationMs) || body.durationMs <= 0) {
+        res.writeHead(400, { "Content-Type": "text/plain" });
+        res.end("durationMs must be a positive number");
+        return;
+      }
+      await holdKey(body.keys, body.durationMs);
+      break;
+    case "type":
+      if (typeof body.text !== "string" || body.text.length === 0) {
+        res.writeHead(400, { "Content-Type": "text/plain" });
+        res.end("text must be a non-empty string");
+        return;
+      }
+      await typeText(body.text);
+      break;
+    default:
+      res.writeHead(400, { "Content-Type": "text/plain" });
+      res.end(
+        `Unknown keyboard action: ${body.action}`
+      );
+      return;
+  }
+  res.writeHead(200, { "Content-Type": "application/json" });
+  res.end(JSON.stringify({ ok: true }));
+}
+async function handleClipboard(req, res) {
+  if (req.method === "GET") {
+    const text = await readClipboard();
+    res.writeHead(200, { "Content-Type": "application/json" });
+    res.end(JSON.stringify({ text }));
+  } else if (req.method === "POST") {
+    const raw = await readBody(req);
+    const body = JSON.parse(raw);
+    await writeClipboard(body.text);
+    res.writeHead(200, { "Content-Type": "application/json" });
+    res.end(JSON.stringify({ ok: true }));
+  } else {
+    res.writeHead(404, { "Content-Type": "text/plain" });
+    res.end("Not found");
+  }
+}
+async function handleOpenApplication(req, res) {
+  const raw = await readBody(req);
+  const body = JSON.parse(raw);
+  if (typeof body.nameOrBundleId !== "string" || body.nameOrBundleId.length === 0) {
+    res.writeHead(400, { "Content-Type": "text/plain" });
+    res.end("nameOrBundleId must be a non-empty string");
+    return;
+  }
+  await openApplication(body.nameOrBundleId);
+  res.writeHead(200, { "Content-Type": "application/json" });
+  res.end(JSON.stringify({ ok: true }));
+}
+async function getRandomPort2() {
+  return new Promise((resolve, reject) => {
+    const server = createNetServer();
+    server.listen(0, "127.0.0.1", () => {
+      const { port } = server.address();
+      server.close(() => {
+        resolve(port);
+      });
+    });
+    server.on("error", reject);
+  });
+}
+async function handleCursorPosition(res) {
+  const position = await getCursorPosition();
+  res.writeHead(200, { "Content-Type": "application/json" });
+  res.end(JSON.stringify(position));
+}
+function routeKey(method, pathname) {
+  return `${method} ${pathname}`;
+}
+async function handleRequest(token, req, res) {
+  if (req.headers["x-vm0-token"] !== token) {
+    res.writeHead(403, { "Content-Type": "text/plain" });
+    res.end("Forbidden");
+    return;
+  }
+  const url = new URL(req.url ?? "/", "http://localhost");
+  const { pathname, searchParams } = url;
+  const key = routeKey(req.method ?? "GET", pathname);
+  try {
+    switch (key) {
+      case "GET /screenshot": {
+        const result = await captureScreenshot();
+        res.writeHead(200, { "Content-Type": "application/json" });
+        res.end(JSON.stringify(result));
+        break;
+      }
+      case "GET /info": {
+        const info = await getScreenInfo();
+        res.writeHead(200, { "Content-Type": "application/json" });
+        res.end(JSON.stringify(info));
+        break;
+      }
+      case "GET /zoom":
+        await handleZoom(searchParams, res);
+        break;
+      case "POST /mouse":
+        await handleMouseRequest(req, res);
+        break;
+      case "GET /clipboard":
+      case "POST /clipboard":
+        await handleClipboard(req, res);
+        break;
+      case "POST /keyboard":
+        await handleKeyboard(req, res);
+        break;
+      case "POST /open-application":
+        await handleOpenApplication(req, res);
+        break;
+      case "GET /cursor-position":
+        await handleCursorPosition(res);
+        break;
+      default:
+        res.writeHead(404, { "Content-Type": "text/plain" });
+        res.end("Not found");
+    }
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Internal server error";
+    res.writeHead(500, { "Content-Type": "text/plain" });
+    res.end(message);
+  }
+}
+function startDesktopServer(token, port) {
+  return new Promise((resolve, reject) => {
+    const server = createServer2((req, res) => {
+      handleRequest(token, req, res).catch(() => {
+        if (!res.headersSent) {
+          res.writeHead(500, { "Content-Type": "text/plain" });
+          res.end("Internal server error");
+        }
+      });
+    });
+    server.on("error", reject);
+    server.listen(port, "127.0.0.1", () => {
+      resolve(server);
+    });
+  });
+}
+
+// src/lib/computer-use/ngrok.ts
+async function loadNgrok2() {
+  try {
+    const mod = await import("@ngrok/ngrok");
+    return mod.default;
+  } catch (cause) {
+    throw new Error(
+      "Failed to load ngrok tunnel module. This may be caused by a system library (GLIBC) incompatibility. See: https://github.com/vm0-ai/vm0/issues/6825",
+      { cause }
+    );
+  }
+}
+async function startDesktopTunnel(ngrokToken, endpointPrefix, port) {
+  const ngrok = await loadNgrok2();
+  await ngrok.forward({
+    addr: `localhost:${port}`,
+    authtoken: ngrokToken,
+    domain: `desktop.${endpointPrefix}.internal`
+  });
+}
+async function stopDesktopTunnel() {
+  const ngrok = await loadNgrok2();
+  await ngrok.kill();
+}
+
+// src/commands/zero/computer-use/host.ts
+var hostStartCommand = new Command74().name("start").description("Start the computer-use host daemon (macOS only)").action(
+  withErrorHandler(async () => {
+    if (process.platform !== "darwin") {
+      throw new Error(
+        "Computer-use host requires macOS\n\nThe host daemon uses macOS-specific commands (screencapture, system_profiler)."
+      );
+    }
+    console.log(chalk57.cyan("Registering computer-use host..."));
+    const credentials = await registerComputerUseHost();
+    const port = await getRandomPort2();
+    const server = await startDesktopServer(credentials.token, port);
+    try {
+      await startDesktopTunnel(
+        credentials.ngrokToken,
+        credentials.endpointPrefix,
+        port
+      );
+      console.log();
+      console.log(chalk57.green("\u2713 Computer-use host active"));
+      console.log(`  Desktop: desktop.${credentials.domain}`);
+      console.log();
+      console.log(chalk57.dim("Press ^C twice to disconnect"));
+      console.log();
+      let sigintCount = 0;
+      await new Promise((resolve) => {
+        const keepAlive = setInterval(() => {
+        }, 6e4);
+        const done = () => {
+          clearInterval(keepAlive);
+          process.removeListener("SIGINT", onSigint);
+          resolve();
+        };
+        const onSigint = () => {
+          sigintCount++;
+          if (sigintCount === 1) {
+            console.log(
+              chalk57.dim("\nPress ^C again to disconnect and exit...")
+            );
+          } else {
+            done();
+          }
+        };
+        process.on("SIGINT", onSigint);
+        process.once("SIGTERM", done);
+      });
+    } finally {
+      console.log();
+      console.log(chalk57.cyan("Stopping computer-use host..."));
+      server.close();
+      await stopDesktopTunnel();
+      await unregisterComputerUseHost().catch(() => {
+      });
+      console.log(chalk57.green("\u2713 Host stopped"));
+    }
+  })
+);
+
+// src/commands/zero/computer-use/client.ts
+import { Command as Command75 } from "commander";
+import { writeFile, mkdir } from "fs/promises";
+import { join as join4 } from "path";
+
+// src/lib/computer-use/client.ts
+var cachedHost = null;
+var CACHE_TTL_MS = 3e4;
+async function discoverHost() {
+  if (cachedHost && Date.now() - cachedHost.cachedAt < CACHE_TTL_MS) {
+    return { domain: cachedHost.domain, token: cachedHost.token };
+  }
+  const host = await getComputerUseHost();
+  if (!host) {
+    throw new Error(
+      "No active computer-use host found\n\nStart a host with: zero computer-use host start"
+    );
+  }
+  cachedHost = { ...host, cachedAt: Date.now() };
+  return host;
+}
+async function callHost(path, options) {
+  const { domain, token } = await discoverHost();
+  const url = `https://desktop.${domain}${path}`;
+  const headers = { "x-vm0-token": token };
+  const init = { headers };
+  if (options?.method) {
+    init.method = options.method;
+  }
+  if (options?.body !== void 0) {
+    headers["content-type"] = "application/json";
+    init.body = JSON.stringify(options.body);
+  }
+  const response = await fetch(url, init);
+  if (!response.ok) {
+    const body = await response.text().catch(() => {
+      return "";
+    });
+    throw new Error(
+      `Host returned ${response.status}: ${body || response.statusText}`
+    );
+  }
+  return response;
+}
+
+// src/commands/zero/computer-use/client.ts
+function mouseClickCommand(name, action, description) {
+  return new Command75().name(name).description(description).argument("<x>", "X coordinate (points)").argument("<y>", "Y coordinate (points)").action(
+    withErrorHandler(async (xStr, yStr) => {
+      const x = parseInt(xStr, 10);
+      const y = parseInt(yStr, 10);
+      if (Number.isNaN(x) || Number.isNaN(y)) {
+        throw new Error("Coordinates must be integers");
+      }
+      const response = await callHost("/mouse", {
+        method: "POST",
+        body: { action, x, y }
+      });
+      const data = await response.json();
+      process.stdout.write(JSON.stringify(data) + "\n");
+    })
+  );
+}
+var clientScreenshotCommand = new Command75().name("screenshot").description("Capture a screenshot from the remote host").action(
+  withErrorHandler(async () => {
+    const response = await callHost("/screenshot");
+    const data = await response.json();
+    const dir = "/tmp/computer-use";
+    await mkdir(dir, { recursive: true });
+    const timestamp = Date.now();
+    const filePath = join4(dir, `screenshot-${timestamp}.${data.format}`);
+    const buffer = Buffer.from(data.image, "base64");
+    await writeFile(filePath, buffer);
+    process.stdout.write(`${filePath}
+`);
+    process.stderr.write(
+      JSON.stringify({
+        width: data.width,
+        height: data.height,
+        scaleFactor: data.scaleFactor
+      }) + "\n"
+    );
+  })
+);
+var clientZoomCommand = new Command75().name("zoom").description("Capture a region screenshot from the remote host").requiredOption("--x <number>", "X coordinate of the region").requiredOption("--y <number>", "Y coordinate of the region").requiredOption("--width <number>", "Width of the region").requiredOption("--height <number>", "Height of the region").action(
+  withErrorHandler(
+    async (opts) => {
+      const params = new URLSearchParams({
+        x: opts.x,
+        y: opts.y,
+        width: opts.width,
+        height: opts.height
+      });
+      const response = await callHost(`/zoom?${params.toString()}`);
+      const data = await response.json();
+      const dir = "/tmp/computer-use";
+      await mkdir(dir, { recursive: true });
+      const timestamp = Date.now();
+      const filePath = join4(dir, `zoom-${timestamp}.${data.format}`);
+      const buffer = Buffer.from(data.image, "base64");
+      await writeFile(filePath, buffer);
+      process.stdout.write(`${filePath}
+`);
+      process.stderr.write(
+        JSON.stringify({
+          width: data.width,
+          height: data.height,
+          scaleFactor: data.scaleFactor
+        }) + "\n"
+      );
+    }
+  )
+);
+var clientInfoCommand = new Command75().name("info").description("Get screen info from the remote host").action(
+  withErrorHandler(async () => {
+    const response = await callHost("/info");
+    const data = await response.json();
+    process.stdout.write(JSON.stringify(data) + "\n");
+  })
+);
+var clientLeftClickCommand = mouseClickCommand(
+  "left-click",
+  "left_click",
+  "Perform a left click at coordinates"
+);
+var clientRightClickCommand = mouseClickCommand(
+  "right-click",
+  "right_click",
+  "Perform a right click at coordinates"
+);
+var clientMiddleClickCommand = mouseClickCommand(
+  "middle-click",
+  "middle_click",
+  "Perform a middle click at coordinates"
+);
+var clientDoubleClickCommand = mouseClickCommand(
+  "double-click",
+  "double_click",
+  "Perform a double click at coordinates"
+);
+var clientTripleClickCommand = mouseClickCommand(
+  "triple-click",
+  "triple_click",
+  "Perform a triple click at coordinates"
+);
+var clientLeftClickDragCommand = new Command75().name("left-click-drag").description("Drag from (startX, startY) to (endX, endY)").argument("<startX>", "Start X coordinate").argument("<startY>", "Start Y coordinate").argument("<endX>", "End X coordinate").argument("<endY>", "End Y coordinate").action(
+  withErrorHandler(
+    async (startX, startY, endX, endY) => {
+      await callHost("/mouse", {
+        method: "POST",
+        body: {
+          action: "left_click_drag",
+          startX: Number(startX),
+          startY: Number(startY),
+          endX: Number(endX),
+          endY: Number(endY)
+        }
+      });
+      process.stdout.write("ok\n");
+    }
+  )
+);
+var clientLeftMouseDownCommand = new Command75().name("left-mouse-down").description("Press and hold the left mouse button at (x, y)").argument("<x>", "X coordinate").argument("<y>", "Y coordinate").action(
+  withErrorHandler(async (x, y) => {
+    await callHost("/mouse", {
+      method: "POST",
+      body: { action: "left_mouse_down", x: Number(x), y: Number(y) }
+    });
+    process.stdout.write("ok\n");
+  })
+);
+var clientLeftMouseUpCommand = new Command75().name("left-mouse-up").description("Release the left mouse button at (x, y)").argument("<x>", "X coordinate").argument("<y>", "Y coordinate").action(
+  withErrorHandler(async (x, y) => {
+    await callHost("/mouse", {
+      method: "POST",
+      body: { action: "left_mouse_up", x: Number(x), y: Number(y) }
+    });
+    process.stdout.write("ok\n");
+  })
+);
+var clientScrollCommand = new Command75().name("scroll").description("Scroll at the given screen position").argument("<x>", "X coordinate").argument("<y>", "Y coordinate").argument("<direction>", "Scroll direction: up, down, left, right").argument("[amount]", "Scroll amount in lines (default 3)").action(
+  withErrorHandler(
+    async (x, y, direction, amount) => {
+      await callHost("/mouse", {
+        method: "POST",
+        body: {
+          action: "scroll",
+          x: Number(x),
+          y: Number(y),
+          direction,
+          ...amount !== void 0 && { amount: Number(amount) }
+        }
+      });
+      process.stdout.write("ok\n");
+    }
+  )
+);
+var clientReadClipboardCommand = new Command75().name("read-clipboard").description("Read text content from the remote clipboard").action(
+  withErrorHandler(async () => {
+    const response = await callHost("/clipboard");
+    const data = await response.json();
+    process.stdout.write(data.text);
+  })
+);
+var clientWriteClipboardCommand = new Command75().name("write-clipboard").description("Write text content to the remote clipboard").argument("<text>", "Text to write to clipboard").action(
+  withErrorHandler(async (text) => {
+    await callHost("/clipboard", {
+      method: "POST",
+      body: { text }
+    });
+    process.stdout.write("ok\n");
+  })
+);
+var clientKeyCommand = new Command75().name("key").description("Press a key or key combination (e.g., cmd+c, return)").argument("<combo>", "Key combo string (e.g., cmd+c, ctrl+shift+s, return)").action(
+  withErrorHandler(async (combo) => {
+    await callHost("/keyboard", {
+      method: "POST",
+      body: { action: "key", keys: combo }
+    });
+    process.stdout.write("ok\n");
+  })
+);
+var clientHoldKeyCommand = new Command75().name("hold-key").description("Hold a key or key combination for a duration").argument("<combo>", "Key combo string (e.g., shift, cmd+shift)").argument("<durationMs>", "Duration to hold in milliseconds").action(
+  withErrorHandler(async (combo, durationStr) => {
+    const durationMs = parseInt(durationStr, 10);
+    if (Number.isNaN(durationMs) || durationMs <= 0) {
+      throw new Error("durationMs must be a positive integer");
+    }
+    await callHost("/keyboard", {
+      method: "POST",
+      body: { action: "hold_key", keys: combo, durationMs }
+    });
+    process.stdout.write("ok\n");
+  })
+);
+var clientTypeCommand = new Command75().name("type").description("Type text at the current cursor position").argument("<text>", "Text to type").action(
+  withErrorHandler(async (text) => {
+    await callHost("/keyboard", {
+      method: "POST",
+      body: { action: "type", text }
+    });
+    process.stdout.write("ok\n");
+  })
+);
+var clientOpenAppCommand = new Command75().name("open-app").description("Open or activate a macOS application by name or bundle ID").argument(
+  "<nameOrBundleId>",
+  "App name (e.g., Safari) or bundle ID (e.g., com.apple.Safari)"
+).action(
+  withErrorHandler(async (nameOrBundleId) => {
+    await callHost("/open-application", {
+      method: "POST",
+      body: { nameOrBundleId }
+    });
+    process.stdout.write("ok\n");
+  })
+);
+var clientMouseMoveCommand = mouseClickCommand(
+  "mouse-move",
+  "move",
+  "Move mouse pointer to coordinates"
+);
+var clientCursorPositionCommand = new Command75().name("cursor-position").description("Get current cursor position from the remote host").action(
+  withErrorHandler(async () => {
+    const response = await callHost("/cursor-position");
+    const data = await response.json();
+    process.stdout.write(JSON.stringify(data) + "\n");
+  })
+);
+
+// src/commands/zero/computer-use/index.ts
+var hostCommand = new Command76().name("host").description("Manage computer-use host daemon").addCommand(hostStartCommand);
+var clientCommand = new Command76().name("client").description("Interact with remote computer-use host").addCommand(clientScreenshotCommand).addCommand(clientZoomCommand).addCommand(clientInfoCommand).addCommand(clientLeftClickCommand).addCommand(clientRightClickCommand).addCommand(clientMiddleClickCommand).addCommand(clientDoubleClickCommand).addCommand(clientTripleClickCommand).addCommand(clientLeftClickDragCommand).addCommand(clientLeftMouseDownCommand).addCommand(clientLeftMouseUpCommand).addCommand(clientScrollCommand).addCommand(clientReadClipboardCommand).addCommand(clientWriteClipboardCommand).addCommand(clientKeyCommand).addCommand(clientHoldKeyCommand).addCommand(clientTypeCommand).addCommand(clientOpenAppCommand).addCommand(clientMouseMoveCommand).addCommand(clientCursorPositionCommand);
+var zeroComputerUseCommand = new Command76().name("computer-use").description("Remote desktop control for cloud agents").addCommand(hostCommand).addCommand(clientCommand).addHelpText(
+  "after",
+  `
+Examples:
+  Start the host daemon (on macOS):  zero computer-use host start
+  Take a screenshot (from agent):    zero computer-use client screenshot
+  Zoom into a region (from agent):   zero computer-use client zoom --x 0 --y 0 --width 500 --height 500
+  Get screen info (from agent):      zero computer-use client info
+  Left click at (500, 300):          zero computer-use client left-click 500 300
+  Double click at (100, 200):        zero computer-use client double-click 100 200
+  Drag from A to B:                  zero computer-use client left-click-drag 100 100 500 500
+  Press mouse button:                zero computer-use client left-mouse-down 200 300
+  Release mouse button:              zero computer-use client left-mouse-up 500 500
+  Scroll down at position:           zero computer-use client scroll 500 300 down 5
+  Read clipboard text:               zero computer-use client read-clipboard
+  Write clipboard text:              zero computer-use client write-clipboard "hello"
+  Press key combo:                   zero computer-use client key "cmd+c"
+  Hold shift for 2 seconds:          zero computer-use client hold-key "shift" 2000
+  Type text:                         zero computer-use client type "Hello, world!"
+  Open an application:               zero computer-use client open-app Safari
+  Open by bundle ID:                 zero computer-use client open-app "com.apple.Safari"
+  Move mouse to (100, 200):          zero computer-use client mouse-move 100 200
+  Get cursor position:               zero computer-use client cursor-position`
+);
+
 // src/zero.ts
 var COMMAND_CAPABILITY_MAP = {
   agent: "agent:read",
@@ -4695,7 +5659,8 @@ var COMMAND_CAPABILITY_MAP = {
   slack: "slack:write",
   whoami: null,
   "ask-user": null,
-  "developer-support": null
+  "developer-support": null,
+  "computer-use": "computer-use:write"
 };
 var DEFAULT_COMMANDS = [
   zeroOrgCommand,
@@ -4712,7 +5677,8 @@ var DEFAULT_COMMANDS = [
   zeroWhoamiCommand,
   zeroAskUserCommand,
   zeroSkillCommand,
-  zeroDeveloperSupportCommand
+  zeroDeveloperSupportCommand,
+  zeroComputerUseCommand
 ];
 function shouldHideCommand(name, payload) {
   if (!payload) return false;
@@ -4728,10 +5694,10 @@ function registerZeroCommands(prog, commands) {
     prog.addCommand(cmd, hidden ? { hidden: true } : {});
   }
 }
-var program = new Command74();
+var program = new Command77();
 program.name("zero").description(
   "Zero CLI \u2014 interact with the zero platform from inside the sandbox"
-).version("9.100.2").addHelpText(
+).version("9.101.0").addHelpText(
   "after",
   `
 Examples: