@vm0/cli 9.237.6 → 9.238.1

package/computer-use-ALMIBYF4.js

@@ -0,0 +1,973 @@
+#!/usr/bin/env node
+import { createRequire as __createRequire } from "node:module";
+const require = __createRequire(import.meta.url);
+import {
+  COMPUTER_USE_FILESYSTEM_PLUGIN,
+  COMPUTER_USE_MCP_LIST_TOOLS,
+  COMPUTER_USE_MCP_PLUGIN,
+  createComputerUsePluginCommand,
+  createComputerUseReadCommand,
+  createComputerUseWriteCommand,
+  fetchComputerUsePluginContent,
+  fetchComputerUseScreenshot,
+  getComputerUseCommand,
+  listComputerUseHosts
+} from "./chunk-37U2ZGBH.js";
+import {
+  ApiRequestError,
+  withErrorHandler
+} from "./chunk-VBI53K3Q.js";
+import "./chunk-JUTUEPIR.js";
+import "./chunk-LRHXR7JT.js";
+import {
+  Command
+} from "./chunk-B3W2RUBP.js";
+import {
+  init_esm_shims
+} from "./chunk-DIRAZ3YX.js";
+
+// src/commands/zero/computer-use/index.ts
+init_esm_shims();
+import { readFileSync } from "fs";
+import { join } from "path";
+
+// src/commands/zero/computer-use/output-artifacts.ts
+init_esm_shims();
+import { randomUUID } from "crypto";
+import {
+  chmod,
+  lstat,
+  mkdir,
+  readdir,
+  rename,
+  rm,
+  writeFile
+} from "fs/promises";
+import { tmpdir } from "os";
+import path from "path";
+var COMPUTER_USE_OUTPUT_DIR_MODE = 448;
+var COMPUTER_USE_OUTPUT_FILE_MODE = 384;
+var COMPUTER_USE_OUTPUT_TTL_MS = 24 * 60 * 60 * 1e3;
+var DEFAULT_COMPUTER_USE_OUTPUT_DIR = path.join(
+  tmpdir(),
+  "vm0",
+  "computer-use"
+);
+function computerUseOutputDir() {
+  const configured = process.env.VM0_COMPUTER_OUTPUT_DIR?.trim();
+  return configured && configured.length > 0 ? configured : DEFAULT_COMPUTER_USE_OUTPUT_DIR;
+}
+async function ensurePrivateDirectory(directory) {
+  await mkdir(directory, {
+    recursive: true,
+    mode: COMPUTER_USE_OUTPUT_DIR_MODE
+  });
+  const stats = await lstat(directory);
+  if (!stats.isDirectory() || stats.isSymbolicLink()) {
+    throw new Error(
+      `Computer-use output path is not a directory: ${directory}`
+    );
+  }
+  await chmod(directory, COMPUTER_USE_OUTPUT_DIR_MODE);
+}
+async function removeStaleEntries(directory, cutoffMs) {
+  let entries;
+  try {
+    entries = await readdir(directory, { withFileTypes: true });
+  } catch (error) {
+    if (typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT") {
+      return;
+    }
+    throw error;
+  }
+  for (const entry of entries) {
+    const entryPath = path.join(directory, entry.name);
+    const stats = await lstat(entryPath).catch(() => {
+      return null;
+    });
+    if (!stats) {
+      continue;
+    }
+    if (entry.isDirectory() && !stats.isSymbolicLink()) {
+      await removeStaleEntries(entryPath, cutoffMs);
+      continue;
+    }
+    if (stats.mtimeMs < cutoffMs) {
+      await rm(entryPath, { force: true, recursive: entry.isDirectory() });
+    }
+  }
+}
+async function prepareComputerUseOutputDir() {
+  const outputDir = computerUseOutputDir();
+  await ensurePrivateDirectory(outputDir);
+  await removeStaleEntries(outputDir, Date.now() - COMPUTER_USE_OUTPUT_TTL_MS);
+  return outputDir;
+}
+async function ensureOutputPathDirectory(outputPath) {
+  const outputDir = await prepareComputerUseOutputDir();
+  const directory = path.dirname(outputPath);
+  const relative = path.relative(outputDir, directory);
+  if (relative.startsWith("..") || path.isAbsolute(relative)) {
+    throw new Error(`Computer-use artifact path escapes output directory`);
+  }
+  let current = outputDir;
+  for (const part of relative.split(path.sep).filter(Boolean)) {
+    current = path.join(current, part);
+    await ensurePrivateDirectory(current);
+  }
+}
+async function writeComputerUseArtifact(outputPath, data) {
+  await ensureOutputPathDirectory(outputPath);
+  const tempPath = path.join(
+    path.dirname(outputPath),
+    `.${path.basename(outputPath)}.${process.pid.toString()}.${randomUUID()}.tmp`
+  );
+  let moved = false;
+  try {
+    await writeFile(tempPath, data, {
+      flag: "wx",
+      mode: COMPUTER_USE_OUTPUT_FILE_MODE
+    });
+    await chmod(tempPath, COMPUTER_USE_OUTPUT_FILE_MODE);
+    await rename(tempPath, outputPath);
+    moved = true;
+    await chmod(outputPath, COMPUTER_USE_OUTPUT_FILE_MODE);
+  } finally {
+    if (!moved) {
+      await rm(tempPath, { force: true });
+    }
+  }
+}
+
+// src/commands/zero/computer-use/index.ts
+var DATA_URL_PATTERN = /^data:([^;,]+);base64,(.*)$/s;
+var COMPUTER_USE_REQUIRED_CAPABILITY_MESSAGE = "Missing required capability: computer-use:write";
+var COMPUTER_USE_AUTHORIZATION_REQUIRED_ERROR = "COMPUTER_USE_AUTHORIZATION_REQUIRED";
+var COMPUTER_USE_HELP_TEXT = `
+Workflow:
+  1. Start the Zero Desktop app and make sure Computer Use is online.
+  2. Run "zero computer-use list-apps" to find the target app's bundleId.
+     --app accepts a bundle id only (e.g. com.google.Chrome); the name is for
+     display. Apps listed without a bundleId cannot be targeted.
+  3. Run "zero computer-use get-app-state --app <bundleId>" to get a screenshot,
+     snapshotId, visible element indexes, and accessibility state.
+  4. Prefer element actions with --snapshot-id and --element-index. Use --x/--y
+     only when the target is visible in the returned screenshot but has no useful
+     accessibility element.
+  5. Read the JSON result. Screenshot and App State data are saved under
+     /tmp/vm0/computer-use and replaced with local file paths in CLI output.
+     Files are named from app and snapshotId; rerunning the same snapshot
+     overwrites the same files.
+
+Notes:
+  Write commands are sent to the connected Desktop host. Coordinate fallbacks use
+  screenshot coordinates from get-app-state; pass the matching --snapshot-id when
+  acting on a prior snapshot.
+  type-text sends literal keyboard input to the target app's current focus. It
+  first verifies the focused element is editable and fails with
+  element_not_editable when it is not (for example a focused table or list), so
+  click into a text field before typing. Use set-value when you need
+  deterministic accessibility value assignment.
+  press-key accepts xdotool-style names such as shift+semicolon, Control_L+J,
+  ctrl+alt+n, and BackSpace, plus existing macOS-style forms such as Command+L.
+  type-text and press-key accept the same --snapshot-id as the element actions:
+  pass it to deliver keyboard input to that snapshot's window. Without it, the
+  most relevant window for the app is picked, which is ambiguous for multi-window
+  apps.
+
+Examples:
+  List available apps:
+    zero computer-use list-apps
+
+  Inspect Safari state:
+    zero computer-use get-app-state --app com.apple.Safari
+
+  Click element index 7 from snapshot desktop_abc:
+    zero computer-use click --app com.apple.Safari --snapshot-id desktop_abc --element-index 7
+
+  Click screenshot coordinate (320, 240) from snapshot desktop_abc:
+    zero computer-use click --app com.apple.Safari --snapshot-id desktop_abc --x 320 --y 240
+
+  Type text into the snapshot desktop_abc window in Safari:
+    zero computer-use type-text --app com.apple.Safari --snapshot-id desktop_abc --text "Hello"
+
+  Press a keyboard shortcut in the snapshot desktop_abc window:
+    zero computer-use press-key --app com.apple.Safari --snapshot-id desktop_abc --key shift+semicolon
+
+  Open an app without activating the current foreground app:
+    zero computer-use open-app --app com.culturedcode.ThingsMac`;
+function sleep(ms) {
+  return new Promise((resolve) => {
+    setTimeout(resolve, ms);
+  });
+}
+function throwComputerUseAuthorizationGuidanceError(error) {
+  if (error instanceof ApiRequestError && error.status === 403 && error.code === "FORBIDDEN" && error.message === COMPUTER_USE_REQUIRED_CAPABILITY_MESSAGE) {
+    throw new ApiRequestError(
+      "Computer Use authorization required",
+      COMPUTER_USE_AUTHORIZATION_REQUIRED_ERROR,
+      403
+    );
+  }
+  throw error;
+}
+function parseTimeoutSeconds(value) {
+  if (!value) return 30;
+  const seconds = Number.parseInt(value, 10);
+  if (!Number.isFinite(seconds) || seconds <= 0) {
+    throw new Error("Timeout must be a positive number of seconds");
+  }
+  return seconds;
+}
+function parseOptionalNonNegativeInteger(value, label) {
+  if (value === void 0) return void 0;
+  const parsed = Number.parseInt(value, 10);
+  if (!Number.isFinite(parsed) || parsed < 0) {
+    throw new Error(`${label} must be a non-negative integer`);
+  }
+  return parsed;
+}
+function parsePositiveInteger(value, label) {
+  if (value === void 0) {
+    throw new Error(`${label} is required`);
+  }
+  const parsed = Number.parseInt(value, 10);
+  if (!Number.isFinite(parsed) || parsed <= 0) {
+    throw new Error(`${label} must be a positive integer`);
+  }
+  return parsed;
+}
+function parsePositiveNumber(value, label) {
+  if (value === void 0) return void 0;
+  const parsed = Number.parseFloat(value);
+  if (!Number.isFinite(parsed) || parsed <= 0) {
+    throw new Error(`${label} must be a positive number`);
+  }
+  return parsed;
+}
+function parseMouseButton(value) {
+  if (value === "left" || value === "right" || value === "middle") {
+    return value;
+  }
+  throw new Error("button must be left, right, or middle");
+}
+function elementTargetPayload(options) {
+  const elementIndex = parseOptionalNonNegativeInteger(
+    options.elementIndex,
+    "element-index"
+  );
+  if (!options.element && elementIndex === void 0) {
+    throw new Error("element or element-index is required");
+  }
+  return {
+    ...options.element ? { elementId: options.element } : {},
+    ...elementIndex !== void 0 ? { elementIndex } : {}
+  };
+}
+function sanitizeFilenamePart(value, fallback) {
+  if (typeof value !== "string") {
+    return fallback;
+  }
+  const sanitized = value.trim().replace(/[^A-Za-z0-9._-]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 80);
+  return sanitized.length > 0 ? sanitized : fallback;
+}
+function extensionForMimeType(mimeType) {
+  if (mimeType === "image/png") {
+    return "png";
+  }
+  if (mimeType === "image/jpeg") {
+    return "jpg";
+  }
+  if (mimeType === "image/webp") {
+    return "webp";
+  }
+  const suffix = mimeType.startsWith("image/") ? mimeType.slice(6) : "bin";
+  return sanitizeFilenamePart(suffix, "bin").toLowerCase();
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function stringField(value, key) {
+  const field = value[key];
+  return typeof field === "string" ? field : void 0;
+}
+async function writeScreenshotDataUrl(result, dataUrl) {
+  const match = DATA_URL_PATTERN.exec(dataUrl);
+  if (!match) {
+    return null;
+  }
+  const mimeType = match[1] ?? "";
+  if (!mimeType.startsWith("image/")) {
+    throw new Error(`Unsupported screenshot MIME type: ${mimeType}`);
+  }
+  const base64Data = match[2] ?? "";
+  const appName = sanitizeFilenamePart(result.app, "app");
+  const snapshotId = sanitizeFilenamePart(result.snapshotId, "snapshot");
+  const outputPath = join(
+    computerUseOutputDir(),
+    `${appName}-${snapshotId}.${extensionForMimeType(mimeType)}`
+  );
+  await writeComputerUseArtifact(outputPath, Buffer.from(base64Data, "base64"));
+  return outputPath;
+}
+function screenshotPointerType(value) {
+  if (typeof value !== "object" || value === null) {
+    return null;
+  }
+  const type = value.type;
+  return type === "s3" || type === "expired" ? type : null;
+}
+async function writeScreenshotBytes(result, buffer, mimeType) {
+  const appName = sanitizeFilenamePart(result.app, "app");
+  const snapshotId = sanitizeFilenamePart(result.snapshotId, "snapshot");
+  const outputPath = join(
+    computerUseOutputDir(),
+    `${appName}-${snapshotId}.${extensionForMimeType(mimeType)}`
+  );
+  await writeComputerUseArtifact(outputPath, buffer);
+  return outputPath;
+}
+async function writeAppStateText(result, appState) {
+  const appName = sanitizeFilenamePart(result.app, "app");
+  const snapshotId = sanitizeFilenamePart(result.snapshotId, "snapshot");
+  const outputPath = join(
+    computerUseOutputDir(),
+    `${appName}-${snapshotId}.appState.txt`
+  );
+  await writeComputerUseArtifact(outputPath, appState);
+  return outputPath;
+}
+function compactActionResult(action) {
+  const compact = {};
+  for (const [key, value] of Object.entries(action)) {
+    if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+      compact[key] = value;
+    }
+  }
+  return compact;
+}
+async function formatComputerUseResultForConsole(result, commandId) {
+  const printable = { status: "succeeded" };
+  const apps = result.apps;
+  if (Array.isArray(apps)) {
+    printable.apps = apps;
+  }
+  const snapshotId = stringField(result, "snapshotId");
+  if (snapshotId) {
+    printable.snapshotId = snapshotId;
+  }
+  const appState = stringField(result, "appState");
+  if (appState) {
+    printable.appState = await writeAppStateText(result, appState);
+  }
+  const screenshot = result.screenshot;
+  if (typeof screenshot === "string") {
+    const screenshotPath = await writeScreenshotDataUrl(result, screenshot);
+    printable.screenshot = screenshotPath ?? screenshot;
+  } else {
+    const pointerType = screenshotPointerType(screenshot);
+    if (pointerType === "s3") {
+      const { buffer, mimeType } = await fetchComputerUseScreenshot(commandId);
+      printable.screenshot = await writeScreenshotBytes(
+        result,
+        buffer,
+        mimeType
+      );
+    } else if (pointerType === "expired") {
+      printable.screenshot = "[screenshot expired]";
+    }
+  }
+  const action = result.action;
+  if (isRecord(action)) {
+    printable.action = compactActionResult(action);
+  }
+  return JSON.stringify(printable, null, 2);
+}
+async function commandOutputText(command) {
+  if (!command.result) {
+    return "";
+  }
+  return await formatComputerUseResultForConsole(command.result, command.id);
+}
+function pluginContentPointerType(value) {
+  if (!isRecord(value)) {
+    return null;
+  }
+  const type = value.type;
+  return type === "s3" || type === "expired" ? type : null;
+}
+function pluginContentFileName(value) {
+  if (!isRecord(value) || typeof value.fileName !== "string") {
+    return "plugin-content.bin";
+  }
+  return sanitizeFilenamePart(value.fileName, "plugin-content.bin");
+}
+async function writePluginContent(commandId, result) {
+  const downloaded = await fetchComputerUsePluginContent(commandId);
+  const pointerFileName = pluginContentFileName(result.pluginContent);
+  const directoryName = sanitizeFilenamePart(commandId, "command");
+  const outputPath = join(
+    computerUseOutputDir(),
+    "plugins",
+    directoryName,
+    sanitizeFilenamePart(
+      downloaded.fileName || pointerFileName,
+      pointerFileName
+    )
+  );
+  await writeComputerUseArtifact(outputPath, downloaded.buffer);
+  return outputPath;
+}
+function formatHumanValue(value) {
+  if (typeof value === "string") {
+    return value;
+  }
+  if (typeof value === "number" || typeof value === "boolean") {
+    return String(value);
+  }
+  if (Array.isArray(value)) {
+    return value.map(formatHumanValue).join("\n");
+  }
+  if (value === null || value === void 0) {
+    return "";
+  }
+  return JSON.stringify(value, null, 2);
+}
+async function pluginCommandOutputText(command) {
+  const result = command.result;
+  if (!result) {
+    return "";
+  }
+  const content = stringField(result, "content");
+  if (content) {
+    return content;
+  }
+  const pluginContentType = pluginContentPointerType(result.pluginContent);
+  if (pluginContentType === "s3") {
+    const outputPath = await writePluginContent(command.id, result);
+    const sizeBytes = typeof result.sizeBytes === "number" ? ` (${result.sizeBytes} bytes)` : "";
+    return `Saved plugin content${sizeBytes}: ${outputPath}`;
+  }
+  if (pluginContentType === "expired") {
+    return "Plugin content expired.";
+  }
+  const lines = [];
+  for (const [key, value] of Object.entries(result)) {
+    if (key === "pluginContent") {
+      continue;
+    }
+    const formatted = formatHumanValue(value);
+    if (formatted) {
+      lines.push(`${key}: ${formatted}`);
+    }
+  }
+  return lines.join("\n");
+}
+async function waitForCommand(commandId, timeoutSeconds, formatter = commandOutputText) {
+  const deadline = Date.now() + timeoutSeconds * 1e3;
+  while (Date.now() <= deadline) {
+    const command = await getComputerUseCommand(commandId);
+    if (command.status === "queued" || command.status === "running") {
+      if (process.stdout.isTTY) {
+        process.stdout.write(".");
+      }
+      await sleep(1e3);
+      continue;
+    }
+    if (process.stdout.isTTY) {
+      process.stdout.write("\n");
+    }
+    if (command.status === "failed") {
+      throw new Error(
+        command.error ? `${command.error.code}: ${command.error.message}` : "Computer-use command failed"
+      );
+    }
+    const text = await formatter(command);
+    if (text) {
+      console.log(text);
+    }
+    return;
+  }
+  throw new Error(`Computer-use command timed out: ${commandId}`);
+}
+async function runReadCommand(kind, options, payload = {}) {
+  const timeoutSeconds = parseTimeoutSeconds(options.timeout);
+  try {
+    const created = await createComputerUseReadCommand({
+      kind,
+      timeoutMs: timeoutSeconds * 1e3,
+      ...payload
+    });
+    await waitForCommand(created.commandId, timeoutSeconds);
+  } catch (error) {
+    throwComputerUseAuthorizationGuidanceError(error);
+  }
+}
+async function runWriteCommand(kind, options, payload) {
+  const timeoutSeconds = parseTimeoutSeconds(options.timeout);
+  try {
+    const created = await createComputerUseWriteCommand({
+      kind,
+      timeoutMs: timeoutSeconds * 1e3,
+      ...payload
+    });
+    await waitForCommand(created.commandId, timeoutSeconds);
+  } catch (error) {
+    throwComputerUseAuthorizationGuidanceError(error);
+  }
+}
+function parseArgumentsJson(value) {
+  if (!value) {
+    return {};
+  }
+  const parsed = JSON.parse(value);
+  if (!isRecord(parsed)) {
+    throw new Error("arguments-json must be a JSON object");
+  }
+  return parsed;
+}
+function withArgumentsJson(options, fallback) {
+  return options.argumentsJson ? parseArgumentsJson(options.argumentsJson) : fallback;
+}
+function parseOptionalPositiveInteger(value, label) {
+  if (value === void 0) {
+    return void 0;
+  }
+  return parsePositiveInteger(value, label);
+}
+async function runFilesystemPluginCommand(tool, options, args) {
+  const timeoutSeconds = parseTimeoutSeconds(options.timeout);
+  const body = {
+    plugin: COMPUTER_USE_FILESYSTEM_PLUGIN,
+    tool,
+    arguments: args,
+    timeoutMs: timeoutSeconds * 1e3
+  };
+  try {
+    const created = await createComputerUsePluginCommand(body);
+    await waitForCommand(
+      created.commandId,
+      timeoutSeconds,
+      pluginCommandOutputText
+    );
+  } catch (error) {
+    throwComputerUseAuthorizationGuidanceError(error);
+  }
+}
+function addTargetOptions(command) {
+  return command.option("--timeout <seconds>", "Maximum time to wait", "30");
+}
+function addPluginOptions(command) {
+  return addTargetOptions(command).option(
+    "--arguments-json <json>",
+    "Raw tool arguments object for advanced cases"
+  );
+}
+function appOption(command) {
+  return command.requiredOption(
+    "--app <bundleId>",
+    "Target app bundle id (e.g. com.google.Chrome); run list-apps to find it"
+  );
+}
+var listAppsCommand = addTargetOptions(
+  new Command().name("list-apps").description("List apps available to the Desktop Computer Use host").action(
+    withErrorHandler(async (options) => {
+      await runReadCommand("apps.list", options);
+    })
+  )
+);
+var getAppStateCommand = appOption(
+  addTargetOptions(
+    new Command().name("get-app-state").description(
+      "Get screenshot and accessibility state without activating an app"
+    ).action(
+      withErrorHandler(async (options) => {
+        await runReadCommand("app.state", options, { app: options.app });
+      })
+    )
+  )
+);
+var clickCommand = appOption(
+  addTargetOptions(
+    new Command().name("click").description(
+      "Click an accessibility element or background screenshot coordinate"
+    ).option("--snapshot-id <id>", "Snapshot id returned by get-app-state").option("--element <id>", "Element id from get-app-state").option("--element-index <index>", "Element index from get-app-state").option("--x <points>", "Screenshot x coordinate fallback").option("--y <points>", "Screenshot y coordinate fallback").option("--button <button>", "Mouse button", "left").option("--click-count <count>", "Number of clicks", "1").action(
+      withErrorHandler(async (options) => {
+        const x = parseOptionalNonNegativeInteger(options.x, "x");
+        const y = parseOptionalNonNegativeInteger(options.y, "y");
+        const elementIndex = parseOptionalNonNegativeInteger(
+          options.elementIndex,
+          "element-index"
+        );
+        await runWriteCommand("element.click", options, {
+          app: options.app,
+          ...options.snapshotId ? { snapshotId: options.snapshotId } : {},
+          ...options.element ? { elementId: options.element } : {},
+          ...elementIndex !== void 0 ? { elementIndex } : {},
+          ...x !== void 0 ? { x } : {},
+          ...y !== void 0 ? { y } : {},
+          button: parseMouseButton(options.button),
+          clickCount: parsePositiveInteger(options.clickCount, "click-count")
+        });
+      })
+    )
+  )
+);
+var scrollCommand = appOption(
+  addTargetOptions(
+    new Command().name("scroll").description("Scroll an accessibility element").option("--snapshot-id <id>", "Snapshot id returned by get-app-state").option("--element <id>", "Element id from get-app-state").option("--element-index <index>", "Element index from get-app-state").requiredOption(
+      "--direction <direction>",
+      "Scroll direction: up, down, left, or right"
+    ).option("--pages <count>", "Number of pages to scroll", "1").action(
+      withErrorHandler(async (options) => {
+        await runWriteCommand("element.scroll", options, {
+          app: options.app,
+          ...options.snapshotId ? { snapshotId: options.snapshotId } : {},
+          ...elementTargetPayload(options),
+          direction: options.direction,
+          pages: parsePositiveNumber(options.pages, "pages")
+        });
+      })
+    )
+  )
+);
+var setValueCommand = appOption(
+  addTargetOptions(
+    new Command().name("set-value").description("Set the value of a settable accessibility element").option("--snapshot-id <id>", "Snapshot id returned by get-app-state").option("--element <id>", "Element id from get-app-state").option("--element-index <index>", "Element index from get-app-state").requiredOption("--value <text>", "Value to assign").action(
+      withErrorHandler(async (options) => {
+        await runWriteCommand("element.set_value", options, {
+          app: options.app,
+          ...options.snapshotId ? { snapshotId: options.snapshotId } : {},
+          ...elementTargetPayload(options),
+          value: options.value
+        });
+      })
+    )
+  )
+);
+var typeTextCommand = appOption(
+  addTargetOptions(
+    new Command().name("type-text").description("Type literal keyboard input into the target app").option("--snapshot-id <id>", "Snapshot id returned by get-app-state").requiredOption("--text <text>", "Text to type").action(
+      withErrorHandler(async (options) => {
+        await runWriteCommand("keyboard.type_text", options, {
+          app: options.app,
+          ...options.snapshotId ? { snapshotId: options.snapshotId } : {},
+          text: options.text
+        });
+      })
+    )
+  )
+);
+var pressKeyCommand = appOption(
+  addTargetOptions(
+    new Command().name("press-key").description("Send a background key or key combination to the target app").option("--snapshot-id <id>", "Snapshot id returned by get-app-state").requiredOption(
+      "--key <key>",
+      "Key or xdotool-style combination, for example Command+K, shift+semicolon, or Control_L+J"
+    ).action(
+      withErrorHandler(async (options) => {
+        await runWriteCommand("keyboard.press_key", options, {
+          app: options.app,
+          ...options.snapshotId ? { snapshotId: options.snapshotId } : {},
+          key: options.key
+        });
+      })
+    )
+  )
+);
+var performActionCommand = appOption(
+  addTargetOptions(
+    new Command().name("perform-action").description("Invoke a secondary accessibility action").option("--snapshot-id <id>", "Snapshot id returned by get-app-state").option("--element <id>", "Element id from get-app-state").option("--element-index <index>", "Element index from get-app-state").requiredOption("--action <name>", "Accessibility action name").action(
+      withErrorHandler(async (options) => {
+        await runWriteCommand("element.perform_action", options, {
+          app: options.app,
+          ...options.snapshotId ? { snapshotId: options.snapshotId } : {},
+          ...elementTargetPayload(options),
+          action: options.action
+        });
+      })
+    )
+  )
+);
+var openAppCommand = appOption(
+  addTargetOptions(
+    new Command().name("open-app").description("Open an app on the Desktop host without activating it").action(
+      withErrorHandler(async (options) => {
+        await runWriteCommand("app.open", options, { app: options.app });
+      })
+    )
+  )
+);
+var filesystemListAllowedDirectoriesCommand = addPluginOptions(
+  new Command().name("list_allowed_directories").description("List directories enabled in Zero Desktop").action(
+    withErrorHandler(async (options) => {
+      await runFilesystemPluginCommand(
+        "list_allowed_directories",
+        options,
+        withArgumentsJson(options, {})
+      );
+    })
+  )
+);
+var filesystemReadTextFileCommand = addPluginOptions(
+  new Command().name("read_text_file").description("Read a text file").requiredOption("--path <path>", "File path").option("--head <lines>", "Read the first N lines").option("--tail <lines>", "Read the last N lines").action(
+    withErrorHandler(async (options) => {
+      await runFilesystemPluginCommand(
+        "read_text_file",
+        options,
+        withArgumentsJson(options, {
+          path: options.path,
+          ...options.head ? { head: parseOptionalPositiveInteger(options.head, "head") } : {},
+          ...options.tail ? { tail: parseOptionalPositiveInteger(options.tail, "tail") } : {}
+        })
+      );
+    })
+  )
+);
+var filesystemReadMediaFileCommand = addPluginOptions(
+  new Command().name("read_media_file").description("Read an image or audio file").requiredOption("--path <path>", "File path").action(
+    withErrorHandler(async (options) => {
+      await runFilesystemPluginCommand(
+        "read_media_file",
+        options,
+        withArgumentsJson(options, { path: options.path })
+      );
+    })
+  )
+);
+var filesystemReadMultipleFilesCommand = addPluginOptions(
+  new Command().name("read_multiple_files").description("Read multiple text files").requiredOption("--path <path...>", "File paths").action(
+    withErrorHandler(async (options) => {
+      await runFilesystemPluginCommand(
+        "read_multiple_files",
+        options,
+        withArgumentsJson(options, { paths: options.path })
+      );
+    })
+  )
+);
+var filesystemWriteFileCommand = addPluginOptions(
+  new Command().name("write_file").description("Write a file").requiredOption("--path <path>", "File path").requiredOption("--content <text>", "File content").action(
+    withErrorHandler(async (options) => {
+      await runFilesystemPluginCommand(
+        "write_file",
+        options,
+        withArgumentsJson(options, {
+          path: options.path,
+          content: options.content
+        })
+      );
+    })
+  )
+);
+var filesystemEditFileCommand = addPluginOptions(
+  new Command().name("edit_file").description("Edit a file").requiredOption("--path <path>", "File path").option("--old-text <text>", "Text to replace").option("--new-text <text>", "Replacement text").option("--dry-run", "Preview changes without writing").action(
+    withErrorHandler(async (options) => {
+      if (!options.argumentsJson && (!options.oldText || options.newText === void 0)) {
+        throw new Error(
+          "edit_file requires --old-text and --new-text, or --arguments-json"
+        );
+      }
+      await runFilesystemPluginCommand(
+        "edit_file",
+        options,
+        withArgumentsJson(options, {
+          path: options.path,
+          edits: [
+            {
+              oldText: options.oldText,
+              newText: options.newText
+            }
+          ],
+          dryRun: options.dryRun === true
+        })
+      );
+    })
+  )
+);
+var filesystemCreateDirectoryCommand = addPluginOptions(
+  new Command().name("create_directory").description("Create a directory").requiredOption("--path <path>", "Directory path").action(
+    withErrorHandler(async (options) => {
+      await runFilesystemPluginCommand(
+        "create_directory",
+        options,
+        withArgumentsJson(options, { path: options.path })
+      );
+    })
+  )
+);
+var filesystemListDirectoryCommand = addPluginOptions(
+  new Command().name("list_directory").description("List directory entries").requiredOption("--path <path>", "Directory path").action(
+    withErrorHandler(async (options) => {
+      await runFilesystemPluginCommand(
+        "list_directory",
+        options,
+        withArgumentsJson(options, { path: options.path })
+      );
+    })
+  )
+);
+var filesystemListDirectoryWithSizesCommand = addPluginOptions(
+  new Command().name("list_directory_with_sizes").description("List directory entries with sizes").requiredOption("--path <path>", "Directory path").option("--sort-by <field>", "Sort by name or size", "name").action(
+    withErrorHandler(
+      async (options) => {
+        await runFilesystemPluginCommand(
+          "list_directory_with_sizes",
+          options,
+          withArgumentsJson(options, {
+            path: options.path,
+            sortBy: options.sortBy ?? "name"
+          })
+        );
+      }
+    )
+  )
+);
+var filesystemDirectoryTreeCommand = addPluginOptions(
+  new Command().name("directory_tree").description("Return a directory tree").requiredOption("--path <path>", "Directory path").option("--exclude-pattern <pattern...>", "Patterns to exclude").action(
+    withErrorHandler(async (options) => {
+      await runFilesystemPluginCommand(
+        "directory_tree",
+        options,
+        withArgumentsJson(options, {
+          path: options.path,
+          ...options.excludePattern ? { excludePatterns: options.excludePattern } : {}
+        })
+      );
+    })
+  )
+);
+var filesystemMoveFileCommand = addPluginOptions(
+  new Command().name("move_file").description("Move or rename a file").requiredOption("--source <path>", "Source path").requiredOption("--destination <path>", "Destination path").action(
+    withErrorHandler(async (options) => {
+      await runFilesystemPluginCommand(
+        "move_file",
+        options,
+        withArgumentsJson(options, {
+          source: options.source,
+          destination: options.destination
+        })
+      );
+    })
+  )
+);
+var filesystemSearchFilesCommand = addPluginOptions(
+  new Command().name("search_files").description("Search files by name").requiredOption("--path <path>", "Directory path").requiredOption("--pattern <pattern>", "Search pattern").option("--exclude-pattern <pattern...>", "Patterns to exclude").action(
+    withErrorHandler(async (options) => {
+      await runFilesystemPluginCommand(
+        "search_files",
+        options,
+        withArgumentsJson(options, {
+          path: options.path,
+          pattern: options.pattern,
+          ...options.excludePattern ? { excludePatterns: options.excludePattern } : {}
+        })
+      );
+    })
+  )
+);
+var filesystemGetFileInfoCommand = addPluginOptions(
+  new Command().name("get_file_info").description("Get file metadata").requiredOption("--path <path>", "File or directory path").action(
+    withErrorHandler(async (options) => {
+      await runFilesystemPluginCommand(
+        "get_file_info",
+        options,
+        withArgumentsJson(options, { path: options.path })
+      );
+    })
+  )
+);
+var filesystemPluginCommand = new Command().name("filesystem").description("Use the Zero Desktop filesystem plugin").addCommand(filesystemListAllowedDirectoriesCommand).addCommand(filesystemReadTextFileCommand).addCommand(filesystemReadMediaFileCommand).addCommand(filesystemReadMultipleFilesCommand).addCommand(filesystemWriteFileCommand).addCommand(filesystemEditFileCommand).addCommand(filesystemCreateDirectoryCommand).addCommand(filesystemListDirectoryCommand).addCommand(filesystemListDirectoryWithSizesCommand).addCommand(filesystemDirectoryTreeCommand).addCommand(filesystemMoveFileCommand).addCommand(filesystemSearchFilesCommand).addCommand(filesystemGetFileInfoCommand);
+var MCP_SERVER_CAPABILITY_PREFIX = `plugin.${COMPUTER_USE_MCP_PLUGIN}.`;
+function parseMcpToolArguments(options) {
+  if (options.args && options.argsFile) {
+    throw new Error("Pass either --args or --args-file, not both");
+  }
+  if (options.argsFile) {
+    return parseArgumentsJson(readFileSync(options.argsFile, "utf8"));
+  }
+  return parseArgumentsJson(options.args);
+}
+async function runMcpPluginCommand(server, tool, options, args) {
+  const timeoutSeconds = parseTimeoutSeconds(options.timeout);
+  const body = {
+    plugin: COMPUTER_USE_MCP_PLUGIN,
+    server,
+    tool,
+    arguments: args,
+    timeoutMs: timeoutSeconds * 1e3
+  };
+  try {
+    const created = await createComputerUsePluginCommand(body);
+    await waitForCommand(
+      created.commandId,
+      timeoutSeconds,
+      pluginCommandOutputText
+    );
+  } catch (error) {
+    throwComputerUseAuthorizationGuidanceError(error);
+  }
+}
+async function printMcpServers() {
+  const hosts = await listComputerUseHosts().catch((error) => {
+    throwComputerUseAuthorizationGuidanceError(error);
+  });
+  const lines = [];
+  for (const host of hosts) {
+    const servers = host.supportedCapabilities.filter((capability) => {
+      return capability.startsWith(MCP_SERVER_CAPABILITY_PREFIX);
+    }).map((capability) => {
+      return capability.slice(MCP_SERVER_CAPABILITY_PREFIX.length);
+    });
+    if (servers.length === 0) {
+      continue;
+    }
+    lines.push(`${host.displayName} (${host.status}): ${servers.join(", ")}`);
+  }
+  if (lines.length === 0) {
+    console.log(
+      "No MCP servers are running on any linked host. Configure and enable them in the Zero Desktop app's Developer Tools section."
+    );
+    return;
+  }
+  console.log(lines.join("\n"));
+}
+var mcpListCommand = new Command().name("list").description(
+  "List MCP servers on linked hosts, or a server's tools and schemas"
+).argument("[server]", "MCP server name; omit to list available servers").action(
+  withErrorHandler(
+    async (server, _options, command) => {
+      if (!server) {
+        await printMcpServers();
+        return;
+      }
+      await runMcpPluginCommand(
+        server,
+        COMPUTER_USE_MCP_LIST_TOOLS,
+        command.optsWithGlobals(),
+        {}
+      );
+    }
+  )
+);
+var mcpCallCommand = new Command().name("call").description("Call a tool on a configured MCP server").argument("<server>", "MCP server name (see: plugin mcp list)").argument("<tool>", "Tool name (see: plugin mcp list <server>)").option("--args <json>", "Tool arguments as a JSON object").option("--args-file <path>", "Read tool arguments JSON from a file").action(
+  withErrorHandler(
+    async (server, tool, options, command) => {
+      await runMcpPluginCommand(
+        server,
+        tool,
+        command.optsWithGlobals(),
+        parseMcpToolArguments(options)
+      );
+    }
+  )
+);
+var mcpPluginCommand = new Command().name("mcp").description("Use custom MCP servers configured in the Zero Desktop app").addCommand(mcpListCommand).addCommand(mcpCallCommand);
+var pluginCommand = addTargetOptions(
+  new Command().name("plugin").description("Use Desktop Computer Use plugins").addCommand(filesystemPluginCommand).addCommand(mcpPluginCommand)
+);
+var zeroComputerUseCommand = new Command().name("computer-use").description("Desktop app computer use through Zero CLI").addHelpText("after", COMPUTER_USE_HELP_TEXT).addCommand(listAppsCommand).addCommand(getAppStateCommand).addCommand(clickCommand).addCommand(scrollCommand).addCommand(setValueCommand).addCommand(typeTextCommand).addCommand(pressKeyCommand).addCommand(performActionCommand).addCommand(openAppCommand).addCommand(pluginCommand);
+export {
+  formatComputerUseResultForConsole,
+  zeroComputerUseCommand
+};
+//# sourceMappingURL=computer-use-ALMIBYF4.js.map