@soleri/core 9.10.0 → 9.12.1

package/src/__tests__/subagent/dispatcher.test.ts

@@ -154,11 +154,11 @@ describe('SubagentDispatcher', () => {
     dispatcher.cleanup();
   });
 
-  it('reapOrphans() returns orphaned results when processes are dead', () => {
+  it('reapOrphans() returns ReapResult with empty arrays when no processes tracked', () => {
     // reapOrphans delegates to the internal OrphanReaper
-    // Without registering processes, it should return empty
-    const orphaned = dispatcher.reapOrphans();
-    expect(orphaned).toEqual([]);
+    // Without registering processes, it should return empty reaped/alive
+    const result = dispatcher.reapOrphans();
+    expect(result).toEqual({ reaped: [], alive: [] });
   });
 
   it('dispatch() stops on first failure in sequential mode', async () => {
@@ -192,4 +192,122 @@ describe('SubagentDispatcher', () => {
     expect(updates.length).toBeGreaterThanOrEqual(1);
     expect(updates[0][0]).toBe('cb-test');
   });
+
+  // ── Timeout + process killing ─────────────────────────────────────
+
+  it('dispatch() returns timeout error when task exceeds timeout', async () => {
+    vi.useFakeTimers();
+
+    (mockAdapter.execute as ReturnType<typeof vi.fn>).mockImplementation(
+      () => new Promise(() => {}), // never resolves
+    );
+
+    const tasks = [makeTask({ taskId: 'timeout-task' })];
+    const dispatchPromise = dispatcher.dispatch(tasks, { parallel: false, timeout: 1000 });
+
+    await vi.advanceTimersByTimeAsync(1000);
+
+    const result = await dispatchPromise;
+    expect(result.failed).toBe(1);
+    expect(result.results[0].error).toBe('Task timed out');
+
+    vi.useRealTimers();
+  });
+
+  it('dispatch() passes onMeta callback to adapter for pid reporting', async () => {
+    let capturedOnMeta: ((meta: Record<string, unknown>) => void) | undefined;
+
+    (mockAdapter.execute as ReturnType<typeof vi.fn>).mockImplementation(async (ctx) => {
+      capturedOnMeta = ctx.onMeta;
+      // Simulate adapter reporting its PID
+      ctx.onMeta?.({ pid: 42 });
+      return { exitCode: 0, summary: 'done' };
+    });
+
+    const tasks = [makeTask({ taskId: 'meta-test' })];
+    const result = await dispatcher.dispatch(tasks, { parallel: false });
+
+    expect(capturedOnMeta).toBeDefined();
+    expect(result.results[0].pid).toBe(42);
+    expect(result.completed).toBe(1);
+  });
+
+  it('dispatch() kills child process on timeout when pid is reported', async () => {
+    vi.useFakeTimers();
+
+    const killSpy = vi.spyOn(process, 'kill');
+    let sigkillSent = false;
+    killSpy.mockImplementation((_pid: number, signal?: string | number) => {
+      if (signal === 0) {
+        // Process alive until SIGKILL
+        if (sigkillSent) {
+          const err = new Error('No such process') as NodeJS.ErrnoException;
+          err.code = 'ESRCH';
+          throw err;
+        }
+        return true;
+      }
+      if (signal === 'SIGTERM') return true;
+      if (signal === 'SIGKILL') {
+        sigkillSent = true;
+        return true;
+      }
+      return true;
+    });
+
+    (mockAdapter.execute as ReturnType<typeof vi.fn>).mockImplementation(async (ctx) => {
+      // Report PID immediately
+      ctx.onMeta?.({ pid: 9876 });
+      // Then hang forever (simulate stuck process)
+      return new Promise(() => {});
+    });
+
+    const tasks = [makeTask({ taskId: 'kill-test' })];
+    const dispatchPromise = dispatcher.dispatch(tasks, { parallel: false, timeout: 500 });
+
+    // Trigger the timeout
+    await vi.advanceTimersByTimeAsync(500);
+
+    const result = await dispatchPromise;
+    expect(result.failed).toBe(1);
+    expect(result.results[0].error).toBe('Task timed out');
+    expect(result.results[0].pid).toBe(9876);
+
+    // Verify SIGTERM was sent
+    expect(killSpy).toHaveBeenCalledWith(9876, 'SIGTERM');
+
+    // Advance past the 5s grace period to trigger SIGKILL escalation
+    await vi.advanceTimersByTimeAsync(5_000);
+    expect(killSpy).toHaveBeenCalledWith(9876, 'SIGKILL');
+
+    killSpy.mockRestore();
+    vi.useRealTimers();
+  });
+
+  it('dispatch() does not attempt kill when no pid is reported', async () => {
+    vi.useFakeTimers();
+
+    const killSpy = vi.spyOn(process, 'kill');
+    killSpy.mockImplementation(() => true);
+
+    (mockAdapter.execute as ReturnType<typeof vi.fn>).mockImplementation(
+      () => new Promise(() => {}), // never resolves, no pid reported
+    );
+
+    const tasks = [makeTask({ taskId: 'no-pid-task' })];
+    const dispatchPromise = dispatcher.dispatch(tasks, { parallel: false, timeout: 500 });
+
+    await vi.advanceTimersByTimeAsync(500);
+
+    const result = await dispatchPromise;
+    expect(result.failed).toBe(1);
+    expect(result.results[0].error).toBe('Task timed out');
+
+    // No SIGTERM or SIGKILL should have been sent (only signal-0 checks from reaper are possible)
+    const termCalls = killSpy.mock.calls.filter((c) => c[1] === 'SIGTERM' || c[1] === 'SIGKILL');
+    expect(termCalls).toHaveLength(0);
+
+    killSpy.mockRestore();
+    vi.useRealTimers();
+  });
 });

package/src/__tests__/subagent/orphan-reaper.test.ts

@@ -28,7 +28,7 @@ describe('OrphanReaper', () => {
     expect(reaper.listTracked()).toHaveLength(0);
   });
 
-  it('reap() returns empty when all processes are alive', () => {
+  it('reap() returns empty reaped when all processes are alive', () => {
     // process.kill(pid, 0) succeeds = process alive
     killSpy.mockImplementation(() => true);
 
@@ -36,8 +36,9 @@ describe('OrphanReaper', () => {
     reaper.register(1234, 'task-1');
     reaper.register(5678, 'task-2');
 
-    const reaped = reaper.reap();
-    expect(reaped).toHaveLength(0);
+    const result = reaper.reap();
+    expect(result.reaped).toHaveLength(0);
+    expect(result.alive).toEqual(['task-1', 'task-2']);
     expect(reaper.listTracked()).toHaveLength(2);
   });
 
@@ -51,10 +52,9 @@ describe('OrphanReaper', () => {
     const reaper = new OrphanReaper();
     reaper.register(1234, 'task-1');
 
-    const reaped = reaper.reap();
-    expect(reaped).toHaveLength(1);
-    expect(reaped[0].taskId).toBe('task-1');
-    expect(reaped[0].pid).toBe(1234);
+    const result = reaper.reap();
+    expect(result.reaped).toEqual(['task-1']);
+    expect(result.alive).toHaveLength(0);
     // Dead process should be removed from tracking
     expect(reaper.isTracked(1234)).toBe(false);
   });
@@ -84,8 +84,9 @@ describe('OrphanReaper', () => {
     const reaper = new OrphanReaper();
     reaper.register(1234, 'task-1');
 
-    const reaped = reaper.reap();
-    expect(reaped).toHaveLength(0);
+    const result = reaper.reap();
+    expect(result.reaped).toHaveLength(0);
+    expect(result.alive).toEqual(['task-1']);
     expect(reaper.isTracked(1234)).toBe(true);
   });
 
@@ -132,10 +133,145 @@ describe('OrphanReaper', () => {
     reaper.register(1234, 'task-alive');
     reaper.register(5678, 'task-dead');
 
-    const reaped = reaper.reap();
-    expect(reaped).toHaveLength(1);
-    expect(reaped[0].taskId).toBe('task-dead');
+    const result = reaper.reap();
+    expect(result.reaped).toEqual(['task-dead']);
+    expect(result.alive).toEqual(['task-alive']);
     expect(reaper.isTracked(1234)).toBe(true);
     expect(reaper.isTracked(5678)).toBe(false);
   });
+
+  // ── isAlive (public) ──────────────────────────────────────────────
+
+  it('isAlive() returns true when process.kill(pid, 0) succeeds', () => {
+    killSpy.mockImplementation(() => true);
+    const reaper = new OrphanReaper();
+    expect(reaper.isAlive(1234)).toBe(true);
+  });
+
+  it('isAlive() returns true for EPERM (process exists, no permission)', () => {
+    killSpy.mockImplementation(() => {
+      const err = new Error('Operation not permitted') as NodeJS.ErrnoException;
+      err.code = 'EPERM';
+      throw err;
+    });
+    const reaper = new OrphanReaper();
+    expect(reaper.isAlive(1234)).toBe(true);
+  });
+
+  it('isAlive() returns false for ESRCH (process dead)', () => {
+    killSpy.mockImplementation(() => {
+      const err = new Error('No such process') as NodeJS.ErrnoException;
+      err.code = 'ESRCH';
+      throw err;
+    });
+    const reaper = new OrphanReaper();
+    expect(reaper.isAlive(1234)).toBe(false);
+  });
+
+  // ── killProcess ───────────────────────────────────────────────────
+
+  describe('killProcess', () => {
+    it('returns killed=true with SIGTERM when process is already dead', async () => {
+      killSpy.mockImplementation(() => {
+        const err = new Error('No such process') as NodeJS.ErrnoException;
+        err.code = 'ESRCH';
+        throw err;
+      });
+
+      const reaper = new OrphanReaper();
+      const result = await reaper.killProcess(9999);
+      expect(result.killed).toBe(true);
+      expect(result.signal).toBe('SIGTERM');
+    });
+
+    it('sends SIGTERM and returns killed=true when process dies from SIGTERM', async () => {
+      let termSent = false;
+      killSpy.mockImplementation((_pid: number, signal?: string | number) => {
+        if (signal === 0) {
+          // isAlive check: alive before SIGTERM, dead after
+          if (termSent) {
+            const err = new Error('No such process') as NodeJS.ErrnoException;
+            err.code = 'ESRCH';
+            throw err;
+          }
+          return true;
+        }
+        if (signal === 'SIGTERM') {
+          termSent = true;
+          return true;
+        }
+        return true;
+      });
+
+      const reaper = new OrphanReaper();
+      // Use escalate=false to avoid the 5s wait
+      const result = await reaper.killProcess(1234, false);
+      expect(result.killed).toBe(true);
+      expect(result.signal).toBe('SIGTERM');
+    });
+
+    it('escalates to SIGKILL when SIGTERM does not kill within grace period', async () => {
+      vi.useFakeTimers();
+
+      let sigkillSent = false;
+      killSpy.mockImplementation((_pid: number, signal?: string | number) => {
+        if (signal === 0) {
+          // Process stays alive until SIGKILL
+          if (sigkillSent) {
+            const err = new Error('No such process') as NodeJS.ErrnoException;
+            err.code = 'ESRCH';
+            throw err;
+          }
+          return true;
+        }
+        if (signal === 'SIGTERM') return true;
+        if (signal === 'SIGKILL') {
+          sigkillSent = true;
+          return true;
+        }
+        return true;
+      });
+
+      const reaper = new OrphanReaper();
+      const promise = reaper.killProcess(1234, true);
+
+      // Advance past the 5s grace period
+      await vi.advanceTimersByTimeAsync(5_000);
+
+      const result = await promise;
+      expect(result.killed).toBe(true);
+      expect(result.signal).toBe('SIGKILL');
+
+      vi.useRealTimers();
+    });
+
+    it('handles SIGTERM throwing (process dies between check and signal)', async () => {
+      let firstCheck = true;
+      killSpy.mockImplementation((_pid: number, signal?: string | number) => {
+        if (signal === 0) {
+          if (firstCheck) {
+            firstCheck = false;
+            return true; // alive on first check
+          }
+          // Dead after
+          const err = new Error('No such process') as NodeJS.ErrnoException;
+          err.code = 'ESRCH';
+          throw err;
+        }
+        if (signal === 'SIGTERM') {
+          // Process died between isAlive check and SIGTERM send
+          const err = new Error('No such process') as NodeJS.ErrnoException;
+          err.code = 'ESRCH';
+          throw err;
+        }
+        return true;
+      });
+
+      const reaper = new OrphanReaper();
+      const result = await reaper.killProcess(1234, false);
+      // Process is dead, so killed=true
+      expect(result.killed).toBe(true);
+      expect(result.signal).toBe('SIGTERM');
+    });
+  });
 });