@ai-matrx/desktop-protocol 0.12.0 → 0.14.0

package/CHANGELOG.md

@@ -1,5 +1,24 @@
 # Changelog
 
+## 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
+  the reason. `git_ingest` moves there (it ingests repository URLs on the server and refuses a local
+  path on a bound computer or sandbox); the status table lists them under "Not device tools".
+- `shell_execute`'s summary: `cd` carries over between calls.
+
+Consumer action: none.
+
 ## 0.12.0
 
 - `TOOL_CATALOG`: `desktop_transcribe` is built — one op, `models.transcribe`, reached through

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 = 3;
 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,86 @@ 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/apps.ts
+var import_zod13 = require("zod");
+var AppKey = import_zod13.z.string().regex(/^[a-z][a-z0-9_-]{0,39}$/);
+var AppProfileId = import_zod13.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_zod13.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_zod13.z.enum(["supported", "partial", "unsupported"]);
+var AppFeatureStatus = import_zod13.z.strictObject({
   status: AppSupport,
   /** One line, set whenever status is not "supported". */
-  reason: import_zod11.z.string().max(140).nullable()
+  reason: import_zod13.z.string().max(140).nullable()
 });
-var AppInfo = import_zod11.z.strictObject({
+var AppInfo = import_zod13.z.strictObject({
   app_key: AppKey,
-  name: import_zod11.z.string().max(64),
-  installed: import_zod11.z.boolean(),
+  name: import_zod13.z.string().max(64),
+  installed: import_zod13.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_zod13.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 +902,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_zod13.z.strictObject({
+  window: import_zod13.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_zod13.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_zod13.z.boolean()
 });
-var AppProfile = import_zod11.z.strictObject({
+var AppProfile = import_zod13.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_zod13.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_zod13.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_zod13.z.boolean(),
   /** An instance with this profile is running; null when it could not be determined. */
-  running: import_zod11.z.boolean().nullable(),
+  running: import_zod13.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_zod13.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_zod13.z.strictObject({});
+var AppsListResult = import_zod13.z.strictObject({ apps: import_zod13.z.array(AppInfo) });
+var AppsProfilesListParams = import_zod13.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_zod13.z.strictObject({
+  profiles: import_zod13.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_zod13.z.enum(["ok", "signed_out", "unavailable"])
 });
-var AppsProfilesSaveParams = import_zod11.z.strictObject({
+var AppsProfilesSaveParams = import_zod13.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_zod13.z.string().min(1).max(120),
+  account_identity: import_zod13.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_zod13.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_zod13.z.strictObject({ id: AppProfileId });
+var AppsProfilesRemoveResult = import_zod13.z.strictObject({ removed: import_zod13.z.boolean() });
+var AppsOpenParams = import_zod13.z.strictObject({
   app_key: AppKey,
   profile_id: AppProfileId.optional()
 });
-var AppsOpenResult = import_zod11.z.strictObject({
+var AppsOpenResult = import_zod13.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_zod13.z.boolean(),
   folder: AbsPath.nullable()
 });
 
@@ -941,7 +1004,12 @@ 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"] }
 };
 var EVENTS = {
   "fs.changed": FsChangedEvent,