circuschief 0.1.0

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

@@ -0,0 +1,86 @@
+import { Router } from 'express';
+import { workLogs } from '../database.js';
+import { broadcastToSession } from '../websocket.js';
+import { WS_MESSAGE_TYPES } from '../../../shared/src/index.js';
+import { textAccumulators, thinkingAccumulators } from '../services/streamEventHandler.js';
+import { requireSession } from '../middleware/sessionLookup.js';
+
+const router = Router();
+
+// GET /api/sessions/:id/work-logs - Get work logs for session
+router.get('/:id/work-logs', requireSession, (req, res) => {
+  // Return work logs grouped by message ID
+  const grouped = workLogs.getBySessionIdGrouped(req.params.id);
+  res.json(grouped);
+});
+
+// GET /api/sessions/:id/streaming-state - Get current streaming snapshot for a running session
+// Returns recent pending work logs, accumulated partial text, and thinking
+router.get('/:id/streaming-state', requireSession, (req, res) => {
+  const sessionId = req.params.id;
+  const pendingWorkLogs = workLogs.getRecentPendingBySessionId(sessionId);
+  const partialText = textAccumulators.get(sessionId) || '';
+  const thinking = thinkingAccumulators.get(sessionId) || null;
+
+  res.json({
+    workLogs: pendingWorkLogs,
+    partialText,
+    thinking,
+  });
+});
+
+// POST /api/sessions/:id/work-logs - Create work log (for testing)
+router.post('/:id/work-logs', requireSession, (req, res) => {
+  const { type, content, toolName, messageId } = req.body;
+  if (!type || !content) {
+    return res.status(400).json({ error: 'Type and content are required' });
+  }
+
+  const log = workLogs.create(req.params.id, type, content, { messageId: messageId || null, toolName: toolName || null });
+
+  // Broadcast to session subscribers
+  broadcastToSession(req.params.id, WS_MESSAGE_TYPES.SESSION_WORK_LOG, {
+    sessionId: req.params.id,
+    log,
+  });
+
+  res.status(201).json(log);
+});
+
+// POST /api/sessions/:id/partial-text - Set partial text (for testing)
+router.post('/:id/partial-text', requireSession, (req, res) => {
+  const { text } = req.body;
+  if (typeof text !== 'string') {
+    return res.status(400).json({ error: 'Text must be a string' });
+  }
+
+  textAccumulators.set(req.params.id, text);
+
+  // Broadcast to session subscribers
+  broadcastToSession(req.params.id, WS_MESSAGE_TYPES.SESSION_PARTIAL, {
+    sessionId: req.params.id,
+    text,
+  });
+
+  res.status(201).json({ text });
+});
+
+// POST /api/sessions/:id/thinking - Set thinking (for testing)
+router.post('/:id/thinking', requireSession, (req, res) => {
+  const { thinking } = req.body;
+  if (typeof thinking !== 'string') {
+    return res.status(400).json({ error: 'Thinking must be a string' });
+  }
+
+  thinkingAccumulators.set(req.params.id, thinking);
+
+  // Broadcast to session subscribers
+  broadcastToSession(req.params.id, WS_MESSAGE_TYPES.SESSION_THINKING_PARTIAL, {
+    sessionId: req.params.id,
+    thinking,
+  });
+
+  res.status(201).json({ thinking });
+});
+
+export default router;

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

@@ -0,0 +1,269 @@
+import { Router } from 'express';
+import { readFileSync, existsSync } from 'fs';
+import { extname, resolve, normalize } from 'path';
+import { sessions, messages, projects, commandRuns, sessionSummaries } from '../database.js';
+import { getChanges, getChangesBranch } from '../services/diffService.js';
+import * as gitService from '../services/gitService.js';
+import { requireSession, requireSessionAndProject } from '../middleware/sessionLookup.js';
+import { commandRunner } from '../services/commandRunner.js';
+
+// Import sub-routers
+import notesRouter from './sessions-notes.js';
+import conversationsRouter from './sessions-conversations.js';
+import commandsRouter from './sessions-commands.js';
+import patchRouter from './sessions-patch.js';
+import archiveRouter from './sessions-archive.js';
+import lifecycleRouter from './sessions-lifecycle.js';
+import streamingRouter from './sessions-streaming.js';
+import messagesRouter from './sessions-messages.js';
+import draftRouter from './sessions-draft.js';
+
+const router = Router();
+
+// Mount sub-routers
+router.use('/', notesRouter);
+router.use('/', conversationsRouter);
+router.use('/', commandsRouter);
+router.use('/', patchRouter);
+router.use('/', archiveRouter);
+router.use('/', lifecycleRouter);
+router.use('/', streamingRouter);
+router.use('/', messagesRouter);
+router.use('/', draftRouter);
+
+// TTL cache for files-count endpoint (60 second TTL)
+const filesCountCache = new Map();
+const FILES_COUNT_CACHE_TTL = 60_000; // 60 seconds
+
+/**
+ * Get cached files count or null if expired/missing
+ * @param {string} sessionId
+ * @returns {{ count: number } | null}
+ */
+function getCachedFilesCount(sessionId) {
+  const cached = filesCountCache.get(sessionId);
+  if (cached && (Date.now() - cached.timestamp) < FILES_COUNT_CACHE_TTL) {
+    return { count: cached.count };
+  }
+  return null;
+}
+
+/**
+ * Set files count in cache
+ * @param {string} sessionId
+ * @param {number} count
+ */
+function setCachedFilesCount(sessionId, count) {
+  filesCountCache.set(sessionId, { count, timestamp: Date.now() });
+}
+
+/**
+ * Invalidate files count cache for a session
+ * @param {string} sessionId
+ */
+export function invalidateFilesCountCache(sessionId) {
+  filesCountCache.delete(sessionId);
+}
+
+// GET /api/sessions - Get all active/waiting sessions across all projects
+router.get('/', (req, res) => {
+  const activeSessions = sessions.getActiveAndWaiting();
+  res.json(activeSessions);
+});
+
+// GET /api/sessions/scheduled - Get all scheduled sessions (optionally filtered by project)
+router.get('/scheduled', (req, res) => {
+  const { projectId } = req.query;
+  const scheduledSessions = sessions.getScheduledSessions(projectId || null);
+  res.json(scheduledSessions);
+});
+
+// POST /api/sessions/summaries/batch - Get summaries for multiple sessions in one request
+// Must be registered before /:id routes to avoid Express matching 'summaries' as an :id param
+router.post('/summaries/batch', (req, res) => {
+  const { ids } = req.body;
+  if (!Array.isArray(ids) || ids.length === 0) {
+    return res.status(400).json({ error: 'ids array is required and must not be empty' });
+  }
+
+  const summaryList = sessionSummaries.getBySessionIds(ids);
+
+  // Build a map of sessionId -> summary (or null if not found)
+  const result = {};
+  for (const id of ids) {
+    result[id] = null;
+  }
+  for (const summary of summaryList) {
+    result[summary.sessionId] = summary;
+  }
+
+  res.json(result);
+});
+
+// GET /api/sessions/:id - Get session details
+// Includes latestCommandRuns (merged from DB completed runs + in-memory running commands)
+router.get('/:id', requireSession, (req, res) => {
+  // Add hasResponses flag to indicate if session has ever received assistant responses
+  // This is used by the frontend to determine if a session is a draft
+  const allMessages = messages.getBySessionId(req.params.id);
+  const hasResponses = allMessages.some(msg => msg.role === 'assistant');
+
+  // Get command run statuses (latest run per button for this session)
+  // Completed runs from DB
+  const dbRuns = commandRuns.getLatestRunsForSession(req.params.id);
+  // Currently running commands from memory - filter all runs for this session
+  const allRunning = commandRunner.getRunsBySession(req.params.id);
+  const runningRuns = allRunning.filter(run => run.status === 'running');
+
+  // Build map of buttonId -> run data
+  // Running commands take precedence over completed ones (more current state)
+  const runsByButton = {};
+
+  // First add DB runs (completed)
+  for (const run of dbRuns) {
+    runsByButton[run.buttonId] = {
+      buttonId: run.buttonId,
+      status: run.status,
+      exitCode: run.exitCode,
+      runId: run.id,
+      startedAt: run.startedAt,
+      completedAt: run.completedAt,
+      output: run.output || null,
+    };
+  }
+
+  // Then overlay running commands (takes precedence)
+  for (const run of runningRuns) {
+    runsByButton[run.buttonId] = {
+      buttonId: run.buttonId,
+      status: 'running',
+      exitCode: null,
+      runId: run.runId,
+      startedAt: run.startedAt,
+    };
+  }
+
+  const latestCommandRuns = Object.values(runsByButton);
+
+  res.json({ ...req.session_, hasResponses, latestCommandRuns });
+});
+
+// GET /api/sessions/:id/changes - Get git changes for session
+// Query params:
+//   compareMode: 'local' (default) or 'branch' - determines what to compare against
+//   branch: branch ref to compare against (e.g., 'origin/main') - used when compareMode='branch'
+router.get('/:id/changes', requireSessionAndProject, async (req, res) => {
+  try {
+    const { compareMode = 'local', branch } = req.query;
+
+    let changes;
+    if (compareMode === 'branch' && branch) {
+      // Get changes compared to a specific branch
+      changes = await getChangesBranch(req.workingDirectory, branch);
+    } else {
+      // Default: get local changes (staged, unstaged, untracked)
+      changes = await getChanges(req.workingDirectory);
+    }
+
+    res.json(changes);
+  } catch (error) {
+    res.status(500).json({ error: error.message });
+  }
+});
+
+// Image MIME types for the file endpoint
+const IMAGE_MIME_TYPES = {
+  '.png': 'image/png',
+  '.jpg': 'image/jpeg',
+  '.jpeg': 'image/jpeg',
+  '.gif': 'image/gif',
+  '.webp': 'image/webp',
+  '.svg': 'image/svg+xml',
+  '.bmp': 'image/bmp',
+  '.ico': 'image/x-icon',
+};
+
+// GET /api/sessions/:id/file - Get a file from the session's working directory
+// Used for displaying images in the diff viewer
+router.get('/:id/file', requireSessionAndProject, (req, res) => {
+  const { path: filePath } = req.query;
+  if (!filePath) {
+    return res.status(400).json({ error: 'path query parameter is required' });
+  }
+
+  // Security: ensure the requested path is within the working directory
+  const fullPath = resolve(req.workingDirectory, filePath);
+  const normalizedDir = normalize(req.workingDirectory);
+  if (!fullPath.startsWith(normalizedDir)) {
+    return res.status(403).json({ error: 'Access denied: path outside working directory' });
+  }
+
+  if (!existsSync(fullPath)) {
+    return res.status(404).json({ error: 'File not found' });
+  }
+
+  try {
+    const ext = extname(fullPath).toLowerCase();
+    const mimeType = IMAGE_MIME_TYPES[ext];
+
+    if (!mimeType) {
+      return res.status(400).json({ error: 'Only image files are supported' });
+    }
+
+    const fileBuffer = readFileSync(fullPath);
+    const base64 = fileBuffer.toString('base64');
+
+    res.json({
+      data: base64,
+      mimeType,
+      filename: filePath,
+    });
+  } catch (error) {
+    res.status(500).json({ error: error.message });
+  }
+});
+
+// GET /api/sessions/:id/default-branch - Get the default branch for branch comparison
+router.get('/:id/default-branch', requireSessionAndProject, async (req, res) => {
+  try {
+    const branch = await gitService.getOriginDefaultBranch(req.workingDirectory);
+    res.json({ branch });
+  } catch (error) {
+    res.status(500).json({ error: error.message });
+  }
+});
+
+// GET /api/sessions/:id/files-count - Get count of modified files
+// Uses a 60-second TTL cache to avoid expensive git operations on every request
+router.get('/:id/files-count', requireSession, async (req, res) => {
+  // Check cache first
+  const cached = getCachedFilesCount(req.params.id);
+  if (cached) {
+    return res.json(cached);
+  }
+
+  const project = projects.getById(req.session_.projectId);
+  if (!project) {
+    return res.status(404).json({ error: 'Project not found' });
+  }
+
+  // Use gitWorktree if set, otherwise use the project's working directory
+  const directory = req.session_.gitWorktree || project.workingDirectory;
+
+  try {
+    // Get the default branch to compare against
+    const defaultBranch = await gitService.getOriginDefaultBranch(directory);
+    const count = await gitService.getModifiedFilesCount(directory, defaultBranch);
+
+    // Cache the result
+    setCachedFilesCount(req.params.id, count);
+
+    res.json({ count });
+  } catch (error) {
+    res.status(500).json({ error: error.message, count: 0 });
+  }
+});
+
+// PATCH /:id and PATCH /:id/pending-prompt are handled by sessions-patch.js sub-router
+
+export default router;

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

@@ -0,0 +1,194 @@
+import { Router } from 'express';
+import { settings } from '../db/index.js';
+import { DEFAULT_SESSION_TITLE_PROMPT } from '../services/summaryService.js';
+
+const router = Router();
+
+/**
+ * GET /api/settings/token-weights
+ * Get current token cost weights
+ */
+router.get('/token-weights', (req, res) => {
+  try {
+    const weights = settings.getTokenCostWeights();
+    res.json(weights);
+  } catch (error) {
+    console.error('Error getting token weights:', error);
+    res.status(500).json({ error: 'Failed to get token weights' });
+  }
+});
+
+/**
+ * PUT /api/settings/token-weights
+ * Update token cost weights
+ */
+router.put('/token-weights', (req, res) => {
+  try {
+    const { input, output, cacheRead, cacheCreation } = req.body;
+
+    // Validate required fields are present and are numbers
+    if (typeof input !== 'number' || typeof output !== 'number' ||
+        typeof cacheRead !== 'number' || typeof cacheCreation !== 'number') {
+      return res.status(400).json({
+        error: 'All weights (input, output, cacheRead, cacheCreation) must be numbers'
+      });
+    }
+
+    // Validate weights are positive
+    if (input < 0 || output < 0 || cacheRead < 0 || cacheCreation < 0) {
+      return res.status(400).json({
+        error: 'All weights must be non-negative numbers'
+      });
+    }
+
+    const updatedWeights = settings.setTokenCostWeights({
+      input,
+      output,
+      cacheRead,
+      cacheCreation,
+    });
+
+    res.json(updatedWeights);
+  } catch (error) {
+    console.error('Error updating token weights:', error);
+    res.status(500).json({ error: 'Failed to update token weights' });
+  }
+});
+
+/**
+ * DELETE /api/settings/token-weights
+ * Reset token cost weights to defaults
+ */
+router.delete('/token-weights', (req, res) => {
+  try {
+    const defaults = settings.resetTokenCostWeights();
+    res.json(defaults);
+  } catch (error) {
+    console.error('Error resetting token weights:', error);
+    res.status(500).json({ error: 'Failed to reset token weights' });
+  }
+});
+
+/**
+ * GET /api/settings/summary
+ * Get summary settings
+ */
+router.get('/summary', (req, res) => {
+  try {
+    const summarySettings = settings.getSummarySettings();
+    // Include the default prompt for UI display/editing
+    res.json({
+      ...summarySettings,
+      defaultSessionTitlePrompt: DEFAULT_SESSION_TITLE_PROMPT,
+    });
+  } catch (error) {
+    console.error('Error getting summary settings:', error);
+    res.status(500).json({ error: 'Failed to get summary settings' });
+  }
+});
+
+/**
+ * PUT /api/settings/summary
+ * Update summary settings
+ */
+router.put('/summary', (req, res) => {
+  try {
+    const { disableSessionSummaries, sessionTitlePrompt } = req.body;
+
+    // Validate that all required fields are present
+    if (typeof disableSessionSummaries !== 'boolean' ||
+        typeof sessionTitlePrompt !== 'string') {
+      return res.status(400).json({
+        error: 'Invalid summary settings. disableSessionSummaries must be a boolean, sessionTitlePrompt must be a string'
+      });
+    }
+
+    const updatedSettings = settings.setSummarySettings({
+      disableSessionSummaries,
+      sessionTitlePrompt,
+    });
+
+    // Include the default prompt for UI display/editing
+    res.json({
+      ...updatedSettings,
+      defaultSessionTitlePrompt: DEFAULT_SESSION_TITLE_PROMPT,
+    });
+  } catch (error) {
+    console.error('Error updating summary settings:', error);
+    res.status(500).json({ error: 'Failed to update summary settings' });
+  }
+});
+
+/**
+ * DELETE /api/settings/summary
+ * Reset summary settings to defaults
+ */
+router.delete('/summary', (req, res) => {
+  try {
+    const defaults = settings.resetSummarySettings();
+    // Include the default prompt for UI display/editing
+    res.json({
+      ...defaults,
+      defaultSessionTitlePrompt: DEFAULT_SESSION_TITLE_PROMPT,
+    });
+  } catch (error) {
+    console.error('Error resetting summary settings:', error);
+    res.status(500).json({ error: 'Failed to reset summary settings' });
+  }
+});
+
+/**
+ * GET /api/settings/general
+ * Get general settings (includes privacy settings)
+ */
+router.get('/general', (req, res) => {
+  try {
+    const generalSettings = settings.getGeneralSettings();
+    res.json(generalSettings);
+  } catch (error) {
+    console.error('Error getting general settings:', error);
+    res.status(500).json({ error: 'Failed to get general settings' });
+  }
+});
+
+/**
+ * PUT /api/settings/general
+ * Update general settings
+ */
+router.put('/general', (req, res) => {
+  try {
+    const { disableAnalytics } = req.body;
+
+    // Validate that disableAnalytics is a boolean
+    if (typeof disableAnalytics !== 'boolean') {
+      return res.status(400).json({
+        error: 'Invalid general settings. disableAnalytics must be a boolean'
+      });
+    }
+
+    const updatedSettings = settings.setGeneralSettings({
+      disableAnalytics,
+    });
+
+    res.json(updatedSettings);
+  } catch (error) {
+    console.error('Error updating general settings:', error);
+    res.status(500).json({ error: 'Failed to update general settings' });
+  }
+});
+
+/**
+ * DELETE /api/settings/general
+ * Reset general settings to defaults
+ */
+router.delete('/general', (req, res) => {
+  try {
+    const defaults = settings.resetGeneralSettings();
+    res.json(defaults);
+  } catch (error) {
+    console.error('Error resetting general settings:', error);
+    res.status(500).json({ error: 'Failed to reset general settings' });
+  }
+});
+
+export default router;

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

@@ -0,0 +1,63 @@
+import { Router } from 'express';
+import { sessionTemplates } from '../database.js';
+import { CreateSessionTemplateRequest, UpdateSessionTemplateRequest } from '../../../shared/src/contracts/templates.js';
+
+const router = Router();
+
+// GET /api/templates - List all global templates
+router.get('/', (_req, res) => {
+  const templates = sessionTemplates.getGlobal();
+  res.json(templates);
+});
+
+// POST /api/templates - Create global template
+router.post('/', (req, res) => {
+  const result = CreateSessionTemplateRequest.safeParse(req.body);
+  if (!result.success) {
+    return res.status(400).json({ error: result.error.issues[0].message });
+  }
+
+  const template = sessionTemplates.create({
+    projectId: null, // Global template
+    ...result.data,
+  });
+  res.status(201).json(template);
+});
+
+// GET /api/templates/:id - Get template by ID
+router.get('/:id', (req, res) => {
+  const template = sessionTemplates.getById(req.params.id);
+  if (!template) {
+    return res.status(404).json({ error: 'Template not found' });
+  }
+  res.json(template);
+});
+
+// PATCH /api/templates/:id - Update template
+router.patch('/:id', (req, res) => {
+  const template = sessionTemplates.getById(req.params.id);
+  if (!template) {
+    return res.status(404).json({ error: 'Template not found' });
+  }
+
+  const result = UpdateSessionTemplateRequest.safeParse(req.body);
+  if (!result.success) {
+    return res.status(400).json({ error: result.error.issues[0].message });
+  }
+
+  const updated = sessionTemplates.update(req.params.id, result.data);
+  res.json(updated);
+});
+
+// DELETE /api/templates/:id - Delete template
+router.delete('/:id', (req, res) => {
+  const template = sessionTemplates.getById(req.params.id);
+  if (!template) {
+    return res.status(404).json({ error: 'Template not found' });
+  }
+
+  sessionTemplates.delete(req.params.id);
+  res.status(204).send();
+});
+
+export default router;

package/packages/server/src/app.js

@@ -0,0 +1,51 @@
+import express from 'express';
+import cors from 'cors';
+import { fileURLToPath } from 'url';
+import { dirname, join } from 'path';
+import apiRouter from './api/index.js';
+import { MAX_JSON_SIZE } from '../../shared/src/index.js';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+/**
+ * Create Express application
+ * @param {Object} options
+ * @param {boolean} options.production - Enable production mode
+ * @returns {express.Application}
+ */
+export function createApp(options = {}) {
+  const app = express();
+
+  // CORS (allow all in dev)
+  app.use(cors());
+
+  // Body parsing
+  app.use(express.json({ limit: MAX_JSON_SIZE }));
+  app.use(express.urlencoded({ extended: true, limit: MAX_JSON_SIZE }));
+
+  // Multipart form data parsing is handled per-route with specific middleware
+  // to avoid conflicts between upload.single() and upload.array() across different endpoints
+
+  // API routes
+  app.use('/api', apiRouter);
+
+  // Static files and SPA fallback (production only - in dev, Vite serves frontend)
+  if (options.production) {
+    const staticPath = join(__dirname, '../../web/dist');
+    app.use(express.static(staticPath));
+
+    // SPA fallback for client-side routing
+    app.get('/*', (_req, res) => {
+      res.sendFile(join(staticPath, 'index.html'));
+    });
+  }
+
+  // Error handler
+  app.use((err, _req, res, _next) => {
+    console.error('Server error:', err);
+    res.status(500).json({ error: err.message || 'Internal server error' });
+  });
+
+  return app;
+}