@ai-matrx/desktop-protocol 0.4.0 → 0.6.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,
@@ -99,6 +100,7 @@ __export(src_exports, {
   HelloMsg: () => HelloMsg,
   Limits: () => Limits,
   NAMED_SCHEMAS: () => NAMED_SCHEMAS,
+  NULL_SINCE: () => NULL_SINCE,
   OPS: () => OPS,
   OpDescriptor: () => OpDescriptor,
   OsPermissionName: () => OsPermissionName,
@@ -112,6 +114,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,
@@ -142,26 +145,34 @@ __export(src_exports, {
   StreamMsg: () => StreamMsg,
   SysinfoGetParams: () => SysinfoGetParams,
   SysinfoGetResult: () => SysinfoGetResult,
+  VERSIONED_RESULT_OPS: () => VERSIONED_RESULT_OPS,
   Welcome: () => Welcome,
+  announcedVersion: () => announcedVersion,
   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,
-  u32: () => u32
+  statusForPeer: () => statusForPeer,
+  u32: () => u32,
+  versionSubprotocol: () => versionSubprotocol
 });
 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_-]+$/);
@@ -655,8 +666,10 @@ var FsPatchResult = import_zod6.z.strictObject({
   applied: nonNegInt,
   size: nonNegInt,
   mtime_ms: epochMs,
-  edits_applied: import_zod6.z.array(FsPatchEditApplied).max(256),
-  edits_failed: import_zod6.z.array(FsPatchEditFailure).max(256)
+  /** 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),
@@ -796,7 +809,11 @@ var SessionControlChangedEvent = import_zod8.z.strictObject({ controller_client_
 var import_zod9 = require("zod");
 var RelayDeviceStatusEvent = import_zod9.z.strictObject({
   online: import_zod9.z.boolean(),
-  since_ms: epochMs,
+  /**
+   * When the device last went online/offline; null = it has never connected (since 1.1 —
+   * NULL_SINCE: a 1.0 reader is sent 0, its old meaning).
+   */
+  since_ms: epochMs.nullable(),
   app_version: import_zod9.z.string().max(32).nullable(),
   protocol_version: ProtocolVersion.nullable()
 });
@@ -807,9 +824,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";
@@ -964,4 +992,67 @@ 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" }
+};
+var NULL_SINCE = {
+  "RelayDeviceStatusEvent.since_ms": { since: "1.1", olderPeersGet: 0 }
+};
+function statusForPeer(status, version) {
+  const rule = NULL_SINCE["RelayDeviceStatusEvent.since_ms"];
+  return status.since_ms === null && !knows(version, rule.since) ? { ...status, since_ms: rule.olderPeersGet } : status;
+}
+function versionSubprotocol(version) {
+  return `matrx.v${version}`;
+}
+function announcedVersion(offered) {
+  let best = `${PROTOCOL_MAJOR}.0`;
+  for (const p of offered) {
+    const m = /^matrx\.v(\d+\.\d+)$/.exec(p.trim());
+    if (m?.[1] && compareVersions(m[1], best) > 0 && m[1].startsWith(`${PROTOCOL_MAJOR}.`)) best = m[1];
+  }
+  return best;
+}
+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