@ai-matrx/desktop-protocol 0.13.0 → 0.15.0

package/CHANGELOG.md

@@ -1,5 +1,31 @@
 # Changelog
 
+## 0.15.0 (protocol 1.4)
+
+- Computer control: `system.open_url` / `system.open_path` / `system.notify`; `screen.list` /
+  `screen.capture` (a display as JPEG or PNG, scaled to `max_width`); `window.list` /
+  `window.focus` / `window.move` / `window.minimize`; `input.type_text` / `input.hotkey` /
+  `input.mouse_move` / `input.mouse_click`; `power.status` / `power.prevent_sleep`;
+  `resources.snapshot` (CPU, memory, swap, disks).
+- Polled folder watches for callers that ask rather than hold a stream: `fs.watch.start` /
+  `fs.watch.events` / `fs.watch.stop`. Background jobs: `exec.job.start` / `exec.job.output` /
+  `exec.job.stop` / `exec.job.list`.
+- TOOL_CATALOG: shell_job, desktop_apps, desktop_system, desktop_screen, desktop_window,
+  desktop_input, desktop_power, desktop_resources and fs_watch are built; desktop_resources is
+  `resources.snapshot` only (the busiest processes are desktop_process).
+
+Consumer action: none (new ops only; an older app answers UNKNOWN_OPERATION).
+
+## 0.14.0 (protocol 1.3)
+
+- The `proc` capability: `proc.list` (by CPU, memory, pid or name; a name filter), `proc.ports`
+  (listening TCP/UDP ports and their processes), `proc.kill` (ask to quit, or force).
+- The `clipboard` capability: `clipboard.read`, `clipboard.write` (text, up to 1 MiB).
+- TOOL_CATALOG: `desktop_process` and `desktop_clipboard` are built; launching and focusing apps
+  move to a planned `desktop_apps` over the `apps` capability.
+
+Consumer action: none (new ops only; an older app answers UNKNOWN_OPERATION).
+
 ## 0.13.0
 
 - `EXCLUDED_TOOLS`: tools armed with a device binding that are deliberately not device tools, with

package/dist/client.cjs

@@ -126,7 +126,7 @@ var import_zod2 = require("zod");
 // src/schema/primitives.ts
 var import_zod = require("zod");
 var PROTOCOL_MAJOR = 1;
-var PROTOCOL_MINOR = 2;
+var PROTOCOL_MINOR = 4;
 var PROTOCOL_VERSION = `${PROTOCOL_MAJOR}.${PROTOCOL_MINOR}`;
 var ProtocolVersion = import_zod.z.string().regex(/^[1-9][0-9]{0,2}\.[0-9]{1,3}$/);
 var RequestId = import_zod.z.string().min(1).max(64).regex(/^[A-Za-z0-9_-]+$/);
@@ -813,23 +813,421 @@ var RelayCallEnvelope = import_zod10.z.strictObject({
   params: import_zod10.z.unknown()
 });
 
-// src/schema/apps.ts
+// src/schema/clipboard.ts
 var import_zod11 = require("zod");
-var AppKey = import_zod11.z.string().regex(/^[a-z][a-z0-9_-]{0,39}$/);
-var AppProfileId = import_zod11.z.string().regex(/^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$/);
-var AppProfileLocator = import_zod11.z.string().min(1).max(512).regex(/^[A-Za-z0-9 _()+@,-][A-Za-z0-9 ._()+@,-]{0,127}(\/[A-Za-z0-9 _()+@,-][A-Za-z0-9 ._()+@,-]{0,127}){0,7}$/);
-var AppSupport = import_zod11.z.enum(["supported", "partial", "unsupported"]);
-var AppFeatureStatus = import_zod11.z.strictObject({
+var ClipboardReadParams = import_zod11.z.strictObject({});
+var ClipboardReadResult = import_zod11.z.strictObject({
+  /** The clipboard's text ("" when it holds none), cut to 1 MiB. */
+  text: import_zod11.z.string().max(1048576),
+  truncated: import_zod11.z.boolean()
+});
+var ClipboardWriteParams = import_zod11.z.strictObject({ text: import_zod11.z.string().max(1048576) });
+var ClipboardWriteResult = import_zod11.z.strictObject({ bytes: nonNegInt });
+
+// src/schema/proc.ts
+var import_zod12 = require("zod");
+var ProcSort = import_zod12.z.enum(["cpu", "memory", "pid", "name"]);
+var ProcListParams = import_zod12.z.strictObject({
+  /** Case-insensitive substring of the process name or its command line. */
+  name: import_zod12.z.string().min(1).max(128).optional(),
+  sort: ProcSort.default("cpu"),
+  limit: import_zod12.z.int().min(1).max(500).default(50)
+});
+var ProcInfo = import_zod12.z.strictObject({
+  pid: import_zod12.z.int().min(0),
+  /** Parent process id; null where the OS does not report it. */
+  ppid: import_zod12.z.int().min(0).nullable(),
+  name: import_zod12.z.string().max(256),
+  /** The command line, cut to 1024 characters. */
+  command: import_zod12.z.string().max(1024),
+  /** Share of one core, as `ps` and Task Manager report it; null where the OS does not say. */
+  cpu_percent: import_zod12.z.number().min(0).nullable(),
+  memory_bytes: nonNegInt.nullable(),
+  user: import_zod12.z.string().max(128).nullable()
+});
+var ProcListResult = import_zod12.z.strictObject({
+  processes: import_zod12.z.array(ProcInfo).max(500),
+  /** Processes that matched before `limit`. */
+  total: nonNegInt,
+  truncated: import_zod12.z.boolean()
+});
+var ProcPortsParams = import_zod12.z.strictObject({
+  /** Only this port. */
+  port: import_zod12.z.int().min(1).max(65535).optional()
+});
+var ProcPort = import_zod12.z.strictObject({
+  port: import_zod12.z.int().min(1).max(65535),
+  protocol: import_zod12.z.enum(["tcp", "udp"]),
+  /** The local address it listens on ("127.0.0.1", "*", "::"). */
+  address: import_zod12.z.string().max(64),
+  pid: import_zod12.z.int().min(0).nullable(),
+  process: import_zod12.z.string().max(256).nullable()
+});
+var ProcPortsResult = import_zod12.z.strictObject({ ports: import_zod12.z.array(ProcPort).max(4e3) });
+var ProcKillParams = import_zod12.z.strictObject({
+  pid: import_zod12.z.int().min(1),
+  /** Kill outright (SIGKILL; on Windows the same /F) instead of asking it to quit. */
+  force: import_zod12.z.boolean().default(false)
+});
+var ProcKillResult = import_zod12.z.strictObject({
+  pid: import_zod12.z.int().min(1),
+  signal: import_zod12.z.enum(["SIGTERM", "SIGKILL"]),
+  /** True when the process was gone within 3 s. */
+  exited: import_zod12.z.boolean()
+});
+
+// src/schema/system.ts
+var import_zod13 = require("zod");
+var SystemOpenUrlParams = import_zod13.z.strictObject({
+  /** http, https or mailto; opened in the person's default app for it. */
+  url: import_zod13.z.string().min(1).max(4096)
+});
+var SystemOpenUrlResult = import_zod13.z.strictObject({ url: import_zod13.z.string().max(4096) });
+var SystemOpenPathParams = import_zod13.z.strictObject({
+  path: AbsPath,
+  /** Show it in the file manager (Finder, Explorer) instead of opening it. */
+  reveal: import_zod13.z.boolean().default(false)
+});
+var SystemOpenPathResult = import_zod13.z.strictObject({ path: AbsPath, revealed: import_zod13.z.boolean() });
+var SystemNotifyParams = import_zod13.z.strictObject({
+  title: import_zod13.z.string().min(1).max(128),
+  body: import_zod13.z.string().max(1024).default("")
+});
+var SystemNotifyResult = import_zod13.z.strictObject({
+  /** False when this computer has no notification service to show it (a bare Linux box). */
+  shown: import_zod13.z.boolean()
+});
+
+// src/schema/screen.ts
+var import_zod14 = require("zod");
+var ScreenDisplay = import_zod14.z.strictObject({
+  /** The OS's display id; pass it to screen.capture. */
+  id: nonNegInt,
+  name: import_zod14.z.string().max(128),
+  /** Position and size in the OS's logical points (x and y may be negative left of or above the main display). */
+  x: import_zod14.z.int(),
+  y: import_zod14.z.int(),
+  width: import_zod14.z.int().min(1),
+  height: import_zod14.z.int().min(1),
+  /** Pixels per point (2 on a Retina display). */
+  scale: import_zod14.z.number().min(0.1).max(8),
+  primary: import_zod14.z.boolean()
+});
+var ScreenListParams = import_zod14.z.strictObject({});
+var ScreenListResult = import_zod14.z.strictObject({ displays: import_zod14.z.array(ScreenDisplay).max(32) });
+var ScreenCaptureParams = import_zod14.z.strictObject({
+  /** The display (from screen.list); the primary display when absent. */
+  display_id: nonNegInt.optional(),
+  format: import_zod14.z.enum(["jpeg", "png"]).default("jpeg"),
+  /** Scale the picture down to at most this width in pixels (kept when already smaller). */
+  max_width: import_zod14.z.int().min(160).max(7680).default(1600)
+});
+var ScreenCaptureResult = import_zod14.z.strictObject({
+  display_id: nonNegInt,
+  mime_type: import_zod14.z.enum(["image/jpeg", "image/png"]),
+  width: import_zod14.z.int().min(1),
+  height: import_zod14.z.int().min(1),
+  /** The display's full resolution in pixels, before scaling. */
+  source_width: import_zod14.z.int().min(1),
+  source_height: import_zod14.z.int().min(1),
+  /** The image, base64 (at most 6 MiB of text). */
+  data_base64: import_zod14.z.string().max(6291456)
+});
+
+// src/schema/window.ts
+var import_zod15 = require("zod");
+var WindowInfo = import_zod15.z.strictObject({
+  /** The OS's window handle (macOS window number, Windows HWND, X11 window id). */
+  id: nonNegInt,
+  title: import_zod15.z.string().max(512),
+  /** Position and size in logical points. */
+  x: import_zod15.z.int(),
+  y: import_zod15.z.int(),
+  width: import_zod15.z.int().min(0),
+  height: import_zod15.z.int().min(0)
+});
+var WindowListParams = import_zod15.z.strictObject({
+  /** Case-insensitive substring of the window title. */
+  title: import_zod15.z.string().min(1).max(256).optional(),
+  limit: import_zod15.z.int().min(1).max(500).default(100)
+});
+var WindowListResult = import_zod15.z.strictObject({
+  windows: import_zod15.z.array(WindowInfo).max(500),
+  total: nonNegInt,
+  truncated: import_zod15.z.boolean()
+});
+var WindowFocusParams = import_zod15.z.strictObject({ id: nonNegInt });
+var WindowFocusResult = import_zod15.z.strictObject({ window: WindowInfo });
+var WindowMoveParams = import_zod15.z.strictObject({
+  id: nonNegInt,
+  /** New top-left corner; unchanged when absent. */
+  x: import_zod15.z.int().optional(),
+  y: import_zod15.z.int().optional(),
+  /** New size; unchanged when absent. */
+  width: import_zod15.z.int().min(50).max(16384).optional(),
+  height: import_zod15.z.int().min(50).max(16384).optional()
+});
+var WindowMoveResult = import_zod15.z.strictObject({ window: WindowInfo });
+var WindowMinimizeParams = import_zod15.z.strictObject({ id: nonNegInt });
+var WindowMinimizeResult = import_zod15.z.strictObject({ id: nonNegInt });
+
+// src/schema/input.ts
+var import_zod16 = require("zod");
+var InputKey = import_zod16.z.enum([
+  "cmd",
+  "ctrl",
+  "alt",
+  "shift",
+  "meta",
+  "a",
+  "b",
+  "c",
+  "d",
+  "e",
+  "f",
+  "g",
+  "h",
+  "i",
+  "j",
+  "k",
+  "l",
+  "m",
+  "n",
+  "o",
+  "p",
+  "q",
+  "r",
+  "s",
+  "t",
+  "u",
+  "v",
+  "w",
+  "x",
+  "y",
+  "z",
+  "0",
+  "1",
+  "2",
+  "3",
+  "4",
+  "5",
+  "6",
+  "7",
+  "8",
+  "9",
+  "f1",
+  "f2",
+  "f3",
+  "f4",
+  "f5",
+  "f6",
+  "f7",
+  "f8",
+  "f9",
+  "f10",
+  "f11",
+  "f12",
+  "enter",
+  "tab",
+  "escape",
+  "space",
+  "backspace",
+  "delete",
+  "up",
+  "down",
+  "left",
+  "right",
+  "home",
+  "end",
+  "pageup",
+  "pagedown",
+  "minus",
+  "equal",
+  "comma",
+  "period",
+  "slash",
+  "semicolon",
+  "quote",
+  "bracketleft",
+  "bracketright",
+  "backslash",
+  "grave"
+]);
+var InputTypeTextParams = import_zod16.z.strictObject({ text: import_zod16.z.string().min(1).max(1e4) });
+var InputTypeTextResult = import_zod16.z.strictObject({ characters: import_zod16.z.int().min(1) });
+var InputHotkeyParams = import_zod16.z.strictObject({
+  /** Pressed together in order and released in reverse: ["cmd", "shift", "t"]. */
+  keys: import_zod16.z.array(InputKey).min(1).max(6)
+});
+var InputHotkeyResult = import_zod16.z.strictObject({ keys: import_zod16.z.array(InputKey) });
+var InputPoint = import_zod16.z.strictObject({ x: import_zod16.z.int(), y: import_zod16.z.int() });
+var InputMouseMoveParams = import_zod16.z.strictObject({
+  /** Screen position in logical points (the coordinates screen.list and window.list report). */
+  x: import_zod16.z.int(),
+  y: import_zod16.z.int()
+});
+var InputMouseMoveResult = import_zod16.z.strictObject({
+  /** Where the pointer is now, read back from the OS. */
+  position: InputPoint
+});
+var InputMouseClickParams = import_zod16.z.strictObject({
+  /** Move here first; clicks where the pointer is when absent. */
+  x: import_zod16.z.int().optional(),
+  y: import_zod16.z.int().optional(),
+  button: import_zod16.z.enum(["left", "right", "middle"]).default("left"),
+  double: import_zod16.z.boolean().default(false)
+});
+var InputMouseClickResult = import_zod16.z.strictObject({
+  position: InputPoint,
+  button: import_zod16.z.enum(["left", "right", "middle"]),
+  double: import_zod16.z.boolean()
+});
+
+// src/schema/power.ts
+var import_zod17 = require("zod");
+var PowerStatusParams = import_zod17.z.strictObject({});
+var PowerStatusResult = import_zod17.z.strictObject({
+  has_battery: import_zod17.z.boolean(),
+  /** 0–100; null without a battery. */
+  percent: import_zod17.z.number().min(0).max(100).nullable(),
+  charging: import_zod17.z.boolean().nullable(),
+  /** On wall power; null where the OS does not say. */
+  plugged_in: import_zod17.z.boolean().nullable(),
+  /** Minutes of battery left; null when charging, unknown or without a battery. */
+  minutes_left: nonNegInt.nullable(),
+  /** Matrx 2 is keeping the computer awake (power.prevent_sleep) until this time; null when it is not. */
+  awake_until_ms: epochMs.nullable()
+});
+var PowerPreventSleepParams = import_zod17.z.strictObject({
+  /** Keep the computer awake this long; 0 lets it sleep again now. */
+  seconds: import_zod17.z.int().min(0).max(86400),
+  /** Shown where the OS lists what keeps it awake. */
+  reason: import_zod17.z.string().min(1).max(128).default("Matrx 2 is working")
+});
+var PowerPreventSleepResult = import_zod17.z.strictObject({
+  /** When it may sleep again; null after seconds 0. */
+  awake_until_ms: epochMs.nullable()
+});
+
+// src/schema/resources.ts
+var import_zod18 = require("zod");
+var ResourcesDisk = import_zod18.z.strictObject({
+  /** Where it is mounted ("/", "C:"). */
+  mount: import_zod18.z.string().max(512),
+  /** The file system ("apfs", "NTFS", "ext4"). */
+  fs: import_zod18.z.string().max(64),
+  size_bytes: nonNegInt,
+  used_bytes: nonNegInt,
+  available_bytes: nonNegInt
+});
+var ResourcesSnapshotParams = import_zod18.z.strictObject({});
+var ResourcesSnapshotResult = import_zod18.z.strictObject({
+  cpu: import_zod18.z.strictObject({
+    /** Busy share of all cores, 0–100, measured now. */
+    percent: import_zod18.z.number().min(0).max(100),
+    cores: import_zod18.z.int().min(1),
+    /** 1, 5 and 15 minute load averages; null on Windows. */
+    load: import_zod18.z.array(import_zod18.z.number().min(0)).length(3).nullable()
+  }),
+  memory: import_zod18.z.strictObject({ total_bytes: nonNegInt, used_bytes: nonNegInt, available_bytes: nonNegInt }),
+  swap: import_zod18.z.strictObject({ total_bytes: nonNegInt, used_bytes: nonNegInt }),
+  disks: import_zod18.z.array(ResourcesDisk).max(64),
+  uptime_seconds: nonNegInt
+});
+
+// src/schema/fs-watch.ts
+var import_zod19 = require("zod");
+var FsWatchId = import_zod19.z.string().regex(/^fw_[A-Za-z0-9]{12,40}$/);
+var FsWatchStartParams = import_zod19.z.strictObject({
+  path: AbsPath,
+  recursive: import_zod19.z.boolean().default(true),
+  /** Globs relative to `path` whose changes are not reported (".git/**", "node_modules/**"). */
+  ignore: import_zod19.z.array(import_zod19.z.string().max(256)).max(64).default([])
+});
+var FsWatchStartResult = import_zod19.z.strictObject({
+  watch_id: FsWatchId,
+  path: AbsPath,
+  /** The watch ends by itself if nobody reads it for 30 minutes. */
+  expires_at_ms: epochMs
+});
+var FsWatchEventsParams = import_zod19.z.strictObject({
+  watch_id: FsWatchId,
+  /** Wait up to this long for a first change when none is waiting (0 answers at once). */
+  wait_ms: import_zod19.z.int().min(0).max(25e3).default(0)
+});
+var FsWatchEventsResult = import_zod19.z.strictObject({
+  /** What changed since the last read, oldest first; re-checked against the disk when read. */
+  changes: import_zod19.z.array(FsChange).max(1e3),
+  /** Changes were dropped (more than 1000 waited): list the folder again. */
+  overflow: import_zod19.z.boolean(),
+  expires_at_ms: epochMs
+});
+var FsWatchStopParams = import_zod19.z.strictObject({ watch_id: FsWatchId });
+var FsWatchStopResult = import_zod19.z.strictObject({ watch_id: FsWatchId });
+
+// src/schema/exec-job.ts
+var import_zod20 = require("zod");
+var ExecJobId = import_zod20.z.string().regex(/^job_[A-Za-z0-9]{12,40}$/);
+var ExecJobStartParams = import_zod20.z.strictObject({
+  command: import_zod20.z.string().min(1).max(131072),
+  /** The folder it runs in; the home folder when absent. */
+  cwd: AbsPath.optional(),
+  env: import_zod20.z.record(import_zod20.z.string().regex(/^[A-Za-z_][A-Za-z0-9_]*$/).max(128), import_zod20.z.string().max(32768)).optional()
+});
+var ExecJobStartResult = import_zod20.z.strictObject({ job_id: ExecJobId, pid: import_zod20.z.int().min(1), cwd: AbsPath });
+var ExecJobOutputParams = import_zod20.z.strictObject({
+  job_id: ExecJobId,
+  /** Byte offset into the job's output to read from (next_offset of the last read; 0 = the start). */
+  offset: nonNegInt.default(0),
+  /** Wait up to this long for new output or the exit when none is waiting (0 answers at once). */
+  wait_ms: import_zod20.z.int().min(0).max(25e3).default(0),
+  max_bytes: import_zod20.z.int().min(1024).max(1048576).default(65536)
+});
+var ExecJobOutputResult = import_zod20.z.strictObject({
+  /** stdout and stderr interleaved as they arrived (UTF-8). */
+  output: import_zod20.z.string(),
+  next_offset: nonNegInt,
+  /** Bytes before `offset` that are gone (the job keeps its last 4 MiB). */
+  dropped_bytes: nonNegInt,
+  running: import_zod20.z.boolean(),
+  exit_code: import_zod20.z.int().nullable()
+});
+var ExecJobStopParams = import_zod20.z.strictObject({
+  job_id: ExecJobId,
+  /** End it at once (SIGKILL; on Windows the whole tree with /F) instead of asking it to quit. */
+  force: import_zod20.z.boolean().default(false)
+});
+var ExecJobStopResult = import_zod20.z.strictObject({ job_id: ExecJobId, exited: import_zod20.z.boolean(), exit_code: import_zod20.z.int().nullable() });
+var ExecJobInfo = import_zod20.z.strictObject({
+  job_id: ExecJobId,
+  command: import_zod20.z.string().max(1024),
+  pid: import_zod20.z.int().min(1),
+  cwd: AbsPath,
+  running: import_zod20.z.boolean(),
+  exit_code: import_zod20.z.int().nullable(),
+  started_at_ms: epochMs,
+  output_bytes: nonNegInt
+});
+var ExecJobListParams = import_zod20.z.strictObject({});
+var ExecJobListResult = import_zod20.z.strictObject({ jobs: import_zod20.z.array(ExecJobInfo).max(64) });
+
+// src/schema/apps.ts
+var import_zod21 = require("zod");
+var AppKey = import_zod21.z.string().regex(/^[a-z][a-z0-9_-]{0,39}$/);
+var AppProfileId = import_zod21.z.string().regex(/^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$/);
+var AppProfileLocator = import_zod21.z.string().min(1).max(512).regex(/^[A-Za-z0-9 _()+@,-][A-Za-z0-9 ._()+@,-]{0,127}(\/[A-Za-z0-9 _()+@,-][A-Za-z0-9 ._()+@,-]{0,127}){0,7}$/);
+var AppSupport = import_zod21.z.enum(["supported", "partial", "unsupported"]);
+var AppFeatureStatus = import_zod21.z.strictObject({
   status: AppSupport,
   /** One line, set whenever status is not "supported". */
-  reason: import_zod11.z.string().max(140).nullable()
+  reason: import_zod21.z.string().max(140).nullable()
 });
-var AppInfo = import_zod11.z.strictObject({
+var AppInfo = import_zod21.z.strictObject({
   app_key: AppKey,
-  name: import_zod11.z.string().max(64),
-  installed: import_zod11.z.boolean(),
+  name: import_zod21.z.string().max(64),
+  installed: import_zod21.z.boolean(),
   /** The app's own version string, or null when it is not installed or does not say. */
-  version: import_zod11.z.string().max(64).nullable(),
+  version: import_zod21.z.string().max(64).nullable(),
   /** The install found (an .app bundle, an .exe, a binary), or null. */
   location: AbsPath.nullable(),
   /** Open the app at all on this OS. */
@@ -839,69 +1237,69 @@ var AppInfo = import_zod11.z.strictObject({
   /** Plan usage read from the app's own files on this OS. */
   usage: AppFeatureStatus
 });
-var AppUsageReading = import_zod11.z.strictObject({
-  window: import_zod11.z.enum(["five_hour", "weekly", "extra"]),
+var AppUsageReading = import_zod21.z.strictObject({
+  window: import_zod21.z.enum(["five_hour", "weekly", "extra"]),
   /** 0–100 for five_hour and weekly; extra-usage spend as a percent of its cap (may pass 100). */
-  percent: import_zod11.z.number().min(0).max(1e4),
+  percent: import_zod21.z.number().min(0).max(1e4),
   /** When the app recorded it. */
   sampled_at_ms: epochMs,
   /** True when the window has rolled over since the sample, so the figure has reset. */
-  reset_since: import_zod11.z.boolean()
+  reset_since: import_zod21.z.boolean()
 });
-var AppProfile = import_zod11.z.strictObject({
+var AppProfile = import_zod21.z.strictObject({
   /** The row's id; null for a folder found on disk that no row names yet. */
   id: AppProfileId.nullable(),
   app_key: AppKey,
-  display_name: import_zod11.z.string().min(1).max(120),
+  display_name: import_zod21.z.string().min(1).max(120),
   /** The account the person means to be signed in here; null when not stated (never guessed). */
-  account_identity: import_zod11.z.string().min(3).max(320).nullable(),
+  account_identity: import_zod21.z.string().min(3).max(320).nullable(),
   profile_locator: AppProfileLocator.nullable(),
   /** The device the row is tied to; null when the row names none. */
   device_id: DeviceId.nullable(),
   /** The folder this profile resolves to on this device; null for a row tied to another device. */
   folder: AbsPath.nullable(),
   /** The folder exists on this device. */
-  on_disk: import_zod11.z.boolean(),
+  on_disk: import_zod21.z.boolean(),
   /** An instance with this profile is running; null when it could not be determined. */
-  running: import_zod11.z.boolean().nullable(),
+  running: import_zod21.z.boolean().nullable(),
   /** Usage the app recorded for this profile; null when the app exposes none here. */
-  usage: import_zod11.z.array(AppUsageReading).nullable(),
+  usage: import_zod21.z.array(AppUsageReading).nullable(),
   last_opened_ms: epochMs.nullable()
 });
-var AppsListParams = import_zod11.z.strictObject({});
-var AppsListResult = import_zod11.z.strictObject({ apps: import_zod11.z.array(AppInfo) });
-var AppsProfilesListParams = import_zod11.z.strictObject({
+var AppsListParams = import_zod21.z.strictObject({});
+var AppsListResult = import_zod21.z.strictObject({ apps: import_zod21.z.array(AppInfo) });
+var AppsProfilesListParams = import_zod21.z.strictObject({
   /** Only this app's profiles; every app's when absent. */
   app_key: AppKey.optional()
 });
-var AppsProfilesListResult = import_zod11.z.strictObject({
-  profiles: import_zod11.z.array(AppProfile),
+var AppsProfilesListResult = import_zod21.z.strictObject({
+  profiles: import_zod21.z.array(AppProfile),
   /**
    * Whether the saved rows could be read: false while signed out or offline, when only folders
    * found on disk are listed.
    */
-  registry: import_zod11.z.enum(["ok", "signed_out", "unavailable"])
+  registry: import_zod21.z.enum(["ok", "signed_out", "unavailable"])
 });
-var AppsProfilesSaveParams = import_zod11.z.strictObject({
+var AppsProfilesSaveParams = import_zod21.z.strictObject({
   id: AppProfileId.optional(),
   app_key: AppKey,
-  display_name: import_zod11.z.string().min(1).max(120),
-  account_identity: import_zod11.z.string().min(3).max(320).nullable(),
+  display_name: import_zod21.z.string().min(1).max(120),
+  account_identity: import_zod21.z.string().min(3).max(320).nullable(),
   /** On create: the folder to use (one found on disk), or null for the app's default profile. Ignored on update. */
   profile_locator: AppProfileLocator.nullable(),
   /** On create with profile_locator null: make a new folder named after display_name instead. */
-  new_folder: import_zod11.z.boolean().default(false)
+  new_folder: import_zod21.z.boolean().default(false)
 });
 var AppsProfilesSaveResult = AppProfile;
-var AppsProfilesRemoveParams = import_zod11.z.strictObject({ id: AppProfileId });
-var AppsProfilesRemoveResult = import_zod11.z.strictObject({ removed: import_zod11.z.boolean() });
-var AppsOpenParams = import_zod11.z.strictObject({
+var AppsProfilesRemoveParams = import_zod21.z.strictObject({ id: AppProfileId });
+var AppsProfilesRemoveResult = import_zod21.z.strictObject({ removed: import_zod21.z.boolean() });
+var AppsOpenParams = import_zod21.z.strictObject({
   app_key: AppKey,
   profile_id: AppProfileId.optional()
 });
-var AppsOpenResult = import_zod11.z.strictObject({
+var AppsOpenResult = import_zod21.z.strictObject({
   /** True when an instance with this profile was already running; it is brought forward. */
-  already_running: import_zod11.z.boolean(),
+  already_running: import_zod21.z.boolean(),
   folder: AbsPath.nullable()
 });
 
@@ -941,7 +1339,35 @@ var OPS = {
   "apps.profiles.list": { params: AppsProfilesListParams, result: AppsProfilesListResult, kind: "unary", since: "1.2", errors: ["NOT_FOUND", "INVALID_PARAMS", "INTERNAL"] },
   "apps.profiles.save": { params: AppsProfilesSaveParams, result: AppsProfilesSaveResult, kind: "unary", since: "1.2", errors: ["AUTH_REQUIRED", "AUTH_FORBIDDEN", "NOT_FOUND", "INVALID_PARAMS", "CONFLICT", "PLATFORM_UNSUPPORTED", "DEVICE_OFFLINE", "INTERNAL"] },
   "apps.profiles.remove": { params: AppsProfilesRemoveParams, result: AppsProfilesRemoveResult, kind: "unary", since: "1.2", errors: ["AUTH_REQUIRED", "AUTH_FORBIDDEN", "NOT_FOUND", "DEVICE_OFFLINE", "INTERNAL"] },
-  "apps.open": { params: AppsOpenParams, result: AppsOpenResult, kind: "unary", since: "1.2", errors: ["NOT_FOUND", "PLATFORM_UNSUPPORTED", "AUTH_REQUIRED", "DEVICE_OFFLINE", "INTERNAL"] }
+  "apps.open": { params: AppsOpenParams, result: AppsOpenResult, kind: "unary", since: "1.2", errors: ["NOT_FOUND", "PLATFORM_UNSUPPORTED", "AUTH_REQUIRED", "DEVICE_OFFLINE", "INTERNAL"] },
+  "proc.list": { params: ProcListParams, result: ProcListResult, kind: "unary", since: "1.3", errors: ["INVALID_PARAMS", "PLATFORM_UNSUPPORTED", "INTERNAL"] },
+  "proc.ports": { params: ProcPortsParams, result: ProcPortsResult, kind: "unary", since: "1.3", errors: ["INVALID_PARAMS", "PERMISSION_DENIED_OS", "PLATFORM_UNSUPPORTED", "INTERNAL"] },
+  "proc.kill": { params: ProcKillParams, result: ProcKillResult, kind: "unary", since: "1.3", errors: ["NOT_FOUND", "AUTH_FORBIDDEN", "PERMISSION_DENIED_OS", "INVALID_PARAMS", "INTERNAL"] },
+  "clipboard.read": { params: ClipboardReadParams, result: ClipboardReadResult, kind: "unary", since: "1.3", errors: ["PLATFORM_UNSUPPORTED", "INTERNAL"] },
+  "clipboard.write": { params: ClipboardWriteParams, result: ClipboardWriteResult, kind: "unary", since: "1.3", errors: ["PLATFORM_UNSUPPORTED", "PAYLOAD_TOO_LARGE", "INTERNAL"] },
+  "fs.watch.start": { params: FsWatchStartParams, result: FsWatchStartResult, kind: "unary", since: "1.4", errors: [...FS_ERR, "RATE_LIMITED"] },
+  "fs.watch.events": { params: FsWatchEventsParams, result: FsWatchEventsResult, kind: "unary", since: "1.4", errors: ["RESOURCE_GONE", "INVALID_PARAMS", "INTERNAL"] },
+  "fs.watch.stop": { params: FsWatchStopParams, result: FsWatchStopResult, kind: "unary", since: "1.4", errors: ["RESOURCE_GONE", "INVALID_PARAMS"] },
+  "exec.job.start": { params: ExecJobStartParams, result: ExecJobStartResult, kind: "unary", since: "1.4", errors: ["INVALID_PARAMS", "NOT_FOUND", "RATE_LIMITED", "INTERNAL"] },
+  "exec.job.output": { params: ExecJobOutputParams, result: ExecJobOutputResult, kind: "unary", since: "1.4", errors: ["RESOURCE_GONE", "INVALID_PARAMS"] },
+  "exec.job.stop": { params: ExecJobStopParams, result: ExecJobStopResult, kind: "unary", since: "1.4", errors: ["RESOURCE_GONE", "INVALID_PARAMS", "INTERNAL"] },
+  "exec.job.list": { params: ExecJobListParams, result: ExecJobListResult, kind: "unary", since: "1.4", errors: ["INTERNAL"] },
+  "system.open_url": { params: SystemOpenUrlParams, result: SystemOpenUrlResult, kind: "unary", since: "1.4", errors: ["INVALID_PARAMS", "PLATFORM_UNSUPPORTED", "INTERNAL"] },
+  "system.open_path": { params: SystemOpenPathParams, result: SystemOpenPathResult, kind: "unary", since: "1.4", errors: ["NOT_FOUND", "INVALID_PARAMS", "PLATFORM_UNSUPPORTED", "INTERNAL"] },
+  "system.notify": { params: SystemNotifyParams, result: SystemNotifyResult, kind: "unary", since: "1.4", errors: ["PERMISSION_DENIED_OS", "INTERNAL"] },
+  "screen.list": { params: ScreenListParams, result: ScreenListResult, kind: "unary", since: "1.4", errors: ["PERMISSION_DENIED_OS", "PLATFORM_UNSUPPORTED", "INTERNAL"] },
+  "screen.capture": { params: ScreenCaptureParams, result: ScreenCaptureResult, kind: "unary", since: "1.4", errors: ["NOT_FOUND", "PERMISSION_DENIED_OS", "PLATFORM_UNSUPPORTED", "PAYLOAD_TOO_LARGE", "INTERNAL"] },
+  "window.list": { params: WindowListParams, result: WindowListResult, kind: "unary", since: "1.4", errors: ["PERMISSION_DENIED_OS", "PLATFORM_UNSUPPORTED", "INTERNAL"] },
+  "window.focus": { params: WindowFocusParams, result: WindowFocusResult, kind: "unary", since: "1.4", errors: ["NOT_FOUND", "PERMISSION_DENIED_OS", "PLATFORM_UNSUPPORTED", "INTERNAL"] },
+  "window.move": { params: WindowMoveParams, result: WindowMoveResult, kind: "unary", since: "1.4", errors: ["NOT_FOUND", "INVALID_PARAMS", "PERMISSION_DENIED_OS", "PLATFORM_UNSUPPORTED", "INTERNAL"] },
+  "window.minimize": { params: WindowMinimizeParams, result: WindowMinimizeResult, kind: "unary", since: "1.4", errors: ["NOT_FOUND", "PERMISSION_DENIED_OS", "PLATFORM_UNSUPPORTED", "INTERNAL"] },
+  "input.type_text": { params: InputTypeTextParams, result: InputTypeTextResult, kind: "unary", since: "1.4", errors: ["PERMISSION_DENIED_OS", "PLATFORM_UNSUPPORTED", "INTERNAL"] },
+  "input.hotkey": { params: InputHotkeyParams, result: InputHotkeyResult, kind: "unary", since: "1.4", errors: ["INVALID_PARAMS", "PERMISSION_DENIED_OS", "PLATFORM_UNSUPPORTED", "INTERNAL"] },
+  "input.mouse_move": { params: InputMouseMoveParams, result: InputMouseMoveResult, kind: "unary", since: "1.4", errors: ["PERMISSION_DENIED_OS", "PLATFORM_UNSUPPORTED", "INTERNAL"] },
+  "input.mouse_click": { params: InputMouseClickParams, result: InputMouseClickResult, kind: "unary", since: "1.4", errors: ["INVALID_PARAMS", "PERMISSION_DENIED_OS", "PLATFORM_UNSUPPORTED", "INTERNAL"] },
+  "power.status": { params: PowerStatusParams, result: PowerStatusResult, kind: "unary", since: "1.4", errors: ["INTERNAL"] },
+  "power.prevent_sleep": { params: PowerPreventSleepParams, result: PowerPreventSleepResult, kind: "unary", since: "1.4", errors: ["PERMISSION_DENIED_OS", "PLATFORM_UNSUPPORTED", "INTERNAL"] },
+  "resources.snapshot": { params: ResourcesSnapshotParams, result: ResourcesSnapshotResult, kind: "unary", since: "1.4", errors: ["INTERNAL"] }
 };
 var EVENTS = {
   "fs.changed": FsChangedEvent,