circuschief 0.1.0

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

@@ -0,0 +1,384 @@
+import { Router } from 'express';
+import { projects, sessions, sessionTemplates, commandButtons, projectDefaults, commandRuns } from '../database.js';
+import { commandRunner } from '../services/commandRunner.js';
+import { CreateProjectRequest, UpdateProjectRequest, ProjectSessionDefaultsRequest } from '../../../shared/src/contracts/projects.js';
+import { ProjectDefaultsRepository } from '../db/ProjectDefaultsRepository.js';
+import { CreateSessionTemplateRequest } from '../../../shared/src/contracts/templates.js';
+import { CreateCommandButtonRequest, UpdateCommandButtonRequest } from '../../../shared/src/contracts/commandButtons.js';
+import { broadcastToProject } from '../websocket.js';
+import { WS_MESSAGE_TYPES } from '../../../shared/src/index.js';
+import { handleUploadError, uploadMiddleware } from '../middleware/upload.js';
+import {
+  generateInitialName,
+  prepareSessionConfig,
+  applyTemplateOverrides,
+  resolveNextTemplateId,
+  determineInitialStatus,
+  buildSchedulingUpdate,
+  setupAndStartSession,
+} from './projects-session-helpers.js';
+import { validateGitSettings, buildRunsBySession } from './projects-helpers.js';
+
+// Error message constants
+const ERR_PROJECT_NOT_FOUND = 'Project not found';
+
+const router = Router();
+
+// GET /api/projects - List all projects
+router.get('/', (_req, res) => {
+  const allProjects = projects.getAll();
+  res.json(allProjects);
+});
+
+// POST /api/projects - Create project
+router.post('/', (req, res) => {
+  const result = CreateProjectRequest.safeParse(req.body);
+  if (!result.success) {
+    return res.status(400).json({ error: result.error.issues[0].message });
+  }
+
+  const { name, workingDirectory, systemPrompt, onSessionCreated, onSessionDeleted } = result.data;
+  const project = projects.create(name, workingDirectory, systemPrompt || null, {
+    onSessionCreated: onSessionCreated || null,
+    onSessionDeleted: onSessionDeleted || null,
+  });
+  res.status(201).json(project);
+});
+
+// GET /api/projects/:id - Get project
+router.get('/:id', (req, res) => {
+  const project = projects.getById(req.params.id);
+  if (!project) {
+    return res.status(404).json({ error: ERR_PROJECT_NOT_FOUND });
+  }
+  res.json(project);
+});
+
+// PUT /api/projects/:id - Update project
+router.put('/:id', (req, res) => {
+  const project = projects.getById(req.params.id);
+  if (!project) {
+    return res.status(404).json({ error: ERR_PROJECT_NOT_FOUND });
+  }
+
+  const result = UpdateProjectRequest.safeParse(req.body);
+  if (!result.success) {
+    return res.status(400).json({ error: result.error.issues[0].message });
+  }
+
+  const updated = projects.update(req.params.id, result.data);
+  res.json(updated);
+});
+
+// DELETE /api/projects/:id - Delete project
+router.delete('/:id', (req, res) => {
+  const project = projects.getById(req.params.id);
+  if (!project) {
+    return res.status(404).json({ error: ERR_PROJECT_NOT_FOUND });
+  }
+
+  projects.delete(req.params.id);
+  res.status(204).send();
+});
+
+// GET /api/projects/:id/sessions - List project sessions
+// Supports ?archived=true|false to filter by archive status
+// Supports ?starred=true|false to filter by starred status
+// Supports ?limit=N&offset=M for pagination (returns pagination metadata when limit is specified)
+// Each session includes latestCommandRuns (merged from DB completed runs + in-memory running commands)
+router.get('/:id/sessions', (req, res) => {
+  const project = projects.getById(req.params.id);
+  if (!project) {
+    return res.status(404).json({ error: ERR_PROJECT_NOT_FOUND });
+  }
+
+  // Parse archived query param: undefined = all, 'true' = archived only, 'false' = non-archived only
+  const { archived, starred, limit, offset } = req.query;
+  let archivedFilter = null;
+  if (archived === 'true') archivedFilter = true;
+  else if (archived === 'false') archivedFilter = false;
+
+  let starredFilter = null;
+  if (starred === 'true') starredFilter = true;
+  else if (starred === 'false') starredFilter = false;
+
+  // Parse pagination params
+  const parsedLimit = limit ? parseInt(limit, 10) : null;
+  const parsedOffset = offset ? parseInt(offset, 10) : 0;
+
+  const projectSessions = sessions.getByProjectId(req.params.id, {
+    archived: archivedFilter,
+    starred: starredFilter,
+    limit: parsedLimit,
+    offset: parsedOffset,
+  });
+
+  // Get total count for pagination (only when limit is specified)
+  let total = null;
+  if (parsedLimit !== null) {
+    total = sessions.getCountByProjectId(req.params.id, {
+      archived: archivedFilter,
+      starred: starredFilter,
+    });
+  }
+
+  // Build merged index of latest command runs per session
+  const runsBySession = buildRunsBySession(
+    commandRuns.getLatestRunsForProject(req.params.id),
+    commandRunner.getRunningByProjectId(req.params.id, (sessionId) => sessions.getById(sessionId))
+  );
+
+  // Attach latestCommandRuns to each session as array
+  const sessionsWithRuns = projectSessions.map(session => ({
+    ...session,
+    latestCommandRuns: Object.values(runsBySession[session.id] || {}),
+  }));
+
+  // Return response with pagination metadata when limit is specified
+  if (parsedLimit !== null) {
+    res.json({
+      sessions: sessionsWithRuns,
+      pagination: {
+        total,
+        limit: parsedLimit,
+        offset: parsedOffset,
+        hasMore: parsedOffset + projectSessions.length < total,
+      },
+    });
+  } else {
+    // Backward compatible: return array when no pagination
+    res.json(sessionsWithRuns);
+  }
+});
+
+// POST /api/projects/:id/sessions - Create session
+// Supports both JSON and multipart/form-data (for file attachments)
+router.post('/:id/sessions', uploadMiddleware('files', 10), handleUploadError, async (req, res) => {
+  const project = projects.getById(req.params.id);
+  if (!project) {
+    return res.status(404).json({ error: ERR_PROJECT_NOT_FOUND });
+  }
+
+  const projectDefs = projectDefaults.getByProjectId(req.params.id);
+  const systemDefaults = ProjectDefaultsRepository.getSystemDefaults();
+  const config = prepareSessionConfig(req.body, projectDefs, systemDefaults);
+  config.files = req.files || [];
+
+  if (!config.prompt) {
+    return res.status(400).json({ error: 'Prompt is required' });
+  }
+
+  // Apply template overrides and resolve nextTemplateId
+  applyTemplateOverrides(config);
+  const { nextTemplateId, error: nextTemplateError } = resolveNextTemplateId(req.body, config.nextTemplateId || null);
+  if (nextTemplateError) {
+    return res.status(400).json({ error: nextTemplateError });
+  }
+  config.nextTemplateId = nextTemplateId;
+
+  const initialStatus = determineInitialStatus(config);
+
+  // Validate git settings for git repos
+  const gitError = await validateGitSettings(config, project);
+  if (gitError) {
+    return res.status(400).json({ error: gitError });
+  }
+
+  const sessionName = config.name || generateInitialName(config.prompt);
+  const session = sessions.create(req.params.id, sessionName, config.prompt, {
+    mode: config.mode,
+    thinkingEnabled: config.thinkingEnabled,
+    gitBranch: config.gitBranch,
+    parentSessionId: config.parentSessionId,
+    status: initialStatus,
+    model: config.model,
+    effortLevel: config.effortLevel,
+  });
+
+  // Apply optional post-create updates (next template + scheduling) in one pass
+  const postCreateUpdate = {
+    ...(nextTemplateId ? { nextTemplateId } : {}),
+    ...buildSchedulingUpdate(config, initialStatus),
+  };
+  if (Object.keys(postCreateUpdate).length > 0) {
+    sessions.update(session.id, postCreateUpdate);
+  }
+
+  // Setup git environment, start session, and broadcast
+  try {
+    const { updatedSession } = await setupAndStartSession({
+      session, config, project, projectId: req.params.id, files: config.files,
+    });
+    res.status(201).json(updatedSession);
+  } catch (error) {
+    console.error('Git setup error:', error);
+    const updatedSession = sessions.update(session.id, { status: 'error', error: error.message });
+
+    broadcastToProject(req.params.id, WS_MESSAGE_TYPES.SESSION_UPDATED, {
+      projectId: req.params.id,
+      sessionId: session.id,
+      session: updatedSession,
+    });
+
+    res.status(500).json({ error: `Git setup failed: ${error.message}` });
+  }
+});
+
+// GET /api/projects/:id/templates - List available templates for project (project + global)
+router.get('/:id/templates', (req, res) => {
+  const project = projects.getById(req.params.id);
+  if (!project) {
+    return res.status(404).json({ error: ERR_PROJECT_NOT_FOUND });
+  }
+
+  const available = sessionTemplates.getAvailableForProject(req.params.id);
+  res.json(available);
+});
+
+// POST /api/projects/:id/templates - Create project template
+router.post('/:id/templates', (req, res) => {
+  const project = projects.getById(req.params.id);
+  if (!project) {
+    return res.status(404).json({ error: ERR_PROJECT_NOT_FOUND });
+  }
+
+  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: req.params.id,
+    ...result.data,
+  });
+  res.status(201).json(template);
+});
+
+// GET /api/projects/:id/command-buttons - List all command buttons for project
+router.get('/:id/command-buttons', (req, res) => {
+  const project = projects.getById(req.params.id);
+  if (!project) {
+    return res.status(404).json({ error: ERR_PROJECT_NOT_FOUND });
+  }
+
+  const buttons = commandButtons.getByProjectId(req.params.id);
+  res.json(buttons);
+});
+
+// POST /api/projects/:id/command-buttons - Create new command button
+router.post('/:id/command-buttons', (req, res) => {
+  const project = projects.getById(req.params.id);
+  if (!project) {
+    return res.status(404).json({ error: ERR_PROJECT_NOT_FOUND });
+  }
+
+  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.id,
+    label: result.data.label,
+    command: result.data.command,
+    sortOrder: result.data.sortOrder,
+    showOnList: result.data.showOnList,
+  });
+
+  res.status(201).json(button);
+});
+
+// GET /api/projects/:id/command-buttons/:buttonId - Get single button
+router.get('/:id/command-buttons/:buttonId', (req, res) => {
+  const project = projects.getById(req.params.id);
+  if (!project) {
+    return res.status(404).json({ error: ERR_PROJECT_NOT_FOUND });
+  }
+
+  const button = commandButtons.getById(req.params.buttonId);
+  if (!button) {
+    return res.status(404).json({ error: 'Command button not found' });
+  }
+  res.json(button);
+});
+
+// PATCH /api/projects/:id/command-buttons/:buttonId - Update button
+router.patch('/:id/command-buttons/:buttonId', (req, res) => {
+  const project = projects.getById(req.params.id);
+  if (!project) {
+    return res.status(404).json({ error: ERR_PROJECT_NOT_FOUND });
+  }
+
+  const button = commandButtons.getById(req.params.buttonId);
+  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 });
+  }
+
+  const updated = commandButtons.update(req.params.buttonId, result.data);
+  res.json(updated);
+});
+
+// DELETE /api/projects/:id/command-buttons/:buttonId - Delete button
+router.delete('/:id/command-buttons/:buttonId', (req, res) => {
+  const project = projects.getById(req.params.id);
+  if (!project) {
+    return res.status(404).json({ error: ERR_PROJECT_NOT_FOUND });
+  }
+
+  const button = commandButtons.getById(req.params.buttonId);
+  if (!button) {
+    return res.status(404).json({ error: 'Command button not found' });
+  }
+
+  commandButtons.delete(req.params.buttonId);
+  res.status(204).send();
+});
+
+// GET /api/projects/:id/session-defaults - Get session defaults for project
+router.get('/:id/session-defaults', (req, res) => {
+  const project = projects.getById(req.params.id);
+  if (!project) {
+    return res.status(404).json({ error: ERR_PROJECT_NOT_FOUND });
+  }
+
+  const defaults = projectDefaults.getByProjectId(req.params.id);
+  if (!defaults) {
+    return res.json(null);
+  }
+
+  res.json(defaults);
+});
+
+// POST /api/projects/:id/session-defaults - Update/create session defaults for project
+router.post('/:id/session-defaults', (req, res) => {
+  const project = projects.getById(req.params.id);
+  if (!project) {
+    return res.status(404).json({ error: ERR_PROJECT_NOT_FOUND });
+  }
+
+  const result = ProjectSessionDefaultsRequest.safeParse(req.body);
+  if (!result.success) {
+    return res.status(400).json({ error: result.error.issues[0].message });
+  }
+
+  const updated = projectDefaults.upsert(req.params.id, result.data);
+  res.status(200).json(updated);
+});
+
+// DELETE /api/projects/:id/session-defaults - Reset session defaults for project
+router.delete('/:id/session-defaults', (req, res) => {
+  const project = projects.getById(req.params.id);
+  if (!project) {
+    return res.status(404).json({ error: ERR_PROJECT_NOT_FOUND });
+  }
+
+  projectDefaults.resetToDefaults(req.params.id);
+  res.json({ message: 'Session defaults reset to system defaults' });
+});
+
+export default router;

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

@@ -0,0 +1,249 @@
+import { Router } from 'express';
+import { modelProviders } from '../database.js';
+import {
+  CreateProviderRequest,
+  UpdateProviderRequest,
+  CreateProviderModelRequest,
+  TestConnectionRequest,
+} from '../../../shared/src/contracts/providers.js';
+import { testProviderConnection } from '../services/providerTestService.js';
+
+// Error message constants
+const ERR_PROVIDER_NOT_FOUND = 'Provider not found';
+
+const router = Router();
+
+/**
+ * Redact auth token in provider response
+ * @param {Object} provider - Provider object
+ * @returns {Object} Provider with redacted auth token
+ */
+function redactAuthToken(provider) {
+  if (!provider) return provider;
+  return {
+    ...provider,
+    authToken: provider.authToken ? '••••••••' : null,
+  };
+}
+
+// GET /api/providers - List all providers
+router.get('/', (_req, res) => {
+  try {
+    const allProviders = modelProviders.getAll();
+    // Redact auth tokens in response
+    const sanitized = allProviders.map(redactAuthToken);
+    res.json(sanitized);
+  } catch (error) {
+    res.status(500).json({ error: error.message });
+  }
+});
+
+// POST /api/providers - Create provider
+router.post('/', (req, res) => {
+  const result = CreateProviderRequest.safeParse(req.body);
+  if (!result.success) {
+    return res.status(400).json({ error: result.error.issues[0].message });
+  }
+
+  try {
+    const provider = modelProviders.create(result.data);
+    res.status(201).json(redactAuthToken(provider));
+  } catch (error) {
+    res.status(500).json({ error: error.message });
+  }
+});
+
+// GET /api/providers/:id - Get provider details
+router.get('/:id', (req, res) => {
+  try {
+    const provider = modelProviders.getById(req.params.id);
+    if (!provider) {
+      return res.status(404).json({ error: ERR_PROVIDER_NOT_FOUND });
+    }
+    res.json(redactAuthToken(provider));
+  } catch (error) {
+    res.status(500).json({ error: error.message });
+  }
+});
+
+// PATCH /api/providers/:id - Update provider
+router.patch('/:id', (req, res) => {
+  try {
+    const provider = modelProviders.getById(req.params.id);
+    if (!provider) {
+      return res.status(404).json({ error: ERR_PROVIDER_NOT_FOUND });
+    }
+
+    const result = UpdateProviderRequest.safeParse(req.body);
+    if (!result.success) {
+      return res.status(400).json({ error: result.error.issues[0].message });
+    }
+
+    const updated = modelProviders.update(req.params.id, result.data);
+    res.json(redactAuthToken(updated));
+  } catch (error) {
+    if (error.message === 'Cannot delete built-in provider') {
+      return res.status(403).json({ error: error.message });
+    }
+    res.status(500).json({ error: error.message });
+  }
+});
+
+// DELETE /api/providers/:id - Delete provider
+router.delete('/:id', (req, res) => {
+  try {
+    const provider = modelProviders.getById(req.params.id);
+    if (!provider) {
+      return res.status(404).json({ error: ERR_PROVIDER_NOT_FOUND });
+    }
+
+    modelProviders.delete(req.params.id);
+    res.status(204).send();
+  } catch (error) {
+    if (error.message === 'Cannot delete built-in provider') {
+      return res.status(403).json({ error: error.message });
+    }
+    res.status(500).json({ error: error.message });
+  }
+});
+
+// POST /api/providers/test - Test provider configuration (before saving)
+router.post('/test', async (req, res) => {
+  const result = TestConnectionRequest.safeParse(req.body);
+  if (!result.success) {
+    return res.status(400).json({ error: result.error.issues[0].message });
+  }
+
+  try {
+    const testResult = await testProviderConnection(result.data);
+    res.json(testResult);
+  } catch (error) {
+    res.status(500).json({
+      success: false,
+      message: error.message || 'Internal server error',
+      details: {
+        type: error.name,
+      },
+    });
+  }
+});
+
+// POST /api/providers/:id/test - Test existing provider connection
+router.post('/:id/test', async (req, res) => {
+  try {
+    const provider = modelProviders.getById(req.params.id);
+    if (!provider) {
+      return res.status(404).json({ error: ERR_PROVIDER_NOT_FOUND });
+    }
+
+    // Pick the sonnet-tiered model (if any) as the test model, falling back to any first model
+    const sonnetModel = provider.models?.find((m) => m.tier === 'sonnet');
+    const testConfig = {
+      baseUrl: provider.baseUrl,
+      authToken: provider.authToken,
+      defaultSonnetModel: sonnetModel?.modelId,
+      apiTimeoutMs: provider.apiTimeoutMs,
+    };
+
+    const testResult = await testProviderConnection(testConfig);
+    res.json(testResult);
+  } catch (error) {
+    res.status(500).json({
+      success: false,
+      message: error.message || 'Internal server error',
+      details: {
+        type: error.name,
+      },
+    });
+  }
+});
+
+// GET /api/providers/:id/models - List models for provider
+router.get('/:id/models', (req, res) => {
+  try {
+    const provider = modelProviders.getById(req.params.id);
+    if (!provider) {
+      return res.status(404).json({ error: ERR_PROVIDER_NOT_FOUND });
+    }
+
+    const models = modelProviders.getModels(req.params.id);
+    res.json(models);
+  } catch (error) {
+    res.status(500).json({ error: error.message });
+  }
+});
+
+// POST /api/providers/:id/models - Add model to provider
+router.post('/:id/models', (req, res) => {
+  try {
+    const provider = modelProviders.getById(req.params.id);
+    if (!provider) {
+      return res.status(404).json({ error: ERR_PROVIDER_NOT_FOUND });
+    }
+
+    const result = CreateProviderModelRequest.safeParse(req.body);
+    if (!result.success) {
+      return res.status(400).json({ error: result.error.issues[0].message });
+    }
+
+    const model = modelProviders.addModel(req.params.id, result.data);
+    res.status(201).json(model);
+  } catch (error) {
+    res.status(500).json({ error: error.message });
+  }
+});
+
+// PATCH /api/providers/:id/models/:modelId - Update model
+router.patch('/:id/models/:modelId', (req, res) => {
+  try {
+    const provider = modelProviders.getById(req.params.id);
+    if (!provider) {
+      return res.status(404).json({ error: ERR_PROVIDER_NOT_FOUND });
+    }
+
+    const model = modelProviders.getModelById(req.params.modelId);
+    if (!model) {
+      return res.status(404).json({ error: 'Model not found' });
+    }
+
+    if (model.providerId !== req.params.id) {
+      return res.status(400).json({ error: 'Model does not belong to this provider' });
+    }
+
+    const result = CreateProviderModelRequest.partial().safeParse(req.body);
+    if (!result.success) {
+      return res.status(400).json({ error: result.error.issues[0].message });
+    }
+
+    const updated = modelProviders.updateModel(req.params.modelId, result.data);
+    res.json(updated);
+  } catch (error) {
+    res.status(500).json({ error: error.message });
+  }
+});
+
+// DELETE /api/providers/:id/models/:modelId - Remove model
+router.delete('/:providerId/models/:modelId', (req, res) => {
+  try {
+    const provider = modelProviders.getById(req.params.providerId);
+    if (!provider) {
+      return res.status(404).json({ error: ERR_PROVIDER_NOT_FOUND });
+    }
+
+    const model = modelProviders.getModelById(req.params.modelId);
+    if (!model) {
+      return res.status(404).json({ error: 'Model not found' });
+    }
+
+    if (model.providerId !== req.params.providerId) {
+      return res.status(400).json({ error: 'Model does not belong to this provider' });
+    }
+
+    modelProviders.removeModel(req.params.modelId);
+    res.status(204).send();
+  } catch (error) {
+    res.status(500).json({ error: error.message });
+  }
+});
+
+export default router;