@ai-matrx/desktop-protocol 0.4.0 → 0.6.0

package/CHANGELOG.md

@@ -1,5 +1,35 @@
 # Changelog
 
+## 0.6.0
+
+- `RelayDeviceStatusEvent.since_ms` is `null` for a device that has never connected (protocol 1.1;
+  `NULL_SINCE`): a 1.0 reader is sent `0`, its old meaning (`statusForPeer`).
+- A WebSocket client may announce its minor at connect by also offering
+  `versionSubprotocol(PROTOCOL_VERSION)` (e.g. `matrx.v1.1`) beside `SUBPROTOCOL`;
+  `announcedVersion(offered)` reads it (servers still answer `SUBPROTOCOL`).
+- The versioning test also refuses a 1.0 field changing type, except a widening to null listed in
+  `NULL_SINCE`.
+
+Consumer action: treat `since_ms: null` as "never connected"; offer the version subprotocol.
+
+## 0.5.0
+
+Version skew is the normal state, so a minor protocol addition must never make an older peer
+fail. Protocol 1.1 (`PROTOCOL_MINOR` 1) and a rule that keeps it that way (`src/versioning.ts`):
+
+- Fields added after 1.0 are optional on read and listed in `FIELDS_SINCE` (exported, and in both
+  generated sides): `FsPatchResult.edits_applied/edits_failed`, `ProtocolErrorBody.data.edits_failed`,
+  `RelayCallResponse.protocol_version`.
+- `forPeer(op, "result" | "error", value, version)` strips fields a peer's negotiated version does
+  not know; `negotiate`, `knows`, `compareVersions`.
+- /call: the caller announces its version in `RELAY_CALL_VERSION_HEADER`; the relay then reports
+  the version the device negotiated (`protocol_version`).
+- `src/versioning.test.ts` fails when any object that existed in 1.0 gains a required field, or a
+  new field is not in `FIELDS_SINCE` (baseline: `generated/baseline/desktop-protocol-1.0.schema.json`).
+
+Consumer action: a writer applies `forPeer` before sending to a peer (the desktop core and relay
+do); a reader that needs a 1.1 field handles its absence from a 1.0 peer explicitly.
+
 ## 0.4.0
 
 fs.patch reports every edit, as the cloud sandbox daemon does (recorded from a live sandbox:

package/dist/client.cjs

@@ -124,7 +124,7 @@ var import_zod2 = require("zod");
 // 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_-]+$/);
@@ -503,8 +503,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),
@@ -644,7 +646,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()
 });
@@ -656,8 +662,18 @@ var RelayCallRequest = import_zod9.z.strictObject({
   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 })
+  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";