@assistkick/create 1.6.0 → 1.8.0

package/templates/assistkick-product-system/packages/backend/src/services/pty_session_manager.test.ts

@@ -1,4 +1,4 @@
-import { describe, it, mock, beforeEach } from 'node:test';
+import { describe, it, mock, beforeEach, afterEach } from 'node:test';
 import assert from 'node:assert/strict';
 import { PtySessionManager } from './pty_session_manager.ts';
 
@@ -14,11 +14,50 @@ const createMockPty = () => {
   };
 };
 
+/** In-memory mock DB that mimics Drizzle's API surface for terminal_sessions. */
+const createMockDb = () => {
+  const rows: any[] = [];
+
+  const where = (pred: any) => ({
+    // select().from().where() returns matching rows
+    then: (resolve: Function) => resolve(rows),
+  });
+
+  return {
+    _rows: rows,
+    select: () => ({
+      from: () => ({
+        where: (_pred: any) => Promise.resolve(rows.filter(() => true)),
+        then: (resolve: Function) => resolve(rows),
+      }),
+    }),
+    insert: () => ({
+      values: (val: any) => {
+        rows.push(val);
+        return Promise.resolve();
+      },
+    }),
+    update: () => ({
+      set: () => ({
+        where: () => Promise.resolve(),
+      }),
+    }),
+    delete: () => ({
+      where: () => {
+        // Remove all rows (simplified for tests)
+        rows.length = 0;
+        return Promise.resolve();
+      },
+    }),
+  };
+};
+
 describe('PtySessionManager', () => {
   let manager: PtySessionManager;
   let spawnMock: ReturnType<typeof mock.fn>;
   let logMock: ReturnType<typeof mock.fn>;
   let mockPty: ReturnType<typeof createMockPty>;
+  let mockDb: ReturnType<typeof createMockDb>;
   const PROJECT_ROOT = '/test/project/root';
   const PROJECT_ID = 'proj_test';
   const PROJECT_NAME = 'Test Project';
@@ -27,125 +66,94 @@ describe('PtySessionManager', () => {
     mockPty = createMockPty();
     spawnMock = mock.fn(() => mockPty);
     logMock = mock.fn();
-    manager = new PtySessionManager({ spawn: spawnMock as any, log: logMock, projectRoot: PROJECT_ROOT });
+    mockDb = createMockDb();
+    manager = new PtySessionManager({
+      spawn: spawnMock as any,
+      log: logMock,
+      projectRoot: PROJECT_ROOT,
+      getDb: () => mockDb,
+    });
   });
 
   describe('spawnCommand uses projectRoot as cwd', () => {
-    it('passes projectRoot as cwd when auto-launching claude', () => {
-      const session = manager.createSession(PROJECT_ID, PROJECT_NAME, 80, 24);
+    it('passes projectRoot as cwd when auto-launching claude', async () => {
+      await manager.createSession(PROJECT_ID, PROJECT_NAME, 80, 24);
 
-      // Auto-launch is triggered on session creation
       assert.equal(spawnMock.mock.calls.length, 1);
       const spawnOptions = spawnMock.mock.calls[0].arguments[2] as Record<string, unknown>;
       assert.equal(spawnOptions.cwd, PROJECT_ROOT);
     });
   });
 
-  describe('validateCommand', () => {
-    it('allows "claude" command', () => {
-      const result = manager.validateCommand('claude');
-      assert.equal(result.valid, true);
-    });
-
-    it('allows "claude" with arguments', () => {
-      const result = manager.validateCommand('claude --help');
-      assert.equal(result.valid, true);
-    });
-
-    it('rejects disallowed commands', () => {
-      const result = manager.validateCommand('rm -rf /');
-      assert.equal(result.valid, false);
-      assert.ok(result.error?.includes('not allowed'));
-    });
-
-    it('rejects empty command', () => {
-      const result = manager.validateCommand('');
-      assert.equal(result.valid, false);
-    });
-  });
-
   describe('session lifecycle', () => {
-    it('creates a new named session with project binding', () => {
-      const session = manager.createSession(PROJECT_ID, PROJECT_NAME, 80, 24);
+    it('creates a new named session with project binding', async () => {
+      const session = await manager.createSession(PROJECT_ID, PROJECT_NAME, 80, 24);
       assert.equal(session.projectId, PROJECT_ID);
       assert.equal(session.projectName, PROJECT_NAME);
-      assert.equal(session.state, 'running'); // auto-launch sets state to running
+      assert.equal(session.state, 'running');
       assert.ok(session.id.startsWith('term_'));
       assert.ok(session.name.startsWith(PROJECT_NAME));
     });
 
-    it('creates separate sessions for the same project', () => {
-      const s1 = manager.createSession(PROJECT_ID, PROJECT_NAME, 80, 24);
-      const s2 = manager.createSession(PROJECT_ID, PROJECT_NAME, 80, 24);
+    it('creates separate sessions for the same project', async () => {
+      const s1 = await manager.createSession(PROJECT_ID, PROJECT_NAME, 80, 24);
+      const s2 = await manager.createSession(PROJECT_ID, PROJECT_NAME, 80, 24);
       assert.notEqual(s1.id, s2.id);
     });
 
-    it('destroys session and kills pty', () => {
-      const session = manager.createSession(PROJECT_ID, PROJECT_NAME, 80, 24);
-      // session.pty is already set by auto-launch
-      manager.destroySession(session.id);
+    it('destroys session and kills pty', async () => {
+      const session = await manager.createSession(PROJECT_ID, PROJECT_NAME, 80, 24);
+      await manager.destroySession(session.id);
       assert.equal(mockPty.kill.mock.calls.length, 1);
-      assert.equal(manager.getSession(session.id), undefined);
-    });
-
-    it('lists all active sessions', () => {
-      const s1 = manager.createSession(PROJECT_ID, PROJECT_NAME, 80, 24);
-      const s2 = manager.createSession('proj_other', 'Other', 80, 24);
-      const list = manager.listSessions();
-      assert.equal(list.length, 2);
-      assert.ok(list.some(s => s.id === s1.id));
-      assert.ok(list.some(s => s.id === s2.id));
     });
 
-    it('session removed from list after destroy', () => {
-      const session = manager.createSession(PROJECT_ID, PROJECT_NAME, 80, 24);
-      manager.destroySession(session.id);
-      const list = manager.listSessions();
-      assert.equal(list.length, 0);
+    it('session state is running immediately after creation', async () => {
+      const session = await manager.createSession(PROJECT_ID, PROJECT_NAME, 80, 24);
+      assert.equal(session.state, 'running');
     });
   });
 
   describe('auto-launch claude on session creation', () => {
-    it('auto-launches claude with --dangerously-skip-permissions and --append-system-prompt on session creation', () => {
-      const session = manager.createSession(PROJECT_ID, PROJECT_NAME, 80, 24);
+    it('auto-launches claude with --dangerously-skip-permissions, --append-system-prompt, and --session-id', async () => {
+      const session = await manager.createSession(PROJECT_ID, PROJECT_NAME, 80, 24);
 
       assert.equal(spawnMock.mock.calls.length, 1);
       const [cmd, args] = spawnMock.mock.calls[0].arguments as [string, string[]];
       assert.equal(cmd, 'claude');
       assert.ok(args.includes('--dangerously-skip-permissions'));
       assert.ok(args.includes('--append-system-prompt'));
+      assert.ok(args.includes('--session-id'));
+      assert.ok(args.includes(session.claudeSessionId));
       assert.ok(args.includes(`We are working on project-id ${PROJECT_ID}`));
     });
 
-    it('uses --append-system-prompt (not --system-prompt) to preserve default prompt', () => {
-      manager.createSession(PROJECT_ID, PROJECT_NAME, 80, 24);
+    it('uses --append-system-prompt (not --system-prompt) to preserve default prompt', async () => {
+      await manager.createSession(PROJECT_ID, PROJECT_NAME, 80, 24);
 
       const [, args] = spawnMock.mock.calls[0].arguments as [string, string[]];
       assert.ok(args.includes('--append-system-prompt'));
-      assert.ok(!args.includes('--system-prompt') || args.indexOf('--system-prompt') === args.indexOf('--append-system-prompt'));
     });
 
-    it('includes the session projectId in the system prompt', () => {
+    it('includes the session projectId in the system prompt', async () => {
       const customProjectId = 'proj_custom_123';
-      manager.createSession(customProjectId, PROJECT_NAME, 80, 24);
+      await manager.createSession(customProjectId, PROJECT_NAME, 80, 24);
 
       const [, args] = spawnMock.mock.calls[0].arguments as [string, string[]];
       const promptIndex = args.indexOf('--append-system-prompt');
       assert.ok(promptIndex !== -1);
       assert.ok(args[promptIndex + 1].includes(customProjectId));
     });
+  });
 
-    it('does not re-launch claude when reconnecting to an existing session', () => {
-      const session = manager.createSession(PROJECT_ID, PROJECT_NAME, 80, 24);
-      // Reconnect is simulated by getSession — no new spawn
-      const existing = manager.getSession(session.id);
-      assert.ok(existing);
+  describe('ensureRunning resumes suspended sessions', () => {
+    it('returns true and does not re-spawn for already live session', async () => {
+      const session = await manager.createSession(PROJECT_ID, PROJECT_NAME, 80, 24);
       assert.equal(spawnMock.mock.calls.length, 1);
-    });
 
-    it('session state is running immediately after creation', () => {
-      const session = manager.createSession(PROJECT_ID, PROJECT_NAME, 80, 24);
-      assert.equal(session.state, 'running');
+      const result = await manager.ensureRunning(session.id, 80, 24);
+      assert.equal(result, true);
+      // No extra spawn
+      assert.equal(spawnMock.mock.calls.length, 1);
     });
   });
 
@@ -156,4 +164,137 @@ describe('PtySessionManager', () => {
       assert.equal(name, 'My Project - 06/03/26 - 14:30');
     });
   });
+
+  describe('orphan session cleanup', () => {
+    afterEach(() => {
+      mock.timers.reset();
+    });
+
+    it('starts idle timer when last listener disconnects', async () => {
+      mock.timers.enable({ apis: ['setTimeout'] });
+      const session = await manager.createSession(PROJECT_ID, PROJECT_NAME, 80, 24);
+      const listener = mock.fn();
+
+      manager.addListener(session.id, listener);
+      manager.removeListener(session.id, listener);
+
+      assert.equal(manager.hasDisconnectTimer(session.id), true);
+    });
+
+    it('does not start timer when other listeners remain', async () => {
+      mock.timers.enable({ apis: ['setTimeout'] });
+      const session = await manager.createSession(PROJECT_ID, PROJECT_NAME, 80, 24);
+      const listener1 = mock.fn();
+      const listener2 = mock.fn();
+
+      manager.addListener(session.id, listener1);
+      manager.addListener(session.id, listener2);
+      manager.removeListener(session.id, listener1);
+
+      assert.equal(manager.hasDisconnectTimer(session.id), false);
+    });
+
+    it('cancels timer when client reconnects before timeout', async () => {
+      mock.timers.enable({ apis: ['setTimeout'] });
+      const session = await manager.createSession(PROJECT_ID, PROJECT_NAME, 80, 24);
+      const listener1 = mock.fn();
+      const listener2 = mock.fn();
+
+      manager.addListener(session.id, listener1);
+      manager.removeListener(session.id, listener1);
+      assert.equal(manager.hasDisconnectTimer(session.id), true);
+
+      // Reconnect before timer fires
+      manager.addListener(session.id, listener2);
+      assert.equal(manager.hasDisconnectTimer(session.id), false);
+
+      // PTY should still be live
+      assert.equal(manager.isLive(session.id), true);
+    });
+
+    it('kills PTY when idle timer fires with zero listeners', async () => {
+      mock.timers.enable({ apis: ['setTimeout'] });
+      const session = await manager.createSession(PROJECT_ID, PROJECT_NAME, 80, 24);
+      const listener = mock.fn();
+
+      manager.addListener(session.id, listener);
+      manager.removeListener(session.id, listener);
+
+      // Advance time past the 30-minute timeout
+      mock.timers.tick(1_800_000);
+
+      // PTY should be killed (removed from live map), but DB record persists
+      assert.equal(manager.isLive(session.id), false);
+      assert.equal(manager.hasDisconnectTimer(session.id), false);
+    });
+
+    it('does not kill PTY if listener reconnects before timer fires', async () => {
+      mock.timers.enable({ apis: ['setTimeout'] });
+      const session = await manager.createSession(PROJECT_ID, PROJECT_NAME, 80, 24);
+      const listener1 = mock.fn();
+      const listener2 = mock.fn();
+
+      manager.addListener(session.id, listener1);
+      manager.removeListener(session.id, listener1);
+
+      // Advance time partially
+      mock.timers.tick(900_000); // 15 minutes
+
+      // Reconnect
+      manager.addListener(session.id, listener2);
+
+      // Advance past original timeout
+      mock.timers.tick(900_001);
+
+      // PTY should still be live
+      assert.equal(manager.isLive(session.id), true);
+    });
+
+    it('clears pending timer when session is manually destroyed', async () => {
+      mock.timers.enable({ apis: ['setTimeout'] });
+      const session = await manager.createSession(PROJECT_ID, PROJECT_NAME, 80, 24);
+      const listener = mock.fn();
+
+      manager.addListener(session.id, listener);
+      manager.removeListener(session.id, listener);
+      assert.equal(manager.hasDisconnectTimer(session.id), true);
+
+      await manager.destroySession(session.id);
+      assert.equal(manager.hasDisconnectTimer(session.id), false);
+      assert.equal(manager.getDisconnectTimerCount(), 0);
+    });
+
+    it('clears all pending timers on destroyAllPty', async () => {
+      mock.timers.enable({ apis: ['setTimeout'] });
+      const s1 = await manager.createSession(PROJECT_ID, PROJECT_NAME, 80, 24);
+      const s2 = await manager.createSession('proj_other', 'Other', 80, 24);
+      const l1 = mock.fn();
+      const l2 = mock.fn();
+
+      manager.addListener(s1.id, l1);
+      manager.addListener(s2.id, l2);
+      manager.removeListener(s1.id, l1);
+      manager.removeListener(s2.id, l2);
+
+      assert.equal(manager.getDisconnectTimerCount(), 2);
+
+      manager.destroyAllPty();
+      assert.equal(manager.getDisconnectTimerCount(), 0);
+    });
+
+    it('only starts one timer per session even with multiple removeListener calls', async () => {
+      mock.timers.enable({ apis: ['setTimeout'] });
+      const session = await manager.createSession(PROJECT_ID, PROJECT_NAME, 80, 24);
+      const listener = mock.fn();
+
+      manager.addListener(session.id, listener);
+      manager.removeListener(session.id, listener);
+
+      // Try removing again (no-op since listener already removed)
+      manager.removeListener(session.id, listener);
+
+      // Should still have exactly one timer
+      assert.equal(manager.hasDisconnectTimer(session.id), true);
+    });
+  });
 });