macro-agent 0.0.17 → 0.1.1

package/src/agent/__tests__/agent-manager.test.ts

@@ -97,7 +97,7 @@ describe("AgentManager", () => {
 
         // Terminate one
         eventStore.emit({
-          type: "terminate",
+          type: "stop",
           source: { agent_id: "agent_2" },
           payload: { reason: "completed" },
         });
@@ -562,6 +562,82 @@ describe("AgentManager Integration (with mocked acp-factory)", () => {
       expect(cwdEnv.value).toBe("/test/cwd");
     });
 
+    it("should propagate OPENTASKS_SOCKET_PATH from config to child agents", async () => {
+      // Create manager with explicit socket path
+      await agentManager.close();
+      agentManager = createAgentManager(eventStore, messageRouter, {
+        openTasksSocketPath: "/tmp/opentasks.sock",
+        taskBackend: "opentasks",
+      });
+
+      await agentManager.spawn({
+        task: "Test task",
+        cwd: "/tmp",
+      });
+
+      const createSessionArgs = mockHandle.createSession.mock.calls[0];
+      const sessionOptions = createSessionArgs[1];
+      const macroAgentMcp = sessionOptions.mcpServers.find(
+        (s: any) => s.name === "macro-agent"
+      );
+
+      const socketPathEnv = macroAgentMcp.env.find(
+        (e: any) => e.name === "OPENTASKS_SOCKET_PATH"
+      );
+      expect(socketPathEnv).toBeDefined();
+      expect(socketPathEnv.value).toBe("/tmp/opentasks.sock");
+    });
+
+    it("should use setOpenTasksSocketPath to override config value", async () => {
+      // Create manager WITHOUT a socket path (simulates autoStart mode)
+      await agentManager.close();
+      agentManager = createAgentManager(eventStore, messageRouter, {
+        taskBackend: "opentasks",
+        // No openTasksSocketPath — simulating daemon auto-start
+      });
+
+      // Late-bind the runtime socket path (as createTaskBackend would provide)
+      agentManager.setOpenTasksSocketPath("/run/daemon/opentasks.sock");
+
+      await agentManager.spawn({
+        task: "Test task",
+        cwd: "/tmp",
+      });
+
+      const createSessionArgs = mockHandle.createSession.mock.calls[0];
+      const sessionOptions = createSessionArgs[1];
+      const macroAgentMcp = sessionOptions.mcpServers.find(
+        (s: any) => s.name === "macro-agent"
+      );
+
+      const socketPathEnv = macroAgentMcp.env.find(
+        (e: any) => e.name === "OPENTASKS_SOCKET_PATH"
+      );
+      expect(socketPathEnv).toBeDefined();
+      expect(socketPathEnv.value).toBe("/run/daemon/opentasks.sock");
+    });
+
+    it("should propagate empty OPENTASKS_SOCKET_PATH when not set", async () => {
+      // Manager with no socket path and no env var
+      await agentManager.spawn({
+        task: "Test task",
+        cwd: "/tmp",
+      });
+
+      const createSessionArgs = mockHandle.createSession.mock.calls[0];
+      const sessionOptions = createSessionArgs[1];
+      const macroAgentMcp = sessionOptions.mcpServers.find(
+        (s: any) => s.name === "macro-agent"
+      );
+
+      const socketPathEnv = macroAgentMcp.env.find(
+        (e: any) => e.name === "OPENTASKS_SOCKET_PATH"
+      );
+      expect(socketPathEnv).toBeDefined();
+      // Should be empty string when nothing is configured
+      expect(socketPathEnv.value).toBe("");
+    });
+
     it("should persist events after spawning for cross-process visibility", async () => {
       // Spy on eventStore.persist
       const persistSpy = vi.spyOn(eventStore, "persist");
@@ -700,6 +776,10 @@ describe("AgentManager Integration (with mocked acp-factory)", () => {
       expect(mockHandle.loadSession).toHaveBeenCalledWith(
         expect.any(String), // session ID
         "/custom/project/path",
+        expect.arrayContaining([
+          expect.objectContaining({ name: "macro-agent" }),
+        ]),
+        undefined,
       );
     });
 
@@ -717,6 +797,10 @@ describe("AgentManager Integration (with mocked acp-factory)", () => {
       expect(mockHandle.loadSession).toHaveBeenCalledWith(
         agent!.provider_session_id,
         expect.any(String),
+        expect.arrayContaining([
+          expect.objectContaining({ name: "macro-agent" }),
+        ]),
+        undefined,
       );
     });
 
@@ -745,7 +829,11 @@ describe("AgentManager Integration (with mocked acp-factory)", () => {
       await agentManager.resume(agentId);
 
       // Should create a new session instead of loading with invalid macro-agent session_id
-      expect(mockHandle.createSession).toHaveBeenCalledWith("/tmp");
+      expect(mockHandle.createSession).toHaveBeenCalledWith("/tmp", {
+        mcpServers: expect.arrayContaining([
+          expect.objectContaining({ name: "macro-agent" }),
+        ]),
+      });
       expect(mockHandle.loadSession).not.toHaveBeenCalled();
     });
   });
@@ -995,6 +1083,144 @@ describe("AgentManager Integration (with mocked acp-factory)", () => {
       expect(result).toBe(false);
     });
   });
+
+  describe("Process cleanup on spawn failure", () => {
+    it("should close handle when createSession throws", async () => {
+      mockHandle.createSession = vi.fn().mockRejectedValue(
+        new Error("Session creation failed")
+      );
+
+      await expect(
+        agentManager.spawn({ task: "Test", cwd: "/tmp" })
+      ).rejects.toThrow("Failed to spawn agent");
+
+      // The handle should have been closed to prevent orphaned process
+      expect(mockHandle.close).toHaveBeenCalled();
+    });
+
+    it("should not leave handle in activeSessions when createSession throws", async () => {
+      mockHandle.createSession = vi.fn().mockRejectedValue(
+        new Error("Session creation failed")
+      );
+
+      await expect(
+        agentManager.spawn({ task: "Test", cwd: "/tmp" })
+      ).rejects.toThrow();
+
+      // No active sessions should remain
+      const agents = agentManager.list({ state: "running" as any });
+      for (const agent of agents) {
+        expect(agentManager.hasActiveSession(agent.id)).toBe(false);
+      }
+    });
+
+    it("should close handle even if handle.close() itself throws", async () => {
+      mockHandle.createSession = vi.fn().mockRejectedValue(
+        new Error("Session creation failed")
+      );
+      mockHandle.close = vi.fn().mockRejectedValue(
+        new Error("Close also failed")
+      );
+
+      // Should still throw the original spawn error, not the close error
+      await expect(
+        agentManager.spawn({ task: "Test", cwd: "/tmp" })
+      ).rejects.toThrow("Failed to spawn agent");
+
+      // close() was attempted
+      expect(mockHandle.close).toHaveBeenCalled();
+    });
+  });
+
+  describe("Process cleanup on resume failure", () => {
+    it("should close handle when loadSession throws", async () => {
+      // Spawn and terminate to create a resumable agent
+      const spawned = await agentManager.spawn({ task: "Test" });
+      await agentManager.terminate(spawned.id, "completed");
+
+      // Make loadSession fail on resume
+      mockHandle.loadSession = vi.fn().mockRejectedValue(
+        new Error("Load session failed")
+      );
+
+      await expect(
+        agentManager.resume(spawned.id)
+      ).rejects.toThrow("Load session failed");
+
+      // The handle should have been closed to prevent orphaned process
+      expect(mockHandle.close).toHaveBeenCalledTimes(2); // once for terminate, once for failed resume
+    });
+
+    it("should close handle when createSession throws during resume (no provider_session_id)", async () => {
+      // Create agent directly without provider_session_id
+      const agentId = "agent_no_provider_resume";
+      eventStore.emit({
+        type: "spawn",
+        source: { agent_id: "system" },
+        payload: {
+          agent_id: agentId,
+          session_id: "session_no_provider_resume",
+          task: "Test",
+          parent: null,
+          cwd: "/tmp",
+        },
+      });
+      eventStore.emit({
+        type: "status",
+        source: { agent_id: agentId },
+        payload: { status_type: "started" },
+      });
+
+      // Make createSession fail on resume
+      mockHandle.createSession = vi.fn().mockRejectedValue(
+        new Error("Create session failed")
+      );
+
+      await expect(
+        agentManager.resume(agentId)
+      ).rejects.toThrow("Create session failed");
+
+      // The handle should have been closed
+      expect(mockHandle.close).toHaveBeenCalled();
+    });
+  });
+
+  describe("Shutdown guard", () => {
+    it("should reject spawn() after close() is called", async () => {
+      await agentManager.close();
+
+      await expect(
+        agentManager.spawn({ task: "Test", cwd: "/tmp" })
+      ).rejects.toThrow("Cannot spawn agent during shutdown");
+    });
+
+    it("should reject resume() after close() is called", async () => {
+      // Create a resumable agent before shutdown
+      const spawned = await agentManager.spawn({ task: "Test" });
+      await agentManager.terminate(spawned.id, "completed");
+
+      await agentManager.close();
+
+      await expect(
+        agentManager.resume(spawned.id)
+      ).rejects.toThrow("Cannot resume agent during shutdown");
+    });
+
+    it("should not spawn new processes after close()", async () => {
+      const { AgentFactory } = await import("acp-factory");
+      const spawnSpy = vi.mocked(AgentFactory.spawn);
+
+      await agentManager.close();
+      spawnSpy.mockClear();
+
+      await expect(
+        agentManager.spawn({ task: "Test", cwd: "/tmp" })
+      ).rejects.toThrow("Cannot spawn agent during shutdown");
+
+      // AgentFactory.spawn should never have been called
+      expect(spawnSpy).not.toHaveBeenCalled();
+    });
+  });
 });
 
 describe("AgentManager HealthCheckService Integration", () => {