@ai-matrx/desktop-protocol 0.1.0

package/dist/index.js

@@ -0,0 +1,853 @@
+// src/schema/primitives.ts
+import { z } from "zod";
+var PROTOCOL_MAJOR = 1;
+var PROTOCOL_MINOR = 0;
+var ProtocolVersion = z.string().regex(/^[1-9][0-9]{0,2}\.[0-9]{1,3}$/);
+var RequestId = z.string().min(1).max(64).regex(/^[A-Za-z0-9_-]+$/);
+var ResourceId = z.string().regex(/^(pty|watch)_[A-Za-z0-9]{16,40}$/);
+var DeviceId = 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 AbsPath = z.string().min(1).max(4096).regex(/^(\/|[A-Za-z]:\/)[^\\\u0000]*$/);
+var u32 = z.int().min(0).max(4294967295);
+var nonNegInt = z.int().min(0);
+var epochMs = z.int().min(0);
+
+// src/schema/errors.ts
+import { z as z2 } from "zod";
+var ErrorCode = z2.enum([
+  "AUTH_REQUIRED",
+  "AUTH_INVALID",
+  "AUTH_EXPIRED",
+  "AUTH_FORBIDDEN",
+  // signed in, but not this device's owner
+  "AUTH_DEVICE_REVOKED",
+  // kill switch
+  "PERMISSION_DENIED_OS",
+  "NOT_FOUND",
+  "CONFLICT",
+  "INVALID_PARAMS",
+  "RESOURCE_BUSY",
+  "RESOURCE_GONE",
+  "CANCELLED",
+  "TIMEOUT",
+  "PLATFORM_UNSUPPORTED",
+  "RATE_LIMITED",
+  "INTERNAL",
+  "PROTOCOL_VERSION_UNSUPPORTED",
+  // NEW: hello refused, carries data.upgrade
+  "PROTOCOL_ERROR",
+  // NEW: malformed envelope/frame, credit overrun, unknown sid
+  "UNKNOWN_OPERATION",
+  // NEW: cap.op not served by this core version
+  "DEVICE_OFFLINE",
+  // NEW: relay has no live device socket (retryable)
+  "PAYLOAD_TOO_LARGE"
+  // NEW: message or frame above limits.max_*_bytes
+]);
+var ErrorReason = z2.enum([
+  "not_a_directory",
+  "is_a_directory",
+  "directory_not_empty",
+  "already_exists",
+  "stale_write",
+  // fs.write if_match_mtime_ms mismatch → CONFLICT
+  "binary_content",
+  // utf8 read of non-UTF-8 bytes → INVALID_PARAMS
+  "not_utf8_boundary",
+  "patch_no_match",
+  "patch_ambiguous",
+  "resource_exited",
+  "resource_expired",
+  "control_taken",
+  // another client of the same user took control
+  "window_exhausted"
+]);
+var ProtocolErrorBody = z2.strictObject({
+  code: ErrorCode,
+  message: z2.string().max(300),
+  // short, human, never a stack trace or a token
+  retryable: z2.boolean(),
+  data: z2.strictObject({
+    reason: ErrorReason.optional(),
+    cap: z2.string().max(32).optional(),
+    op: z2.string().max(64).optional(),
+    path: AbsPath.optional(),
+    settings_url: z2.string().max(512).optional(),
+    // PERMISSION_DENIED_OS deep link
+    retry_after_ms: nonNegInt.optional(),
+    limit_bytes: nonNegInt.optional(),
+    upgrade: z2.strictObject({
+      min_version: ProtocolVersion,
+      max_version: ProtocolVersion,
+      download_url: z2.url().optional()
+    }).optional()
+  }).optional()
+});
+
+// src/schema/frame.ts
+import { z as z3 } from "zod";
+
+// src/error.ts
+var DesktopProtocolError = class extends Error {
+  code;
+  retryable;
+  data;
+  constructor(code, message, options = {}) {
+    super(message, options.cause === void 0 ? void 0 : { cause: options.cause });
+    this.name = "DesktopProtocolError";
+    this.code = code;
+    this.retryable = options.retryable ?? false;
+    this.data = options.data;
+  }
+  /** The wire body (ProtocolErrorBody) — what a core or relay sends for this error. */
+  toBody() {
+    return this.data === void 0 ? { code: this.code, message: this.message, retryable: this.retryable } : { code: this.code, message: this.message, retryable: this.retryable, data: this.data };
+  }
+};
+function isDesktopProtocolError(value) {
+  return value instanceof DesktopProtocolError || value instanceof Error && value.name === "DesktopProtocolError" && "code" in value;
+}
+
+// src/frame.ts
+var FRAME_HEADER_BYTES = 16;
+var FRAME_VERSION = 1;
+var FRAME_STRUCT_FORMAT = ">BBBBIII";
+var FrameFlag = { FIN: 1, REPLAY: 2 };
+var FrameChannel = {
+  /** core→client: pty output, fs.read_stream bytes */
+  DATA: 0,
+  /** core→client: stderr of a non-pty process (reserved for exec.spawn in v1.1) */
+  STDERR: 1,
+  /** client→core: keystrokes / stdin to sid */
+  STDIN: 2,
+  /** core→client: serialized terminal screen (attach when since_seq is outside the ring) */
+  SNAPSHOT: 3,
+  /** relay↔device hop only: a JSON envelope carried inside a binary frame so the relay can route
+   *  by cid without parsing JSON. Never seen by clients. */
+  ENVELOPE: 255
+};
+var U32_MAX = 4294967295;
+var CHANNELS = new Set(Object.values(FrameChannel));
+function frameError(message) {
+  return new DesktopProtocolError("PROTOCOL_ERROR", message);
+}
+function checkU32(name, value) {
+  if (!Number.isInteger(value) || value < 0 || value > U32_MAX) throw frameError(`frame ${name} is not a u32: ${value}`);
+}
+function assertFrameHeader(h) {
+  if (h.version !== FRAME_VERSION) throw frameError(`unsupported frame version ${String(h.version)}`);
+  if (!Number.isInteger(h.flags) || h.flags < 0 || h.flags > 3) throw frameError(`reserved frame flag bits set: ${h.flags}`);
+  if (!CHANNELS.has(h.channel)) throw frameError(`unknown frame channel ${String(h.channel)}`);
+  checkU32("cid", h.cid);
+  checkU32("sid", h.sid);
+  checkU32("seq", h.seq);
+}
+function encodeFrame(h, payload) {
+  assertFrameHeader(h);
+  const out = new Uint8Array(FRAME_HEADER_BYTES + payload.byteLength);
+  const v = new DataView(out.buffer);
+  v.setUint8(0, h.version);
+  v.setUint8(1, h.flags);
+  v.setUint8(2, h.channel);
+  v.setUint8(3, 0);
+  v.setUint32(4, h.cid);
+  v.setUint32(8, h.sid);
+  v.setUint32(12, h.seq);
+  out.set(payload, FRAME_HEADER_BYTES);
+  return out;
+}
+function decodeFrame(buf) {
+  const bytes = buf instanceof Uint8Array ? buf : new Uint8Array(buf);
+  if (bytes.byteLength < FRAME_HEADER_BYTES) throw frameError(`short frame: ${bytes.byteLength} bytes`);
+  const v = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  if (v.getUint8(3) !== 0) throw frameError("reserved frame byte 3 is not 0");
+  const header = {
+    version: v.getUint8(0),
+    flags: v.getUint8(1),
+    channel: v.getUint8(2),
+    cid: v.getUint32(4),
+    sid: v.getUint32(8),
+    seq: v.getUint32(12)
+  };
+  assertFrameHeader(header);
+  return { header, payload: bytes.subarray(FRAME_HEADER_BYTES) };
+}
+function readCid(frame) {
+  if (frame.byteLength < FRAME_HEADER_BYTES) throw frameError(`short frame: ${frame.byteLength} bytes`);
+  return new DataView(frame.buffer, frame.byteOffset, frame.byteLength).getUint32(4);
+}
+function stampCid(frame, cid) {
+  if (frame.byteLength < FRAME_HEADER_BYTES) throw frameError(`short frame: ${frame.byteLength} bytes`);
+  checkU32("cid", cid);
+  new DataView(frame.buffer, frame.byteOffset, frame.byteLength).setUint32(4, cid);
+  return frame;
+}
+function hasFlag(header, flag) {
+  return (header.flags & flag) !== 0;
+}
+
+// src/schema/frame.ts
+var FrameHeader = z3.strictObject({
+  version: z3.literal(FRAME_VERSION),
+  flags: z3.int().min(0).max(3),
+  channel: z3.union([z3.literal(0), z3.literal(1), z3.literal(2), z3.literal(3), z3.literal(255)]),
+  cid: u32,
+  sid: u32,
+  seq: u32
+});
+var DEFAULT_WINDOW_BYTES = 262144;
+var DEFAULT_MAX_FRAME_PAYLOAD_BYTES = 65536;
+var DEFAULT_MAX_MESSAGE_BYTES = 8388608;
+
+// src/schema/envelope.ts
+import { z as z4 } from "zod";
+var ClientType = z4.enum(["screen", "web", "extension", "server", "test"]);
+var Limits = z4.strictObject({
+  max_message_bytes: z4.int().min(65536),
+  max_frame_payload_bytes: z4.int().min(4096),
+  default_window_bytes: z4.int().min(4096),
+  max_streams_per_client: z4.int().min(1),
+  max_resources_per_user: z4.int().min(1)
+});
+var OpDescriptor = z4.strictObject({ cap: z4.string().max(32), op: z4.string().max(64), since: ProtocolVersion });
+var Welcome = z4.strictObject({
+  protocol_version: ProtocolVersion,
+  // negotiated = min(client, core) within the same major
+  session_id: z4.string().min(8).max(64),
+  client_id: z4.string().min(8).max(64),
+  // this connection's identity in the Session Manager
+  device_id: DeviceId,
+  device_name: z4.string().max(128),
+  app_version: z4.string().max(32),
+  platform: z4.enum(["darwin", "win32", "linux"]),
+  ops: z4.array(OpDescriptor),
+  limits: Limits,
+  server_time_ms: epochMs
+});
+var HelloMsg = z4.strictObject({
+  type: z4.literal("hello"),
+  id: RequestId,
+  // answered by response{id, result: Welcome} or error{id}
+  protocolVersion: ProtocolVersion,
+  clientType: ClientType,
+  clientVersion: z4.string().min(1).max(32)
+});
+var RequestMsg = z4.strictObject({
+  id: RequestId,
+  type: z4.literal("request"),
+  cap: z4.string().min(1).max(32),
+  op: z4.string().min(1).max(64),
+  params: z4.unknown()
+  // validated by the Router against OPS[cap.op].params — once, there
+});
+var ResponseMsg = z4.strictObject({ id: RequestId, type: z4.literal("response"), result: z4.unknown() });
+var ErrorMsg = z4.strictObject({ id: RequestId, type: z4.literal("error"), error: ProtocolErrorBody });
+var StreamMeta = z4.discriminatedUnion("kind", [
+  /** Binds request id → numeric sid; binary frames for this stream follow. */
+  z4.strictObject({
+    kind: z4.literal("open"),
+    sid: u32,
+    window_bytes: z4.int().min(4096),
+    resource_id: ResourceId.optional()
+  }),
+  /** Frames after this (channel SNAPSHOT) are a serialized screen; live DATA resumes after. */
+  z4.strictObject({ kind: z4.literal("snapshot"), cols: z4.int().min(1), rows: z4.int().min(1) }),
+  /** Frames [from_seq, to_seq] are gone from the ring; a snapshot follows. */
+  z4.strictObject({ kind: z4.literal("gap"), from_seq: u32, to_seq: u32 })
+]);
+var StreamMsg = z4.strictObject({ id: RequestId, type: z4.literal("stream"), seq: u32, meta: StreamMeta });
+var EndReason = z4.enum(["completed", "cancelled", "detached", "resource_exited", "error"]);
+var EndMsg = z4.strictObject({ id: RequestId, type: z4.literal("end"), seq: u32, reason: EndReason.optional() });
+var CancelMsg = z4.strictObject({ id: RequestId, type: z4.literal("cancel") });
+var CreditMsg = z4.strictObject({ id: RequestId, type: z4.literal("credit"), n: z4.int().min(1).max(2147483647) });
+var EventMsg = z4.strictObject({
+  type: z4.literal("event"),
+  cap: z4.string().min(1).max(32),
+  name: z4.string().min(1).max(64),
+  payload: z4.unknown(),
+  // validated against EVENTS[cap.name]
+  resourceId: ResourceId.optional()
+});
+var RelayMsg = z4.discriminatedUnion("op", [
+  /** Fresh access token before the current one expires (relay closes 4008 at exp + 60 s). */
+  z4.strictObject({ type: z4.literal("relay"), op: z4.literal("reauth"), token: z4.string().min(16).max(8192) })
+]);
+var PING_TEXT = '{"type":"ping"}';
+var PONG_TEXT = '{"type":"pong"}';
+var ClientToCoreMsg = z4.discriminatedUnion("type", [HelloMsg, RequestMsg, CancelMsg, CreditMsg]);
+var CoreToClientMsg = z4.discriminatedUnion("type", [ResponseMsg, ErrorMsg, StreamMsg, EndMsg, CreditMsg, EventMsg]);
+var CloseCode = {
+  NORMAL: 1e3,
+  GOING_AWAY: 1001,
+  // relay deploy / app quit — reconnect immediately
+  AUTH_INVALID: 4001,
+  AUTH_FORBIDDEN: 4003,
+  DEVICE_NOT_FOUND: 4004,
+  AUTH_EXPIRED: 4008,
+  // no reauth before exp + 60 s
+  REPLACED: 4009,
+  // a newer device socket for the same device took over
+  DEVICE_REVOKED: 4010,
+  // kill switch — do NOT reconnect
+  PROTOCOL_ERROR: 4400,
+  UPGRADE_REQUIRED: 4426
+};
+
+// src/schema/sysinfo.ts
+import { z as z5 } from "zod";
+var OsPermissionName = z5.enum([
+  "full_disk_access",
+  "accessibility",
+  "screen_recording",
+  "microphone",
+  "camera",
+  "automation",
+  "contacts",
+  "calendars",
+  "photos",
+  "location",
+  "local_network",
+  "bluetooth",
+  "notifications"
+]);
+var SysinfoGetParams = z5.strictObject({});
+var SysinfoGetResult = z5.strictObject({
+  device_id: DeviceId,
+  device_name: z5.string().max(128),
+  hostname: z5.string().max(255),
+  platform: z5.enum(["darwin", "win32", "linux"]),
+  os_version: z5.string().max(64),
+  arch: z5.enum(["arm64", "x64"]),
+  app_version: z5.string().max(32),
+  protocol_version: ProtocolVersion,
+  user: z5.strictObject({ username: z5.string().max(128), shell: z5.string().max(512) }),
+  paths: z5.strictObject({
+    home: AbsPath,
+    desktop: AbsPath,
+    documents: AbsPath,
+    downloads: AbsPath,
+    app_data: AbsPath,
+    temp: AbsPath
+  }),
+  cpu: z5.strictObject({ model: z5.string().max(128), cores: z5.int().min(1) }),
+  memory: z5.strictObject({ total_bytes: nonNegInt, free_bytes: nonNegInt }),
+  uptime_seconds: nonNegInt,
+  on_battery: z5.boolean().nullable(),
+  sleep_prevented: z5.boolean(),
+  // true while any remote session holds the power blocker
+  permissions: z5.array(
+    z5.strictObject({
+      name: OsPermissionName,
+      state: z5.enum(["granted", "denied", "not_determined", "not_applicable"]),
+      settings_url: z5.string().max(512).nullable()
+    })
+  )
+});
+
+// src/schema/fs.ts
+import { z as z6 } from "zod";
+var FsKind = z6.enum(["file", "dir", "symlink"]);
+var FsEntry = z6.strictObject({
+  name: z6.string().max(1024),
+  path: AbsPath,
+  kind: FsKind,
+  size: nonNegInt,
+  mtime: z6.number().min(0),
+  // seconds, float — daemon parity
+  mtime_ms: epochMs,
+  mode: z6.int().min(0).max(4095),
+  target: AbsPath.nullable(),
+  // symlink target, never followed
+  hidden: z6.boolean()
+});
+var FsListParams = z6.strictObject({
+  path: AbsPath,
+  recursive: z6.boolean().default(false),
+  depth: z6.int().min(1).max(32).default(1),
+  pattern: z6.string().max(256).optional(),
+  // glob on name
+  limit: z6.int().min(1).max(5e3).default(500),
+  page_token: z6.string().max(256).optional(),
+  show_hidden: z6.boolean().default(false),
+  sort: z6.enum(["name", "mtime", "size", "kind"]).default("kind")
+});
+var FsListResult = z6.strictObject({
+  entries: z6.array(FsEntry),
+  truncated: z6.boolean(),
+  next_page_token: z6.string().max(256).nullable(),
+  scanned: nonNegInt
+});
+var FsStatParams = z6.strictObject({ path: AbsPath });
+var FsStatResult = FsEntry;
+var FsEncoding = z6.enum(["utf8", "base64"]);
+var FsReadParams = z6.strictObject({
+  path: AbsPath,
+  encoding: FsEncoding.default("utf8"),
+  offset: nonNegInt.default(0),
+  limit: z6.int().min(1).max(4194304).default(262144)
+});
+var FsReadResult = z6.strictObject({
+  content: z6.string(),
+  encoding: FsEncoding,
+  size: nonNegInt,
+  offset: nonNegInt,
+  next_offset: nonNegInt,
+  truncated: z6.boolean(),
+  mime: z6.string().max(128).nullable(),
+  mtime_ms: epochMs
+  // pass back as if_match_mtime_ms to guard a later write
+});
+var FsReadStreamParams = z6.strictObject({
+  path: AbsPath,
+  offset: nonNegInt.default(0),
+  length: nonNegInt.optional(),
+  // absent = to EOF
+  window_bytes: z6.int().min(4096).max(16777216).optional()
+});
+var FsReadStreamResult = z6.strictObject({ size: nonNegInt, mime: z6.string().max(128).nullable(), mtime_ms: epochMs });
+var FsWriteParams = z6.strictObject({
+  path: AbsPath,
+  content: z6.string().max(5592406),
+  // ≤ 4 MiB of bytes after base64 decode
+  encoding: FsEncoding.default("utf8"),
+  mode: z6.int().min(0).max(4095).optional(),
+  create_parents: z6.boolean().default(false),
+  /** Optimistic concurrency: CONFLICT/stale_write if the file changed since this mtime. */
+  if_match_mtime_ms: epochMs.optional(),
+  /** Refuse to replace an existing file (CONFLICT/already_exists). */
+  exclusive: z6.boolean().default(false)
+});
+var FsWriteResult = z6.strictObject({ path: AbsPath, size: nonNegInt, mtime_ms: epochMs, created: z6.boolean() });
+var FsMkdirParams = z6.strictObject({ path: AbsPath, parents: z6.boolean().default(false) });
+var FsMkdirResult = z6.strictObject({ path: AbsPath, created: z6.boolean() });
+var FsMoveParams = z6.strictObject({ from_path: AbsPath, to_path: AbsPath, overwrite: z6.boolean().default(false) });
+var FsMoveResult = z6.strictObject({ from_path: AbsPath, to_path: AbsPath });
+var FsDeleteParams = z6.strictObject({
+  path: AbsPath,
+  recursive: z6.boolean().default(false),
+  to_trash: z6.boolean().default(true)
+});
+var FsDeleteResult = z6.strictObject({ deleted: z6.literal(true), trashed_to: AbsPath.nullable() });
+var FsWatchParams = z6.strictObject({
+  path: AbsPath,
+  recursive: z6.boolean().default(false),
+  ignore: z6.array(z6.string().max(256)).max(64).default([]),
+  debounce_ms: z6.int().min(0).max(5e3).default(50)
+});
+var FsWatchResult = z6.strictObject({ resource_id: ResourceId, path: AbsPath });
+var FsPatchParams = z6.strictObject({
+  path: AbsPath,
+  edits: z6.array(
+    z6.strictObject({
+      old_text: z6.string(),
+      new_text: z6.string(),
+      replace_all: z6.boolean().default(false)
+    })
+  ).min(1).max(256),
+  create_if_missing: z6.boolean().default(false)
+});
+var FsPatchResult = z6.strictObject({ path: AbsPath, applied: nonNegInt, size: nonNegInt, mtime_ms: epochMs });
+var FsSearchPathsParams = z6.strictObject({
+  pattern: z6.string().min(1).max(512),
+  cwd: AbsPath,
+  hidden: z6.boolean().default(false),
+  max_results: z6.int().min(1).max(5e3).default(100)
+});
+var FsSearchPathsResult = z6.strictObject({ paths: z6.array(AbsPath), truncated: z6.boolean() });
+var FsSearchContentParams = z6.strictObject({
+  query: z6.string().min(1).max(1024),
+  cwd: AbsPath,
+  regex: z6.boolean().default(true),
+  case_sensitive: z6.boolean().default(false),
+  include: z6.array(z6.string().max(256)).max(64).optional(),
+  exclude: z6.array(z6.string().max(256)).max(64).optional(),
+  max_results: z6.int().min(1).max(5e3).default(100)
+});
+var FsSearchContentResult = z6.strictObject({
+  results: z6.array(
+    z6.strictObject({
+      path: AbsPath,
+      lines: z6.string(),
+      line_number: z6.int().min(1),
+      submatches: z6.array(z6.strictObject({ match: z6.string(), start: nonNegInt, end: nonNegInt }))
+    })
+  ),
+  truncated: z6.boolean()
+});
+var FsChange = z6.strictObject({
+  type: z6.enum(["created", "modified", "deleted", "moved"]),
+  path: AbsPath,
+  to_path: AbsPath.optional(),
+  kind: z6.enum(["file", "dir", "symlink", "unknown"])
+});
+var FsChangedEvent = z6.strictObject({ changes: z6.array(FsChange).min(1).max(1e3), overflow: z6.boolean() });
+
+// src/schema/exec.ts
+import { z as z7 } from "zod";
+var Signal = z7.enum(["SIGINT", "SIGTERM", "SIGKILL", "SIGHUP", "SIGQUIT", "SIGTSTP", "SIGCONT", "SIGUSR1", "SIGUSR2"]);
+var cols = z7.int().min(2).max(1e3);
+var rows = z7.int().min(1).max(500);
+var ExecPtyStartParams = z7.strictObject({
+  cols,
+  rows,
+  cwd: AbsPath.optional(),
+  // default: home
+  shell: z7.string().max(512).optional(),
+  // default: user's login shell (PowerShell on Windows)
+  args: z7.array(z7.string().max(4096)).max(64).optional(),
+  env: z7.record(z7.string().regex(/^[A-Za-z_][A-Za-z0-9_]*$/).max(128), z7.string().max(32768)).optional(),
+  name: z7.string().max(64).optional(),
+  // tab label
+  window_bytes: z7.int().min(4096).max(16777216).optional()
+});
+var PtyInfo = z7.strictObject({
+  resource_id: ResourceId,
+  pid: z7.int().min(1),
+  shell: z7.string().max(512),
+  cwd: AbsPath,
+  // live, from OSC 7 / process cwd
+  title: z7.string().max(256),
+  name: z7.string().max(64).nullable(),
+  cols,
+  rows,
+  state: z7.enum(["running", "exited"]),
+  exit_code: z7.int().nullable(),
+  exit_signal: Signal.nullable(),
+  last_seq: u32,
+  created_at_ms: epochMs,
+  controller_client_id: z7.string().max(64).nullable(),
+  // null = orphaned (in grace period)
+  attached_clients: nonNegInt,
+  orphan_expires_at_ms: epochMs.nullable()
+});
+var ExecPtyStartResult = PtyInfo;
+var ExecPtyWriteParams = z7.strictObject({ resource_id: ResourceId, data: z7.string().min(1).max(65536) });
+var ExecPtyWriteResult = z7.strictObject({ written: nonNegInt });
+var ExecPtyResizeParams = z7.strictObject({ resource_id: ResourceId, cols, rows });
+var ExecPtyResizeResult = z7.strictObject({ cols, rows });
+var ExecPtySignalParams = z7.strictObject({ resource_id: ResourceId, signal: Signal });
+var ExecPtySignalResult = z7.strictObject({ delivered: z7.boolean() });
+var ExecPtyKillParams = z7.strictObject({ resource_id: ResourceId, grace_ms: z7.int().min(0).max(3e4).default(2e3) });
+var ExecPtyKillResult = z7.strictObject({ exit_code: z7.int().nullable(), exit_signal: Signal.nullable() });
+var ExecListParams = z7.strictObject({});
+var ExecListResult = z7.strictObject({ sessions: z7.array(PtyInfo) });
+var ExecRunParams = z7.strictObject({
+  command: z7.string().min(1).max(131072),
+  cwd: AbsPath.optional(),
+  cwd_key: z7.string().max(128).optional(),
+  env: z7.record(z7.string().regex(/^[A-Za-z_][A-Za-z0-9_]*$/).max(128), z7.string().max(32768)).optional(),
+  stdin: z7.string().max(1048576).optional(),
+  timeout: z7.int().min(1).max(3600).default(60),
+  // seconds, daemon parity
+  max_output_bytes: z7.int().min(1024).max(8388608).default(1048576)
+});
+var ExecRunResult = z7.strictObject({
+  exit_code: z7.int(),
+  stdout: z7.string(),
+  stderr: z7.string(),
+  cwd: AbsPath,
+  duration_ms: nonNegInt,
+  timed_out: z7.boolean(),
+  output_truncated: z7.boolean()
+});
+var ExecExitedEvent = z7.strictObject({ exit_code: z7.int().nullable(), exit_signal: Signal.nullable() });
+var ExecTitleEvent = z7.strictObject({ title: z7.string().max(256) });
+var ExecCwdEvent = z7.strictObject({ cwd: AbsPath });
+
+// src/schema/session.ts
+import { z as z8 } from "zod";
+var SessionAttachParams = z8.strictObject({
+  resource_id: ResourceId,
+  mode: z8.enum(["control", "read_only"]).default("control"),
+  since_seq: u32.optional(),
+  window_bytes: z8.int().min(4096).max(16777216).optional()
+});
+var ResourceInfo = z8.discriminatedUnion("kind", [
+  z8.strictObject({ kind: z8.literal("pty"), pty: PtyInfo }),
+  z8.strictObject({
+    kind: z8.literal("watch"),
+    resource_id: ResourceId,
+    path: AbsPath,
+    orphan_expires_at_ms: epochMs.nullable()
+  })
+]);
+var SessionAttachResult = ResourceInfo;
+var SessionDetachParams = z8.strictObject({ resource_id: ResourceId });
+var SessionDetachResult = z8.strictObject({ orphan_expires_at_ms: epochMs.nullable() });
+var SessionReleaseParams = z8.strictObject({ resource_id: ResourceId });
+var SessionReleaseResult = z8.strictObject({ released: z8.literal(true) });
+var SessionListParams = z8.strictObject({});
+var SessionListResult = z8.strictObject({ resources: z8.array(ResourceInfo) });
+var SessionControlChangedEvent = z8.strictObject({ controller_client_id: z8.string().max(64).nullable(), your_mode: z8.enum(["control", "read_only"]) });
+
+// src/schema/relay.ts
+import { z as z9 } from "zod";
+var RelayDeviceStatusEvent = z9.strictObject({
+  online: z9.boolean(),
+  since_ms: epochMs,
+  app_version: z9.string().max(32).nullable(),
+  protocol_version: ProtocolVersion.nullable()
+});
+var RelayAuthExpiringEvent = z9.strictObject({ expires_at_ms: epochMs });
+var RelayCallRequest = z9.strictObject({
+  cap: z9.string().min(1).max(32),
+  op: z9.string().min(1).max(64),
+  params: z9.unknown(),
+  timeout_ms: z9.int().min(100).max(37e5).default(7e4)
+});
+var RelayCallResponse = z9.discriminatedUnion("ok", [
+  z9.strictObject({ ok: z9.literal(true), result: z9.unknown() }),
+  z9.strictObject({ ok: z9.literal(false), error: ProtocolErrorBody })
+]);
+var RelayStatusResponse = RelayDeviceStatusEvent;
+
+// src/schema/registry.ts
+var FS_ERR = ["NOT_FOUND", "PERMISSION_DENIED_OS", "INVALID_PARAMS", "RESOURCE_BUSY", "INTERNAL"];
+var OPS = {
+  "sysinfo.get": { params: SysinfoGetParams, result: SysinfoGetResult, kind: "unary", since: "1.0", errors: ["INTERNAL"] },
+  "fs.list": { params: FsListParams, result: FsListResult, kind: "unary", since: "1.0", errors: FS_ERR },
+  "fs.stat": { params: FsStatParams, result: FsStatResult, kind: "unary", since: "1.0", errors: FS_ERR },
+  "fs.read": { params: FsReadParams, result: FsReadResult, kind: "unary", since: "1.0", errors: [...FS_ERR, "PAYLOAD_TOO_LARGE"] },
+  "fs.read_stream": { params: FsReadStreamParams, result: FsReadStreamResult, kind: "stream", since: "1.0", errors: [...FS_ERR, "CANCELLED"] },
+  "fs.write": { params: FsWriteParams, result: FsWriteResult, kind: "unary", since: "1.0", errors: [...FS_ERR, "CONFLICT", "PAYLOAD_TOO_LARGE"] },
+  "fs.mkdir": { params: FsMkdirParams, result: FsMkdirResult, kind: "unary", since: "1.0", errors: [...FS_ERR, "CONFLICT"] },
+  "fs.move": { params: FsMoveParams, result: FsMoveResult, kind: "unary", since: "1.0", errors: [...FS_ERR, "CONFLICT"] },
+  "fs.delete": { params: FsDeleteParams, result: FsDeleteResult, kind: "unary", since: "1.0", errors: FS_ERR },
+  "fs.watch": { params: FsWatchParams, result: FsWatchResult, kind: "resource", since: "1.0", errors: [...FS_ERR, "RATE_LIMITED"] },
+  "fs.patch": { params: FsPatchParams, result: FsPatchResult, kind: "unary", since: "1.0", errors: [...FS_ERR, "CONFLICT"] },
+  "fs.search_paths": { params: FsSearchPathsParams, result: FsSearchPathsResult, kind: "unary", since: "1.0", errors: [...FS_ERR, "TIMEOUT"] },
+  "fs.search_content": { params: FsSearchContentParams, result: FsSearchContentResult, kind: "unary", since: "1.0", errors: [...FS_ERR, "TIMEOUT"] },
+  "exec.pty.start": { params: ExecPtyStartParams, result: ExecPtyStartResult, kind: "resource", since: "1.0", errors: ["INVALID_PARAMS", "NOT_FOUND", "RATE_LIMITED", "PLATFORM_UNSUPPORTED", "INTERNAL"] },
+  "exec.pty.write": { params: ExecPtyWriteParams, result: ExecPtyWriteResult, kind: "unary", since: "1.0", errors: ["RESOURCE_GONE", "AUTH_FORBIDDEN", "INVALID_PARAMS"] },
+  "exec.pty.resize": { params: ExecPtyResizeParams, result: ExecPtyResizeResult, kind: "unary", since: "1.0", errors: ["RESOURCE_GONE", "AUTH_FORBIDDEN"] },
+  "exec.pty.signal": { params: ExecPtySignalParams, result: ExecPtySignalResult, kind: "unary", since: "1.0", errors: ["RESOURCE_GONE", "AUTH_FORBIDDEN", "PLATFORM_UNSUPPORTED"] },
+  "exec.pty.kill": { params: ExecPtyKillParams, result: ExecPtyKillResult, kind: "unary", since: "1.0", errors: ["RESOURCE_GONE", "AUTH_FORBIDDEN"] },
+  "exec.list": { params: ExecListParams, result: ExecListResult, kind: "unary", since: "1.0", errors: ["INTERNAL"] },
+  "exec.run": { params: ExecRunParams, result: ExecRunResult, kind: "unary", since: "1.0", errors: ["INVALID_PARAMS", "NOT_FOUND", "TIMEOUT", "CANCELLED", "INTERNAL"] },
+  "session.attach": { params: SessionAttachParams, result: SessionAttachResult, kind: "stream", since: "1.0", errors: ["RESOURCE_GONE", "AUTH_FORBIDDEN", "RESOURCE_BUSY"] },
+  "session.detach": { params: SessionDetachParams, result: SessionDetachResult, kind: "unary", since: "1.0", errors: ["RESOURCE_GONE"] },
+  "session.release": { params: SessionReleaseParams, result: SessionReleaseResult, kind: "unary", since: "1.0", errors: ["RESOURCE_GONE", "AUTH_FORBIDDEN"] },
+  "session.list": { params: SessionListParams, result: SessionListResult, kind: "unary", since: "1.0", errors: ["INTERNAL"] }
+};
+var EVENTS = {
+  "fs.changed": FsChangedEvent,
+  "exec.exited": ExecExitedEvent,
+  "exec.title": ExecTitleEvent,
+  "exec.cwd": ExecCwdEvent,
+  "session.control_changed": SessionControlChangedEvent,
+  "relay.device_status": RelayDeviceStatusEvent,
+  "relay.auth_expiring": RelayAuthExpiringEvent
+};
+var NAMED_SCHEMAS = {
+  ProtocolVersion,
+  RequestId,
+  ResourceId,
+  DeviceId,
+  AbsPath,
+  ErrorCode,
+  ErrorReason,
+  ProtocolErrorBody,
+  FrameHeader,
+  ClientType,
+  Limits,
+  OpDescriptor,
+  Welcome,
+  HelloMsg,
+  RequestMsg,
+  ResponseMsg,
+  ErrorMsg,
+  StreamMeta,
+  StreamMsg,
+  EndReason,
+  EndMsg,
+  CancelMsg,
+  CreditMsg,
+  EventMsg,
+  RelayMsg,
+  ClientToCoreMsg,
+  CoreToClientMsg,
+  OsPermissionName,
+  SysinfoGetParams,
+  SysinfoGetResult,
+  FsKind,
+  FsEntry,
+  FsListParams,
+  FsListResult,
+  FsStatParams,
+  FsEncoding,
+  FsReadParams,
+  FsReadResult,
+  FsReadStreamParams,
+  FsReadStreamResult,
+  FsWriteParams,
+  FsWriteResult,
+  FsMkdirParams,
+  FsMkdirResult,
+  FsMoveParams,
+  FsMoveResult,
+  FsDeleteParams,
+  FsDeleteResult,
+  FsWatchParams,
+  FsWatchResult,
+  FsPatchParams,
+  FsPatchResult,
+  FsSearchPathsParams,
+  FsSearchPathsResult,
+  FsSearchContentParams,
+  FsSearchContentResult,
+  FsChange,
+  FsChangedEvent,
+  Signal,
+  ExecPtyStartParams,
+  PtyInfo,
+  ExecPtyWriteParams,
+  ExecPtyWriteResult,
+  ExecPtyResizeParams,
+  ExecPtyResizeResult,
+  ExecPtySignalParams,
+  ExecPtySignalResult,
+  ExecPtyKillParams,
+  ExecPtyKillResult,
+  ExecListParams,
+  ExecListResult,
+  ExecRunParams,
+  ExecRunResult,
+  ExecExitedEvent,
+  ExecTitleEvent,
+  ExecCwdEvent,
+  SessionAttachParams,
+  ResourceInfo,
+  SessionDetachParams,
+  SessionDetachResult,
+  SessionReleaseParams,
+  SessionReleaseResult,
+  SessionListParams,
+  SessionListResult,
+  SessionControlChangedEvent,
+  RelayDeviceStatusEvent,
+  RelayAuthExpiringEvent,
+  RelayCallRequest,
+  RelayCallResponse
+};
+export {
+  AbsPath,
+  CancelMsg,
+  ClientToCoreMsg,
+  ClientType,
+  CloseCode,
+  CoreToClientMsg,
+  CreditMsg,
+  DEFAULT_MAX_FRAME_PAYLOAD_BYTES,
+  DEFAULT_MAX_MESSAGE_BYTES,
+  DEFAULT_WINDOW_BYTES,
+  DesktopProtocolError,
+  DeviceId,
+  EVENTS,
+  EndMsg,
+  EndReason,
+  ErrorCode,
+  ErrorMsg,
+  ErrorReason,
+  EventMsg,
+  ExecCwdEvent,
+  ExecExitedEvent,
+  ExecListParams,
+  ExecListResult,
+  ExecPtyKillParams,
+  ExecPtyKillResult,
+  ExecPtyResizeParams,
+  ExecPtyResizeResult,
+  ExecPtySignalParams,
+  ExecPtySignalResult,
+  ExecPtyStartParams,
+  ExecPtyStartResult,
+  ExecPtyWriteParams,
+  ExecPtyWriteResult,
+  ExecRunParams,
+  ExecRunResult,
+  ExecTitleEvent,
+  FRAME_HEADER_BYTES,
+  FRAME_STRUCT_FORMAT,
+  FRAME_VERSION,
+  FrameChannel,
+  FrameFlag,
+  FrameHeader,
+  FsChange,
+  FsChangedEvent,
+  FsDeleteParams,
+  FsDeleteResult,
+  FsEncoding,
+  FsEntry,
+  FsKind,
+  FsListParams,
+  FsListResult,
+  FsMkdirParams,
+  FsMkdirResult,
+  FsMoveParams,
+  FsMoveResult,
+  FsPatchParams,
+  FsPatchResult,
+  FsReadParams,
+  FsReadResult,
+  FsReadStreamParams,
+  FsReadStreamResult,
+  FsSearchContentParams,
+  FsSearchContentResult,
+  FsSearchPathsParams,
+  FsSearchPathsResult,
+  FsStatParams,
+  FsStatResult,
+  FsWatchParams,
+  FsWatchResult,
+  FsWriteParams,
+  FsWriteResult,
+  HelloMsg,
+  Limits,
+  NAMED_SCHEMAS,
+  OPS,
+  OpDescriptor,
+  OsPermissionName,
+  PING_TEXT,
+  PONG_TEXT,
+  PROTOCOL_MAJOR,
+  PROTOCOL_MINOR,
+  ProtocolErrorBody,
+  ProtocolVersion,
+  PtyInfo,
+  RelayAuthExpiringEvent,
+  RelayCallRequest,
+  RelayCallResponse,
+  RelayDeviceStatusEvent,
+  RelayMsg,
+  RelayStatusResponse,
+  RequestId,
+  RequestMsg,
+  ResourceId,
+  ResourceInfo,
+  ResponseMsg,
+  SessionAttachParams,
+  SessionAttachResult,
+  SessionControlChangedEvent,
+  SessionDetachParams,
+  SessionDetachResult,
+  SessionListParams,
+  SessionListResult,
+  SessionReleaseParams,
+  SessionReleaseResult,
+  Signal,
+  StreamMeta,
+  StreamMsg,
+  SysinfoGetParams,
+  SysinfoGetResult,
+  Welcome,
+  assertFrameHeader,
+  decodeFrame,
+  encodeFrame,
+  epochMs,
+  hasFlag,
+  isDesktopProtocolError,
+  nonNegInt,
+  readCid,
+  stampCid,
+  u32
+};
+//# sourceMappingURL=index.js.map