circuschief 0.1.0

package/packages/server/src/api/quickResponses.js

@@ -0,0 +1,129 @@
+import { Router } from 'express';
+import { projects, quickResponses } from '../database.js';
+import {
+  CreateQuickResponseRequest,
+  UpdateQuickResponseRequest,
+  ReorderQuickResponsesRequest,
+} from '../../../shared/src/contracts/quickResponses.js';
+
+const router = Router();
+
+// GET /api/projects/:projectId/quick-responses - List quick responses for a project
+router.get('/projects/:projectId/quick-responses', (req, res) => {
+  const { projectId } = req.params;
+
+  const project = projects.getById(projectId);
+  if (!project) {
+    return res.status(404).json({ error: 'Project not found' });
+  }
+
+  const responses = quickResponses.getAvailableForProject(projectId);
+  res.json(responses);
+});
+
+// POST /api/projects/:projectId/quick-responses - Create a quick response
+router.post('/projects/:projectId/quick-responses', (req, res) => {
+  const { projectId } = req.params;
+
+  const project = projects.getById(projectId);
+  if (!project) {
+    return res.status(404).json({ error: 'Project not found' });
+  }
+
+  const result = CreateQuickResponseRequest.safeParse(req.body);
+  if (!result.success) {
+    return res.status(400).json({ error: result.error.issues[0].message });
+  }
+
+  const { label, content, autoSubmit, category, sortOrder, isGlobal } = result.data;
+
+  const response = quickResponses.create({
+    projectId: isGlobal ? null : projectId,
+    label: label.trim(),
+    content,
+    autoSubmit,
+    category,
+    sortOrder,
+  });
+
+  res.status(201).json(response);
+});
+
+// GET /api/quick-responses/global - List global quick responses only
+router.get('/quick-responses/global', (_req, res) => {
+  const responses = quickResponses.getGlobal();
+  res.json(responses);
+});
+
+// PATCH /api/quick-responses/:id - Update a quick response
+router.patch('/quick-responses/:id', (req, res) => {
+  const { id } = req.params;
+
+  const existing = quickResponses.getById(id);
+  if (!existing) {
+    return res.status(404).json({ error: 'Quick response not found' });
+  }
+
+  const result = UpdateQuickResponseRequest.safeParse(req.body);
+  if (!result.success) {
+    return res.status(400).json({ error: result.error.issues[0].message });
+  }
+
+  const updates = { ...result.data };
+  if (updates.label) {
+    updates.label = updates.label.trim();
+  }
+
+  const updated = quickResponses.update(id, updates);
+  res.json(updated);
+});
+
+// DELETE /api/quick-responses/:id - Delete a quick response
+router.delete('/quick-responses/:id', (req, res) => {
+  const { id } = req.params;
+
+  const existing = quickResponses.getById(id);
+  if (!existing) {
+    return res.status(404).json({ error: 'Quick response not found' });
+  }
+
+  quickResponses.deleteById(id);
+  res.status(204).send();
+});
+
+// POST /api/projects/:projectId/quick-responses/reorder - Reorder quick responses
+router.post('/projects/:projectId/quick-responses/reorder', (req, res) => {
+  const { projectId } = req.params;
+
+  const project = projects.getById(projectId);
+  if (!project) {
+    return res.status(404).json({ error: 'Project not found' });
+  }
+
+  const result = ReorderQuickResponsesRequest.safeParse(req.body);
+  if (!result.success) {
+    return res.status(400).json({ error: result.error.issues[0].message });
+  }
+
+  quickResponses.updateSortOrder(result.data);
+
+  // Return the updated responses
+  const responses = quickResponses.getAvailableForProject(projectId);
+  res.json(responses);
+});
+
+// POST /api/quick-responses/global/reorder - Reorder global quick responses
+router.post('/quick-responses/global/reorder', (req, res) => {
+  const result = ReorderQuickResponsesRequest.safeParse(req.body);
+  if (!result.success) {
+    return res.status(400).json({ error: result.error.issues[0].message });
+  }
+
+  quickResponses.updateSortOrder(result.data);
+
+  // Return the updated global responses
+  const responses = quickResponses.getGlobal();
+  res.json(responses);
+});
+
+export default router;

package/packages/server/src/api/sessions-archive.js

@@ -0,0 +1,69 @@
+import { Router } from 'express';
+import { sessions } from '../database.js';
+import { broadcastToProject } from '../websocket.js';
+import { WS_MESSAGE_TYPES } from '../../../shared/src/index.js';
+import { requireSession, requireSessionAndProject } from '../middleware/sessionLookup.js';
+import { executeHookAsync } from '../services/hookService.js';
+
+const router = Router();
+
+// POST /api/sessions/:id/archive - Archive a session
+router.post('/:id/archive', requireSessionAndProject, async (req, res) => {
+  // Only allow archiving stopped/waiting/error sessions (not active sessions like starting/running)
+  if (!['stopped', 'waiting', 'error'].includes(req.session_.status)) {
+    return res.status(400).json({ error: 'Can only archive stopped, waiting, or error sessions' });
+  }
+
+  const { cleanup } = req.body || {};
+
+  const updated = sessions.update(req.params.id, { archived: true });
+
+  // Execute project cleanup command if cleanup requested and project has one configured
+  // Skip for child sessions - they share parent's resources and shouldn't trigger teardown
+  if (cleanup && req.project?.onSessionDeleted && !req.session_.parentSessionId) {
+    executeHookAsync(req.project.onSessionDeleted, req.workingDirectory, {
+      sessionId: req.session_.id,
+      projectId: req.project.id,
+      sessionName: req.session_.name,
+    });
+  }
+
+  // Broadcast update to project subscribers
+  broadcastToProject(req.session_.projectId, WS_MESSAGE_TYPES.SESSION_UPDATED, {
+    projectId: req.session_.projectId,
+    sessionId: req.params.id,
+    session: updated,
+  });
+
+  res.json(updated);
+});
+
+// POST /api/sessions/:id/unarchive - Unarchive a session
+router.post('/:id/unarchive', requireSession, (req, res) => {
+  const updated = sessions.update(req.params.id, { archived: false });
+
+  // Broadcast update to project subscribers
+  broadcastToProject(req.session_.projectId, WS_MESSAGE_TYPES.SESSION_UPDATED, {
+    projectId: req.session_.projectId,
+    sessionId: req.params.id,
+    session: updated,
+  });
+
+  res.json(updated);
+});
+
+// POST /api/sessions/:id/star - Toggle star status for a session
+router.post('/:id/star', requireSession, (req, res) => {
+  const updated = sessions.update(req.params.id, { starred: !req.session_.starred });
+
+  // Broadcast update to project subscribers
+  broadcastToProject(req.session_.projectId, WS_MESSAGE_TYPES.SESSION_UPDATED, {
+    projectId: req.session_.projectId,
+    sessionId: req.params.id,
+    session: updated,
+  });
+
+  res.json(updated);
+});
+
+export default router;

package/packages/server/src/api/sessions-commands.js

@@ -0,0 +1,220 @@
+import { Router } from 'express';
+import { commandButtons, commandRuns } from '../database.js';
+import { broadcastToSession, broadcastToProject } from '../websocket.js';
+import { WS_MESSAGE_TYPES } from '../../../shared/src/index.js';
+import { requireSession, requireSessionAndProject } from '../middleware/sessionLookup.js';
+import { commandRunner } from '../services/commandRunner.js';
+import { databaseManager } from '../db/DatabaseManager.js';
+
+const router = Router();
+
+/**
+ * Broadcast command output to session and project subscribers.
+ * @param {{ sessionId: string, projectId: string, runId: string, buttonId: string }} ctx - Context
+ * @param {string} output - Output text
+ */
+function broadcastCommandOutput(ctx, output) {
+  const { sessionId, projectId, runId, buttonId } = ctx;
+  broadcastToSession(sessionId, WS_MESSAGE_TYPES.COMMAND_RUN_OUTPUT, { sessionId, runId, buttonId, output });
+  broadcastToProject(projectId, WS_MESSAGE_TYPES.COMMAND_RUN_OUTPUT, { projectId, sessionId, runId, buttonId, output });
+}
+
+/**
+ * Broadcast command completion to session and project subscribers.
+ * @param {{ sessionId: string, projectId: string, runId: string, buttonId: string }} ctx - Context
+ * @param {{ exitCode: number, output: string }} result - Completion result
+ */
+function broadcastCommandComplete(ctx, result) {
+  const { sessionId, projectId, runId, buttonId } = ctx;
+  const { exitCode, output } = result;
+  const status = exitCode === 0 ? 'success' : 'error';
+  console.log(`[RUN] Command completed for runId: ${runId}, exitCode: ${exitCode}, status: ${status}`);
+  broadcastToSession(sessionId, WS_MESSAGE_TYPES.COMMAND_RUN_COMPLETE, { sessionId, runId, buttonId, status, exitCode, output });
+  console.log(`[RUN] Broadcasting COMMAND_RUN_COMPLETE to project ${projectId}`);
+  broadcastToProject(projectId, WS_MESSAGE_TYPES.COMMAND_RUN_COMPLETE, { projectId, sessionId, runId, buttonId, status, exitCode, output });
+}
+
+/**
+ * Broadcast command error to session and project subscribers.
+ * @param {{ sessionId: string, projectId: string, runId: string, buttonId: string }} ctx - Context
+ * @param {string} errorMessage - Error message
+ */
+function broadcastCommandError(ctx, errorMessage) {
+  const { sessionId, projectId, runId, buttonId } = ctx;
+  console.log(`[RUN] Error for runId: ${runId}: ${errorMessage}`);
+  broadcastToSession(sessionId, WS_MESSAGE_TYPES.COMMAND_RUN_ERROR, { sessionId, runId, buttonId, error: errorMessage });
+  broadcastToProject(projectId, WS_MESSAGE_TYPES.COMMAND_RUN_ERROR, { projectId, sessionId, runId, buttonId, error: errorMessage });
+}
+
+// POST /api/sessions/:id/command-buttons/:buttonId/run - Execute button command
+router.post('/:id/command-buttons/:buttonId/run', requireSessionAndProject, (req, res) => {
+  const sessionId = req.params.id;
+  const buttonId = req.params.buttonId;
+
+  console.log(`[RUN] Starting command for buttonId: ${buttonId}, sessionId: ${sessionId}`);
+
+  const button = commandButtons.getById(buttonId);
+  if (!button) {
+    return res.status(404).json({ error: 'Command button not found' });
+  }
+
+  // Generate run ID
+  const runId = databaseManager.generateId();
+
+  console.log(`[RUN] Generated runId: ${runId} for command: ${button.command}`);
+
+  // Return immediately with runId
+  res.json({ runId, buttonId, status: 'running', output: '' });
+
+  // Capture middleware values for use in async callbacks
+  const projectId = req.session_.projectId;
+  const workingDirectory = req.workingDirectory;
+  const ctx = { sessionId, projectId, runId, buttonId };
+
+  // Broadcast initial "running" status immediately so session list can show the running indicator
+  broadcastCommandOutput(ctx, '');
+
+  // Execute command asynchronously
+  (async () => {
+    try {
+      console.log(`[RUN] Starting async execution for runId: ${runId}`);
+      await commandRunner.run(
+        { runId, command: button.command, workingDirectory },
+        {
+          onOutput: (text) => {
+            console.log(`[RUN] Output received for runId: ${runId}`);
+            broadcastCommandOutput(ctx, text);
+          },
+          onComplete: (exitCode, output) => broadcastCommandComplete(ctx, { exitCode, output }),
+          onError: (message) => broadcastCommandError(ctx, message),
+        },
+        { sessionId, buttonId }
+      );
+    } catch (error) {
+      console.error(`Error running command button ${buttonId}:`, error);
+      broadcastCommandError(ctx, error.message);
+    }
+  })();
+});
+
+// GET /api/sessions/:id/command-buttons/runs - Get active runs for session
+router.get('/:id/command-buttons/runs', requireSession, (req, res) => {
+  const sessionId = req.params.id;
+
+  const activeRuns = commandRunner.getRunsBySession(sessionId);
+  res.json(activeRuns);
+});
+
+// GET /api/sessions/:id/command-buttons/runs/:runId - Get single run by ID
+router.get('/:id/command-buttons/runs/:runId', requireSession, (req, res) => {
+  const { id: sessionId, runId } = req.params;
+
+  // Check if run is currently running (in memory)
+  if (commandRunner.isRunning(runId)) {
+    const activeRuns = commandRunner.getRunsBySession(sessionId);
+    const run = activeRuns.find((r) => r.runId === runId);
+    if (run) {
+      return res.json(run);
+    }
+  }
+
+  // Otherwise check database
+  const run = commandRuns.getById(runId);
+  if (!run || run.sessionId !== sessionId) {
+    return res.status(404).json({ error: 'Run not found' });
+  }
+
+  res.json({
+    runId: run.id,
+    buttonId: run.buttonId,
+    status: run.status,
+    output: run.output,
+    exitCode: run.exitCode,
+    startedAt: run.startedAt,
+    completedAt: run.completedAt,
+  });
+});
+
+// DELETE /api/sessions/:id/command-buttons/runs/:runId - Delete a command run record
+router.delete('/:id/command-buttons/runs/:runId', requireSessionAndProject, (req, res) => {
+  const sessionId = req.params.id;
+  const { runId } = req.params;
+
+  const run = commandRuns.getById(runId);
+  if (!run || run.sessionId !== sessionId) {
+    return res.status(404).json({ error: 'Run not found' });
+  }
+
+  if (commandRunner.isRunning(runId)) {
+    return res.status(409).json({ error: 'Cannot delete a running command. Kill it first.' });
+  }
+
+  commandRuns.deleteById(runId);
+
+  const projectId = req.session_.projectId;
+
+  // Broadcast deletion to session and project subscribers
+  broadcastToSession(sessionId, WS_MESSAGE_TYPES.COMMAND_RUN_DELETED, {
+    runId,
+    buttonId: run.buttonId,
+    sessionId,
+  });
+  broadcastToProject(projectId, WS_MESSAGE_TYPES.COMMAND_RUN_DELETED, {
+    runId,
+    buttonId: run.buttonId,
+    sessionId,
+    projectId,
+  });
+
+  res.status(204).send();
+});
+
+// DELETE /api/sessions/:id/command-buttons/:buttonId/runs/all - Delete all runs for a button in a session
+router.delete('/:id/command-buttons/:buttonId/runs/all', requireSessionAndProject, (req, res) => {
+  const sessionId = req.params.id;
+  const { buttonId } = req.params;
+
+  const button = commandButtons.getById(buttonId);
+  if (!button) {
+    return res.status(404).json({ error: 'Command button not found' });
+  }
+
+  const { deletedRuns } = commandRuns.deleteByButtonAndSession(buttonId, sessionId);
+
+  const projectId = req.session_.projectId;
+
+  // Broadcast individual COMMAND_RUN_DELETED events for each deleted run
+  for (const run of deletedRuns) {
+    broadcastToSession(sessionId, WS_MESSAGE_TYPES.COMMAND_RUN_DELETED, {
+      runId: run.id,
+      buttonId: run.buttonId,
+      sessionId,
+    });
+    broadcastToProject(projectId, WS_MESSAGE_TYPES.COMMAND_RUN_DELETED, {
+      runId: run.id,
+      buttonId: run.buttonId,
+      sessionId,
+      projectId,
+    });
+  }
+
+  res.status(204).send();
+});
+
+// POST /api/sessions/:id/command-buttons/runs/:runId/kill - Kill running command
+router.post('/:id/command-buttons/runs/:runId/kill', requireSession, (req, res) => {
+  const sessionId = req.params.id;
+  const runId = req.params.runId;
+
+  console.log(`[KILL] Kill request for runId: ${runId}, sessionId: ${sessionId}`);
+
+  const killed = commandRunner.kill(runId);
+  console.log(`[KILL] Kill result: ${killed} for runId: ${runId}`);
+  if (!killed) {
+    return res.status(404).json({ error: 'Run not found or already completed' });
+  }
+
+  res.json({ success: true, runId });
+});
+
+export default router;

package/packages/server/src/api/sessions-conversations.js

@@ -0,0 +1,168 @@
+import { Router } from 'express';
+import { messages, conversations, projects } from '../database.js';
+import { continueSessionWithExistingMessage } from '../services/sessionManager.js';
+import { broadcastToSession } from '../websocket.js';
+import { WS_MESSAGE_TYPES } from '../../../shared/src/index.js';
+import { requireSession } from '../middleware/sessionLookup.js';
+
+const router = Router();
+
+// GET /api/sessions/:id/conversations - List all conversations for a session
+router.get('/:id/conversations', requireSession, (req, res) => {
+  // Use getBySessionIdWithBranchInfo to include branching metadata
+  const sessionConversations = conversations.getBySessionIdWithBranchInfo(req.params.id);
+  res.json(sessionConversations);
+});
+
+// POST /api/sessions/:id/conversations - Create new conversation
+router.post('/:id/conversations', requireSession, async (req, res) => {
+  // Block creating new conversation while session is running
+  if (req.session_.status === 'running') {
+    return res.status(400).json({ error: 'Cannot create new conversation while session is running' });
+  }
+
+  const { name } = req.body;
+
+  const conversation = conversations.create(req.params.id, name || null, true);
+
+  // Broadcast conversation created event
+  broadcastToSession(req.params.id, WS_MESSAGE_TYPES.CONVERSATION_CREATED, {
+    sessionId: req.params.id,
+    conversation,
+  });
+
+  res.status(201).json(conversation);
+});
+
+// GET /api/sessions/:id/conversations/:convId - Get specific conversation
+router.get('/:id/conversations/:convId', (req, res) => {
+  const conversation = conversations.getById(req.params.convId);
+  if (!conversation || conversation.sessionId !== req.params.id) {
+    return res.status(404).json({ error: 'Conversation not found' });
+  }
+
+  // Include message count
+  const messageCount = messages.getCountByConversationId(req.params.convId);
+  res.json({ ...conversation, messageCount });
+});
+
+// PATCH /api/sessions/:id/conversations/:convId - Update conversation
+router.patch('/:id/conversations/:convId', requireSession, async (req, res) => {
+  const conversation = conversations.getById(req.params.convId);
+  if (!conversation || conversation.sessionId !== req.params.id) {
+    return res.status(404).json({ error: 'Conversation not found' });
+  }
+
+  const { name, isActive } = req.body;
+
+  // Block switching conversation while session is running
+  if (isActive && req.session_.status === 'running') {
+    return res.status(400).json({ error: 'Cannot switch conversation while session is running' });
+  }
+
+  const updateData = {};
+  if (name !== undefined) updateData.name = name;
+  if (isActive !== undefined) updateData.isActive = isActive;
+
+  const updated = conversations.update(req.params.convId, updateData);
+
+  // Broadcast conversation updated event
+  broadcastToSession(req.params.id, WS_MESSAGE_TYPES.CONVERSATION_UPDATED, {
+    sessionId: req.params.id,
+    conversation: updated,
+  });
+
+  res.json(updated);
+});
+
+// DELETE /api/sessions/:id/conversations/:convId - Delete conversation
+router.delete('/:id/conversations/:convId', requireSession, (req, res) => {
+  // Block deleting conversation while session is running
+  if (req.session_.status === 'running') {
+    return res.status(400).json({ error: 'Cannot delete conversation while session is running' });
+  }
+
+  const conversation = conversations.getById(req.params.convId);
+  if (!conversation || conversation.sessionId !== req.params.id) {
+    return res.status(404).json({ error: 'Conversation not found' });
+  }
+
+  // Delete and handle active conversation logic
+  const newActive = conversations.deleteAndHandleActive(req.params.convId);
+
+  // Broadcast conversation deleted event
+  broadcastToSession(req.params.id, WS_MESSAGE_TYPES.CONVERSATION_DELETED, {
+    sessionId: req.params.id,
+    conversationId: req.params.convId,
+    newActiveConversation: newActive,
+  });
+
+  res.status(204).send();
+});
+
+// POST /api/sessions/:id/conversations/:convId/branch - Create a branch from a conversation
+router.post('/:id/conversations/:convId/branch', requireSession, async (req, res) => {
+  // Block branching while session is running
+  if (req.session_.status === 'running') {
+    return res.status(400).json({ error: 'Cannot branch conversation while session is running' });
+  }
+
+  const conversation = conversations.getById(req.params.convId);
+  if (!conversation || conversation.sessionId !== req.params.id) {
+    return res.status(404).json({ error: 'Conversation not found' });
+  }
+
+  const { messageId, prompt } = req.body;
+
+  if (!messageId) {
+    return res.status(400).json({ error: 'messageId is required' });
+  }
+
+  if (!prompt || !prompt.trim()) {
+    return res.status(400).json({ error: 'prompt is required' });
+  }
+
+  try {
+    // Create the branch
+    // Note: name is auto-generated from the prompt in ConversationRepository.branch()
+    const branchConversation = conversations.branch(
+      req.params.convId,
+      messageId,
+      null, // name is auto-generated from prompt
+      prompt
+    );
+
+    // Broadcast the new conversation to session subscribers
+    broadcastToSession(req.params.id, WS_MESSAGE_TYPES.CONVERSATION_CREATED, {
+      sessionId: req.params.id,
+      conversation: branchConversation,
+    });
+
+    // Auto-submit to Claude: Start the session with the new prompt
+    // The branch already has the user message, so we use continueSessionWithExistingMessage
+    // which triggers Claude's response WITHOUT creating a duplicate user message
+    try {
+      const project = projects.getById(req.session_.projectId);
+      const workingDirectory = req.session_.gitWorktree || project?.workingDirectory;
+      if (workingDirectory) {
+        await continueSessionWithExistingMessage(
+          req.params.id,
+          branchConversation.id,
+          workingDirectory,
+          { systemPrompt: project?.systemPrompt }
+        );
+      }
+    } catch (err) {
+      console.error('Failed to auto-start branched conversation:', err);
+      // Don't fail the whole request if auto-start fails
+      // User can manually trigger from the UI
+    }
+
+    res.status(201).json(branchConversation);
+  } catch (error) {
+    console.error('Branch conversation error:', error);
+    res.status(400).json({ error: error.message });
+  }
+});
+
+export default router;

package/packages/server/src/api/sessions-draft.js

@@ -0,0 +1,72 @@
+import { Router } from 'express';
+import { messages } from '../database.js';
+import { broadcastToSession } from '../websocket.js';
+import { WS_MESSAGE_TYPES } from '../../../shared/src/index.js';
+import { requireSession } from '../middleware/sessionLookup.js';
+import { validateDraftSession, startDraft, DraftSessionError } from '../services/draftSessionService.js';
+
+const router = Router();
+
+// PUT /api/sessions/:id/initial-prompt - Update the initial prompt for a draft session
+router.put('/:id/initial-prompt', requireSession, (req, res) => {
+  const validation = validateDraftSession(req.session_);
+  if (!validation.valid) {
+    return res.status(400).json({ error: validation.error });
+  }
+
+  // Get the request body
+  const { prompt } = req.body;
+
+  // Validate prompt is provided and non-empty
+  if (!prompt || typeof prompt !== 'string' || prompt.trim() === '') {
+    return res.status(400).json({ error: 'Prompt must be a non-empty string' });
+  }
+
+  try {
+    const allMessages = messages.getBySessionId(req.session_.id);
+    // Find the first user message and update it
+    const userMessages = allMessages.filter(msg => msg.role === 'user');
+    if (userMessages.length === 0) {
+      return res.status(400).json({ error: 'No initial prompt found' });
+    }
+
+    const initialMessage = userMessages[0];
+    const updatedMessage = messages.updateContent(initialMessage.id, prompt);
+
+    // Broadcast the update to session subscribers
+    broadcastToSession(req.session_.id, WS_MESSAGE_TYPES.MESSAGE_UPDATED, {
+      sessionId: req.session_.id,
+      message: updatedMessage,
+    });
+
+    res.json({ success: true, message: updatedMessage });
+  } catch (error) {
+    console.error('Update initial prompt error:', error);
+    res.status(500).json({ error: error.message });
+  }
+});
+
+// POST /api/sessions/:id/start - Start a draft session (waiting status with no assistant messages)
+router.post('/:id/start', requireSession, async (req, res) => {
+  const validation = validateDraftSession(req.session_);
+  if (!validation.valid) {
+    return res.status(400).json({ error: validation.error });
+  }
+
+  try {
+    const updatedSession = await startDraft(req.session_, {
+      prompt: req.body.prompt,
+      model: req.body.model,
+    });
+
+    res.json({ success: true, session: updatedSession });
+  } catch (error) {
+    if (error instanceof DraftSessionError) {
+      return res.status(error.statusCode).json({ error: error.message });
+    }
+    console.error('Start session error:', error);
+    res.status(500).json({ error: error.message });
+  }
+});
+
+export default router;