circuschief 0.1.0

package/packages/server/src/db/session-helpers.js

@@ -0,0 +1,150 @@
+/**
+ * Shared helpers for SessionRepository: SQL fragments, row mappers,
+ * config parsing, and update-clause builders.
+ */
+
+/** Reusable SQL fragment for computed activity fields on sessions */
+export const ACTIVITY_FIELDS_SQL = `
+  (SELECT MAX(cm.timestamp) FROM conversation_messages cm WHERE cm.session_id = s.id) AS last_activity_at,
+  (CAST(
+    CASE
+      WHEN (SELECT MAX(cm2.timestamp) FROM conversation_messages cm2 WHERE cm2.session_id = s.id) IS NOT NULL
+      THEN (SELECT MAX(cm2.timestamp) FROM conversation_messages cm2 WHERE cm2.session_id = s.id)
+         - (SELECT MIN(cm2.timestamp) FROM conversation_messages cm2 WHERE cm2.session_id = s.id)
+      ELSE 0
+    END AS INTEGER)
+  ) AS active_time_ms`;
+
+/**
+ * Map token-usage columns from a DB row to a JS object.
+ * @param {Object} row - database row
+ * @returns {Object}
+ */
+export function mapTokenUsage(row) {
+  return {
+    inputTokens: row.input_tokens || 0,
+    outputTokens: row.output_tokens || 0,
+    cacheReadInputTokens: row.cache_read_input_tokens || 0,
+    cacheCreationInputTokens: row.cache_creation_input_tokens || 0,
+    webSearchRequests: row.web_search_requests || 0,
+    contextWindow: row.context_window || 200000,
+  };
+}
+
+/**
+ * Map scheduling columns from a DB row to a JS object.
+ * @param {Object} row - database row
+ * @returns {Object}
+ */
+export function mapScheduling(row) {
+  return {
+    scheduledAt: row.scheduled_at || null,
+    rescheduleDelayMinutes: row.reschedule_delay_minutes || 15,
+    autoRescheduleEnabled: Boolean(row.auto_reschedule_enabled),
+    rescheduleOnTokenLimit: Boolean(row.reschedule_on_token_limit),
+    rescheduleOnServiceError: Boolean(row.reschedule_on_service_error),
+    maxRescheduleCount: row.max_reschedule_count,
+    maxTotalTokens: row.max_total_tokens,
+    rescheduleCount: row.reschedule_count || 0,
+    rescheduleAtTokenCount: row.reschedule_at_token_count,
+  };
+}
+
+/** Default values for session-create config fields */
+const CONFIG_DEFAULTS = {
+  mode: 'standard',
+  thinkingEnabled: false,
+  gitBranch: null,
+  parentSessionId: null,
+  status: 'starting',
+  model: null,
+  effortLevel: null,
+};
+
+function buildConfig(src) {
+  return Object.fromEntries(
+    Object.entries(CONFIG_DEFAULTS).map(([k, d]) => [k, src[k] ?? d])
+  );
+}
+
+/**
+ * Parse session-create options supporting both the modern object form
+ * and the legacy positional-arguments form.
+ * @param {Object|string} options
+ * @param {Array} extraArgs - additional positional arguments (legacy)
+ * @returns {Object} normalised config
+ */
+export function parseCreateConfig(options, extraArgs) {
+  if (typeof options !== 'string') return buildConfig(options);
+
+  const keys = ['mode', 'thinkingEnabled', 'gitBranch', 'parentSessionId', 'status', 'model'];
+  const vals = { mode: options };
+  keys.slice(1).forEach((k, i) => { vals[k] = extraArgs[i]; });
+  vals.effortLevel = (extraArgs[5] || {}).effortLevel;
+  return buildConfig(vals);
+}
+
+/** camelCase -> snake_case column mapping for direct (non-boolean) fields */
+export const DIRECT_FIELD_MAP = {
+  name: 'name',
+  status: 'status',
+  mode: 'mode',
+  gitBranch: 'git_branch',
+  gitWorktree: 'git_worktree',
+  prUrl: 'pr_url',
+  error: 'error',
+  costUsd: 'cost_usd',
+  claudeSessionId: 'claude_session_id',
+  model: 'model',
+  nextTemplateId: 'next_template_id',
+  parentSessionId: 'parent_session_id',
+  scheduledAt: 'scheduled_at',
+  rescheduleDelayMinutes: 'reschedule_delay_minutes',
+  maxRescheduleCount: 'max_reschedule_count',
+  maxTotalTokens: 'max_total_tokens',
+  rescheduleCount: 'reschedule_count',
+  rescheduleAtTokenCount: 'reschedule_at_token_count',
+  pendingPrompt: 'pending_prompt',
+  pendingModel: 'pending_model',
+  effortLevel: 'effort_level',
+  targetLaneId: 'target_lane_id',
+  laneTriggerDepth: 'lane_trigger_depth',
+};
+
+/** camelCase -> snake_case column mapping for boolean fields (converted to 1/0) */
+export const BOOLEAN_FIELD_MAP = {
+  thinkingEnabled: 'thinking_enabled',
+  archived: 'archived',
+  starred: 'starred',
+  manuallyNamed: 'manually_named',
+  autoRescheduleEnabled: 'auto_reschedule_enabled',
+  rescheduleOnTokenLimit: 'reschedule_on_token_limit',
+  rescheduleOnServiceError: 'reschedule_on_service_error',
+  autoSendPendingPrompt: 'auto_send_pending_prompt',
+};
+
+/**
+ * Build SET clause entries and parameter values from update data.
+ * @param {Object} data - camelCase update fields
+ * @returns {{ updates: string[], values: any[] }}
+ */
+export function buildUpdateClauses(data) {
+  const updates = [];
+  const values = [];
+
+  for (const [field, column] of Object.entries(DIRECT_FIELD_MAP)) {
+    if (data[field] !== undefined) {
+      updates.push(`${column} = ?`);
+      values.push(data[field]);
+    }
+  }
+
+  for (const [field, column] of Object.entries(BOOLEAN_FIELD_MAP)) {
+    if (data[field] !== undefined) {
+      updates.push(`${column} = ?`);
+      values.push(data[field] ? 1 : 0);
+    }
+  }
+
+  return { updates, values };
+}

package/packages/server/src/index.js

@@ -0,0 +1,106 @@
+import { createServer } from 'http';
+import { parseArgs } from 'node:util';
+import { execSync } from 'child_process';
+import { createApp } from './app.js';
+import { initDatabase } from './database.js';
+import { initWebSocket } from './websocket.js';
+import { DEFAULT_SERVER_PORT } from '../../shared/src/index.js';
+import * as prStatusService from './services/prStatusService.js';
+import * as systemMonitor from './services/systemMonitor.js';
+import { schedulerService } from './services/schedulerService.js';
+import * as sessionManager from './services/sessionManager.js';
+
+/**
+ * Validate Node.js environment at startup.
+ * Warns if 'node' is not in PATH (common with nvm/fnm version managers).
+ */
+function validateNodeEnvironment() {
+  try {
+    execSync('node --version', { stdio: 'ignore' });
+  } catch {
+    console.warn('');
+    console.warn('[Warning] "node" is not found in PATH.');
+    console.warn('If using nvm/fnm/volta, ensure your shell is properly configured.');
+    console.warn(`Current Node binary: ${process.execPath}`);
+    console.warn('This will be used for child processes (Claude Code sessions).');
+    console.warn('');
+  }
+}
+
+const { values } = parseArgs({
+  options: {
+    port: {
+      type: 'string',
+      short: 'p',
+      default: String(DEFAULT_SERVER_PORT),
+    },
+  },
+});
+
+const port = parseInt(values.port, 10);
+process.env.PORT = String(port);
+const production = process.env.NODE_ENV === 'production';
+const dbPath = process.env.DB_PATH || 'circuschief.db';
+
+// Catch uncaught exceptions
+process.on('uncaughtException', (err) => {
+  console.error('Uncaught Exception:', err);
+});
+process.on('unhandledRejection', (reason, promise) => {
+  console.error('Unhandled Rejection at:', promise, 'reason:', reason);
+});
+
+// Validate Node.js environment
+validateNodeEnvironment();
+
+// Initialize database
+initDatabase(dbPath);
+console.log(`Database initialized: ${dbPath}`);
+
+// Create Express app
+const app = createApp({ production });
+
+// Create HTTP server
+const server = createServer(app);
+
+// Initialize WebSocket for app
+initWebSocket(server);
+
+// Initialize and start scheduler service
+schedulerService.initialize(sessionManager);
+schedulerService.start();
+
+// Start PR status polling service
+prStatusService.start();
+
+// Start system metrics broadcast service
+systemMonitor.start();
+
+// Graceful shutdown
+process.on('SIGTERM', () => {
+  console.log('SIGTERM received, shutting down gracefully');
+  schedulerService.stop();
+  prStatusService.stop();
+  systemMonitor.stop();
+  server.close(() => {
+    console.log('Server closed');
+    process.exit(0);
+  });
+});
+
+process.on('SIGINT', () => {
+  console.log('SIGINT received, shutting down gracefully');
+  schedulerService.stop();
+  prStatusService.stop();
+  systemMonitor.stop();
+  server.close(() => {
+    console.log('Server closed');
+    process.exit(0);
+  });
+});
+
+// Start server on all interfaces
+server.listen(port, '0.0.0.0', () => {
+  console.log(`Server running on http://0.0.0.0:${port}`);
+  console.log(`WebSocket available at ws://0.0.0.0:${port}/ws`);
+});

package/packages/server/src/logger.js

@@ -0,0 +1,22 @@
+/**
+ * Simple logger that respects NODE_ENV
+ * Suppresses debug logs during testing
+ */
+
+export const logger = {
+  log: (...args) => {
+    if (process.env.NODE_ENV !== 'test') {
+      console.log(...args);
+    }
+  },
+  error: (...args) => {
+    console.error(...args);
+  },
+  warn: (...args) => {
+    if (process.env.NODE_ENV !== 'test') {
+      console.warn(...args);
+    }
+  },
+};
+
+export default logger;

package/packages/server/src/middleware/sessionLookup.js

@@ -0,0 +1,57 @@
+import { sessions, projects } from '../database.js';
+
+/**
+ * Middleware: Look up a session by req.params.id and attach to req.session_.
+ * Returns 404 if session not found.
+ * Uses session_ to avoid conflict with express-session's req.session.
+ */
+export function requireSession(req, res, next) {
+  const session = sessions.getById(req.params.id);
+  if (!session) {
+    return res.status(404).json({ error: 'Session not found' });
+  }
+  req.session_ = session;
+  next();
+}
+
+/**
+ * Middleware: Look up session AND its project. Attaches req.session_ and req.project.
+ * Returns 404 if either is not found.
+ * Also resolves req.workingDirectory (gitWorktree || project.workingDirectory).
+ */
+/**
+ * Middleware factory: Validates that req.session_.status is one of the allowed statuses.
+ * Must be used AFTER requireSession or requireSessionAndProject middleware.
+ * @param {string[]} allowedStatuses - Array of allowed status strings
+ * @param {string} [errorMessage] - Optional custom error message
+ * @returns {Function} Express middleware
+ */
+export function requireSessionStatus(allowedStatuses, errorMessage) {
+  return (req, res, next) => {
+    if (!req.session_) {
+      return res.status(500).json({ error: 'requireSessionStatus must be used after requireSession' });
+    }
+    if (!allowedStatuses.includes(req.session_.status)) {
+      const message = errorMessage || `Session status must be one of: ${allowedStatuses.join(', ')}`;
+      return res.status(400).json({ error: message });
+    }
+    next();
+  };
+}
+
+export function requireSessionAndProject(req, res, next) {
+  const session = sessions.getById(req.params.id);
+  if (!session) {
+    return res.status(404).json({ error: 'Session not found' });
+  }
+
+  const project = projects.getById(session.projectId);
+  if (!project) {
+    return res.status(404).json({ error: 'Project not found' });
+  }
+
+  req.session_ = session;
+  req.project = project;
+  req.workingDirectory = session.gitWorktree || project.workingDirectory;
+  next();
+}

package/packages/server/src/middleware/upload.js

@@ -0,0 +1,94 @@
+import multer from 'multer';
+
+/**
+ * Allowed MIME types for file uploads
+ */
+const ALLOWED_MIME_TYPES = [
+  // Images
+  'image/png',
+  'image/jpeg',
+  'image/gif',
+  'image/webp',
+  'image/svg+xml',
+  // Text files
+  'text/plain',
+  'text/markdown',
+  'text/csv',
+  'text/html',
+  'text/css',
+  'text/javascript',
+  'text/xml',
+  // Application types
+  'application/json',
+  'application/pdf',
+  'application/javascript',
+  'application/xml',
+  'application/x-yaml',
+  'application/x-sh',
+];
+
+/**
+ * File filter for multer - allows common file types
+ */
+function fileFilter(_req, file, cb) {
+  // Allow if MIME type is in allowed list or starts with 'text/'
+  if (ALLOWED_MIME_TYPES.includes(file.mimetype) || file.mimetype.startsWith('text/')) {
+    cb(null, true);
+  } else {
+    cb(new Error(`File type ${file.mimetype} not allowed`), false);
+  }
+}
+
+/**
+ * Multer configuration for file uploads
+ * - Uses memory storage (files are stored in memory as Buffer)
+ * - 10MB max file size
+ * - Max 10 files per request
+ */
+export const upload = multer({
+  storage: multer.memoryStorage(),
+  limits: {
+    fileSize: 10 * 1024 * 1024, // 10MB per file
+    files: 10, // Max 10 files per request
+  },
+  fileFilter,
+});
+
+/**
+ * Error handler middleware for multer errors
+ */
+export function handleUploadError(err, req, res, next) {
+  if (err instanceof multer.MulterError) {
+    if (err.code === 'LIMIT_FILE_SIZE') {
+      return res.status(400).json({ error: 'File too large. Maximum size is 10MB.' });
+    }
+    if (err.code === 'LIMIT_FILE_COUNT') {
+      return res.status(400).json({ error: 'Too many files. Maximum is 10 files per request.' });
+    }
+    return res.status(400).json({ error: err.message });
+  }
+  if (err) {
+    return res.status(400).json({ error: err.message });
+  }
+  next();
+}
+
+/**
+ * Wrapper that makes multer skip processing for non-multipart requests
+ * This allows the same route to handle both JSON and multipart/form-data requests
+ */
+export function uploadMiddleware(fieldName, maxCount) {
+  return (req, res, next) => {
+    // Check if the request is multipart/form-data
+    const contentType = req.get('content-type');
+
+    if (!contentType || !contentType.startsWith('multipart/form-data')) {
+      // Not a multipart request, skip multer processing
+      req.files = [];
+      return next();
+    }
+
+    // Multipart request, use multer to process
+    upload.array(fieldName, maxCount)(req, res, next);
+  };
+}