@assistkick/create 1.7.0 → 1.9.0

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

@@ -1,6 +1,8 @@
 /**
  * ProjectWorkspaceService — manages per-project workspace directories.
- * Each project gets a workspace at <projectRoot>/workspaces/<projectId>/.
+ * Each project gets a workspace at <workspacesDir>/<projectId>/.
+ * workspacesDir is injected via DI — in production it resolves to a persistent
+ * volume (/data/workspaces), in development to <projectRoot>/workspaces.
  * If a remote git repo is connected, it is cloned there.
  * If not, git init creates a local repo so worktrees and branching always work.
  */
@@ -8,27 +10,31 @@
 import { join } from 'node:path';
 import { existsSync } from 'node:fs';
 import { mkdir } from 'node:fs/promises';
+import type { SshKeyService } from './ssh_key_service.js';
 
 interface ProjectWorkspaceServiceDeps {
-  claudeService: { spawnCommand: (cmd: string, args: string[], cwd: string) => Promise<string> };
-  projectRoot: string;
+  claudeService: { spawnCommand: (cmd: string, args: string[], cwd: string, env?: Record<string, string>) => Promise<string> };
+  workspacesDir: string;
   log: (tag: string, ...args: any[]) => void;
+  sshKeyService?: SshKeyService;
 }
 
 export class ProjectWorkspaceService {
   private readonly claudeService: ProjectWorkspaceServiceDeps['claudeService'];
-  private readonly projectRoot: string;
+  private readonly workspacesDir: string;
   private readonly log: ProjectWorkspaceServiceDeps['log'];
+  private readonly sshKeyService?: SshKeyService;
 
-  constructor({ claudeService, projectRoot, log }: ProjectWorkspaceServiceDeps) {
+  constructor({ claudeService, workspacesDir, log, sshKeyService }: ProjectWorkspaceServiceDeps) {
     this.claudeService = claudeService;
-    this.projectRoot = projectRoot;
+    this.workspacesDir = workspacesDir;
     this.log = log;
+    this.sshKeyService = sshKeyService;
   }
 
   /** Get the workspace directory path for a project. */
   getWorkspacePath = (projectId: string): string => {
-    return join(this.projectRoot, 'workspaces', projectId);
+    return join(this.workspacesDir, projectId);
   };
 
   /** Get the worktrees directory inside a project workspace. */
@@ -71,17 +77,16 @@ export class ProjectWorkspaceService {
   /** Clone a remote repository into the project workspace. */
   cloneRepo = async (projectId: string, cloneUrl: string): Promise<string> => {
     const wsPath = this.getWorkspacePath(projectId);
-    const parentDir = join(this.projectRoot, 'workspaces');
-    await this.ensureDir(parentDir);
+    await this.ensureDir(this.workspacesDir);
 
     // If workspace already exists, remove it first
     if (existsSync(wsPath)) {
       this.log('WORKSPACE', `Removing existing workspace before clone: ${wsPath}`);
-      await this.claudeService.spawnCommand('rm', ['-rf', wsPath], parentDir);
+      await this.claudeService.spawnCommand('rm', ['-rf', wsPath], this.workspacesDir);
     }
 
     this.log('WORKSPACE', `Cloning ${cloneUrl} into ${wsPath}`);
-    await this.claudeService.spawnCommand('git', ['clone', cloneUrl, wsPath], parentDir);
+    await this.claudeService.spawnCommand('git', ['clone', cloneUrl, wsPath], this.workspacesDir);
     this.log('WORKSPACE', `Clone completed for project ${projectId}`);
     return wsPath;
   };
@@ -162,6 +167,77 @@ export class ProjectWorkspaceService {
     }
   };
 
+  /**
+   * Run a git command with GIT_SSH_COMMAND set for SSH key auth.
+   * Handles writing temp key, setting env, running the command, and cleanup.
+   */
+  private withSshKey = async <T>(encryptedPrivateKey: string, fn: () => Promise<T>): Promise<T> => {
+    if (!this.sshKeyService) throw new Error('SshKeyService not available');
+
+    const privateKeyPem = this.sshKeyService.decrypt(encryptedPrivateKey);
+    const keyFilePath = await this.sshKeyService.writeTempKeyFile(privateKeyPem);
+    const gitSshCommand = this.sshKeyService.buildGitSshCommand(keyFilePath);
+    const previousValue = process.env.GIT_SSH_COMMAND;
+
+    process.env.GIT_SSH_COMMAND = gitSshCommand;
+    try {
+      return await fn();
+    } finally {
+      if (previousValue !== undefined) {
+        process.env.GIT_SSH_COMMAND = previousValue;
+      } else {
+        delete process.env.GIT_SSH_COMMAND;
+      }
+      await this.sshKeyService.removeTempKeyFile(keyFilePath);
+    }
+  };
+
+  /** Clone a remote repository using SSH key authentication. */
+  cloneRepoSsh = async (projectId: string, sshCloneUrl: string, encryptedPrivateKey: string): Promise<string> => {
+    const wsPath = this.getWorkspacePath(projectId);
+    await this.ensureDir(this.workspacesDir);
+
+    if (existsSync(wsPath)) {
+      this.log('WORKSPACE', `Removing existing workspace before SSH clone: ${wsPath}`);
+      await this.claudeService.spawnCommand('rm', ['-rf', wsPath], this.workspacesDir);
+    }
+
+    this.log('WORKSPACE', `SSH cloning into ${wsPath}`);
+    await this.withSshKey(encryptedPrivateKey, () =>
+      this.claudeService.spawnCommand('git', ['clone', sshCloneUrl, wsPath], this.workspacesDir),
+    );
+    this.log('WORKSPACE', `SSH clone completed for project ${projectId}`);
+    return wsPath;
+  };
+
+  /** Pull latest changes using SSH key authentication. */
+  pullLatestSsh = async (projectId: string, encryptedPrivateKey: string): Promise<void> => {
+    const wsPath = this.getWorkspacePath(projectId);
+
+    try {
+      const branch = await this.getDefaultBranch(projectId);
+      this.log('WORKSPACE', `SSH pulling latest on ${branch} for project ${projectId}`);
+      await this.withSshKey(encryptedPrivateKey, () =>
+        this.claudeService.spawnCommand('git', ['pull', 'origin', branch], wsPath),
+      );
+      this.log('WORKSPACE', `SSH pull completed for project ${projectId}`);
+    } catch (err: any) {
+      this.log('WORKSPACE', `SSH pull failed (non-fatal): ${err.message}`);
+    }
+  };
+
+  /** Push the default branch to the remote using SSH key authentication. */
+  pushToRemoteSsh = async (projectId: string, encryptedPrivateKey: string): Promise<void> => {
+    const wsPath = this.getWorkspacePath(projectId);
+    const branch = await this.getDefaultBranch(projectId);
+
+    this.log('WORKSPACE', `SSH pushing ${branch} to remote for project ${projectId}`);
+    await this.withSshKey(encryptedPrivateKey, () =>
+      this.claudeService.spawnCommand('git', ['push', 'origin', branch], wsPath),
+    );
+    this.log('WORKSPACE', `SSH push completed for project ${projectId}`);
+  };
+
   /** Get workspace git status info. */
   getStatus = async (projectId: string): Promise<{
     hasWorkspace: boolean;

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);
+    });
+  });
 });