@vm0/cli 9.278.0 → 9.278.1

package/chunk-SJPOFQJU.js

@@ -0,0 +1,792 @@
+#!/usr/bin/env node
+import { createRequire as __createRequire } from "node:module";
+const require = __createRequire(import.meta.url);
+import {
+  authHeadersSchema
+} from "./chunk-JV6LM2YC.js";
+import {
+  apiErrorSchema,
+  external_exports,
+  initContract
+} from "./chunk-GHKWW4NC.js";
+import {
+  init_esm_shims
+} from "./chunk-AUWSMG4F.js";
+
+// ../../packages/api-contracts/src/contracts/zero-computer-use-plugins.ts
+init_esm_shims();
+var COMPUTER_USE_PLUGIN_CALL_KIND = "plugin.call";
+var COMPUTER_USE_FILESYSTEM_PLUGIN = "filesystem";
+var COMPUTER_USE_MCP_PLUGIN = "mcp";
+var COMPUTER_USE_MCP_LIST_TOOLS = "tools/list";
+var COMPUTER_USE_PLUGIN_RESULT_INLINE_TEXT_MAX_BYTES = 64 * 1024;
+var COMPUTER_USE_PLUGIN_RESULT_INLINE_JSON_MAX_BYTES = 256 * 1024;
+var COMPUTER_USE_PLUGIN_RESULT_BLOB_MAX_BYTES = 10 * 1024 * 1024;
+var computerUseFilesystemToolNames = [
+  "list_allowed_directories",
+  "read_text_file",
+  "read_media_file",
+  "read_multiple_files",
+  "write_file",
+  "edit_file",
+  "create_directory",
+  "list_directory",
+  "list_directory_with_sizes",
+  "directory_tree",
+  "move_file",
+  "search_files",
+  "get_file_info"
+];
+var computerUseFilesystemToolSchema = external_exports.enum(
+  computerUseFilesystemToolNames
+);
+var computerUsePluginNameSchema = external_exports.literal(
+  COMPUTER_USE_FILESYSTEM_PLUGIN
+);
+var pathArgumentSchema = external_exports.string().trim().min(1).max(16384);
+var textContentSchema = external_exports.string().max(COMPUTER_USE_PLUGIN_RESULT_BLOB_MAX_BYTES);
+var excludePatternsSchema = external_exports.array(external_exports.string().trim().min(1)).max(512);
+var noArgumentsSchema = external_exports.object({}).strict();
+var readTextFileArgumentsSchema = external_exports.object({
+  path: pathArgumentSchema,
+  tail: external_exports.number().int().positive().optional(),
+  head: external_exports.number().int().positive().optional()
+}).strict().superRefine((args, ctx) => {
+  if (args.head !== void 0 && args.tail !== void 0) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["head"],
+      message: "read_text_file accepts either head or tail, not both"
+    });
+  }
+});
+var readMediaFileArgumentsSchema = external_exports.object({
+  path: pathArgumentSchema
+}).strict();
+var readMultipleFilesArgumentsSchema = external_exports.object({
+  paths: external_exports.array(pathArgumentSchema).min(1).max(100)
+}).strict();
+var writeFileArgumentsSchema = external_exports.object({
+  path: pathArgumentSchema,
+  content: textContentSchema
+}).strict();
+var editFileArgumentsSchema = external_exports.object({
+  path: pathArgumentSchema,
+  edits: external_exports.array(
+    external_exports.object({
+      oldText: textContentSchema,
+      newText: textContentSchema
+    }).strict()
+  ).min(1).max(1e3),
+  dryRun: external_exports.boolean().optional()
+}).strict();
+var createDirectoryArgumentsSchema = external_exports.object({
+  path: pathArgumentSchema
+}).strict();
+var listDirectoryArgumentsSchema = external_exports.object({
+  path: pathArgumentSchema
+}).strict();
+var listDirectoryWithSizesArgumentsSchema = external_exports.object({
+  path: pathArgumentSchema,
+  sortBy: external_exports.enum(["name", "size"]).optional()
+}).strict();
+var directoryTreeArgumentsSchema = external_exports.object({
+  path: pathArgumentSchema,
+  excludePatterns: excludePatternsSchema.optional()
+}).strict();
+var moveFileArgumentsSchema = external_exports.object({
+  source: pathArgumentSchema,
+  destination: pathArgumentSchema
+}).strict();
+var searchFilesArgumentsSchema = external_exports.object({
+  path: pathArgumentSchema,
+  pattern: external_exports.string().trim().min(1).max(4096),
+  excludePatterns: excludePatternsSchema.optional()
+}).strict();
+var getFileInfoArgumentsSchema = external_exports.object({
+  path: pathArgumentSchema
+}).strict();
+function computerUseFilesystemToolArgumentsSchema(tool) {
+  switch (tool) {
+    case "list_allowed_directories":
+      return noArgumentsSchema;
+    case "read_text_file":
+      return readTextFileArgumentsSchema;
+    case "read_media_file":
+      return readMediaFileArgumentsSchema;
+    case "read_multiple_files":
+      return readMultipleFilesArgumentsSchema;
+    case "write_file":
+      return writeFileArgumentsSchema;
+    case "edit_file":
+      return editFileArgumentsSchema;
+    case "create_directory":
+      return createDirectoryArgumentsSchema;
+    case "list_directory":
+      return listDirectoryArgumentsSchema;
+    case "list_directory_with_sizes":
+      return listDirectoryWithSizesArgumentsSchema;
+    case "directory_tree":
+      return directoryTreeArgumentsSchema;
+    case "move_file":
+      return moveFileArgumentsSchema;
+    case "search_files":
+      return searchFilesArgumentsSchema;
+    case "get_file_info":
+      return getFileInfoArgumentsSchema;
+  }
+}
+var computerUsePluginCallBodySchema = external_exports.object({
+  plugin: computerUsePluginNameSchema,
+  tool: computerUseFilesystemToolSchema,
+  arguments: external_exports.record(external_exports.string(), external_exports.unknown()).default({}),
+  timeoutMs: external_exports.number().int().min(1e3).max(12e4).default(6e4)
+}).superRefine((body, ctx) => {
+  const parsed = computerUseFilesystemToolArgumentsSchema(
+    body.tool
+  ).safeParse(body.arguments);
+  if (parsed.success) {
+    return;
+  }
+  for (const issue of parsed.error.issues) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["arguments", ...issue.path],
+      message: issue.message
+    });
+  }
+});
+var COMPUTER_USE_MCP_SERVER_NAME_PATTERN = /^[a-z0-9_-]{1,64}$/;
+var computerUseMcpPluginCallBodySchema = external_exports.object({
+  plugin: external_exports.literal(COMPUTER_USE_MCP_PLUGIN),
+  server: external_exports.string().regex(
+    COMPUTER_USE_MCP_SERVER_NAME_PATTERN,
+    "MCP server names must match [a-z0-9_-]{1,64}"
+  ),
+  tool: external_exports.string().trim().min(1).max(256),
+  arguments: external_exports.record(external_exports.string(), external_exports.unknown()).default({}),
+  timeoutMs: external_exports.number().int().min(1e3).max(12e4).default(6e4)
+});
+var computerUseAnyPluginCallBodySchema = external_exports.union([
+  computerUsePluginCallBodySchema,
+  computerUseMcpPluginCallBodySchema
+]);
+
+// ../../packages/api-contracts/src/contracts/zero-computer-use.ts
+init_esm_shims();
+var c = initContract();
+var computerUseHostStatusSchema = external_exports.enum(["online", "offline"]);
+var computerUseReadCommandKindSchema = external_exports.enum([
+  "apps.list",
+  "app.state"
+]);
+var computerUseWriteCommandKindSchema = external_exports.enum([
+  "app.open",
+  "element.click",
+  "element.scroll",
+  "element.set_value",
+  "element.perform_action",
+  "keyboard.type_text",
+  "keyboard.press_key"
+]);
+var computerUsePluginCommandKindSchema = external_exports.literal(
+  COMPUTER_USE_PLUGIN_CALL_KIND
+);
+var computerUseCommandKindSchema = external_exports.enum([
+  ...computerUseReadCommandKindSchema.options,
+  ...computerUseWriteCommandKindSchema.options,
+  COMPUTER_USE_PLUGIN_CALL_KIND
+]);
+var computerUseCommandStatusSchema = external_exports.enum([
+  "queued",
+  "running",
+  "succeeded",
+  "failed"
+]);
+var computerUseCommandErrorCodeSchema = external_exports.enum([
+  "no_host",
+  "permission_denied",
+  "accessibility_unavailable",
+  "automation_permission_denied",
+  "window_unavailable",
+  "screen_recording_unavailable",
+  "app_not_found",
+  "app_open_failed",
+  "element_action_unsupported",
+  "element_not_editable",
+  "unsupported_command",
+  "timeout",
+  "command_timeout",
+  "feature_disabled",
+  "plugin_disabled",
+  "plugin_unavailable",
+  "plugin_restarting",
+  "unknown_plugin",
+  "unknown_tool",
+  "invalid_arguments",
+  "path_denied",
+  "result_too_large",
+  "input_too_large",
+  "mcp_error"
+]);
+var hostNameSchema = external_exports.string().trim().min(1).max(253);
+var hostInstallationIdSchema = external_exports.string().trim().uuid();
+var hostVersionSchema = external_exports.string().trim().min(1).max(64);
+var hostOsVersionSchema = external_exports.string().trim().min(1).max(128);
+var authorizationRequestTokenPathParamsSchema = external_exports.object({
+  requestToken: external_exports.string().min(1)
+});
+var commandIdPathParamsSchema = external_exports.object({
+  commandId: external_exports.string().min(1)
+});
+var supportedCapabilitiesSchema = external_exports.array(external_exports.string().trim().min(1).max(128)).max(50);
+var appNameSchema = external_exports.string().trim().min(1).max(256);
+var snapshotIdSchema = external_exports.string().trim().min(1).max(256);
+var elementIdSchema = external_exports.string().trim().min(1).max(256);
+var elementIndexSchema = external_exports.number().int().min(0);
+var computerUsePermissionsSchema = external_exports.object({
+  accessibility: external_exports.boolean(),
+  screenRecording: external_exports.boolean(),
+  automation: external_exports.object({
+    chrome: external_exports.object({
+      status: external_exports.enum([
+        "unknown",
+        "granted",
+        "denied",
+        "not_installed",
+        "not_running"
+      ]),
+      updatedAt: external_exports.string().nullable().default(null),
+      reason: external_exports.string().nullable().default(null)
+    }).default({ status: "unknown", updatedAt: null, reason: null }),
+    safari: external_exports.object({
+      status: external_exports.enum([
+        "unknown",
+        "granted",
+        "denied",
+        "not_installed",
+        "not_running"
+      ]),
+      updatedAt: external_exports.string().nullable().default(null),
+      reason: external_exports.string().nullable().default(null)
+    }).default({ status: "unknown", updatedAt: null, reason: null })
+  }).default({
+    chrome: { status: "unknown", updatedAt: null, reason: null },
+    safari: { status: "unknown", updatedAt: null, reason: null }
+  })
+});
+var computerUseRuntimeBodySchema = external_exports.object({
+  installationId: hostInstallationIdSchema.optional(),
+  hostName: hostNameSchema,
+  appVersion: hostVersionSchema,
+  osVersion: hostOsVersionSchema,
+  supportedCapabilities: supportedCapabilitiesSchema.default([]),
+  permissions: computerUsePermissionsSchema
+});
+var computerUseCommandTargetShape = {
+  timeoutMs: external_exports.number().int().min(1e3).max(12e4).default(6e4)
+};
+var computerUseCommandPayloadShape = {
+  app: appNameSchema.optional(),
+  snapshotId: snapshotIdSchema.optional(),
+  elementId: elementIdSchema.optional(),
+  elementIndex: elementIndexSchema.optional(),
+  x: external_exports.number().int().min(0).optional(),
+  y: external_exports.number().int().min(0).optional(),
+  button: external_exports.enum(["left", "right", "middle"]).optional(),
+  clickCount: external_exports.number().int().min(1).max(3).optional(),
+  direction: external_exports.enum(["up", "down", "left", "right"]).optional(),
+  pages: external_exports.number().positive().max(25).optional(),
+  value: external_exports.string().min(1).max(64e3).optional(),
+  text: external_exports.string().min(1).max(64e3).optional(),
+  key: external_exports.string().trim().min(1).max(256).optional(),
+  action: external_exports.string().trim().min(1).max(256).optional()
+};
+var computerUseCommandCreateBodySchema = external_exports.object({
+  kind: computerUseReadCommandKindSchema,
+  ...computerUseCommandTargetShape,
+  ...computerUseCommandPayloadShape
+}).superRefine((body, ctx) => {
+  if (body.kind === "app.state" && !body.app) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["app"],
+      message: "app.state requires app"
+    });
+  }
+});
+var computerUseWriteCommandCreateBaseSchema = external_exports.object({
+  kind: computerUseWriteCommandKindSchema,
+  ...computerUseCommandTargetShape,
+  ...computerUseCommandPayloadShape
+});
+function requireComputerUseField(ctx, field, message) {
+  ctx.addIssue({ code: "custom", path: [field], message });
+}
+function validateElementClickCommand(body, ctx) {
+  const hasPoint = body.x !== void 0 && body.y !== void 0;
+  if (!body.elementId && body.elementIndex === void 0 && !hasPoint) {
+    requireComputerUseField(
+      ctx,
+      "elementIndex",
+      "element.click requires elementId, elementIndex, or x/y"
+    );
+  }
+  if (body.x === void 0 !== (body.y === void 0)) {
+    requireComputerUseField(
+      ctx,
+      "x",
+      "element.click coordinates require both x and y"
+    );
+  }
+}
+function validateElementScrollCommand(body, ctx) {
+  if (!body.elementId && body.elementIndex === void 0) {
+    requireComputerUseField(
+      ctx,
+      "elementIndex",
+      "element.scroll requires elementId or elementIndex"
+    );
+  }
+  if (!body.direction) {
+    requireComputerUseField(
+      ctx,
+      "direction",
+      "element.scroll requires direction"
+    );
+  }
+}
+function validateElementSetValueCommand(body, ctx) {
+  if (!body.elementId && body.elementIndex === void 0) {
+    requireComputerUseField(
+      ctx,
+      "elementIndex",
+      "element.set_value requires elementId or elementIndex"
+    );
+  }
+  if (!body.value) {
+    requireComputerUseField(ctx, "value", "element.set_value requires value");
+  }
+}
+function validateElementActionCommand(body, ctx) {
+  if (!body.elementId && body.elementIndex === void 0) {
+    requireComputerUseField(
+      ctx,
+      "elementIndex",
+      "element.perform_action requires elementId or elementIndex"
+    );
+  }
+  if (!body.action) {
+    requireComputerUseField(
+      ctx,
+      "action",
+      "element.perform_action requires action"
+    );
+  }
+}
+function validateComputerUseWriteCommand(body, ctx) {
+  if (!body.app) {
+    requireComputerUseField(ctx, "app", `${body.kind} requires app`);
+    return;
+  }
+  switch (body.kind) {
+    case "app.open":
+      return;
+    case "element.click":
+      validateElementClickCommand(body, ctx);
+      return;
+    case "element.scroll":
+      validateElementScrollCommand(body, ctx);
+      return;
+    case "element.set_value":
+      validateElementSetValueCommand(body, ctx);
+      return;
+    case "element.perform_action":
+      validateElementActionCommand(body, ctx);
+      return;
+    case "keyboard.type_text":
+      if (!body.text) {
+        requireComputerUseField(
+          ctx,
+          "text",
+          "keyboard.type_text requires text"
+        );
+      }
+      return;
+    case "keyboard.press_key":
+      if (!body.key) {
+        requireComputerUseField(ctx, "key", "keyboard.press_key requires key");
+      }
+  }
+}
+var computerUseWriteCommandCreateBodySchema = computerUseWriteCommandCreateBaseSchema.superRefine(
+  validateComputerUseWriteCommand
+);
+var computerUseCommandErrorSchema = external_exports.object({
+  code: computerUseCommandErrorCodeSchema,
+  message: external_exports.string()
+});
+var computerUseCommandResultSchema = external_exports.record(external_exports.string(), external_exports.unknown());
+var computerUseHostSchema = external_exports.object({
+  id: external_exports.string(),
+  hostName: external_exports.string().optional(),
+  displayName: external_exports.string(),
+  appVersion: external_exports.string(),
+  osVersion: external_exports.string(),
+  supportedCapabilities: external_exports.array(external_exports.string()),
+  permissions: computerUsePermissionsSchema,
+  status: computerUseHostStatusSchema,
+  lastSeenAt: external_exports.string(),
+  createdAt: external_exports.string()
+});
+var computerUseHostStartResponseSchema = external_exports.object({
+  hostId: external_exports.string(),
+  hostToken: external_exports.string()
+});
+var computerUseHeartbeatResponseSchema = external_exports.object({
+  ok: external_exports.literal(true),
+  hostId: external_exports.string()
+});
+var computerUseHostStopBodySchema = external_exports.object({});
+var computerUseHostStopResponseSchema = external_exports.object({
+  ok: external_exports.literal(true),
+  hostId: external_exports.string()
+});
+var computerUseHostListResponseSchema = external_exports.object({
+  hosts: external_exports.array(computerUseHostSchema)
+});
+var computerUseAuthorizationSourceSchema = external_exports.enum([
+  "chat",
+  "slack",
+  "teams"
+]);
+var computerUseAuthorizationRequestCreateBodySchema = external_exports.object({});
+var computerUseAuthorizationRequestCreateResponseSchema = external_exports.object({
+  authorizationUrl: external_exports.string().url(),
+  source: computerUseAuthorizationSourceSchema,
+  expiresAt: external_exports.string()
+});
+var computerUseAuthorizationRequestResponseSchema = external_exports.object({
+  source: computerUseAuthorizationSourceSchema,
+  expiresAt: external_exports.string(),
+  completedAt: external_exports.string().nullable(),
+  computerUseHostId: external_exports.string().uuid().nullable(),
+  hosts: external_exports.array(computerUseHostSchema)
+});
+var computerUseAuthorizationRequestApplyBodySchema = external_exports.object({
+  computerUseHostId: external_exports.string().uuid()
+});
+var computerUseAuthorizationRequestApplyResponseSchema = external_exports.object({
+  ok: external_exports.literal(true),
+  source: computerUseAuthorizationSourceSchema,
+  computerUseHostId: external_exports.string().uuid()
+});
+var computerUseCommandCreateResponseSchema = external_exports.object({
+  commandId: external_exports.string(),
+  status: external_exports.literal("queued")
+});
+var computerUseCommandResponseSchema = external_exports.object({
+  id: external_exports.string(),
+  kind: computerUseCommandKindSchema,
+  status: computerUseCommandStatusSchema,
+  hostId: external_exports.string().nullable(),
+  hostName: external_exports.string().nullable(),
+  payload: external_exports.record(external_exports.string(), external_exports.unknown()),
+  result: computerUseCommandResultSchema.optional(),
+  error: computerUseCommandErrorSchema.optional(),
+  timeoutMs: external_exports.number().int().nullable(),
+  createdAt: external_exports.string(),
+  claimedAt: external_exports.string().nullable(),
+  completedAt: external_exports.string().nullable()
+});
+var computerUseHostCommandNextBodySchema = external_exports.object({
+  supportedCapabilities: supportedCapabilitiesSchema.default([])
+});
+var computerUseHostCommandNextResponseSchema = external_exports.discriminatedUnion(
+  "status",
+  [
+    external_exports.object({ status: external_exports.literal("idle") }),
+    external_exports.object({
+      status: external_exports.literal("command"),
+      command: computerUseCommandResponseSchema
+    })
+  ]
+);
+var computerUseHostCommandCompleteBodySchema = external_exports.discriminatedUnion(
+  "status",
+  [
+    external_exports.object({
+      status: external_exports.literal("succeeded"),
+      result: computerUseCommandResultSchema
+    }),
+    external_exports.object({
+      status: external_exports.literal("failed"),
+      error: computerUseCommandErrorSchema
+    })
+  ]
+);
+var computerUseCommandCompleteResponseSchema = external_exports.object({
+  ok: external_exports.literal(true)
+});
+var computerUseAuditEventSchema = external_exports.object({
+  id: external_exports.string(),
+  commandId: external_exports.string(),
+  runId: external_exports.string().nullable(),
+  hostId: external_exports.string().nullable(),
+  kind: computerUseCommandKindSchema,
+  app: external_exports.string().nullable(),
+  event: external_exports.literal("completed"),
+  redactedResult: external_exports.record(external_exports.string(), external_exports.unknown()).nullable(),
+  error: external_exports.record(external_exports.string(), external_exports.unknown()).nullable(),
+  createdAt: external_exports.string()
+});
+var computerUseAuditEventListResponseSchema = external_exports.object({
+  auditEvents: external_exports.array(computerUseAuditEventSchema)
+});
+var zeroComputerUseHostsContract = c.router({
+  start: {
+    method: "POST",
+    path: "/api/zero/computer-use/hosts/start",
+    headers: authHeadersSchema,
+    body: computerUseRuntimeBodySchema,
+    responses: {
+      200: computerUseHostStartResponseSchema,
+      401: apiErrorSchema,
+      403: apiErrorSchema,
+      409: apiErrorSchema
+    },
+    summary: "Start or reactivate a desktop computer-use host"
+  },
+  list: {
+    method: "GET",
+    path: "/api/zero/computer-use/hosts",
+    headers: authHeadersSchema,
+    responses: {
+      200: computerUseHostListResponseSchema,
+      401: apiErrorSchema,
+      403: apiErrorSchema
+    },
+    summary: "List linked desktop computer-use hosts"
+  }
+});
+var zeroComputerUseHeartbeatContract = c.router({
+  heartbeat: {
+    method: "POST",
+    path: "/api/zero/computer-use/heartbeat",
+    headers: authHeadersSchema,
+    body: computerUseRuntimeBodySchema,
+    responses: {
+      200: computerUseHeartbeatResponseSchema,
+      401: apiErrorSchema,
+      409: apiErrorSchema
+    },
+    summary: "Refresh a desktop computer-use host heartbeat"
+  },
+  stop: {
+    method: "POST",
+    path: "/api/zero/computer-use/host/stop",
+    headers: authHeadersSchema,
+    body: computerUseHostStopBodySchema,
+    responses: {
+      200: computerUseHostStopResponseSchema,
+      401: apiErrorSchema
+    },
+    summary: "Stop a desktop computer-use host"
+  }
+});
+var zeroComputerUseAuthorizationRequestsContract = c.router({
+  create: {
+    method: "POST",
+    path: "/api/zero/computer-use/authorization-requests",
+    headers: authHeadersSchema,
+    body: computerUseAuthorizationRequestCreateBodySchema,
+    responses: {
+      200: computerUseAuthorizationRequestCreateResponseSchema,
+      400: apiErrorSchema,
+      401: apiErrorSchema,
+      403: apiErrorSchema,
+      404: apiErrorSchema,
+      409: apiErrorSchema
+    },
+    summary: "Create a short-lived Computer Use authorization request for the current run"
+  },
+  get: {
+    method: "GET",
+    path: "/api/zero/computer-use/authorization-requests/:requestToken",
+    headers: authHeadersSchema,
+    pathParams: authorizationRequestTokenPathParamsSchema,
+    responses: {
+      200: computerUseAuthorizationRequestResponseSchema,
+      401: apiErrorSchema,
+      403: apiErrorSchema,
+      404: apiErrorSchema,
+      410: apiErrorSchema
+    },
+    summary: "Read a Computer Use authorization request"
+  },
+  apply: {
+    method: "POST",
+    path: "/api/zero/computer-use/authorization-requests/:requestToken/apply",
+    headers: authHeadersSchema,
+    pathParams: authorizationRequestTokenPathParamsSchema,
+    body: computerUseAuthorizationRequestApplyBodySchema,
+    responses: {
+      200: computerUseAuthorizationRequestApplyResponseSchema,
+      400: apiErrorSchema,
+      401: apiErrorSchema,
+      403: apiErrorSchema,
+      404: apiErrorSchema,
+      410: apiErrorSchema
+    },
+    summary: "Bind a Computer Use host for a delegated authorization request"
+  }
+});
+var zeroComputerUseCommandContract = c.router({
+  create: {
+    method: "POST",
+    path: "/api/zero/computer-use/commands",
+    headers: authHeadersSchema,
+    body: computerUseCommandCreateBodySchema,
+    responses: {
+      200: computerUseCommandCreateResponseSchema,
+      400: apiErrorSchema,
+      401: apiErrorSchema,
+      403: apiErrorSchema,
+      404: apiErrorSchema,
+      409: apiErrorSchema
+    },
+    summary: "Create a read-only desktop computer-use command"
+  },
+  get: {
+    method: "GET",
+    path: "/api/zero/computer-use/commands/:commandId",
+    headers: authHeadersSchema,
+    pathParams: commandIdPathParamsSchema,
+    responses: {
+      200: computerUseCommandResponseSchema,
+      401: apiErrorSchema,
+      403: apiErrorSchema,
+      404: apiErrorSchema
+    },
+    summary: "Get a desktop computer-use command result"
+  },
+  getScreenshot: {
+    method: "GET",
+    path: "/api/zero/computer-use/commands/:commandId/screenshot",
+    headers: authHeadersSchema,
+    pathParams: commandIdPathParamsSchema,
+    responses: {
+      200: c.type(),
+      401: apiErrorSchema,
+      403: apiErrorSchema,
+      404: apiErrorSchema
+    },
+    summary: "Download a desktop computer-use command screenshot"
+  },
+  getPluginContent: {
+    method: "GET",
+    path: "/api/zero/computer-use/commands/:commandId/plugin-content",
+    headers: authHeadersSchema,
+    pathParams: commandIdPathParamsSchema,
+    responses: {
+      200: c.type(),
+      401: apiErrorSchema,
+      403: apiErrorSchema,
+      404: apiErrorSchema
+    },
+    summary: "Download offloaded desktop computer-use plugin content"
+  }
+});
+var zeroComputerUseWriteCommandContract = c.router({
+  create: {
+    method: "POST",
+    path: "/api/zero/computer-use/write-commands",
+    headers: authHeadersSchema,
+    body: computerUseWriteCommandCreateBodySchema,
+    responses: {
+      200: computerUseCommandCreateResponseSchema,
+      400: apiErrorSchema,
+      401: apiErrorSchema,
+      403: apiErrorSchema,
+      404: apiErrorSchema,
+      409: apiErrorSchema
+    },
+    summary: "Create a desktop computer-use write command"
+  }
+});
+var zeroComputerUsePluginCommandContract = c.router({
+  create: {
+    method: "POST",
+    path: "/api/zero/computer-use/plugin-commands",
+    headers: authHeadersSchema,
+    body: computerUseAnyPluginCallBodySchema,
+    responses: {
+      200: computerUseCommandCreateResponseSchema,
+      400: apiErrorSchema,
+      401: apiErrorSchema,
+      403: apiErrorSchema,
+      404: apiErrorSchema,
+      409: apiErrorSchema
+    },
+    summary: "Create a desktop computer-use plugin command"
+  }
+});
+var zeroComputerUseHostCommandsContract = c.router({
+  next: {
+    method: "POST",
+    path: "/api/zero/computer-use/host/commands/next",
+    headers: authHeadersSchema,
+    body: computerUseHostCommandNextBodySchema,
+    responses: {
+      200: computerUseHostCommandNextResponseSchema,
+      401: apiErrorSchema
+    },
+    summary: "Claim the next approved desktop computer-use command"
+  },
+  complete: {
+    method: "POST",
+    path: "/api/zero/computer-use/host/commands/:commandId/complete",
+    headers: authHeadersSchema,
+    pathParams: commandIdPathParamsSchema,
+    body: computerUseHostCommandCompleteBodySchema,
+    responses: {
+      200: computerUseCommandCompleteResponseSchema,
+      400: apiErrorSchema,
+      401: apiErrorSchema,
+      404: apiErrorSchema,
+      409: apiErrorSchema
+    },
+    summary: "Complete a desktop computer-use command"
+  }
+});
+var zeroComputerUseAuditEventsContract = c.router({
+  list: {
+    method: "GET",
+    path: "/api/zero/computer-use/audit-events",
+    headers: authHeadersSchema,
+    query: external_exports.object({
+      limit: external_exports.coerce.number().int().positive().max(200).default(50),
+      commandId: external_exports.string().optional(),
+      hostId: external_exports.string().optional(),
+      runId: external_exports.string().optional()
+    }),
+    responses: {
+      200: computerUseAuditEventListResponseSchema,
+      401: apiErrorSchema,
+      403: apiErrorSchema
+    },
+    summary: "List desktop computer-use write command audit events"
+  }
+});
+
+export {
+  COMPUTER_USE_FILESYSTEM_PLUGIN,
+  COMPUTER_USE_MCP_PLUGIN,
+  COMPUTER_USE_MCP_LIST_TOOLS,
+  zeroComputerUseHostsContract,
+  zeroComputerUseAuthorizationRequestsContract,
+  zeroComputerUseCommandContract,
+  zeroComputerUseWriteCommandContract,
+  zeroComputerUsePluginCommandContract
+};
+//# sourceMappingURL=chunk-SJPOFQJU.js.map