@ai-matrx/desktop-protocol 0.3.0 → 0.5.0

package/CHANGELOG.md

@@ -1,5 +1,37 @@
 # Changelog
 
+## 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:
+matrx-desktop `test/fixtures/sandbox-daemon/observed.json`, `patch_cases`).
+
+- `FsPatchResult` gains `edits_applied` (`{ edit_index, mode: "create" | "replace" |
+  "replace_all", matches_replaced? }`, `matches_replaced` only for replace_all) and `edits_failed`
+  (`{ edit_index, reason }`, the daemon's reason text verbatim). `applied` stays (= the count).
+- When every edit fails (CONFLICT, reason `patch_no_match` / `patch_ambiguous`), the error's
+  `data.edits_failed` lists them — the daemon's 422 `failures`.
+
+Consumer action: none required (additive). Read `edits_failed` instead of reconstructing it from
+`applied`.
+
 ## 0.3.0
 
 SPEC 6.1 sandbox parity: every search and list op now answers exactly what the cloud 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_-]+$/);
@@ -184,6 +184,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),
@@ -198,6 +199,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,
@@ -489,7 +492,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,
@@ -640,8 +658,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";