🤖 fix: normalize legacy mux metadata

_Generated with `mux`_

Author: ammar-agent

src/constants/events.ts

@@ -49,16 +49,12 @@ export const CUSTOM_EVENTS = {
    * Event to execute a command from the command palette
    * Detail: { commandId: string }
    */
-<<<<<<< HEAD
   EXECUTE_COMMAND: "mux:executeCommand",
   /**
    * Event to enter the chat-based workspace creation experience.
    * Detail: { projectPath: string, startMessage?: string, model?: string, trunkBranch?: string, runtime?: string }
    */
   START_WORKSPACE_CREATION: "mux:startWorkspaceCreation",
-=======
-  EXECUTE_COMMAND: "mux:executeCommand",
->>>>>>> a3cb9358 (🤖 chore: rename cmux refs to mux)
 } as const;
 
 /**

src/services/historyService.test.ts

@@ -99,6 +99,25 @@ describe("HistoryService", () => {
       }
     });
 
+    it("hydrates legacy cmuxMetadata entries", async () => {
+      const workspaceId = "workspace-legacy";
+      const workspaceDir = config.getSessionDir(workspaceId);
+      await fs.mkdir(workspaceDir, { recursive: true });
+
+      const legacyMessage = createMuxMessage("msg-legacy", "user", "legacy", {
+        historySequence: 0,
+      });
+      (legacyMessage.metadata as Record<string, unknown>).cmuxMetadata = { type: "normal" };
+
+      const chatPath = path.join(workspaceDir, "chat.jsonl");
+      await fs.writeFile(chatPath, JSON.stringify({ ...legacyMessage, workspaceId }) + "\n");
+
+      const result = await service.getHistory(workspaceId);
+      expect(result.success).toBe(true);
+      if (result.success) {
+        expect(result.data[0].metadata?.muxMetadata?.type).toBe("normal");
+      }
+    });
     it("should handle empty lines in history file", async () => {
       const workspaceId = "workspace1";
       const workspaceDir = config.getSessionDir(workspaceId);

src/services/historyService.ts

@@ -8,6 +8,7 @@ import { workspaceFileLocks } from "@/utils/concurrency/workspaceFileLocks";
 import { log } from "./log";
 import { getTokenizerForModel } from "@/utils/main/tokenizer";
 import { KNOWN_MODELS } from "@/constants/knownModels";
+import { normalizeLegacyMuxMetadata } from "@/utils/messages/legacy";
 
 /**
  * HistoryService - Manages chat history persistence and sequence numbering
@@ -49,7 +50,7 @@ export class HistoryService {
       for (let i = 0; i < lines.length; i++) {
         try {
           const message = JSON.parse(lines[i]) as MuxMessage;
-          messages.push(message);
+          messages.push(normalizeLegacyMuxMetadata(message));
         } catch (parseError) {
           // Skip malformed lines but log error for debugging
           console.error(

src/services/partialService.test.ts

@@ -1,10 +1,13 @@
 /* eslint-disable @typescript-eslint/unbound-method */
-import { describe, test, expect, beforeEach, mock } from "bun:test";
+import { describe, test, expect, beforeEach, afterEach, mock } from "bun:test";
 import { PartialService } from "./partialService";
 import type { HistoryService } from "./historyService";
-import type { Config } from "@/config";
-import type { MuxMessage } from "@/types/message";
+import { Config } from "@/config";
+import { createMuxMessage, type MuxMessage } from "@/types/message";
 import { Ok } from "@/types/result";
+import * as fs from "fs/promises";
+import * as path from "path";
+import * as os from "os";
 
 // Mock Config
 const createMockConfig = (): Config => {
@@ -194,3 +197,36 @@ describe("PartialService - Error Recovery", () => {
     expect(deletePartial).toHaveBeenCalledWith(workspaceId);
   });
 });
+
+describe("PartialService - Legacy compatibility", () => {
+  let tempDir: string;
+  let config: Config;
+  let partialService: PartialService;
+
+  beforeEach(async () => {
+    tempDir = await fs.mkdtemp(path.join(os.tmpdir(), "mux-partial-legacy-"));
+    config = new Config(tempDir);
+    partialService = new PartialService(config, createMockHistoryService());
+  });
+
+  afterEach(async () => {
+    await fs.rm(tempDir, { recursive: true, force: true });
+  });
+
+  test("readPartial upgrades legacy cmuxMetadata", async () => {
+    const workspaceId = "legacy-ws";
+    const workspaceDir = config.getSessionDir(workspaceId);
+    await fs.mkdir(workspaceDir, { recursive: true });
+
+    const partialMessage = createMuxMessage("partial-1", "assistant", "legacy", {
+      historySequence: 0,
+    });
+    (partialMessage.metadata as Record<string, unknown>).cmuxMetadata = { type: "normal" };
+
+    const partialPath = path.join(workspaceDir, "partial.json");
+    await fs.writeFile(partialPath, JSON.stringify(partialMessage));
+
+    const result = await partialService.readPartial(workspaceId);
+    expect(result?.metadata?.muxMetadata?.type).toBe("normal");
+  });
+});

src/services/partialService.ts

@@ -6,6 +6,7 @@ import type { MuxMessage } from "@/types/message";
 import type { Config } from "@/config";
 import type { HistoryService } from "./historyService";
 import { workspaceFileLocks } from "@/utils/concurrency/workspaceFileLocks";
+import { normalizeLegacyMuxMetadata } from "@/utils/messages/legacy";
 
 /**
  * PartialService - Manages partial message persistence for interrupted streams
@@ -48,7 +49,8 @@ export class PartialService {
     try {
       const partialPath = this.getPartialPath(workspaceId);
       const data = await fs.readFile(partialPath, "utf-8");
-      return JSON.parse(data) as MuxMessage;
+      const message = JSON.parse(data) as MuxMessage;
+      return normalizeLegacyMuxMetadata(message);
     } catch (error) {
       if (error && typeof error === "object" && "code" in error && error.code === "ENOENT") {
         return null; // No partial exists

src/utils/messages/legacy.ts

@@ -0,0 +1,39 @@
+import type { MuxFrontendMetadata, MuxMessage, MuxMetadata } from "@/types/message";
+
+interface LegacyMuxMetadata extends MuxMetadata {
+  cmuxMetadata?: MuxFrontendMetadata;
+}
+
+/**
+ * Normalize persisted messages that were stored before the mux rename.
+ *
+ * Older builds recorded frontend metadata under `metadata.cmuxMetadata`.
+ * After the rename, the field lives under `metadata.muxMetadata`.
+ *
+ * This helper upgrades the legacy field on read so UI code keeps working.
+ */
+export function normalizeLegacyMuxMetadata(message: MuxMessage): MuxMessage {
+  const metadata = message.metadata as LegacyMuxMetadata | undefined;
+  if (metadata?.cmuxMetadata === undefined) {
+    return message;
+  }
+
+  const { cmuxMetadata, ...rest } = metadata;
+  const normalizedMetadata: MuxMetadata = rest;
+
+  if (metadata.muxMetadata) {
+    // Message already has the new field; just drop the legacy copy.
+    return {
+      ...message,
+      metadata: normalizedMetadata,
+    };
+  }
+
+  return {
+    ...message,
+    metadata: {
+      ...normalizedMetadata,
+      muxMetadata: cmuxMetadata,
+    },
+  };
+}