circuschief 0.1.0

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

@@ -0,0 +1,331 @@
+import { Router } from 'express';
+import { readFileSync, existsSync, statSync } from 'fs';
+import { mkdir } from 'fs/promises';
+import { extname, join, basename } from 'path';
+import { sessions, canvasItems } from '../database.js';
+import { broadcastToSession } from '../websocket.js';
+import { WS_MESSAGE_TYPES, UpdateCanvasItemRequest } from '../../../shared/src/index.js';
+import { upload, handleUploadError } from '../middleware/upload.js';
+import {
+  isBinaryContent,
+  getTypeFromExtension,
+  processFileBuffer,
+  VALID_INLINE_TYPES,
+  validateInlineType,
+  buildInlineItemData,
+  broadcastCanvasUpdate,
+  writeCanvasItemToFile,
+} from './canvas-helpers.js';
+import trashRoutes from './canvas-trash-routes.js';
+
+// Error message constants
+const ERR_SESSION_NOT_FOUND = 'Session not found';
+
+/**
+ * Process multipart file upload (Mode 1)
+ * @param {Express.Multer.File} file - The uploaded file from multer
+ * @returns {{ itemData: Object } | { error: string }}
+ */
+function handleMultipartUpload(file) {
+  const result = processFileBuffer(file.buffer, file.originalname);
+  if (result.error) {
+    return { error: result.error };
+  }
+  return { itemData: result.itemData };
+}
+
+/**
+ * Process file path upload (Mode 2) - reads file from disk
+ * @param {string} filePath - Path to the file on disk
+ * @returns {{ itemData: Object } | { error: string }}
+ */
+function handleFilePathUpload(filePath) {
+  if (!existsSync(filePath)) {
+    return { error: `File not found: ${filePath}` };
+  }
+
+  try {
+    const fileBuffer = readFileSync(filePath);
+    const result = processFileBuffer(fileBuffer, basename(filePath));
+    if (result.error) {
+      return { error: result.error };
+    }
+    return { itemData: result.itemData };
+  } catch (err) {
+    return { error: `Failed to read file: ${err.message}` };
+  }
+}
+
+/**
+ * Process inline content upload (Mode 3)
+ * @param {string} type - The content type
+ * @param {string} content - The content data
+ * @param {string} filename - The filename
+ * @returns {{ itemData: Object } | { error: string }}
+ */
+function handleInlineUpload(type, content, filename) {
+  const validationError = validateInlineType(type);
+  if (validationError) {
+    return { error: validationError };
+  }
+  return { itemData: buildInlineItemData(type, content, filename) };
+}
+
+// Re-export for tests
+export { isBinaryContent, getTypeFromExtension };
+
+const router = Router();
+
+// Mount trash and bulk operation routes
+router.use('/', trashRoutes);
+
+// POST /api/sessions/:id/canvas - Add canvas item
+// Supports three modes:
+// 1. Multipart mode: FormData with 'file' field - from browser file uploads
+// 2. File mode: { filePath } - reads file from disk
+// 3. Inline mode: { type, content, filename } - uses provided content directly
+router.post('/:id/canvas', upload.single('file'), handleUploadError, (req, res) => {
+  const session = sessions.getById(req.params.id);
+  if (!session) {
+    return res.status(404).json({ error: ERR_SESSION_NOT_FOUND });
+  }
+
+  const { filePath, type, content, filename } = req.body;
+  let result;
+
+  // Determine upload mode and process accordingly
+  if (req.file) {
+    result = handleMultipartUpload(req.file);
+  } else if (filePath) {
+    result = handleFilePathUpload(filePath);
+  } else if (content !== undefined && type && filename) {
+    result = handleInlineUpload(type, content, filename);
+  } else {
+    return res.status(400).json({
+      error: 'Either file upload, filePath, or (type + content + filename) is required'
+    });
+  }
+
+  if (result.error) {
+    return res.status(400).json({ error: result.error });
+  }
+
+  const item = canvasItems.create(req.params.id, result.itemData);
+
+  // Broadcast to session subscribers
+  broadcastCanvasUpdate(req.params.id, item);
+
+  res.status(201).json(item);
+});
+
+// PUT /api/sessions/:id/canvas/:itemId - Update canvas item content in-place
+router.put('/:id/canvas/:itemId', (req, res) => {
+  const session = sessions.getById(req.params.id);
+  if (!session) {
+    return res.status(404).json({ error: ERR_SESSION_NOT_FOUND });
+  }
+
+  const parsed = UpdateCanvasItemRequest.safeParse(req.body);
+  if (!parsed.success) {
+    return res.status(400).json({ error: 'Invalid request body', details: parsed.error.issues });
+  }
+
+  const item = canvasItems.getById(req.params.itemId);
+  if (!item) {
+    return res.status(404).json({ error: 'Canvas item not found' });
+  }
+
+  if (item.sessionId !== req.params.id) {
+    return res.status(400).json({ error: 'Canvas item does not belong to this session' });
+  }
+
+  if (!VALID_INLINE_TYPES.includes(item.type)) {
+    return res.status(400).json({ error: `Cannot update content for type: ${item.type}. Editable types: ${VALID_INLINE_TYPES.join(', ')}` });
+  }
+
+  const updatedItem = canvasItems.updateContent(req.params.itemId, parsed.data.content);
+  broadcastToSession(req.params.id, WS_MESSAGE_TYPES.CANVAS_UPDATE, { item: updatedItem });
+  res.json(updatedItem);
+});
+
+// GET /api/sessions/:id/canvas - List canvas items
+// Returns only latest version of each file (no version metadata exposed)
+router.get('/:id/canvas', (req, res) => {
+  const session = sessions.getById(req.params.id);
+  if (!session) {
+    return res.status(404).json({ error: ERR_SESSION_NOT_FOUND });
+  }
+
+  // Get only latest versions (one per filename)
+  const items = canvasItems.getLatestVersionsBySessionId(req.params.id);
+
+  // Strip content/data from list responses to reduce payload size.
+  // Clients should use GET /canvas/file/:filename/content for inline content.
+  res.json(items.map(({ content: _content, data: _data, ...meta }) => meta));
+});
+
+// GET /api/sessions/:id/canvas/all - List ALL canvas items (including all versions)
+// Returns all versions of each file for the frontend UI
+router.get('/:id/canvas/all', (req, res) => {
+  const session = sessions.getById(req.params.id);
+  if (!session) {
+    return res.status(404).json({ error: ERR_SESSION_NOT_FOUND });
+  }
+
+  // Get ALL versions (not just latest)
+  const items = canvasItems.getBySessionId(req.params.id);
+
+  // Strip content/data from list responses to reduce payload size.
+  res.json(items.map(({ content: _content, data: _data, ...meta }) => meta));
+});
+
+// GET /api/sessions/:id/canvas/file/:filename/history/:version - Get historical version of canvas file
+// Uses standard versioning: version 1 = oldest, version N = latest (where N = totalVersions)
+// NOTE: This route must be defined BEFORE the main file route to match correctly
+router.get('/:id/canvas/file/:filename/history/:version', async (req, res) => {
+  const { id: sessionId, filename, version } = req.params;
+  const versionNum = parseInt(version, 10);
+
+  const session = sessions.getById(sessionId);
+  if (!session) {
+    return res.status(404).json({ error: ERR_SESSION_NOT_FOUND });
+  }
+
+  // Get all versions of this file (newest first)
+  const allVersions = canvasItems.getAllVersionsByFilename(sessionId, filename);
+  if (allVersions.length === 0) {
+    return res.status(404).json({ error: 'File not found on canvas' });
+  }
+
+  // Validate version number
+  if (isNaN(versionNum) || versionNum < 1 || versionNum > allVersions.length) {
+    return res.status(404).json({
+      error: `Version ${versionNum} not found. Available versions: 1-${allVersions.length} (1 = oldest, ${allVersions.length} = latest)`
+    });
+  }
+
+  // Convert version number to array index
+  // allVersions is sorted DESC (newest first): [0] = newest, [length-1] = oldest
+  // Standard versioning: version 1 = oldest, version N = newest
+  // Mapping: version 1 → index (length-1), version N → index 0
+  // Formula: index = length - version
+  const index = allVersions.length - versionNum;
+  const item = allVersions[index];
+
+  try {
+    // Create temp directory for this session
+    const tempDir = `/tmp/canvas-${sessionId}`;
+    await mkdir(tempDir, { recursive: true });
+
+    // Include version in filename to avoid collisions when viewing multiple versions
+    const ext = extname(filename);
+    const base = basename(filename, ext);
+    const tempFilename = `${base}.v${versionNum}${ext}`;
+    const filePath = join(tempDir, tempFilename);
+
+    // Write content based on type
+    await writeCanvasItemToFile(item, filePath);
+
+    // Get file size
+    const stats = statSync(filePath);
+    const fileSize = stats.size;
+
+    res.json({
+      filePath,
+      type: item.type,
+      mimeType: item.mimeType,
+      fileSize,
+      createdAt: item.createdAt,
+      version: versionNum,
+      totalVersions: allVersions.length
+    });
+  } catch (err) {
+    res.status(500).json({ error: `Failed to write file: ${err.message}` });
+  }
+});
+
+// GET /api/sessions/:id/canvas/file/:filename/content - Get canvas file content inline
+// Returns content/data inline in JSON for browser consumption (unlike the temp-file endpoint below)
+// Supports ?version=N query param (1-based, 1 = oldest)
+router.get('/:id/canvas/file/:filename/content', (req, res) => {
+  const session = sessions.getById(req.params.id);
+  if (!session) return res.status(404).json({ error: ERR_SESSION_NOT_FOUND });
+
+  const allVersions = canvasItems.getAllVersionsByFilename(req.params.id, req.params.filename);
+  if (allVersions.length === 0) return res.status(404).json({ error: 'File not found' });
+
+  // Support ?version=N (1-based, 1 = oldest)
+  const versionParam = parseInt(req.query.version);
+  let item;
+  if (!isNaN(versionParam) && versionParam >= 1 && versionParam <= allVersions.length) {
+    // allVersions is sorted DESC (newest first): [0] = newest, [length-1] = oldest
+    // Standard versioning: version 1 = oldest, version N = newest
+    const index = allVersions.length - versionParam;
+    item = allVersions[index];
+  } else if (!isNaN(versionParam)) {
+    return res.status(404).json({
+      error: `Version ${versionParam} not found. Available versions: 1-${allVersions.length}`
+    });
+  } else {
+    item = allVersions[0]; // latest
+  }
+
+  res.json({
+    content: item.content ?? null,
+    data: item.data ?? null,
+    type: item.type,
+    mimeType: item.mimeType,
+    filename: item.filename,
+  });
+});
+
+// GET /api/sessions/:id/canvas/file/:filename - Get canvas file by filename
+// Writes the file to /tmp and returns the file path for Claude's Read tool
+// Always returns the latest version
+router.get('/:id/canvas/file/:filename', async (req, res) => {
+  const { id: sessionId, filename } = req.params;
+
+  const session = sessions.getById(sessionId);
+  if (!session) {
+    return res.status(404).json({ error: ERR_SESSION_NOT_FOUND });
+  }
+
+  // Get all versions of this file (newest first)
+  const allVersions = canvasItems.getAllVersionsByFilename(sessionId, filename);
+  if (allVersions.length === 0) {
+    return res.status(404).json({ error: 'File not found on canvas' });
+  }
+
+  // Always use latest version (index 0)
+  const item = allVersions[0];
+
+  try {
+    // Create temp directory for this session
+    const tempDir = `/tmp/canvas-${sessionId}`;
+    await mkdir(tempDir, { recursive: true });
+
+    // Use original filename without version suffix
+    const filePath = join(tempDir, filename);
+
+    // Write content based on type
+    await writeCanvasItemToFile(item, filePath);
+
+    // Get file size
+    const stats = statSync(filePath);
+    const fileSize = stats.size;
+
+    res.json({
+      filePath,
+      type: item.type,
+      mimeType: item.mimeType,
+      fileSize,
+      createdAt: item.createdAt,
+      version: allVersions.length, // Latest version number in standard versioning
+      totalVersions: allVersions.length
+    });
+  } catch (err) {
+    res.status(500).json({ error: `Failed to write file: ${err.message}` });
+  }
+});
+
+export default router;

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

@@ -0,0 +1,312 @@
+import { Router } from 'express';
+import { commandButtons, sessions, commandRuns, projects } from '../database.js';
+import { CreateCommandButtonRequest, UpdateCommandButtonRequest } from '../../../shared/src/contracts/commandButtons.js';
+import { commandRunner } from '../services/commandRunner.js';
+import { broadcastToSession, broadcastToProject } from '../websocket.js';
+import { WS_MESSAGE_TYPES } from '../../../shared/src/index.js';
+import { databaseManager } from '../db/DatabaseManager.js';
+
+// Error message constants
+const ERR_SESSION_NOT_FOUND = 'Session not found';
+
+const router = Router({ mergeParams: true });
+
+/**
+ * Create WebSocket broadcast callbacks for a command run
+ * @param {string} sessionId
+ * @param {string} projectId
+ * @param {string} runId
+ * @param {string} buttonId
+ * @returns {Object} Callbacks for onOutput, onComplete, onError
+ */
+function createCommandRunCallbacks(sessionId, projectId, runId, buttonId) {
+  return {
+    onOutput: (text) => {
+      broadcastToSession(sessionId, WS_MESSAGE_TYPES.COMMAND_RUN_OUTPUT, {
+        sessionId, runId, buttonId, output: text,
+      });
+      broadcastToProject(projectId, WS_MESSAGE_TYPES.COMMAND_RUN_OUTPUT, {
+        projectId, sessionId, runId, buttonId, output: text,
+      });
+    },
+    onComplete: (exitCode, output) => {
+      const status = exitCode === 0 ? 'success' : 'error';
+      console.log(`[CommandButtons] Command completed: runId=${runId}, buttonId=${buttonId}, exitCode=${exitCode}, status=${status}`);
+      console.log(`[CommandButtons] Broadcasting to session ${sessionId}`);
+      broadcastToSession(sessionId, WS_MESSAGE_TYPES.COMMAND_RUN_COMPLETE, {
+        sessionId, runId, buttonId, status, exitCode, output,
+      });
+      console.log(`[CommandButtons] Broadcasting to project ${projectId}`);
+      broadcastToProject(projectId, WS_MESSAGE_TYPES.COMMAND_RUN_COMPLETE, {
+        projectId, sessionId, runId, buttonId, status, exitCode, output,
+      });
+    },
+    onError: (message) => {
+      broadcastToSession(sessionId, WS_MESSAGE_TYPES.COMMAND_RUN_ERROR, {
+        sessionId, runId, buttonId, error: message,
+      });
+      broadcastToProject(projectId, WS_MESSAGE_TYPES.COMMAND_RUN_ERROR, {
+        projectId, sessionId, runId, buttonId, error: message,
+      });
+    },
+  };
+}
+
+/**
+ * Broadcast a command run error to session and project subscribers
+ */
+function broadcastCommandRunError({ sessionId, projectId, runId, buttonId, 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,
+  });
+}
+
+// GET /api/projects/:projectId/command-buttons - List all command buttons for project
+router.get('/', (req, res) => {
+  const { projectId } = req.params;
+  const buttons = commandButtons.getByProjectId(projectId);
+  res.json(buttons);
+});
+
+// GET /api/projects/:projectId/command-buttons/latest-runs - Get latest run for each button per session in project
+router.get('/latest-runs', (req, res) => {
+  const { projectId } = req.params;
+
+  // Verify project exists
+  const project = projects.getById(projectId);
+  if (!project) {
+    return res.status(404).json({ error: 'Project not found' });
+  }
+
+  const latestRuns = commandRuns.getLatestRunsForProject(projectId);
+  res.json(latestRuns);
+});
+
+// POST /api/projects/:projectId/command-buttons - Create new command button
+router.post('/', (req, res) => {
+  const result = CreateCommandButtonRequest.safeParse(req.body);
+  if (!result.success) {
+    return res.status(400).json({ error: result.error.issues[0].message });
+  }
+
+  const button = commandButtons.create({
+    projectId: req.params.projectId,
+    label: result.data.label,
+    command: result.data.command,
+    sortOrder: result.data.sortOrder,
+    showOnList: result.data.showOnList,
+  });
+
+  res.status(201).json(button);
+});
+
+// GET /api/projects/:projectId/command-buttons/:id - Get single button
+router.get('/:id', (req, res) => {
+  const button = commandButtons.getById(req.params.id);
+  if (!button) {
+    return res.status(404).json({ error: 'Command button not found' });
+  }
+  res.json(button);
+});
+
+// PATCH /api/projects/:projectId/command-buttons/:id - Update button
+router.patch('/:id', (req, res) => {
+  const button = commandButtons.getById(req.params.id);
+  if (!button) {
+    return res.status(404).json({ error: 'Command button not found' });
+  }
+
+  const result = UpdateCommandButtonRequest.safeParse(req.body);
+  if (!result.success) {
+    return res.status(400).json({ error: result.error.issues[0].message });
+  }
+
+  // Map validated data and only include fields that were provided
+  const updateData = {};
+  if (result.data.label !== undefined) updateData.label = result.data.label;
+  if (result.data.command !== undefined) updateData.command = result.data.command;
+  if (result.data.sortOrder !== undefined) updateData.sortOrder = result.data.sortOrder;
+  if (result.data.showOnList !== undefined) updateData.showOnList = result.data.showOnList;
+
+  const updated = commandButtons.update(req.params.id, updateData);
+  res.json(updated);
+});
+
+// DELETE /api/projects/:projectId/command-buttons/:id - Delete button
+router.delete('/:id', (req, res) => {
+  const button = commandButtons.getById(req.params.id);
+  if (!button) {
+    return res.status(404).json({ error: 'Command button not found' });
+  }
+
+  commandButtons.delete(req.params.id);
+  res.status(204).send();
+});
+
+// POST /api/sessions/:sessionId/command-buttons/:buttonId/run - Execute button command
+router.post('/run/:buttonId', (req, res) => {
+  const { sessionId, buttonId } = req.params;
+
+  const session = sessions.getById(sessionId);
+  if (!session) {
+    return res.status(404).json({ error: ERR_SESSION_NOT_FOUND });
+  }
+
+  const button = commandButtons.getById(buttonId);
+  if (!button) {
+    return res.status(404).json({ error: 'Command button not found' });
+  }
+
+  const workingDirectory = session.gitWorktree || session.project?.workingDirectory || process.cwd();
+  const runId = databaseManager.generateId();
+
+  res.json({ runId, buttonId, status: 'running', output: '' });
+
+  const callbacks = createCommandRunCallbacks(sessionId, session.projectId, runId, buttonId);
+
+  (async () => {
+    try {
+      await commandRunner.run(
+        { runId, command: button.command, workingDirectory },
+        callbacks,
+        { sessionId, buttonId }
+      );
+    } catch (error) {
+      console.error(`Error running command button ${buttonId}:`, error);
+      broadcastCommandRunError({ sessionId, projectId: session.projectId, runId, buttonId, errorMessage: error.message });
+    }
+  })();
+});
+
+// GET /api/sessions/:sessionId/command-buttons/runs - Get active runs for session
+router.get('/runs', (req, res) => {
+  const { sessionId } = req.params;
+
+  const session = sessions.getById(sessionId);
+  if (!session) {
+    return res.status(404).json({ error: ERR_SESSION_NOT_FOUND });
+  }
+
+  // Get running + recent (last hour) from commandRunner
+  const activeRuns = commandRunner.getRunsBySession(sessionId);
+
+  // Also get latest run per button (for historical context beyond 1 hour)
+  const latestRuns = commandRuns.getLatestRunsForSession(sessionId);
+
+  // Merge, preferring activeRuns data (more current output)
+  // Use buttonId as the key to avoid duplicates
+  const runMap = new Map();
+
+  // First add latest runs from database
+  for (const run of latestRuns) {
+    runMap.set(run.buttonId, {
+      runId: run.id,
+      buttonId: run.buttonId,
+      status: run.status,
+      output: run.output,
+      exitCode: run.exitCode,
+      startedAt: run.startedAt,
+      completedAt: run.completedAt,
+    });
+  }
+
+  // Override with active/recent runs (they're more current)
+  for (const run of activeRuns) {
+    runMap.set(run.buttonId, run);
+  }
+
+  res.json(Array.from(runMap.values()));
+});
+
+// GET /api/sessions/:sessionId/command-buttons/runs/:runId - Get single run by ID
+router.get('/runs/:runId', (req, res) => {
+  const { sessionId, runId } = req.params;
+
+  const session = sessions.getById(sessionId);
+  if (!session) {
+    return res.status(404).json({ error: ERR_SESSION_NOT_FOUND });
+  }
+
+  // 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/:sessionId/command-buttons/runs/:runId - Delete a command run record
+router.delete('/runs/:runId', (req, res) => {
+  const { sessionId, runId } = req.params;
+
+  const session = sessions.getById(sessionId);
+  if (!session) {
+    return res.status(404).json({ error: ERR_SESSION_NOT_FOUND });
+  }
+
+  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);
+
+  // Broadcast deletion to session and project subscribers
+  broadcastToSession(sessionId, WS_MESSAGE_TYPES.COMMAND_RUN_DELETED, {
+    runId,
+    buttonId: run.buttonId,
+    sessionId,
+  });
+  broadcastToProject(session.projectId, WS_MESSAGE_TYPES.COMMAND_RUN_DELETED, {
+    runId,
+    buttonId: run.buttonId,
+    sessionId,
+    projectId: session.projectId,
+  });
+
+  res.status(204).send();
+});
+
+// POST /api/sessions/:sessionId/command-buttons/runs/:runId/kill - Kill running command
+router.post('/runs/:runId/kill', (req, res) => {
+  const { sessionId, runId } = req.params;
+
+  const session = sessions.getById(sessionId);
+  if (!session) {
+    return res.status(404).json({ error: ERR_SESSION_NOT_FOUND });
+  }
+
+  const killed = commandRunner.kill(runId);
+  if (!killed) {
+    return res.status(404).json({ error: 'Run not found or already completed' });
+  }
+
+  res.json({ success: true, runId });
+});
+
+export default router;