circuschief 0.1.0

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

@@ -0,0 +1,190 @@
+import { Router } from 'express';
+import { sessions, attachments, sessionSummaries } from '../database.js';
+import { cleanupActiveSession, stopSession, restartSession } from '../services/sessionManager.js';
+import { broadcastToSession, broadcastToProject } from '../websocket.js';
+import { WS_MESSAGE_TYPES } from '../../../shared/src/index.js';
+import * as gitService from '../services/gitService.js';
+import * as summaryService from '../services/summaryService.js';
+import { executeHookAsync } from '../services/hookService.js';
+import { requireSession, requireSessionAndProject } from '../middleware/sessionLookup.js';
+import { duplicateSession } from '../services/sessionDuplicator.js';
+import { configureSchedule, ScheduleError } from '../services/scheduleService.js';
+
+const router = Router();
+
+// GET /api/sessions/:id/summary - Get session summary
+router.get('/:id/summary', requireSession, async (req, res) => {
+  // Check if generateIfMissing query param is set
+  const generateIfMissing = req.query.generate === 'true';
+
+  try {
+    const summary = await summaryService.getSummary(req.params.id, generateIfMissing);
+    if (!summary) {
+      return res.status(404).json({ error: 'Summary not found' });
+    }
+    res.json(summary);
+  } catch (error) {
+    res.status(500).json({ error: error.message });
+  }
+});
+
+// POST /api/sessions/:id/summary - Generate/regenerate session summary
+router.post('/:id/summary', requireSession, async (req, res) => {
+  try {
+    const summary = await summaryService.regenerateSummary(req.params.id);
+    if (!summary) {
+      return res.status(500).json({ error: 'Failed to generate summary' });
+    }
+    res.status(201).json(summary);
+  } catch (error) {
+    res.status(500).json({ error: error.message });
+  }
+});
+
+// PUT /api/sessions/:id/summary - Directly set summary data (for testing/seeding)
+router.put('/:id/summary', requireSession, async (req, res) => {
+  try {
+    const summary = sessionSummaries.upsert(req.params.id, req.body);
+    res.json(summary);
+  } catch (error) {
+    res.status(500).json({ error: error.message });
+  }
+});
+
+// POST /api/sessions/:id/schedule - Schedule a follow-up message for an existing session
+router.post('/:id/schedule', requireSessionAndProject, async (req, res) => {
+  try {
+    const updated = configureSchedule(req.session_, req.body);
+    res.json(updated);
+  } catch (error) {
+    if (error instanceof ScheduleError) {
+      return res.status(error.statusCode).json({ error: error.message });
+    }
+    console.error('Schedule session error:', error);
+    res.status(500).json({ error: error.message });
+  }
+});
+
+// POST /api/sessions/:id/duplicate - Duplicate a session
+router.post('/:id/duplicate', requireSession, async (req, res) => {
+  try {
+    const { name } = req.body;
+    const newSession = await duplicateSession(req.params.id, { name });
+
+    // Broadcast new session creation to project subscribers
+    broadcastToProject(req.session_.projectId, WS_MESSAGE_TYPES.SESSION_CREATED, {
+      projectId: req.session_.projectId,
+      session: newSession,
+    });
+
+    res.status(201).json(newSession);
+  } catch (error) {
+    console.error('Error duplicating session:', error);
+    res.status(500).json({ error: error.message });
+  }
+});
+
+// POST /api/sessions/:id/stop - Stop running session
+router.post('/:id/stop', requireSession, async (req, res) => {
+  // Allow stopping running, waiting, or stuck sessions (crashed sessions may be stuck in 'running')
+  // Don't allow stopping already errored or stopped sessions
+  if (req.session_.status === 'error' || req.session_.status === 'stopped') {
+    return res.status(400).json({ error: 'Session is not active' });
+  }
+
+  try {
+    await stopSession(req.session_.id);
+    res.json({ success: true });
+  } catch (error) {
+    res.status(500).json({ error: error.message });
+  }
+});
+
+// POST /api/sessions/:id/restart - Restart a completed/error session
+router.post('/:id/restart', requireSession, (req, res) => {
+  if (req.session_.status !== 'stopped' && req.session_.status !== 'error') {
+    return res.status(400).json({ error: 'Session can only be restarted when stopped or in error state' });
+  }
+
+  try {
+    restartSession(req.session_.id);
+    res.json({ success: true });
+  } catch (error) {
+    res.status(500).json({ error: error.message });
+  }
+});
+
+// DELETE /api/sessions/:id - Delete session
+router.delete('/:id', requireSessionAndProject, async (req, res) => {
+  // Collect all descendant session IDs before any deletions
+  // (database ON DELETE SET NULL would orphan them otherwise)
+  const descendantIds = sessions.getAllDescendantIds(req.params.id);
+
+  // Helper: clean up and delete a single session by ID
+  const cleanupAndDeleteSession = async (sessionId) => {
+    // Clean up active session if running
+    cleanupActiveSession(sessionId);
+
+    // Clean up summary service debounce timers
+    summaryService.cleanupSession(sessionId);
+
+    // Clean up attachment files from disk
+    try {
+      attachments.deleteSessionAttachmentsFromDisk(req.workingDirectory, sessionId);
+    } catch (error) {
+      console.warn(`Failed to remove attachment files for session ${sessionId}:`, error.message);
+    }
+
+    // Broadcast deletion to close any open WebSocket subscriptions
+    broadcastToSession(sessionId, WS_MESSAGE_TYPES.SESSION_DELETED, { sessionId });
+
+    // Delete session (cascade will handle messages, canvas items, notes)
+    sessions.delete(sessionId);
+  };
+
+  // Delete all descendants first (leaves before branches to avoid orphaning)
+  for (const descendantId of descendantIds.reverse()) {
+    await cleanupAndDeleteSession(descendantId);
+  }
+
+  // Remove git worktree if parent session has one (skip for child sessions - they may share parent's worktree)
+  if (req.session_.gitWorktree && !req.session_.parentSessionId) {
+    try {
+      await gitService.removeWorktree(req.project.workingDirectory, req.session_.gitWorktree, true);
+    } catch (error) {
+      // Log but don't fail - worktree may already be removed or have issues
+      console.warn(`Failed to remove worktree for session ${req.session_.id}:`, error.message);
+    }
+  }
+
+  // Clean up and delete the parent session itself
+  await cleanupAndDeleteSession(req.params.id);
+
+  // Broadcast deletion to project subscribers for real-time list updates
+  // (sends one event per deleted session so the frontend can remove them all)
+  broadcastToProject(req.session_.projectId, WS_MESSAGE_TYPES.SESSION_DELETED, {
+    projectId: req.session_.projectId,
+    sessionId: req.params.id,
+  });
+
+  for (const descendantId of descendantIds) {
+    broadcastToProject(req.session_.projectId, WS_MESSAGE_TYPES.SESSION_DELETED, {
+      projectId: req.session_.projectId,
+      sessionId: descendantId,
+    });
+  }
+
+  // Execute on_session_deleted hook if configured (non-blocking)
+  // Skip for child sessions - they share parent's resources and shouldn't trigger teardown
+  if (req.project?.onSessionDeleted && !req.session_.parentSessionId) {
+    executeHookAsync(req.project.onSessionDeleted, req.workingDirectory, {
+      sessionId: req.session_.id,
+      projectId: req.project.id,
+      sessionName: req.session_.name,
+    });
+  }
+
+  res.status(204).send();
+});
+
+export default router;

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

@@ -0,0 +1,141 @@
+import { Router } from 'express';
+import { sessions, messages, todos, conversations, attachments } from '../database.js';
+import { continueSession } from '../services/sessionManager.js';
+import { upload as _upload, handleUploadError } from '../middleware/upload.js';
+import { requireSession, requireSessionAndProject } from '../middleware/sessionLookup.js';
+import * as slashCommandService from '../services/slashCommandService.js';
+
+const router = Router();
+
+// GET /api/sessions/:id/messages - Get session messages
+// Supports ?conversation_id=xxx to filter by conversation
+router.get('/:id/messages', requireSession, (req, res) => {
+  const { conversation_id } = req.query;
+
+  let sessionMessages;
+  let resolvedConvId = null;
+  if (conversation_id) {
+    // Get messages for specific conversation
+    const conv = conversations.getById(conversation_id);
+    if (!conv || conv.sessionId !== req.params.id) {
+      return res.status(404).json({ error: 'Conversation not found' });
+    }
+    sessionMessages = messages.getByConversationId(conversation_id);
+    resolvedConvId = conversation_id;
+  } else {
+    // Get messages for active conversation, or all messages if no active conversation
+    const activeConv = conversations.getActiveBySessionId(req.params.id);
+    if (activeConv) {
+      sessionMessages = messages.getByConversationId(activeConv.id);
+      resolvedConvId = activeConv.id;
+    } else {
+      // Fall back to all messages (for legacy/migration)
+      sessionMessages = messages.getBySessionId(req.params.id);
+      resolvedConvId = 'all (no active conversation)';
+    }
+  }
+
+  console.log(`[API] fetchMessages: session ${req.params.id}, conversation ${resolvedConvId}, returned ${sessionMessages.length} messages`);
+
+  // Attach file attachments to each message (without content for efficiency)
+  const messagesWithAttachments = sessionMessages.map((msg) => ({
+    ...msg,
+    attachments: attachments.getByMessageIdWithoutContent(msg.id),
+  }));
+
+  res.json(messagesWithAttachments);
+});
+
+// POST /api/sessions/:id/message - Send follow-up message
+// Supports both JSON and multipart/form-data (for file attachments)
+router.post('/:id/message', _upload.array('files', 10), handleUploadError, requireSessionAndProject, async (req, res) => {
+  const content = req.body.content;
+  const model = req.body.model || null; // Model to use for this message
+  const files = req.files || [];
+
+  if (!content) {
+    return res.status(400).json({ error: 'Content is required' });
+  }
+
+  if (req.session_.status !== 'waiting' && req.session_.status !== 'stopped' && req.session_.status !== 'error') {
+    return res.status(400).json({ error: 'Session is not waiting for input' });
+  }
+
+  try {
+    // Store file attachments if any - saves to disk in workingDirectory/.attachments
+    const messageAttachments = attachments.createBatch(req.session_.id, null, files, req.workingDirectory);
+
+    // Check if the message is a slash command/skill invocation (starts with "/")
+    const resolved = await slashCommandService.resolvePromptSkillOrCommand(
+      req.workingDirectory, content, req.project.systemPrompt || null
+    );
+
+    if (resolved) {
+      continueSession(req.session_.id, resolved.userMessage, req.workingDirectory, { systemPrompt: resolved.systemPrompt, fileAttachments: messageAttachments, model }).catch((error) => {
+        console.error(`Continue session error (${resolved.type}):`, error);
+      });
+      return res.json({ success: true });
+    }
+
+    // Standard plain text message
+    continueSession(req.session_.id, content, req.workingDirectory, { systemPrompt: req.project.systemPrompt, fileAttachments: messageAttachments, model }).catch((error) => {
+      console.error('Continue session error:', error);
+    });
+    res.json({ success: true });
+  } catch (error) {
+    res.status(500).json({ error: error.message });
+  }
+});
+
+// GET /api/sessions/:id/todos - Get session todos
+// Supports ?conversation_id=xxx to fetch todos for a specific conversation
+router.get('/:id/todos', requireSession, (req, res) => {
+  const { conversation_id } = req.query;
+
+  let sessionTodos;
+  if (conversation_id) {
+    // Get todos for specific conversation
+    const conv = conversations.getById(conversation_id);
+    if (!conv || conv.sessionId !== req.params.id) {
+      return res.status(404).json({ error: 'Conversation not found' });
+    }
+    sessionTodos = todos.getByConversationId(conversation_id);
+  } else {
+    // Get todos for active conversation, or empty array if no active conversation
+    const activeConv = conversations.getActiveBySessionId(req.params.id);
+    sessionTodos = activeConv ? todos.getByConversationId(activeConv.id) : [];
+  }
+
+  res.json(sessionTodos);
+});
+
+// GET /api/sessions/:id/workflow-latest-response - Get the most recent assistant response across the entire workflow
+router.get('/:id/workflow-latest-response', requireSession, (req, res) => {
+  try {
+    // Find the root of the workflow
+    const rootId = sessions.getRootSessionId(req.params.id);
+    if (!rootId) {
+      return res.status(404).json({ error: 'Session not found' });
+    }
+
+    // Collect all session IDs in the workflow
+    const descendantIds = sessions.getAllDescendantIds(rootId);
+    const allSessionIds = [rootId, ...descendantIds];
+
+    // Find the most recent assistant message across all sessions
+    const message = messages.getLatestAssistantMessageForSessions(allSessionIds);
+    if (!message) {
+      return res.status(404).json({ error: 'No assistant response found' });
+    }
+
+    // Look up the session name for context
+    const messageSession = sessions.getById(message.sessionId);
+    const sessionName = messageSession?.name || null;
+
+    res.json({ message, sessionName });
+  } catch (error) {
+    res.status(500).json({ error: error.message });
+  }
+});
+
+export default router;

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

@@ -0,0 +1,51 @@
+import { Router } from 'express';
+import { sessionNotes } from '../database.js';
+import { requireSession } from '../middleware/sessionLookup.js';
+
+const router = Router();
+
+// GET /api/sessions/:id/notes - Get session notes
+router.get('/:id/notes', requireSession, (req, res) => {
+  const notes = sessionNotes.getBySessionId(req.params.id);
+  res.json(notes);
+});
+
+// POST /api/sessions/:id/notes - Create session note
+router.post('/:id/notes', requireSession, (req, res) => {
+  const { content } = req.body;
+  if (!content) {
+    return res.status(400).json({ error: 'Content is required' });
+  }
+
+  const note = sessionNotes.create(req.params.id, content);
+  res.status(201).json(note);
+});
+
+// PUT /api/sessions/:id/notes/:noteId - Update session note
+router.put('/:id/notes/:noteId', (req, res) => {
+  const note = sessionNotes.getById(req.params.noteId);
+  if (!note || note.sessionId !== req.params.id) {
+    return res.status(404).json({ error: 'Note not found' });
+  }
+
+  const { content } = req.body;
+  if (!content) {
+    return res.status(400).json({ error: 'Content is required' });
+  }
+
+  const updated = sessionNotes.update(req.params.noteId, content);
+  res.json(updated);
+});
+
+// DELETE /api/sessions/:id/notes/:noteId - Delete session note
+router.delete('/:id/notes/:noteId', (req, res) => {
+  const note = sessionNotes.getById(req.params.noteId);
+  if (!note || note.sessionId !== req.params.id) {
+    return res.status(404).json({ error: 'Note not found' });
+  }
+
+  sessionNotes.delete(req.params.noteId);
+  res.status(204).send();
+});
+
+export default router;

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

@@ -0,0 +1,252 @@
+import { Router } from 'express';
+import { sessions, sessionTemplates, modelProviders } from '../database.js';
+import { broadcastToSession, broadcastToProject } from '../websocket.js';
+import { WS_MESSAGE_TYPES } from '../../../shared/src/index.js';
+import * as summaryService from '../services/summaryService.js';
+import { setSessionNameFromPr } from '../services/prUrlService.js';
+import { requireSession } from '../middleware/sessionLookup.js';
+
+const router = Router();
+
+/**
+ * Validate effortLevel field
+ * @param {*} value
+ * @returns {{ error?: string, value: * }}
+ */
+function validateEffortLevel(value) {
+  if (value === null) return { value };
+  const valid = ['low', 'medium', 'high', 'max', 'auto'];
+  if (!valid.includes(value)) {
+    return { error: 'Invalid effort level. Must be one of: low, medium, high, max, auto' };
+  }
+  // Normalize 'auto' to null
+  return { value: value === 'auto' ? null : value };
+}
+
+/**
+ * Validate status field
+ * @param {*} value
+ * @returns {{ error?: string, value: * }}
+ */
+function validateStatus(value) {
+  const valid = ['starting', 'running', 'waiting', 'error', 'stopped', 'scheduled'];
+  if (!valid.includes(value)) {
+    return { error: 'Invalid status' };
+  }
+  return { value };
+}
+
+/**
+ * Validate mode field
+ * @param {*} value
+ * @returns {{ error?: string, value: * }}
+ */
+function validateMode(value) {
+  const valid = ['plan', 'standard', 'yolo'];
+  if (!valid.includes(value)) {
+    return { error: 'Invalid mode. Must be one of: plan, standard, yolo' };
+  }
+  return { value };
+}
+
+/**
+ * Validate nextTemplateId field
+ * @param {*} value
+ * @returns {{ error?: string, value: * }}
+ */
+function validateNextTemplateId(value) {
+  if (value !== null) {
+    const template = sessionTemplates.getById(value);
+    if (!template) {
+      return { error: 'Template not found' };
+    }
+  }
+  return { value };
+}
+
+/**
+ * Validate providerId field
+ * @param {*} value
+ * @returns {{ error?: string, value: * }}
+ */
+function validateProviderId(value) {
+  if (value !== null) {
+    const provider = modelProviders.getById(value);
+    if (!provider) {
+      return { error: 'Provider not found' };
+    }
+  }
+  return { value };
+}
+
+/**
+ * Validate prUrl field
+ * @param {*} value
+ * @returns {{ error?: string, value: * }}
+ */
+function validatePrUrl(value) {
+  if (value === null || value === '') {
+    return { value: null };
+  }
+  if (typeof value !== 'string') {
+    return { error: 'prUrl must be a string or null' };
+  }
+  const prUrlPattern = /^https:\/\/github\.com\/[^/]+\/[^/]+\/pull\/\d+$/;
+  if (!prUrlPattern.test(value)) {
+    return { error: 'Invalid PR URL format. Must be a valid GitHub PR URL (e.g., https://github.com/owner/repo/pull/123)' };
+  }
+  return { value };
+}
+
+/**
+ * Field definitions for PATCH /:id with optional validators and transforms.
+ * Each entry maps a request body field name to its processing config.
+ */
+const FIELD_DEFINITIONS = [
+  { field: 'name' },
+  { field: 'manuallyNamed', transform: Boolean },
+  { field: 'thinkingEnabled', transform: Boolean },
+  { field: 'effortLevel', validate: validateEffortLevel },
+  { field: 'status', validate: validateStatus },
+  { field: 'mode', validate: validateMode },
+  { field: 'nextTemplateId', validate: validateNextTemplateId },
+  { field: 'model' },
+  { field: 'pendingModel' },
+  { field: 'autoSendPendingPrompt', transform: Boolean },
+  { field: 'providerId', validate: validateProviderId },
+  { field: 'prUrl', validate: validatePrUrl },
+  // Scheduling fields
+  { field: 'scheduledAt' },
+  { field: 'autoRescheduleEnabled', transform: Boolean },
+  { field: 'rescheduleDelayMinutes', transform: (v) => parseInt(v, 10) },
+  { field: 'rescheduleOnTokenLimit', transform: Boolean },
+  { field: 'rescheduleOnServiceError', transform: Boolean },
+  { field: 'maxRescheduleCount', transform: (v) => v ? parseInt(v, 10) : null },
+  { field: 'maxTotalTokens', transform: (v) => v ? parseInt(v, 10) : null },
+  { field: 'rescheduleCount', transform: (v) => parseInt(v, 10) },
+  { field: 'rescheduleAtTokenCount', transform: (v) => v ? parseInt(v, 10) : null },
+];
+
+/**
+ * Build update data object from request body using field definitions.
+ * Returns { updateData, error } where error is a string if validation failed.
+ * @param {object} body - The request body
+ * @returns {{ updateData: object, error?: string }}
+ */
+function buildUpdateData(body) {
+  const updateData = {};
+
+  for (const { field, validate, transform } of FIELD_DEFINITIONS) {
+    const value = body[field];
+    if (value === undefined) continue;
+
+    if (validate) {
+      const result = validate(value);
+      if (result.error) return { updateData: {}, error: result.error };
+      updateData[field] = result.value;
+    } else if (transform) {
+      updateData[field] = transform(value);
+    } else {
+      updateData[field] = value;
+    }
+  }
+
+  // Special case: auto-set manuallyNamed when name is updated (unless explicitly provided)
+  if (body.name !== undefined && body.manuallyNamed === undefined) {
+    updateData.manuallyNamed = true;
+  }
+
+  return { updateData };
+}
+
+/**
+ * Broadcast session update to both session and project subscribers.
+ * @param {string} sessionId
+ * @param {string} projectId
+ * @param {object} updated - The updated session object
+ * @param {object} updateData - The fields that were updated
+ */
+function broadcastSessionUpdate(sessionId, projectId, updated, updateData) {
+  // Broadcast status update if status changed
+  if (updateData.status) {
+    broadcastToSession(sessionId, WS_MESSAGE_TYPES.SESSION_STATUS, {
+      sessionId,
+      status: updateData.status,
+    });
+  }
+
+  // Broadcast session update to session subscribers (e.g. detail view)
+  broadcastToSession(sessionId, WS_MESSAGE_TYPES.SESSION_UPDATED, {
+    sessionId,
+    session: updated,
+  });
+
+  // Broadcast session update to project subscribers for real-time list updates
+  broadcastToProject(projectId, WS_MESSAGE_TYPES.SESSION_UPDATED, {
+    projectId,
+    sessionId,
+    session: updated,
+  });
+}
+
+// PATCH /api/sessions/:id - Update session settings
+router.patch('/:id', requireSession, (req, res) => {
+  const { updateData, error } = buildUpdateData(req.body);
+
+  if (error) {
+    return res.status(400).json({ error });
+  }
+
+  if (Object.keys(updateData).length === 0) {
+    return res.status(400).json({ error: 'No valid fields to update' });
+  }
+
+  const updated = sessions.update(req.params.id, updateData);
+
+  // Propagate PR URL to parent session if set (not when clearing)
+  if (updateData.prUrl) {
+    summaryService.propagatePrUrlToParent(req.params.id, updateData.prUrl);
+
+    // Set session name from PR title (fire-and-forget async)
+    // The response returns immediately; client gets name update via WebSocket
+    setSessionNameFromPr(req.params.id, updateData.prUrl).catch(err => {
+      console.error(`[Sessions API] Failed to set session name from PR:`, err);
+    });
+  }
+
+  broadcastSessionUpdate(req.params.id, req.session_.projectId, updated, updateData);
+
+  res.json(updated);
+});
+
+// PATCH /api/sessions/:id/pending-prompt - Update pending prompt for auto-save
+router.patch('/:id/pending-prompt', requireSession, (req, res) => {
+  const { pendingPrompt } = req.body;
+
+  // Allow null or string (including empty string for clearing)
+  if (pendingPrompt !== null && typeof pendingPrompt !== 'string') {
+    return res.status(400).json({ error: 'pendingPrompt must be a string or null' });
+  }
+
+  const updated = sessions.update(req.params.id, { pendingPrompt });
+
+  // Broadcast update to session subscribers
+  broadcastToSession(req.params.id, WS_MESSAGE_TYPES.SESSION_UPDATED, {
+    sessionId: req.params.id,
+    session: updated,
+  });
+
+  // Broadcast to project subscribers for real-time updates
+  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;
+
+// Export for testing
+export { buildUpdateData, broadcastSessionUpdate, FIELD_DEFINITIONS };