@ai-matrx/desktop-protocol 0.3.0 → 0.5.0

package/dist/index.cjs

@@ -59,6 +59,7 @@ __export(src_exports, {
   ExecRunParams: () => ExecRunParams,
   ExecRunResult: () => ExecRunResult,
   ExecTitleEvent: () => ExecTitleEvent,
+  FIELDS_SINCE: () => FIELDS_SINCE,
   FRAME_HEADER_BYTES: () => FRAME_HEADER_BYTES,
   FRAME_STRUCT_FORMAT: () => FRAME_STRUCT_FORMAT,
   FRAME_VERSION: () => FRAME_VERSION,
@@ -78,6 +79,8 @@ __export(src_exports, {
   FsMkdirResult: () => FsMkdirResult,
   FsMoveParams: () => FsMoveParams,
   FsMoveResult: () => FsMoveResult,
+  FsPatchEditApplied: () => FsPatchEditApplied,
+  FsPatchEditFailure: () => FsPatchEditFailure,
   FsPatchParams: () => FsPatchParams,
   FsPatchResult: () => FsPatchResult,
   FsReadParams: () => FsReadParams,
@@ -110,6 +113,7 @@ __export(src_exports, {
   PtyInfo: () => PtyInfo,
   RELAY_CALL_HELLO_ID: () => RELAY_CALL_HELLO_ID,
   RELAY_CALL_REQUEST_ID: () => RELAY_CALL_REQUEST_ID,
+  RELAY_CALL_VERSION_HEADER: () => RELAY_CALL_VERSION_HEADER,
   RelayAuthExpiringEvent: () => RelayAuthExpiringEvent,
   RelayCallEnvelope: () => RelayCallEnvelope,
   RelayCallHello: () => RelayCallHello,
@@ -140,15 +144,20 @@ __export(src_exports, {
   StreamMsg: () => StreamMsg,
   SysinfoGetParams: () => SysinfoGetParams,
   SysinfoGetResult: () => SysinfoGetResult,
+  VERSIONED_RESULT_OPS: () => VERSIONED_RESULT_OPS,
   Welcome: () => Welcome,
   assertFrameHeader: () => assertFrameHeader,
+  compareVersions: () => compareVersions,
   connectionEndFrame: () => connectionEndFrame,
   decodeFrame: () => decodeFrame,
   encodeFrame: () => encodeFrame,
   epochMs: () => epochMs,
+  forPeer: () => forPeer,
   hasFlag: () => hasFlag,
   isConnectionEnd: () => isConnectionEnd,
   isDesktopProtocolError: () => isDesktopProtocolError,
+  knows: () => knows,
+  negotiate: () => negotiate,
   nonNegInt: () => nonNegInt,
   readCid: () => readCid,
   stampCid: () => stampCid,
@@ -159,7 +168,7 @@ module.exports = __toCommonJS(src_exports);
 // src/schema/primitives.ts
 var import_zod = require("zod");
 var PROTOCOL_MAJOR = 1;
-var PROTOCOL_MINOR = 0;
+var PROTOCOL_MINOR = 1;
 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_-]+$/);
@@ -220,6 +229,7 @@ var ErrorReason = import_zod2.z.enum([
   // another client of the same user took control
   "window_exhausted"
 ]);
+var FsPatchEditFailure = import_zod2.z.strictObject({ edit_index: nonNegInt, reason: import_zod2.z.string().max(300) });
 var ProtocolErrorBody = import_zod2.z.strictObject({
   code: ErrorCode,
   message: import_zod2.z.string().max(300),
@@ -234,6 +244,8 @@ var ProtocolErrorBody = import_zod2.z.strictObject({
     // PERMISSION_DENIED_OS deep link
     retry_after_ms: nonNegInt.optional(),
     limit_bytes: nonNegInt.optional(),
+    /** fs.patch when every edit failed (CONFLICT, patch_no_match / patch_ambiguous): the daemon's 422 `failures`. */
+    edits_failed: import_zod2.z.array(FsPatchEditFailure).max(256).optional(),
     upgrade: import_zod2.z.strictObject({
       min_version: ProtocolVersion,
       max_version: ProtocolVersion,
@@ -639,7 +651,22 @@ var FsPatchParams = import_zod6.z.strictObject({
   ).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 FsPatchEditApplied = import_zod6.z.strictObject({
+  edit_index: nonNegInt,
+  mode: import_zod6.z.enum(["create", "replace", "replace_all"]),
+  /** Present for replace_all only, as the daemon sends it. */
+  matches_replaced: nonNegInt.optional()
+});
+var FsPatchResult = import_zod6.z.strictObject({
+  path: AbsPath,
+  applied: nonNegInt,
+  size: nonNegInt,
+  mtime_ms: epochMs,
+  /** Since 1.1 (FIELDS_SINCE): a 1.0 app sends only `applied`. Always sent to a ≥1.1 peer. */
+  edits_applied: import_zod6.z.array(FsPatchEditApplied).max(256).optional(),
+  /** Since 1.1 (FIELDS_SINCE). */
+  edits_failed: import_zod6.z.array(FsPatchEditFailure).max(256).optional()
+});
 var FsSearchPathsParams = import_zod6.z.strictObject({
   pattern: import_zod6.z.string().min(1).max(512),
   cwd: AbsPath,
@@ -789,9 +816,20 @@ var RelayCallRequest = import_zod9.z.strictObject({
   params: import_zod9.z.unknown(),
   timeout_ms: import_zod9.z.int().min(100).max(37e5).default(7e4)
 });
+var RELAY_CALL_VERSION_HEADER = "x-matrx-protocol-version";
 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 })
+  import_zod9.z.strictObject({
+    ok: import_zod9.z.literal(true),
+    result: import_zod9.z.unknown(),
+    /** Since 1.1: the version the device negotiated for this call (its welcome). */
+    protocol_version: ProtocolVersion.optional()
+  }),
+  import_zod9.z.strictObject({
+    ok: import_zod9.z.literal(false),
+    error: ProtocolErrorBody,
+    /** Since 1.1, as above (absent when the device never answered hello). */
+    protocol_version: ProtocolVersion.optional()
+  })
 ]);
 var RELAY_CALL_HELLO_ID = "hello";
 var RELAY_CALL_REQUEST_ID = "call";
@@ -856,6 +894,7 @@ var NAMED_SCHEMAS = {
   AbsPath,
   ErrorCode,
   ErrorReason,
+  FsPatchEditFailure,
   ProtocolErrorBody,
   FrameHeader,
   ClientType,
@@ -899,6 +938,7 @@ var NAMED_SCHEMAS = {
   FsDeleteResult,
   FsWatchParams,
   FsWatchResult,
+  FsPatchEditApplied,
   FsPatchParams,
   FsPatchResult,
   FsSearchPathsParams,
@@ -944,4 +984,49 @@ var NAMED_SCHEMAS = {
   RelayHopConnectionEnd,
   CloseCodeValue
 };
+
+// src/versioning.ts
+var FIELDS_SINCE = {
+  FsPatchResult: { edits_applied: "1.1", edits_failed: "1.1" },
+  "ProtocolErrorBody.data": { edits_failed: "1.1" },
+  "RelayCallResponse|0": { protocol_version: "1.1" },
+  "RelayCallResponse|1": { protocol_version: "1.1" }
+};
+function compareVersions(a, b) {
+  const [am = 0, an = 0] = a.split(".").map(Number);
+  const [bm = 0, bn = 0] = b.split(".").map(Number);
+  return am - bm || an - bn;
+}
+function knows(version, since) {
+  return compareVersions(version, since) >= 0;
+}
+function negotiate(peerVersion) {
+  const [major = 0, minor = 0] = peerVersion.split(".").map(Number);
+  if (major !== PROTOCOL_MAJOR) return `${PROTOCOL_MAJOR}.0`;
+  return `${PROTOCOL_MAJOR}.${Math.min(minor, PROTOCOL_MINOR)}`;
+}
+function strip(value, fields, version) {
+  if (!fields || value === null || typeof value !== "object" || Array.isArray(value)) return value;
+  let out = null;
+  for (const [field, since] of Object.entries(fields)) {
+    if (field in value && !knows(version, since)) {
+      out ??= { ...value };
+      delete out[field];
+    }
+  }
+  return out ?? value;
+}
+var RESULT_PATH = /* @__PURE__ */ new Map([["fs.patch", "FsPatchResult"]]);
+function forPeer(op, part, value, version) {
+  if (part === "result") {
+    const path = op ? RESULT_PATH.get(op) : void 0;
+    return path ? strip(value, FIELDS_SINCE[path], version) : value;
+  }
+  if (value === null || typeof value !== "object") return value;
+  const body = value;
+  if (body.data === void 0) return value;
+  const data = strip(body.data, FIELDS_SINCE["ProtocolErrorBody.data"], version);
+  return data === body.data ? value : { ...body, data };
+}
+var VERSIONED_RESULT_OPS = [...RESULT_PATH.keys()];
 //# sourceMappingURL=index.cjs.map