@ai-matrx/desktop-protocol 0.1.0

package/dist/index.cjs

@@ -0,0 +1,876 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  AbsPath: () => AbsPath,
+  CancelMsg: () => CancelMsg,
+  ClientToCoreMsg: () => ClientToCoreMsg,
+  ClientType: () => ClientType,
+  CloseCode: () => CloseCode,
+  CoreToClientMsg: () => CoreToClientMsg,
+  CreditMsg: () => CreditMsg,
+  DEFAULT_MAX_FRAME_PAYLOAD_BYTES: () => DEFAULT_MAX_FRAME_PAYLOAD_BYTES,
+  DEFAULT_MAX_MESSAGE_BYTES: () => DEFAULT_MAX_MESSAGE_BYTES,
+  DEFAULT_WINDOW_BYTES: () => DEFAULT_WINDOW_BYTES,
+  DesktopProtocolError: () => DesktopProtocolError,
+  DeviceId: () => DeviceId,
+  EVENTS: () => EVENTS,
+  EndMsg: () => EndMsg,
+  EndReason: () => EndReason,
+  ErrorCode: () => ErrorCode,
+  ErrorMsg: () => ErrorMsg,
+  ErrorReason: () => ErrorReason,
+  EventMsg: () => EventMsg,
+  ExecCwdEvent: () => ExecCwdEvent,
+  ExecExitedEvent: () => ExecExitedEvent,
+  ExecListParams: () => ExecListParams,
+  ExecListResult: () => ExecListResult,
+  ExecPtyKillParams: () => ExecPtyKillParams,
+  ExecPtyKillResult: () => ExecPtyKillResult,
+  ExecPtyResizeParams: () => ExecPtyResizeParams,
+  ExecPtyResizeResult: () => ExecPtyResizeResult,
+  ExecPtySignalParams: () => ExecPtySignalParams,
+  ExecPtySignalResult: () => ExecPtySignalResult,
+  ExecPtyStartParams: () => ExecPtyStartParams,
+  ExecPtyStartResult: () => ExecPtyStartResult,
+  ExecPtyWriteParams: () => ExecPtyWriteParams,
+  ExecPtyWriteResult: () => ExecPtyWriteResult,
+  ExecRunParams: () => ExecRunParams,
+  ExecRunResult: () => ExecRunResult,
+  ExecTitleEvent: () => ExecTitleEvent,
+  FRAME_HEADER_BYTES: () => FRAME_HEADER_BYTES,
+  FRAME_STRUCT_FORMAT: () => FRAME_STRUCT_FORMAT,
+  FRAME_VERSION: () => FRAME_VERSION,
+  FrameChannel: () => FrameChannel,
+  FrameFlag: () => FrameFlag,
+  FrameHeader: () => FrameHeader,
+  FsChange: () => FsChange,
+  FsChangedEvent: () => FsChangedEvent,
+  FsDeleteParams: () => FsDeleteParams,
+  FsDeleteResult: () => FsDeleteResult,
+  FsEncoding: () => FsEncoding,
+  FsEntry: () => FsEntry,
+  FsKind: () => FsKind,
+  FsListParams: () => FsListParams,
+  FsListResult: () => FsListResult,
+  FsMkdirParams: () => FsMkdirParams,
+  FsMkdirResult: () => FsMkdirResult,
+  FsMoveParams: () => FsMoveParams,
+  FsMoveResult: () => FsMoveResult,
+  FsPatchParams: () => FsPatchParams,
+  FsPatchResult: () => FsPatchResult,
+  FsReadParams: () => FsReadParams,
+  FsReadResult: () => FsReadResult,
+  FsReadStreamParams: () => FsReadStreamParams,
+  FsReadStreamResult: () => FsReadStreamResult,
+  FsSearchContentParams: () => FsSearchContentParams,
+  FsSearchContentResult: () => FsSearchContentResult,
+  FsSearchPathsParams: () => FsSearchPathsParams,
+  FsSearchPathsResult: () => FsSearchPathsResult,
+  FsStatParams: () => FsStatParams,
+  FsStatResult: () => FsStatResult,
+  FsWatchParams: () => FsWatchParams,
+  FsWatchResult: () => FsWatchResult,
+  FsWriteParams: () => FsWriteParams,
+  FsWriteResult: () => FsWriteResult,
+  HelloMsg: () => HelloMsg,
+  Limits: () => Limits,
+  NAMED_SCHEMAS: () => NAMED_SCHEMAS,
+  OPS: () => OPS,
+  OpDescriptor: () => OpDescriptor,
+  OsPermissionName: () => OsPermissionName,
+  PING_TEXT: () => PING_TEXT,
+  PONG_TEXT: () => PONG_TEXT,
+  PROTOCOL_MAJOR: () => PROTOCOL_MAJOR,
+  PROTOCOL_MINOR: () => PROTOCOL_MINOR,
+  ProtocolErrorBody: () => ProtocolErrorBody,
+  ProtocolVersion: () => ProtocolVersion,
+  PtyInfo: () => PtyInfo,
+  RelayAuthExpiringEvent: () => RelayAuthExpiringEvent,
+  RelayCallRequest: () => RelayCallRequest,
+  RelayCallResponse: () => RelayCallResponse,
+  RelayDeviceStatusEvent: () => RelayDeviceStatusEvent,
+  RelayMsg: () => RelayMsg,
+  RelayStatusResponse: () => RelayStatusResponse,
+  RequestId: () => RequestId,
+  RequestMsg: () => RequestMsg,
+  ResourceId: () => ResourceId,
+  ResourceInfo: () => ResourceInfo,
+  ResponseMsg: () => ResponseMsg,
+  SessionAttachParams: () => SessionAttachParams,
+  SessionAttachResult: () => SessionAttachResult,
+  SessionControlChangedEvent: () => SessionControlChangedEvent,
+  SessionDetachParams: () => SessionDetachParams,
+  SessionDetachResult: () => SessionDetachResult,
+  SessionListParams: () => SessionListParams,
+  SessionListResult: () => SessionListResult,
+  SessionReleaseParams: () => SessionReleaseParams,
+  SessionReleaseResult: () => SessionReleaseResult,
+  Signal: () => Signal,
+  StreamMeta: () => StreamMeta,
+  StreamMsg: () => StreamMsg,
+  SysinfoGetParams: () => SysinfoGetParams,
+  SysinfoGetResult: () => SysinfoGetResult,
+  Welcome: () => Welcome,
+  assertFrameHeader: () => assertFrameHeader,
+  decodeFrame: () => decodeFrame,
+  encodeFrame: () => encodeFrame,
+  epochMs: () => epochMs,
+  hasFlag: () => hasFlag,
+  isDesktopProtocolError: () => isDesktopProtocolError,
+  nonNegInt: () => nonNegInt,
+  readCid: () => readCid,
+  stampCid: () => stampCid,
+  u32: () => u32
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/schema/primitives.ts
+var import_zod = require("zod");
+var PROTOCOL_MAJOR = 1;
+var PROTOCOL_MINOR = 0;
+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_-]+$/);
+var ResourceId = import_zod.z.string().regex(/^(pty|watch)_[A-Za-z0-9]{16,40}$/);
+var DeviceId = import_zod.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 = import_zod.z.string().min(1).max(4096).regex(/^(\/|[A-Za-z]:\/)[^\\\u0000]*$/);
+var u32 = import_zod.z.int().min(0).max(4294967295);
+var nonNegInt = import_zod.z.int().min(0);
+var epochMs = import_zod.z.int().min(0);
+
+// src/schema/errors.ts
+var import_zod2 = require("zod");
+var ErrorCode = import_zod2.z.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 = import_zod2.z.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 = import_zod2.z.strictObject({
+  code: ErrorCode,
+  message: import_zod2.z.string().max(300),
+  // short, human, never a stack trace or a token
+  retryable: import_zod2.z.boolean(),
+  data: import_zod2.z.strictObject({
+    reason: ErrorReason.optional(),
+    cap: import_zod2.z.string().max(32).optional(),
+    op: import_zod2.z.string().max(64).optional(),
+    path: AbsPath.optional(),
+    settings_url: import_zod2.z.string().max(512).optional(),
+    // PERMISSION_DENIED_OS deep link
+    retry_after_ms: nonNegInt.optional(),
+    limit_bytes: nonNegInt.optional(),
+    upgrade: import_zod2.z.strictObject({
+      min_version: ProtocolVersion,
+      max_version: ProtocolVersion,
+      download_url: import_zod2.z.url().optional()
+    }).optional()
+  }).optional()
+});
+
+// src/schema/frame.ts
+var import_zod3 = require("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 = import_zod3.z.strictObject({
+  version: import_zod3.z.literal(FRAME_VERSION),
+  flags: import_zod3.z.int().min(0).max(3),
+  channel: import_zod3.z.union([import_zod3.z.literal(0), import_zod3.z.literal(1), import_zod3.z.literal(2), import_zod3.z.literal(3), import_zod3.z.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
+var import_zod4 = require("zod");
+var ClientType = import_zod4.z.enum(["screen", "web", "extension", "server", "test"]);
+var Limits = import_zod4.z.strictObject({
+  max_message_bytes: import_zod4.z.int().min(65536),
+  max_frame_payload_bytes: import_zod4.z.int().min(4096),
+  default_window_bytes: import_zod4.z.int().min(4096),
+  max_streams_per_client: import_zod4.z.int().min(1),
+  max_resources_per_user: import_zod4.z.int().min(1)
+});
+var OpDescriptor = import_zod4.z.strictObject({ cap: import_zod4.z.string().max(32), op: import_zod4.z.string().max(64), since: ProtocolVersion });
+var Welcome = import_zod4.z.strictObject({
+  protocol_version: ProtocolVersion,
+  // negotiated = min(client, core) within the same major
+  session_id: import_zod4.z.string().min(8).max(64),
+  client_id: import_zod4.z.string().min(8).max(64),
+  // this connection's identity in the Session Manager
+  device_id: DeviceId,
+  device_name: import_zod4.z.string().max(128),
+  app_version: import_zod4.z.string().max(32),
+  platform: import_zod4.z.enum(["darwin", "win32", "linux"]),
+  ops: import_zod4.z.array(OpDescriptor),
+  limits: Limits,
+  server_time_ms: epochMs
+});
+var HelloMsg = import_zod4.z.strictObject({
+  type: import_zod4.z.literal("hello"),
+  id: RequestId,
+  // answered by response{id, result: Welcome} or error{id}
+  protocolVersion: ProtocolVersion,
+  clientType: ClientType,
+  clientVersion: import_zod4.z.string().min(1).max(32)
+});
+var RequestMsg = import_zod4.z.strictObject({
+  id: RequestId,
+  type: import_zod4.z.literal("request"),
+  cap: import_zod4.z.string().min(1).max(32),
+  op: import_zod4.z.string().min(1).max(64),
+  params: import_zod4.z.unknown()
+  // validated by the Router against OPS[cap.op].params — once, there
+});
+var ResponseMsg = import_zod4.z.strictObject({ id: RequestId, type: import_zod4.z.literal("response"), result: import_zod4.z.unknown() });
+var ErrorMsg = import_zod4.z.strictObject({ id: RequestId, type: import_zod4.z.literal("error"), error: ProtocolErrorBody });
+var StreamMeta = import_zod4.z.discriminatedUnion("kind", [
+  /** Binds request id → numeric sid; binary frames for this stream follow. */
+  import_zod4.z.strictObject({
+    kind: import_zod4.z.literal("open"),
+    sid: u32,
+    window_bytes: import_zod4.z.int().min(4096),
+    resource_id: ResourceId.optional()
+  }),
+  /** Frames after this (channel SNAPSHOT) are a serialized screen; live DATA resumes after. */
+  import_zod4.z.strictObject({ kind: import_zod4.z.literal("snapshot"), cols: import_zod4.z.int().min(1), rows: import_zod4.z.int().min(1) }),
+  /** Frames [from_seq, to_seq] are gone from the ring; a snapshot follows. */
+  import_zod4.z.strictObject({ kind: import_zod4.z.literal("gap"), from_seq: u32, to_seq: u32 })
+]);
+var StreamMsg = import_zod4.z.strictObject({ id: RequestId, type: import_zod4.z.literal("stream"), seq: u32, meta: StreamMeta });
+var EndReason = import_zod4.z.enum(["completed", "cancelled", "detached", "resource_exited", "error"]);
+var EndMsg = import_zod4.z.strictObject({ id: RequestId, type: import_zod4.z.literal("end"), seq: u32, reason: EndReason.optional() });
+var CancelMsg = import_zod4.z.strictObject({ id: RequestId, type: import_zod4.z.literal("cancel") });
+var CreditMsg = import_zod4.z.strictObject({ id: RequestId, type: import_zod4.z.literal("credit"), n: import_zod4.z.int().min(1).max(2147483647) });
+var EventMsg = import_zod4.z.strictObject({
+  type: import_zod4.z.literal("event"),
+  cap: import_zod4.z.string().min(1).max(32),
+  name: import_zod4.z.string().min(1).max(64),
+  payload: import_zod4.z.unknown(),
+  // validated against EVENTS[cap.name]
+  resourceId: ResourceId.optional()
+});
+var RelayMsg = import_zod4.z.discriminatedUnion("op", [
+  /** Fresh access token before the current one expires (relay closes 4008 at exp + 60 s). */
+  import_zod4.z.strictObject({ type: import_zod4.z.literal("relay"), op: import_zod4.z.literal("reauth"), token: import_zod4.z.string().min(16).max(8192) })
+]);
+var PING_TEXT = '{"type":"ping"}';
+var PONG_TEXT = '{"type":"pong"}';
+var ClientToCoreMsg = import_zod4.z.discriminatedUnion("type", [HelloMsg, RequestMsg, CancelMsg, CreditMsg]);
+var CoreToClientMsg = import_zod4.z.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
+var import_zod5 = require("zod");
+var OsPermissionName = import_zod5.z.enum([
+  "full_disk_access",
+  "accessibility",
+  "screen_recording",
+  "microphone",
+  "camera",
+  "automation",
+  "contacts",
+  "calendars",
+  "photos",
+  "location",
+  "local_network",
+  "bluetooth",
+  "notifications"
+]);
+var SysinfoGetParams = import_zod5.z.strictObject({});
+var SysinfoGetResult = import_zod5.z.strictObject({
+  device_id: DeviceId,
+  device_name: import_zod5.z.string().max(128),
+  hostname: import_zod5.z.string().max(255),
+  platform: import_zod5.z.enum(["darwin", "win32", "linux"]),
+  os_version: import_zod5.z.string().max(64),
+  arch: import_zod5.z.enum(["arm64", "x64"]),
+  app_version: import_zod5.z.string().max(32),
+  protocol_version: ProtocolVersion,
+  user: import_zod5.z.strictObject({ username: import_zod5.z.string().max(128), shell: import_zod5.z.string().max(512) }),
+  paths: import_zod5.z.strictObject({
+    home: AbsPath,
+    desktop: AbsPath,
+    documents: AbsPath,
+    downloads: AbsPath,
+    app_data: AbsPath,
+    temp: AbsPath
+  }),
+  cpu: import_zod5.z.strictObject({ model: import_zod5.z.string().max(128), cores: import_zod5.z.int().min(1) }),
+  memory: import_zod5.z.strictObject({ total_bytes: nonNegInt, free_bytes: nonNegInt }),
+  uptime_seconds: nonNegInt,
+  on_battery: import_zod5.z.boolean().nullable(),
+  sleep_prevented: import_zod5.z.boolean(),
+  // true while any remote session holds the power blocker
+  permissions: import_zod5.z.array(
+    import_zod5.z.strictObject({
+      name: OsPermissionName,
+      state: import_zod5.z.enum(["granted", "denied", "not_determined", "not_applicable"]),
+      settings_url: import_zod5.z.string().max(512).nullable()
+    })
+  )
+});
+
+// src/schema/fs.ts
+var import_zod6 = require("zod");
+var FsKind = import_zod6.z.enum(["file", "dir", "symlink"]);
+var FsEntry = import_zod6.z.strictObject({
+  name: import_zod6.z.string().max(1024),
+  path: AbsPath,
+  kind: FsKind,
+  size: nonNegInt,
+  mtime: import_zod6.z.number().min(0),
+  // seconds, float — daemon parity
+  mtime_ms: epochMs,
+  mode: import_zod6.z.int().min(0).max(4095),
+  target: AbsPath.nullable(),
+  // symlink target, never followed
+  hidden: import_zod6.z.boolean()
+});
+var FsListParams = import_zod6.z.strictObject({
+  path: AbsPath,
+  recursive: import_zod6.z.boolean().default(false),
+  depth: import_zod6.z.int().min(1).max(32).default(1),
+  pattern: import_zod6.z.string().max(256).optional(),
+  // glob on name
+  limit: import_zod6.z.int().min(1).max(5e3).default(500),
+  page_token: import_zod6.z.string().max(256).optional(),
+  show_hidden: import_zod6.z.boolean().default(false),
+  sort: import_zod6.z.enum(["name", "mtime", "size", "kind"]).default("kind")
+});
+var FsListResult = import_zod6.z.strictObject({
+  entries: import_zod6.z.array(FsEntry),
+  truncated: import_zod6.z.boolean(),
+  next_page_token: import_zod6.z.string().max(256).nullable(),
+  scanned: nonNegInt
+});
+var FsStatParams = import_zod6.z.strictObject({ path: AbsPath });
+var FsStatResult = FsEntry;
+var FsEncoding = import_zod6.z.enum(["utf8", "base64"]);
+var FsReadParams = import_zod6.z.strictObject({
+  path: AbsPath,
+  encoding: FsEncoding.default("utf8"),
+  offset: nonNegInt.default(0),
+  limit: import_zod6.z.int().min(1).max(4194304).default(262144)
+});
+var FsReadResult = import_zod6.z.strictObject({
+  content: import_zod6.z.string(),
+  encoding: FsEncoding,
+  size: nonNegInt,
+  offset: nonNegInt,
+  next_offset: nonNegInt,
+  truncated: import_zod6.z.boolean(),
+  mime: import_zod6.z.string().max(128).nullable(),
+  mtime_ms: epochMs
+  // pass back as if_match_mtime_ms to guard a later write
+});
+var FsReadStreamParams = import_zod6.z.strictObject({
+  path: AbsPath,
+  offset: nonNegInt.default(0),
+  length: nonNegInt.optional(),
+  // absent = to EOF
+  window_bytes: import_zod6.z.int().min(4096).max(16777216).optional()
+});
+var FsReadStreamResult = import_zod6.z.strictObject({ size: nonNegInt, mime: import_zod6.z.string().max(128).nullable(), mtime_ms: epochMs });
+var FsWriteParams = import_zod6.z.strictObject({
+  path: AbsPath,
+  content: import_zod6.z.string().max(5592406),
+  // ≤ 4 MiB of bytes after base64 decode
+  encoding: FsEncoding.default("utf8"),
+  mode: import_zod6.z.int().min(0).max(4095).optional(),
+  create_parents: import_zod6.z.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: import_zod6.z.boolean().default(false)
+});
+var FsWriteResult = import_zod6.z.strictObject({ path: AbsPath, size: nonNegInt, mtime_ms: epochMs, created: import_zod6.z.boolean() });
+var FsMkdirParams = import_zod6.z.strictObject({ path: AbsPath, parents: import_zod6.z.boolean().default(false) });
+var FsMkdirResult = import_zod6.z.strictObject({ path: AbsPath, created: import_zod6.z.boolean() });
+var FsMoveParams = import_zod6.z.strictObject({ from_path: AbsPath, to_path: AbsPath, overwrite: import_zod6.z.boolean().default(false) });
+var FsMoveResult = import_zod6.z.strictObject({ from_path: AbsPath, to_path: AbsPath });
+var FsDeleteParams = import_zod6.z.strictObject({
+  path: AbsPath,
+  recursive: import_zod6.z.boolean().default(false),
+  to_trash: import_zod6.z.boolean().default(true)
+});
+var FsDeleteResult = import_zod6.z.strictObject({ deleted: import_zod6.z.literal(true), trashed_to: AbsPath.nullable() });
+var FsWatchParams = import_zod6.z.strictObject({
+  path: AbsPath,
+  recursive: import_zod6.z.boolean().default(false),
+  ignore: import_zod6.z.array(import_zod6.z.string().max(256)).max(64).default([]),
+  debounce_ms: import_zod6.z.int().min(0).max(5e3).default(50)
+});
+var FsWatchResult = import_zod6.z.strictObject({ resource_id: ResourceId, path: AbsPath });
+var FsPatchParams = import_zod6.z.strictObject({
+  path: AbsPath,
+  edits: import_zod6.z.array(
+    import_zod6.z.strictObject({
+      old_text: import_zod6.z.string(),
+      new_text: import_zod6.z.string(),
+      replace_all: import_zod6.z.boolean().default(false)
+    })
+  ).min(1).max(256),
+  create_if_missing: import_zod6.z.boolean().default(false)
+});
+var FsPatchResult = import_zod6.z.strictObject({ path: AbsPath, applied: nonNegInt, size: nonNegInt, mtime_ms: epochMs });
+var FsSearchPathsParams = import_zod6.z.strictObject({
+  pattern: import_zod6.z.string().min(1).max(512),
+  cwd: AbsPath,
+  hidden: import_zod6.z.boolean().default(false),
+  max_results: import_zod6.z.int().min(1).max(5e3).default(100)
+});
+var FsSearchPathsResult = import_zod6.z.strictObject({ paths: import_zod6.z.array(AbsPath), truncated: import_zod6.z.boolean() });
+var FsSearchContentParams = import_zod6.z.strictObject({
+  query: import_zod6.z.string().min(1).max(1024),
+  cwd: AbsPath,
+  regex: import_zod6.z.boolean().default(true),
+  case_sensitive: import_zod6.z.boolean().default(false),
+  include: import_zod6.z.array(import_zod6.z.string().max(256)).max(64).optional(),
+  exclude: import_zod6.z.array(import_zod6.z.string().max(256)).max(64).optional(),
+  max_results: import_zod6.z.int().min(1).max(5e3).default(100)
+});
+var FsSearchContentResult = import_zod6.z.strictObject({
+  results: import_zod6.z.array(
+    import_zod6.z.strictObject({
+      path: AbsPath,
+      lines: import_zod6.z.string(),
+      line_number: import_zod6.z.int().min(1),
+      submatches: import_zod6.z.array(import_zod6.z.strictObject({ match: import_zod6.z.string(), start: nonNegInt, end: nonNegInt }))
+    })
+  ),
+  truncated: import_zod6.z.boolean()
+});
+var FsChange = import_zod6.z.strictObject({
+  type: import_zod6.z.enum(["created", "modified", "deleted", "moved"]),
+  path: AbsPath,
+  to_path: AbsPath.optional(),
+  kind: import_zod6.z.enum(["file", "dir", "symlink", "unknown"])
+});
+var FsChangedEvent = import_zod6.z.strictObject({ changes: import_zod6.z.array(FsChange).min(1).max(1e3), overflow: import_zod6.z.boolean() });
+
+// src/schema/exec.ts
+var import_zod7 = require("zod");
+var Signal = import_zod7.z.enum(["SIGINT", "SIGTERM", "SIGKILL", "SIGHUP", "SIGQUIT", "SIGTSTP", "SIGCONT", "SIGUSR1", "SIGUSR2"]);
+var cols = import_zod7.z.int().min(2).max(1e3);
+var rows = import_zod7.z.int().min(1).max(500);
+var ExecPtyStartParams = import_zod7.z.strictObject({
+  cols,
+  rows,
+  cwd: AbsPath.optional(),
+  // default: home
+  shell: import_zod7.z.string().max(512).optional(),
+  // default: user's login shell (PowerShell on Windows)
+  args: import_zod7.z.array(import_zod7.z.string().max(4096)).max(64).optional(),
+  env: import_zod7.z.record(import_zod7.z.string().regex(/^[A-Za-z_][A-Za-z0-9_]*$/).max(128), import_zod7.z.string().max(32768)).optional(),
+  name: import_zod7.z.string().max(64).optional(),
+  // tab label
+  window_bytes: import_zod7.z.int().min(4096).max(16777216).optional()
+});
+var PtyInfo = import_zod7.z.strictObject({
+  resource_id: ResourceId,
+  pid: import_zod7.z.int().min(1),
+  shell: import_zod7.z.string().max(512),
+  cwd: AbsPath,
+  // live, from OSC 7 / process cwd
+  title: import_zod7.z.string().max(256),
+  name: import_zod7.z.string().max(64).nullable(),
+  cols,
+  rows,
+  state: import_zod7.z.enum(["running", "exited"]),
+  exit_code: import_zod7.z.int().nullable(),
+  exit_signal: Signal.nullable(),
+  last_seq: u32,
+  created_at_ms: epochMs,
+  controller_client_id: import_zod7.z.string().max(64).nullable(),
+  // null = orphaned (in grace period)
+  attached_clients: nonNegInt,
+  orphan_expires_at_ms: epochMs.nullable()
+});
+var ExecPtyStartResult = PtyInfo;
+var ExecPtyWriteParams = import_zod7.z.strictObject({ resource_id: ResourceId, data: import_zod7.z.string().min(1).max(65536) });
+var ExecPtyWriteResult = import_zod7.z.strictObject({ written: nonNegInt });
+var ExecPtyResizeParams = import_zod7.z.strictObject({ resource_id: ResourceId, cols, rows });
+var ExecPtyResizeResult = import_zod7.z.strictObject({ cols, rows });
+var ExecPtySignalParams = import_zod7.z.strictObject({ resource_id: ResourceId, signal: Signal });
+var ExecPtySignalResult = import_zod7.z.strictObject({ delivered: import_zod7.z.boolean() });
+var ExecPtyKillParams = import_zod7.z.strictObject({ resource_id: ResourceId, grace_ms: import_zod7.z.int().min(0).max(3e4).default(2e3) });
+var ExecPtyKillResult = import_zod7.z.strictObject({ exit_code: import_zod7.z.int().nullable(), exit_signal: Signal.nullable() });
+var ExecListParams = import_zod7.z.strictObject({});
+var ExecListResult = import_zod7.z.strictObject({ sessions: import_zod7.z.array(PtyInfo) });
+var ExecRunParams = import_zod7.z.strictObject({
+  command: import_zod7.z.string().min(1).max(131072),
+  cwd: AbsPath.optional(),
+  cwd_key: import_zod7.z.string().max(128).optional(),
+  env: import_zod7.z.record(import_zod7.z.string().regex(/^[A-Za-z_][A-Za-z0-9_]*$/).max(128), import_zod7.z.string().max(32768)).optional(),
+  stdin: import_zod7.z.string().max(1048576).optional(),
+  timeout: import_zod7.z.int().min(1).max(3600).default(60),
+  // seconds, daemon parity
+  max_output_bytes: import_zod7.z.int().min(1024).max(8388608).default(1048576)
+});
+var ExecRunResult = import_zod7.z.strictObject({
+  exit_code: import_zod7.z.int(),
+  stdout: import_zod7.z.string(),
+  stderr: import_zod7.z.string(),
+  cwd: AbsPath,
+  duration_ms: nonNegInt,
+  timed_out: import_zod7.z.boolean(),
+  output_truncated: import_zod7.z.boolean()
+});
+var ExecExitedEvent = import_zod7.z.strictObject({ exit_code: import_zod7.z.int().nullable(), exit_signal: Signal.nullable() });
+var ExecTitleEvent = import_zod7.z.strictObject({ title: import_zod7.z.string().max(256) });
+var ExecCwdEvent = import_zod7.z.strictObject({ cwd: AbsPath });
+
+// src/schema/session.ts
+var import_zod8 = require("zod");
+var SessionAttachParams = import_zod8.z.strictObject({
+  resource_id: ResourceId,
+  mode: import_zod8.z.enum(["control", "read_only"]).default("control"),
+  since_seq: u32.optional(),
+  window_bytes: import_zod8.z.int().min(4096).max(16777216).optional()
+});
+var ResourceInfo = import_zod8.z.discriminatedUnion("kind", [
+  import_zod8.z.strictObject({ kind: import_zod8.z.literal("pty"), pty: PtyInfo }),
+  import_zod8.z.strictObject({
+    kind: import_zod8.z.literal("watch"),
+    resource_id: ResourceId,
+    path: AbsPath,
+    orphan_expires_at_ms: epochMs.nullable()
+  })
+]);
+var SessionAttachResult = ResourceInfo;
+var SessionDetachParams = import_zod8.z.strictObject({ resource_id: ResourceId });
+var SessionDetachResult = import_zod8.z.strictObject({ orphan_expires_at_ms: epochMs.nullable() });
+var SessionReleaseParams = import_zod8.z.strictObject({ resource_id: ResourceId });
+var SessionReleaseResult = import_zod8.z.strictObject({ released: import_zod8.z.literal(true) });
+var SessionListParams = import_zod8.z.strictObject({});
+var SessionListResult = import_zod8.z.strictObject({ resources: import_zod8.z.array(ResourceInfo) });
+var SessionControlChangedEvent = import_zod8.z.strictObject({ controller_client_id: import_zod8.z.string().max(64).nullable(), your_mode: import_zod8.z.enum(["control", "read_only"]) });
+
+// src/schema/relay.ts
+var import_zod9 = require("zod");
+var RelayDeviceStatusEvent = import_zod9.z.strictObject({
+  online: import_zod9.z.boolean(),
+  since_ms: epochMs,
+  app_version: import_zod9.z.string().max(32).nullable(),
+  protocol_version: ProtocolVersion.nullable()
+});
+var RelayAuthExpiringEvent = import_zod9.z.strictObject({ expires_at_ms: epochMs });
+var RelayCallRequest = import_zod9.z.strictObject({
+  cap: import_zod9.z.string().min(1).max(32),
+  op: import_zod9.z.string().min(1).max(64),
+  params: import_zod9.z.unknown(),
+  timeout_ms: import_zod9.z.int().min(100).max(37e5).default(7e4)
+});
+var RelayCallResponse = import_zod9.z.discriminatedUnion("ok", [
+  import_zod9.z.strictObject({ ok: import_zod9.z.literal(true), result: import_zod9.z.unknown() }),
+  import_zod9.z.strictObject({ ok: import_zod9.z.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
+};
+//# sourceMappingURL=index.cjs.map