@ai-devkit/agent-manager 0.41.0 → 0.42.0

package/src/__tests__/harnesses/muse/MuseAdapter.test.ts

@@ -0,0 +1,197 @@
+/**
+ * Tests for harnesses/muse/MuseAdapter.ts — detection through the real
+ * locator/parser/mapper against a fake Muse home (no mocks).
+ */
+
+import * as fs from "fs";
+import * as os from "os";
+import * as path from "path";
+import { AgentStatus } from "../../../adapters/AgentAdapter.js";
+import type { ProcessInfo } from "../../../adapters/AgentAdapter.js";
+import { MuseAdapter } from "../../../harnesses/muse/MuseAdapter.js";
+
+const SID = "01a12618-d918-7b63-91c8-4e896326eb1a";
+const PROJECT = "codeaholicguy/Code/ai-devkit";
+
+function frame(inner: unknown): string {
+  return JSON.stringify(inner);
+}
+
+function intent(text: string, recordedAtUs: number): unknown {
+  return {
+    schema_version: 1,
+    stream: { kind: "session", id: SID },
+    sequence: 2,
+    recorded_at: recordedAtUs,
+    record_type: "event",
+    payload_type: "runtime.user_intent.accepted",
+    payload: { refill_blocks: [{ kind: "text", text }] },
+  };
+}
+
+describe("MuseAdapter", () => {
+  let home: string;
+  let adapter: MuseAdapter;
+
+  beforeEach(() => {
+    home = fs.mkdtempSync(path.join(os.tmpdir(), "muse-adapter-test-"));
+    adapter = new MuseAdapter({ homeDir: home });
+  });
+
+  afterEach(() => {
+    fs.rmSync(home, { recursive: true, force: true });
+  });
+
+  function writeTranscript(lines: string[]): string {
+    const dir = path.join(home, ".local", "share", "muse", "sessions", "2026/10/10", SID);
+    fs.mkdirSync(dir, { recursive: true });
+    const filePath = path.join(dir, "session.jsonl");
+    fs.writeFileSync(filePath, lines.join("\n"));
+    return filePath;
+  }
+
+  function writeRuntimeFile(pid: number): void {
+    const dir = path.join(home, ".local", "share", "muse", "runtime", "muse", "sessions");
+    fs.mkdirSync(dir, { recursive: true });
+    fs.writeFileSync(
+      path.join(dir, `${SID}.json`),
+      JSON.stringify({ schema_version: 1, session_id: SID, process_generation_hint: `pid=${pid}` }),
+    );
+  }
+
+  function proc(overrides: Partial<ProcessInfo> = {}): ProcessInfo {
+    return {
+      pid: 16174,
+      command: "/Users/tester/.local/bin/muse-bin-1.4.4-R5419.1",
+      cwd: `/Users/tester/${PROJECT}`,
+      tty: "ttys001",
+      startTime: new Date(),
+      ...overrides,
+    };
+  }
+
+  it("handles versioned launcher commands and rejects others", () => {
+    expect(adapter.canHandle(proc())).toBe(true);
+    expect(adapter.canHandle(proc({ command: "/usr/local/bin/muse" }))).toBe(true);
+    expect(adapter.canHandle(proc({ command: "/usr/local/bin/claude" }))).toBe(false);
+    expect(adapter.canHandle(proc({ command: "/usr/bin/museums" }))).toBe(false);
+  });
+
+  it("detects a live session through the runtime file", async () => {
+    const filePath = writeTranscript([
+      frame({
+        schema_version: 1,
+        stream: { kind: "session", id: SID },
+        sequence: 1,
+        recorded_at: 1791640525332173,
+        record_type: "event",
+        payload_type: "runtime.session.metadata",
+        payload: {
+          kind: "metadata",
+          record: { workspace_root: `/Users/tester/${PROJECT}` },
+        },
+      }),
+      frame(intent("hello", 1791640525332174)),
+    ]);
+    writeRuntimeFile(16174);
+    const start = new Date(fs.statSync(filePath).birthtimeMs);
+
+    const agents = await adapter.detectAgents({ processes: [proc({ startTime: start })] });
+    expect(agents).toHaveLength(1);
+    expect(agents[0]).toMatchObject({
+      type: "muse",
+      pid: 16174,
+      sessionId: SID,
+      projectPath: `/Users/tester/${PROJECT}`,
+      summary: "hello",
+    });
+    expect(agents[0].sessionFilePath).toBe(filePath);
+  });
+
+  it("matches a process by cwd and birthtime without a runtime file", async () => {
+    const filePath = writeTranscript([
+      frame({
+        schema_version: 1,
+        stream: { kind: "session", id: SID },
+        sequence: 1,
+        recorded_at: 1791640525332173,
+        record_type: "event",
+        payload_type: "runtime.session.metadata",
+        payload: {
+          kind: "metadata",
+          record: { workspace_root: `/Users/tester/${PROJECT}` },
+        },
+      }),
+      frame(intent("legacy hello", 1791640525332174)),
+    ]);
+    const start = new Date(fs.statSync(filePath).birthtimeMs);
+
+    const agents = await adapter.detectAgents({
+      processes: [proc({ pid: 7777, startTime: start })],
+    });
+    expect(agents).toHaveLength(1);
+    expect(agents[0]).toMatchObject({
+      type: "muse",
+      pid: 7777,
+      sessionId: SID,
+      summary: "legacy hello",
+    });
+  });
+
+  it("skips transcripts with no conversation signal in history", async () => {
+    writeTranscript([
+      frame({
+        schema_version: 1,
+        stream: { kind: "session", id: SID },
+        sequence: 1,
+        recorded_at: 1791640525332173,
+        record_type: "event",
+        payload_type: "runtime.session.metadata",
+        payload: { kind: "metadata", record: { workspace_root: "/Users/tester/empty" } },
+      }),
+    ]);
+    expect(await adapter.listSessions()).toEqual([]);
+  });
+
+  it("reports an unmatched process as a running placeholder", async () => {
+    const agents = await adapter.detectAgents({ processes: [proc({ pid: 4242 })] });
+    expect(agents).toHaveLength(1);
+    expect(agents[0]).toMatchObject({
+      type: "muse",
+      status: AgentStatus.RUNNING,
+      sessionId: "pid-4242",
+    });
+  });
+
+  it("lists historical sessions with strict cwd filtering", async () => {
+    writeTranscript([
+      frame({
+        schema_version: 1,
+        stream: { kind: "session", id: SID },
+        sequence: 1,
+        recorded_at: 1791640525332173,
+        record_type: "event",
+        payload_type: "runtime.session.metadata",
+        payload: {
+          kind: "metadata",
+          record: { workspace_root: `/Users/tester/${PROJECT}` },
+        },
+      }),
+      frame(intent("hello", 1791640525332174)),
+    ]);
+
+    const all = await adapter.listSessions();
+    expect(all).toHaveLength(1);
+    expect(all[0]).toMatchObject({
+      type: "muse",
+      sessionId: SID,
+      cwd: `/Users/tester/${PROJECT}`,
+      firstUserMessage: "hello",
+    });
+
+    expect(await adapter.listSessions({ cwd: "/elsewhere" })).toEqual([]);
+    const found = await adapter.findSessionsById(SID);
+    expect(found.map((s) => s.sessionId)).toEqual([SID]);
+    expect(await adapter.findSessionsById("00000000-0000-0000-0000-000000000000")).toEqual([]);
+  });
+});

package/src/__tests__/harnesses/muse/MuseAgentMapper.test.ts

@@ -0,0 +1,83 @@
+import { AgentStatus } from "../../../adapters/AgentAdapter.js";
+import type { ProcessInfo } from "../../../adapters/AgentAdapter.js";
+import type { SessionFile } from "../../../utils/session.js";
+import { MuseAgentMapper } from "../../../harnesses/muse/MuseAgentMapper.js";
+import type { MuseSession } from "../../../harnesses/muse/MuseSessionParser.js";
+
+const SID = "01a12618-d918-7b63-91c8-4e896326eb1a";
+
+function session(overrides: Partial<MuseSession> = {}): MuseSession {
+  return {
+    sessionId: SID,
+    projectPath: "/Users/tester/proj",
+    sessionStart: new Date("2026-10-10T13:55:25.332Z"),
+    lastActive: new Date("2026-10-10T14:00:00.000Z"),
+    lastSignal: "assistant",
+    lastUserMessage: "what is this repo about",
+    firstUserMessage: "what is this repo about",
+    ...overrides,
+  };
+}
+
+function sessionFile(): SessionFile {
+  return {
+    sessionId: SID,
+    filePath: `/home/tester/.local/share/muse/sessions/2026/10/10/${SID}/session.jsonl`,
+    projectDir: `/home/tester/.local/share/muse/sessions/2026/10/10/${SID}`,
+    birthtimeMs: 1791640525332,
+    resolvedCwd: "/Users/tester/proj",
+  };
+}
+
+function proc(): ProcessInfo {
+  return {
+    pid: 16174,
+    command: "/Users/tester/.local/bin/muse-bin-1.4.4-R5419.1",
+    cwd: "/Users/tester/proj",
+    tty: "ttys001",
+  };
+}
+
+describe("MuseAgentMapper", () => {
+  const mapper = new MuseAgentMapper();
+
+  it("maps a session to a project-named agent", () => {
+    const agent = mapper.mapSessionToAgent({
+      session: session(),
+      processInfo: proc(),
+      sessionFile: sessionFile(),
+    });
+    expect(agent).toMatchObject({
+      name: "proj-16174",
+      type: "muse",
+      status: AgentStatus.WAITING,
+      summary: "what is this repo about",
+      pid: 16174,
+      projectPath: "/Users/tester/proj",
+      sessionId: SID,
+    });
+    expect(agent.lastActive).toEqual(new Date("2026-10-10T14:00:00.000Z"));
+    expect(agent.sessionFilePath).toContain("session.jsonl");
+  });
+
+  it("falls back to a started summary and process cwd without workspace root", () => {
+    const agent = mapper.mapSessionToAgent({
+      session: session({ projectPath: "", lastUserMessage: undefined, lastSignal: undefined }),
+      processInfo: proc(),
+      sessionFile: { ...sessionFile(), resolvedCwd: "" },
+    });
+    expect(agent.summary).toBe("Session started");
+    expect(agent.projectPath).toBe("/Users/tester/proj");
+    expect(agent.status).toBe(AgentStatus.UNKNOWN);
+  });
+
+  it("maps an unmatched process to a running placeholder", () => {
+    const agent = mapper.mapProcessOnlyAgent(proc());
+    expect(agent).toMatchObject({
+      type: "muse",
+      status: AgentStatus.RUNNING,
+      pid: 16174,
+      sessionId: "pid-16174",
+    });
+  });
+});

package/src/__tests__/harnesses/muse/MuseSessionLocator.test.ts

@@ -0,0 +1,177 @@
+/**
+ * Tests for harnesses/muse/MuseSessionLocator.ts — runtime-file matching,
+ * dated-archive discovery, and session lookup by id.
+ */
+
+import * as fs from "fs";
+import * as os from "os";
+import * as path from "path";
+import type { ProcessInfo } from "../../../adapters/AgentAdapter.js";
+import { MuseSessionLocator } from "../../../harnesses/muse/MuseSessionLocator.js";
+
+const SID = "01a12618-d918-7b63-91c8-4e896326eb1a";
+const OTHER_SID = "2288dbd2-d703-444d-afce-59e40a8ad8b1";
+
+function frame(inner: unknown): string {
+  return JSON.stringify(inner);
+}
+
+function intent(text: string, recordedAtUs: number): unknown {
+  return {
+    schema_version: 1,
+    stream: { kind: "session", id: SID },
+    sequence: 2,
+    recorded_at: recordedAtUs,
+    record_type: "event",
+    payload_type: "runtime.user_intent.accepted",
+    payload: { refill_blocks: [{ kind: "text", text }] },
+  };
+}
+
+function metadata(workspaceRoot: string, recordedAtUs: number): unknown {
+  return {
+    schema_version: 1,
+    stream: { kind: "session", id: SID },
+    sequence: 1,
+    recorded_at: recordedAtUs,
+    record_type: "event",
+    payload_type: "runtime.session.metadata",
+    payload: { kind: "metadata", record: { workspace_root: workspaceRoot } },
+  };
+}
+
+function proc(pid: number, cwd: string, startTime: Date): ProcessInfo {
+  return {
+    pid,
+    command: `/Users/tester/.local/bin/muse-bin-1.4.4-R5419.1`,
+    cwd,
+    tty: "ttys001",
+    startTime,
+  };
+}
+
+describe("MuseSessionLocator", () => {
+  let home: string;
+  let locator: MuseSessionLocator;
+
+  beforeEach(() => {
+    home = fs.mkdtempSync(path.join(os.tmpdir(), "muse-locator-test-"));
+    locator = new MuseSessionLocator({ homeDir: home });
+  });
+
+  afterEach(() => {
+    fs.rmSync(home, { recursive: true, force: true });
+  });
+
+  function writeTranscript(sessionId: string, dayDir: string, lines: string[]): string {
+    const dir = path.join(home, ".local", "share", "muse", "sessions", dayDir, sessionId);
+    fs.mkdirSync(dir, { recursive: true });
+    const filePath = path.join(dir, "session.jsonl");
+    fs.writeFileSync(filePath, lines.join("\n"));
+    return filePath;
+  }
+
+  function writeRuntimeFile(sessionId: string, pid: number): string {
+    const dir = path.join(home, ".local", "share", "muse", "runtime", "muse", "sessions");
+    fs.mkdirSync(dir, { recursive: true });
+    const filePath = path.join(dir, `${sessionId}.jsonl`.replace(".jsonl", ".json"));
+    fs.writeFileSync(
+      filePath,
+      JSON.stringify({
+        schema_version: 1,
+        session_id: sessionId,
+        process_generation_hint: `pid=${pid}`,
+      }),
+    );
+    return filePath;
+  }
+
+  it("matches a live process to its transcript via the runtime file", () => {
+    const now = Date.now();
+    const filePath = writeTranscript(SID, "2026/10/10", [
+      frame(metadata("/Users/tester/proj", now * 1000)),
+      frame(intent("hello", now * 1000)),
+    ]);
+    writeRuntimeFile(SID, 16174);
+    // Align file birthtime with process start for the staleness guard.
+    const start = new Date(fs.statSync(filePath).birthtimeMs);
+
+    const { direct } = locator.matchRunningProcesses([proc(16174, "/Users/tester/proj", start)]);
+    expect(direct).toHaveLength(1);
+    expect(direct[0].process.pid).toBe(16174);
+    expect(direct[0].sessionFile.filePath).toBe(filePath);
+    expect(direct[0].sessionFile.sessionId).toBe(SID);
+  });
+
+  it("rejects runtime matches when the pid was recycled", () => {
+    writeTranscript(SID, "2026/10/10", [frame(intent("hello", 1791640525332173))]);
+    writeRuntimeFile(SID, 16174);
+
+    // Process started an hour after the session file was born: recycled pid.
+    const { direct, fallback } = locator.matchRunningProcesses([
+      proc(16174, "/Users/tester/proj", new Date(Date.now() + 3600_000)),
+    ]);
+    expect(direct).toHaveLength(0);
+    expect(fallback.map((p) => p.pid)).toContain(16174);
+  });
+
+  it("ignores malformed runtime files (processes fall through to legacy)", () => {
+    writeTranscript(SID, "2026/10/10", [frame(intent("hello", 1791640525332173))]);
+    const dir = path.join(home, ".local", "share", "muse", "runtime", "muse", "sessions");
+    fs.mkdirSync(dir, { recursive: true });
+    fs.writeFileSync(path.join(dir, `${SID}.json`), "not json");
+    fs.writeFileSync(
+      path.join(dir, "other.json"),
+      JSON.stringify({ session_id: "other", process_generation_hint: "nonsense" }),
+    );
+
+    // Non-muse processes never reach the locator: the adapter pre-filters via canHandle.
+    const { direct, fallback } = locator.matchRunningProcesses([
+      proc(16174, "/Users/tester/proj", new Date()),
+    ]);
+    expect(direct).toHaveLength(0);
+    expect(fallback.map((p) => p.pid)).toEqual([16174]);
+  });
+
+  it("discovers historical sessions across dated dirs, skipping noise", () => {
+    writeTranscript(SID, "2026/10/10", [frame(intent("hello", 1791640525332173))]);
+    writeTranscript(OTHER_SID, "2026/10/09", [frame(intent("world", 1791640525332173))]);
+    // Noise: subagent-style nested dir without session.jsonl, stray files.
+    const noise = path.join(
+      home,
+      ".local",
+      "share",
+      "muse",
+      "sessions",
+      "2026/10/10",
+      "not-a-uuid",
+    );
+    fs.mkdirSync(noise, { recursive: true });
+    fs.writeFileSync(path.join(noise, "notes.txt"), "hi");
+
+    const found = locator.discoverHistoricalSessionFiles();
+    expect(found.map((f) => f.filePath).sort()).toEqual(
+      [
+        path.join(
+          home,
+          ".local",
+          "share",
+          "muse",
+          "sessions",
+          "2026/10/09",
+          OTHER_SID,
+          "session.jsonl",
+        ),
+        path.join(home, ".local", "share", "muse", "sessions", "2026/10/10", SID, "session.jsonl"),
+      ].sort(),
+    );
+  });
+
+  it("finds a session file by id without enumerating everything", () => {
+    const filePath = writeTranscript(SID, "2026/10/10", [frame(intent("hello", 1791640525332173))]);
+    const found = locator.findHistoricalSessionFilesById(SID);
+    expect(found).toEqual([{ filePath, defaultCwd: "" }]);
+    expect(locator.findHistoricalSessionFilesById("nope")).toEqual([]);
+    expect(locator.findHistoricalSessionFilesById("../evil")).toEqual([]);
+  });
+});