@assistkick/create 1.2.0 → 1.3.0

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

@@ -1,15 +1,13 @@
 /**
- * PTY Session Manager — manages restricted command execution per user.
+ * PTY Session Manager — manages named, project-scoped terminal sessions.
  * Implements dec_029 (Command Prefix Whitelist) and dec_030 (Server-Side PTY Session Persistence).
  *
- * Architecture: No interactive shell is spawned. Instead, the server manages a
- * command-line state machine that collects user input character-by-character,
- * validates complete commands against the whitelist, then spawns only the
- * validated command as a PTY process. While a command is running, raw input
- * is forwarded to it. When the command exits, the session returns to idle.
+ * Each session has a unique ID, a human-readable name (project name + creation timestamp),
+ * and is permanently bound to a project. Sessions persist across WebSocket disconnects.
  */
 
 import type { IPty } from 'node-pty';
+import { randomBytes } from 'node:crypto';
 
 const OUTPUT_BUFFER_MAX = 50_000;
 
@@ -27,7 +25,10 @@ interface PtySessionManagerDeps {
 }
 
 interface PtySession {
-  userId: string;
+  id: string;
+  name: string;
+  projectId: string;
+  projectName: string;
   pty: IPty | null;
   state: 'idle' | 'running';
   cols: number;
@@ -38,6 +39,15 @@ interface PtySession {
   createdAt: Date;
 }
 
+export interface SessionInfo {
+  id: string;
+  name: string;
+  projectId: string;
+  projectName: string;
+  state: 'idle' | 'running';
+  createdAt: string;
+}
+
 export class PtySessionManager {
   private readonly sessions = new Map<string, PtySession>();
   private readonly spawn: PtySessionManagerDeps['spawn'];
@@ -50,6 +60,20 @@ export class PtySessionManager {
     this.projectRoot = projectRoot;
   }
 
+  generateId = (): string => {
+    const hex = randomBytes(3).toString('hex');
+    return `term_${hex}`;
+  };
+
+  formatSessionName = (projectName: string, date: Date): string => {
+    const dd = String(date.getDate()).padStart(2, '0');
+    const mm = String(date.getMonth() + 1).padStart(2, '0');
+    const yy = String(date.getFullYear()).slice(2);
+    const hh = String(date.getHours()).padStart(2, '0');
+    const min = String(date.getMinutes()).padStart(2, '0');
+    return `${projectName} - ${dd}/${mm}/${yy} - ${hh}:${min}`;
+  };
+
   validateCommand = (input: string): { valid: boolean; error?: string } => {
     const trimmed = input.trim();
     if (!trimmed) {
@@ -69,19 +93,31 @@ export class PtySessionManager {
     return { valid: true };
   };
 
-  getSession = (userId: string): PtySession | undefined => {
-    return this.sessions.get(userId);
+  listSessions = (): SessionInfo[] => {
+    return Array.from(this.sessions.values()).map(s => ({
+      id: s.id,
+      name: s.name,
+      projectId: s.projectId,
+      projectName: s.projectName,
+      state: s.state,
+      createdAt: s.createdAt.toISOString(),
+    }));
   };
 
-  createSession = (userId: string, cols: number, rows: number): PtySession => {
-    const existing = this.sessions.get(userId);
-    if (existing) {
-      this.log('PTY', `Reusing existing session for user ${userId}`);
-      return existing;
-    }
+  getSession = (sessionId: string): PtySession | undefined => {
+    return this.sessions.get(sessionId);
+  };
+
+  createSession = (projectId: string, projectName: string, cols: number, rows: number): PtySession => {
+    const id = this.generateId();
+    const createdAt = new Date();
+    const name = this.formatSessionName(projectName, createdAt);
 
     const session: PtySession = {
-      userId,
+      id,
+      name,
+      projectId,
+      projectName,
       pty: null,
       state: 'idle',
       cols,
@@ -89,35 +125,35 @@ export class PtySessionManager {
       outputBuffer: '',
       inputBuffer: '',
       listeners: new Set(),
-      createdAt: new Date(),
+      createdAt,
     };
 
-    this.sessions.set(userId, session);
-    this.log('PTY', `Created new session for user ${userId}`);
+    this.sessions.set(id, session);
+    this.log('PTY', `Created session "${name}" (${id}) for project ${projectId}`);
 
-    // Show welcome message and prompt
+    // Show welcome message then auto-launch claude with project context
     this.emitOutput(session, WELCOME_MSG);
-    this.emitOutput(session, PROMPT);
+    this.autoLaunchClaude(session);
 
     return session;
   };
 
-  addListener = (userId: string, listener: (data: string) => void): void => {
-    const session = this.sessions.get(userId);
+  addListener = (sessionId: string, listener: (data: string) => void): void => {
+    const session = this.sessions.get(sessionId);
     if (session) {
       session.listeners.add(listener);
     }
   };
 
-  removeListener = (userId: string, listener: (data: string) => void): void => {
-    const session = this.sessions.get(userId);
+  removeListener = (sessionId: string, listener: (data: string) => void): void => {
+    const session = this.sessions.get(sessionId);
     if (session) {
       session.listeners.delete(listener);
     }
   };
 
-  writeToSession = (userId: string, data: string): void => {
-    const session = this.sessions.get(userId);
+  writeToSession = (sessionId: string, data: string): void => {
+    const session = this.sessions.get(sessionId);
     if (!session) return;
 
     if (session.state === 'running' && session.pty) {
@@ -129,8 +165,8 @@ export class PtySessionManager {
     }
   };
 
-  resizeSession = (userId: string, cols: number, rows: number): void => {
-    const session = this.sessions.get(userId);
+  resizeSession = (sessionId: string, cols: number, rows: number): void => {
+    const session = this.sessions.get(sessionId);
     if (session) {
       session.cols = cols;
       session.rows = rows;
@@ -140,25 +176,25 @@ export class PtySessionManager {
     }
   };
 
-  destroySession = (userId: string): void => {
-    const session = this.sessions.get(userId);
+  destroySession = (sessionId: string): void => {
+    const session = this.sessions.get(sessionId);
     if (session) {
       if (session.pty) {
         session.pty.kill();
       }
-      this.sessions.delete(userId);
-      this.log('PTY', `Destroyed session for user ${userId}`);
+      this.sessions.delete(sessionId);
+      this.log('PTY', `Destroyed session "${session.name}" (${sessionId})`);
     }
   };
 
   destroyAll = (): void => {
-    for (const [userId] of this.sessions) {
-      this.destroySession(userId);
+    for (const [sessionId] of this.sessions) {
+      this.destroySession(sessionId);
     }
   };
 
-  getBufferedOutput = (userId: string): string => {
-    const session = this.sessions.get(userId);
+  getBufferedOutput = (sessionId: string): string => {
+    const session = this.sessions.get(sessionId);
     return session?.outputBuffer ?? '';
   };
 
@@ -202,6 +238,45 @@ export class PtySessionManager {
     }
   };
 
+  private autoLaunchClaude = (session: PtySession): void => {
+    const projectContext = `We are working on project-id ${session.projectId}`;
+    const args = ['--dangerously-skip-permissions', '--append-system-prompt', projectContext];
+
+    this.log('PTY', `Auto-launching claude for session ${session.id} (project ${session.projectId})`);
+
+    let spawnedPty: IPty;
+    try {
+      spawnedPty = this.spawn('claude', args, {
+        name: 'xterm-256color',
+        cols: session.cols,
+        rows: session.rows,
+        cwd: this.projectRoot,
+        env: this.buildEnv(),
+      });
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      this.emitOutput(session, `\x1b[31mFailed to auto-launch claude: ${msg}\x1b[0m\r\n`);
+      this.log('PTY', `Auto-launch failed for session ${session.id}: ${msg}`);
+      this.emitOutput(session, PROMPT);
+      return;
+    }
+
+    session.pty = spawnedPty;
+    session.state = 'running';
+
+    spawnedPty.onData((data: string) => {
+      this.emitOutput(session, data);
+    });
+
+    spawnedPty.onExit(({ exitCode }) => {
+      this.log('PTY', `Auto-launched claude exited with code ${exitCode} for session ${session.id}`);
+      session.pty = null;
+      session.state = 'idle';
+      this.emitOutput(session, '\r\n');
+      this.emitOutput(session, PROMPT);
+    });
+  };
+
   private buildEnv = (): Record<string, string> => {
     const env = { ...process.env } as Record<string, string>;
     const home = env.HOME || '/root';
@@ -228,7 +303,7 @@ export class PtySessionManager {
     const cmd = parts[0];
     const args = parts.slice(1);
 
-    this.log('PTY', `Executing validated command "${command}" for user ${session.userId}`);
+    this.log('PTY', `Executing validated command "${command}" for session ${session.id}`);
 
     let spawnedPty: IPty;
     try {
@@ -259,7 +334,7 @@ export class PtySessionManager {
     });
 
     spawnedPty.onExit(({ exitCode }) => {
-      this.log('PTY', `Command exited with code ${exitCode} for user ${session.userId}`);
+      this.log('PTY', `Command exited with code ${exitCode} for session ${session.id}`);
       session.pty = null;
       session.state = 'idle';
       this.emitOutput(session, '\r\n');

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

@@ -1,7 +1,7 @@
 /**
  * WebSocket handler for terminal connections.
  * Authenticates via cookie, enforces admin-only access,
- * and bridges WebSocket ↔ PTY session.
+ * and bridges WebSocket ↔ PTY session by sessionId.
  */
 
 import type { IncomingMessage } from 'node:http';
@@ -50,7 +50,8 @@ export class TerminalWsHandler {
   }
 
   handleUpgrade = (req: IncomingMessage, socket: Duplex, head: Buffer): void => {
-    if (req.url !== '/api/terminal') {
+    const url = new URL(req.url || '', 'http://localhost');
+    if (url.pathname !== '/api/terminal') {
       return;
     }
 
@@ -84,14 +85,27 @@ export class TerminalWsHandler {
       return;
     }
 
-    const userId = payload.sub;
-    this.log('TERMINAL', `Admin ${payload.email} connected to terminal`);
+    // Parse sessionId from query params
+    const url = new URL(req.url || '', 'http://localhost');
+    const sessionId = url.searchParams.get('sessionId');
 
-    // Get or create PTY session (default 80x24, client will send resize)
-    const session = this.ptyManager.createSession(userId, 80, 24);
+    if (!sessionId) {
+      this.log('TERMINAL', 'Connection rejected — no sessionId provided');
+      ws.close(4004, 'Session ID required');
+      return;
+    }
+
+    const session = this.ptyManager.getSession(sessionId);
+    if (!session) {
+      this.log('TERMINAL', `Connection rejected — session ${sessionId} not found`);
+      ws.close(4004, 'Session not found');
+      return;
+    }
+
+    this.log('TERMINAL', `Admin ${payload.email} connected to session ${session.name}`);
 
-    // Send buffered output from previous session
-    const buffered = this.ptyManager.getBufferedOutput(userId);
+    // Send buffered output from previous connection
+    const buffered = this.ptyManager.getBufferedOutput(sessionId);
     if (buffered) {
       ws.send(JSON.stringify({ type: 'output', data: buffered }));
     }
@@ -102,7 +116,7 @@ export class TerminalWsHandler {
         ws.send(JSON.stringify({ type: 'output', data }));
       }
     };
-    this.ptyManager.addListener(userId, outputListener);
+    this.ptyManager.addListener(sessionId, outputListener);
 
     ws.on('message', (raw: Buffer | string) => {
       let msg: TerminalMessage;
@@ -113,21 +127,21 @@ export class TerminalWsHandler {
       }
 
       if (msg.type === 'input' && typeof msg.data === 'string') {
-        this.ptyManager.writeToSession(userId, msg.data);
+        this.ptyManager.writeToSession(sessionId, msg.data);
       } else if (msg.type === 'resize' && typeof msg.cols === 'number' && typeof msg.rows === 'number') {
-        this.ptyManager.resizeSession(userId, msg.cols, msg.rows);
+        this.ptyManager.resizeSession(sessionId, msg.cols, msg.rows);
       }
     });
 
     ws.on('close', () => {
-      this.log('TERMINAL', `Admin ${payload.email} disconnected from terminal`);
-      this.ptyManager.removeListener(userId, outputListener);
+      this.log('TERMINAL', `Admin ${payload.email} disconnected from session ${session.name}`);
+      this.ptyManager.removeListener(sessionId, outputListener);
       // PTY session persists (dec_030) — not destroyed on disconnect
     });
 
     ws.on('error', (err) => {
       this.log('TERMINAL', `WebSocket error: ${err.message}`);
-      this.ptyManager.removeListener(userId, outputListener);
+      this.ptyManager.removeListener(sessionId, outputListener);
     });
   };
 }

package/templates/assistkick-product-system/packages/frontend/src/App.tsx

@@ -17,7 +17,7 @@ export function App() {
       <Route path="/reset-password" element={<ResetPasswordRoute />} />
       <Route path="/accept-invitation" element={<AcceptInvitationRoute />} />
       <Route element={<ProtectedRoute />}>
-        <Route path="/" element={<Navigate to="/graph" replace />} />
+        <Route path="/" element={<Navigate to="/kanban" replace />} />
         <Route path="/graph" element={<DashboardRoute />} />
         <Route path="/kanban" element={<DashboardRoute />} />
         <Route path="/coherence" element={<DashboardRoute />} />

package/templates/assistkick-product-system/packages/frontend/src/api/client.ts

@@ -190,6 +190,54 @@ export class ApiClient {
     return resp.json();
   };
 
+  // --- Orchestrator (Play All) ---
+
+  startPlayAll = async (projectId?: string) => {
+    const qs = projectId ? `?project_id=${encodeURIComponent(projectId)}` : '';
+    const resp = await this.fetchWithRefresh(`${this.baseUrl}/api/pipeline/play-all${qs}`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+    });
+    if (!resp.ok) {
+      let msg = `Failed to start Play All: ${resp.status}`;
+      try { const err = await resp.json(); msg = err.error || msg; } catch { /* non-JSON */ }
+      throw new Error(msg);
+    }
+    return resp.json();
+  };
+
+  stopPlayAll = async () => {
+    const resp = await this.fetchWithRefresh(`${this.baseUrl}/api/pipeline/stop-all`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+    });
+    if (!resp.ok) {
+      let msg = `Failed to stop Play All: ${resp.status}`;
+      try { const err = await resp.json(); msg = err.error || msg; } catch { /* non-JSON */ }
+      throw new Error(msg);
+    }
+    return resp.json();
+  };
+
+  getOrchestratorStatus = async () => {
+    const resp = await this.fetchWithRefresh(`${this.baseUrl}/api/pipeline/orchestrator-status`);
+    if (!resp.ok) throw new Error(`Failed to get orchestrator status: ${resp.status}`);
+    return resp.json();
+  };
+
+  resumePipeline = async (featureId: string) => {
+    const resp = await this.fetchWithRefresh(`${this.baseUrl}/api/kanban/${featureId}/resume`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+    });
+    if (!resp.ok) {
+      let msg = `Failed to resume pipeline: ${resp.status}`;
+      try { const err = await resp.json(); msg = err.error || msg; } catch { /* non-JSON response */ }
+      throw new Error(msg);
+    }
+    return resp.json();
+  };
+
   unblockCard = async (featureId: string) => {
     const resp = await this.fetchWithRefresh(`${this.baseUrl}/api/kanban/${featureId}/unblock`, {
       method: 'POST',
@@ -368,6 +416,109 @@ export class ApiClient {
     return resp.json();
   };
 
+  // --- Git repository management ---
+
+  getGitStatus = async (projectId: string) => {
+    const resp = await this.fetchWithRefresh(`${this.baseUrl}/api/projects/${projectId}/git/status`);
+    if (!resp.ok) throw new Error(`Failed to get git status: ${resp.status}`);
+    return resp.json();
+  };
+
+  connectGitRepo = async (projectId: string, opts: {
+    repoUrl?: string;
+    githubInstallationId?: string;
+    githubRepoFullName?: string;
+    baseBranch?: string;
+  }) => {
+    const resp = await this.fetchWithRefresh(`${this.baseUrl}/api/projects/${projectId}/git/connect`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify(opts),
+    });
+    if (!resp.ok) {
+      const data = await resp.json();
+      throw new Error(data.error || `Failed to connect repo: ${resp.status}`);
+    }
+    return resp.json();
+  };
+
+  initGitRepo = async (projectId: string) => {
+    const resp = await this.fetchWithRefresh(`${this.baseUrl}/api/projects/${projectId}/git/init`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+    });
+    if (!resp.ok) {
+      const data = await resp.json();
+      throw new Error(data.error || `Failed to init repo: ${resp.status}`);
+    }
+    return resp.json();
+  };
+
+  disconnectGitRepo = async (projectId: string) => {
+    const resp = await this.fetchWithRefresh(`${this.baseUrl}/api/projects/${projectId}/git/disconnect`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+    });
+    if (!resp.ok) {
+      const data = await resp.json();
+      throw new Error(data.error || `Failed to disconnect repo: ${resp.status}`);
+    }
+    return resp.json();
+  };
+
+  testGitHubApp = async (projectId: string) => {
+    const resp = await this.fetchWithRefresh(`${this.baseUrl}/api/projects/${projectId}/git/test`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+    });
+    if (!resp.ok) throw new Error(`Failed to test GitHub App: ${resp.status}`);
+    return resp.json();
+  };
+
+  listGitHubInstallations = async (projectId: string) => {
+    const resp = await this.fetchWithRefresh(`${this.baseUrl}/api/projects/${projectId}/git/installations`);
+    if (!resp.ok) throw new Error(`Failed to list installations: ${resp.status}`);
+    return resp.json();
+  };
+
+  listGitHubRepos = async (projectId: string, installationId: string) => {
+    const resp = await this.fetchWithRefresh(
+      `${this.baseUrl}/api/projects/${projectId}/git/repos?installation_id=${encodeURIComponent(installationId)}`,
+    );
+    if (!resp.ok) throw new Error(`Failed to list repos: ${resp.status}`);
+    return resp.json();
+  };
+
+  listTerminalSessions = async () => {
+    const resp = await this.fetchWithRefresh(`${this.baseUrl}/api/terminal/sessions`);
+    if (!resp.ok) throw new Error(`Failed to list terminal sessions: ${resp.status}`);
+    return resp.json();
+  };
+
+  createTerminalSession = async (projectId: string, projectName: string) => {
+    const resp = await this.fetchWithRefresh(`${this.baseUrl}/api/terminal/sessions`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ projectId, projectName }),
+    });
+    if (!resp.ok) {
+      const data = await resp.json();
+      throw new Error(data.error || `Failed to create terminal session: ${resp.status}`);
+    }
+    return resp.json();
+  };
+
+  killTerminalSession = async (sessionId: string) => {
+    const resp = await this.fetchWithRefresh(`${this.baseUrl}/api/terminal/sessions/${sessionId}`, {
+      method: 'DELETE',
+    });
+    if (!resp.ok) {
+      const data = await resp.json();
+      throw new Error(data.error || `Failed to kill terminal session: ${resp.status}`);
+    }
+    return resp.json();
+  };
+
   acceptInvitation = async (token: string, email: string, password: string) => {
     const resp = await fetch(`${this.baseUrl}/api/auth/accept-invitation`, {
       method: 'POST',