chainlesschain 0.45.64 → 0.45.66

package/src/gateways/ws/worktree-protocol.js

@@ -2,44 +2,57 @@ import { createWorktreeRecord } from "../../runtime/contracts/worktree-record.js
 import {
   RUNTIME_EVENTS,
   createRuntimeEvent,
+  createCodingAgentEvent,
+  CODING_AGENT_EVENT_TYPES,
 } from "../../runtime/runtime-events.js";
 
+function envelopeResponse(type, id, payload) {
+  return createCodingAgentEvent(type, payload || {}, {
+    requestId: id,
+    source: "cli-runtime",
+  });
+}
+
+function envelopeError(id, code, message) {
+  return createCodingAgentEvent(
+    CODING_AGENT_EVENT_TYPES.ERROR,
+    { code, message },
+    { requestId: id, source: "cli-runtime" },
+  );
+}
+
 export async function handleWorktreeDiff(server, id, ws, message) {
   try {
     const { diffWorktree } = await import("../../lib/worktree-isolator.js");
     const { branch, baseBranch, filePath } = message;
     if (!branch) {
-      server._send(ws, {
-        id,
-        type: "error",
-        code: "NO_BRANCH",
-        message: "branch required",
-      });
+      server._send(ws, envelopeError(id, "NO_BRANCH", "branch required"));
       return;
     }
     const result = diffWorktree(process.cwd(), branch, {
       baseBranch,
       filePath,
     });
-    server._send(ws, {
-      id,
-      type: "worktree-diff",
-      filePath: result.filePath || filePath || null,
-      files: result.files,
-      summary: result.summary,
-      diff: result.diff,
-      record: createWorktreeRecord({
-        branch,
-        baseBranch,
+    server._send(
+      ws,
+      envelopeResponse(CODING_AGENT_EVENT_TYPES.WORKTREE_DIFF, id, {
+        filePath: result.filePath || filePath || null,
+        files: result.files,
         summary: result.summary,
-        previewEntrypoints: [
-          {
-            type: "worktree-diff",
-            branch,
-          },
-        ],
+        diff: result.diff,
+        record: createWorktreeRecord({
+          branch,
+          baseBranch,
+          summary: result.summary,
+          previewEntrypoints: [
+            {
+              type: "worktree-diff",
+              branch,
+            },
+          ],
+        }),
       }),
-    });
+    );
     server.emit(
       RUNTIME_EVENTS.WORKTREE_DIFF_READY,
       createRuntimeEvent(
@@ -64,12 +77,7 @@ export async function handleWorktreeDiff(server, id, ws, message) {
       ),
     );
   } catch (err) {
-    server._send(ws, {
-      id,
-      type: "error",
-      code: "WORKTREE_DIFF_FAILED",
-      message: err.message,
-    });
+    server._send(ws, envelopeError(id, "WORKTREE_DIFF_FAILED", err.message));
   }
 }
 
@@ -78,35 +86,31 @@ export async function handleWorktreeMerge(server, id, ws, message) {
     const { mergeWorktree } = await import("../../lib/worktree-isolator.js");
     const { branch, strategy, commitMessage } = message;
     if (!branch) {
-      server._send(ws, {
-        id,
-        type: "error",
-        code: "NO_BRANCH",
-        message: "branch required",
-      });
+      server._send(ws, envelopeError(id, "NO_BRANCH", "branch required"));
       return;
     }
     const result = mergeWorktree(process.cwd(), branch, {
       strategy: strategy || "merge",
       message: commitMessage,
     });
-    server._send(ws, {
-      id,
-      type: "worktree-merged",
-      ...result,
-      record: createWorktreeRecord(
-        {
-          branch,
-          summary: result.summary || null,
-          conflicts: result.conflicts || [],
-          previewEntrypoints: result.previewEntrypoints || [],
-        },
-        {
-          strategy: strategy || "merge",
-          success: result.success,
-        },
-      ),
-    });
+    server._send(
+      ws,
+      envelopeResponse(CODING_AGENT_EVENT_TYPES.WORKTREE_MERGED, id, {
+        ...result,
+        record: createWorktreeRecord(
+          {
+            branch,
+            summary: result.summary || null,
+            conflicts: result.conflicts || [],
+            previewEntrypoints: result.previewEntrypoints || [],
+          },
+          {
+            strategy: strategy || "merge",
+            success: result.success,
+          },
+        ),
+      }),
+    );
     server.emit(
       RUNTIME_EVENTS.WORKTREE_MERGED,
       createRuntimeEvent(
@@ -131,12 +135,7 @@ export async function handleWorktreeMerge(server, id, ws, message) {
       ),
     );
   } catch (err) {
-    server._send(ws, {
-      id,
-      type: "error",
-      code: "WORKTREE_MERGE_FAILED",
-      message: err.message,
-    });
+    server._send(ws, envelopeError(id, "WORKTREE_MERGE_FAILED", err.message));
   }
 }
 
@@ -146,12 +145,7 @@ export async function handleWorktreeMergePreview(server, id, ws, message) {
       await import("../../lib/worktree-isolator.js");
     const { branch, baseBranch, strategy } = message;
     if (!branch) {
-      server._send(ws, {
-        id,
-        type: "error",
-        code: "NO_BRANCH",
-        message: "branch required",
-      });
+      server._send(ws, envelopeError(id, "NO_BRANCH", "branch required"));
       return;
     }
 
@@ -159,32 +153,31 @@ export async function handleWorktreeMergePreview(server, id, ws, message) {
       baseBranch,
       strategy: strategy || "merge",
     });
-    server._send(ws, {
-      id,
-      type: "worktree-merge-preview",
-      ...result,
-      record: createWorktreeRecord(
-        {
-          branch,
-          baseBranch: result.baseBranch || baseBranch || null,
-          summary: result.summary || null,
-          conflicts: result.conflicts || [],
-          previewEntrypoints: result.previewEntrypoints || [],
-        },
-        {
-          strategy: strategy || "merge",
-          success: result.success,
-          previewOnly: true,
-        },
-      ),
-    });
+    server._send(
+      ws,
+      envelopeResponse(CODING_AGENT_EVENT_TYPES.WORKTREE_MERGE_PREVIEW, id, {
+        ...result,
+        record: createWorktreeRecord(
+          {
+            branch,
+            baseBranch: result.baseBranch || baseBranch || null,
+            summary: result.summary || null,
+            conflicts: result.conflicts || [],
+            previewEntrypoints: result.previewEntrypoints || [],
+          },
+          {
+            strategy: strategy || "merge",
+            success: result.success,
+            previewOnly: true,
+          },
+        ),
+      }),
+    );
   } catch (err) {
-    server._send(ws, {
-      id,
-      type: "error",
-      code: "WORKTREE_MERGE_PREVIEW_FAILED",
-      message: err.message,
-    });
+    server._send(
+      ws,
+      envelopeError(id, "WORKTREE_MERGE_PREVIEW_FAILED", err.message),
+    );
   }
 }
 
@@ -194,21 +187,18 @@ export async function handleWorktreeAutomationApply(server, id, ws, message) {
       await import("../../lib/worktree-isolator.js");
     const { branch, baseBranch, filePath, candidateId, conflictType } = message;
     if (!branch) {
-      server._send(ws, {
-        id,
-        type: "error",
-        code: "NO_BRANCH",
-        message: "branch required",
-      });
+      server._send(ws, envelopeError(id, "NO_BRANCH", "branch required"));
       return;
     }
     if (!filePath || !candidateId) {
-      server._send(ws, {
-        id,
-        type: "error",
-        code: "INVALID_WORKTREE_AUTOMATION",
-        message: "filePath and candidateId are required",
-      });
+      server._send(
+        ws,
+        envelopeError(
+          id,
+          "INVALID_WORKTREE_AUTOMATION",
+          "filePath and candidateId are required",
+        ),
+      );
       return;
     }
 
@@ -219,43 +209,46 @@ export async function handleWorktreeAutomationApply(server, id, ws, message) {
       conflictType,
     });
 
-    server._send(ws, {
-      id,
-      type: "worktree-automation-applied",
-      ...result,
-      record: createWorktreeRecord(
-        {
-          branch,
-          baseBranch: result.baseBranch || baseBranch || null,
-          hasChanges: (result.summary?.filesChanged || 0) > 0,
-          summary: result.summary || null,
-          conflicts: [],
-          previewEntrypoints:
-            result.filePath && (result.summary?.filesChanged || 0) > 0
-              ? [
-                  {
-                    type: "worktree-diff",
-                    branch,
-                    filePath: result.filePath,
-                  },
-                ]
-              : [],
-        },
+    server._send(
+      ws,
+      envelopeResponse(
+        CODING_AGENT_EVENT_TYPES.WORKTREE_AUTOMATION_APPLIED,
+        id,
         {
-          candidateId,
-          filePath,
-          conflictType: conflictType || null,
-          success: true,
+          ...result,
+          record: createWorktreeRecord(
+            {
+              branch,
+              baseBranch: result.baseBranch || baseBranch || null,
+              hasChanges: (result.summary?.filesChanged || 0) > 0,
+              summary: result.summary || null,
+              conflicts: [],
+              previewEntrypoints:
+                result.filePath && (result.summary?.filesChanged || 0) > 0
+                  ? [
+                      {
+                        type: "worktree-diff",
+                        branch,
+                        filePath: result.filePath,
+                      },
+                    ]
+                  : [],
+            },
+            {
+              candidateId,
+              filePath,
+              conflictType: conflictType || null,
+              success: true,
+            },
+          ),
         },
       ),
-    });
+    );
   } catch (err) {
-    server._send(ws, {
-      id,
-      type: "error",
-      code: "WORKTREE_AUTOMATION_FAILED",
-      message: err.message,
-    });
+    server._send(
+      ws,
+      envelopeError(id, "WORKTREE_AUTOMATION_FAILED", err.message),
+    );
   }
 }
 
@@ -265,14 +258,14 @@ export async function handleWorktreeList(server, id, ws) {
     const worktrees = listWorktrees(process.cwd()).filter(
       (wt) => wt.branch && wt.branch.startsWith("agent/"),
     );
-    server._send(ws, { id, type: "worktree-list", worktrees });
+    server._send(
+      ws,
+      envelopeResponse(CODING_AGENT_EVENT_TYPES.WORKTREE_LIST, id, {
+        worktrees,
+      }),
+    );
   } catch (err) {
-    server._send(ws, {
-      id,
-      type: "error",
-      code: "WORKTREE_LIST_FAILED",
-      message: err.message,
-    });
+    server._send(ws, envelopeError(id, "WORKTREE_LIST_FAILED", err.message));
   }
 }