circuschief 0.1.0

package/packages/server/src/services/schedulerService.js

@@ -0,0 +1,281 @@
+import { sessions, messages, conversations, projects, attachments } from '../database.js';
+import { broadcastToSession } from '../websocket.js';
+import { WS_MESSAGE_TYPES } from '../../../shared/src/index.js';
+import * as slashCommandService from './slashCommandService.js';
+
+/**
+ * Service for managing scheduled session execution
+ * Polls for due sessions every 30 seconds and handles rescheduling logic
+ */
+class SchedulerService {
+  constructor() {
+    this.pollInterval = 30000; // 30 seconds
+    this.intervalId = null;
+    this.sessionManager = null; // Will be set during initialization
+  }
+
+  /**
+   * Initialize the scheduler with dependencies
+   * @param {object} sessionManager - Session manager instance
+   */
+  initialize(sessionManager) {
+    this.sessionManager = sessionManager;
+  }
+
+  /**
+   * Start the scheduler polling
+   */
+  start() {
+    if (this.intervalId) {
+      console.log('[SchedulerService] Already running');
+      return;
+    }
+
+    console.log('[SchedulerService] Starting scheduler with', this.pollInterval, 'ms interval');
+    this.intervalId = setInterval(() => this.checkScheduledSessions(), this.pollInterval);
+
+    // Also check immediately on startup
+    this.checkScheduledSessions();
+  }
+
+  /**
+   * Stop the scheduler polling
+   */
+  stop() {
+    if (this.intervalId) {
+      console.log('[SchedulerService] Stopping scheduler');
+      clearInterval(this.intervalId);
+      this.intervalId = null;
+    }
+  }
+
+  /**
+   * Check for scheduled sessions that are due to start
+   */
+  async checkScheduledSessions() {
+    const now = Date.now();
+    const dueSessions = sessions.getScheduledSessionsDue(now);
+
+    if (dueSessions.length > 0) {
+      console.log(`[SchedulerService] Found ${dueSessions.length} session(s) due to start`);
+    }
+
+    for (const session of dueSessions) {
+      try {
+        await this.startScheduledSession(session);
+      } catch (error) {
+        console.error(`[SchedulerService] Error starting scheduled session ${session.id}:`, error);
+        // Mark session as error
+        sessions.update(session.id, {
+          status: 'error',
+          error: `Failed to start scheduled session: ${error.message}`,
+        });
+        broadcastToSession(session.id, WS_MESSAGE_TYPES.SESSION_STATUS, { sessionId: session.id, status: 'error' });
+      }
+    }
+  }
+
+  /**
+   * Start a scheduled session
+   * @param {object} session - Session to start
+   */
+  async startScheduledSession(session) {
+    if (!this.sessionManager) {
+      throw new Error('SchedulerService not initialized with sessionManager');
+    }
+
+    console.log(`[SchedulerService] Starting scheduled session ${session.id}: ${session.name}`);
+
+    // Get the project for working directory and system prompt
+    const project = projects.getById(session.projectId);
+    if (!project) {
+      throw new Error(`Project not found for session ${session.id}`);
+    }
+
+    // Determine working directory
+    const workingDirectory = session.gitWorktree || project.workingDirectory;
+
+    // Use pendingPrompt as the message to send
+    if (!session.pendingPrompt || session.pendingPrompt.trim() === '') {
+      throw new Error(`No pendingPrompt found for session ${session.id}`);
+    }
+
+    const prompt = session.pendingPrompt.trim();
+
+    // Get the session messages to determine if this is initial or continuation
+    const sessionMessages = messages.getBySessionId(session.id);
+    const hasAssistantResponses = sessionMessages.some((msg) => msg.role === 'assistant');
+
+    // Get attachments for context
+    const sessionAttachments = attachments.getBySessionId(session.id);
+
+    // Resolve skill/command invocations so skill body goes into system prompt
+    const resolved = await slashCommandService.resolvePromptSkillOrCommand(
+      workingDirectory, prompt, project.systemPrompt
+    );
+    const effectivePrompt = resolved ? resolved.userMessage : prompt;
+    const effectiveSystemPrompt = resolved ? resolved.systemPrompt : project.systemPrompt;
+
+    // Determine if this is an initial run or a continuation
+    if (hasAssistantResponses) {
+      // Session has conversation history - this is a scheduled continuation
+
+      // Update status from 'scheduled' to 'starting' and clear pendingPrompt
+      sessions.update(session.id, {
+        status: 'starting',
+        scheduledAt: null,
+        pendingPrompt: null,
+      });
+      broadcastToSession(session.id, WS_MESSAGE_TYPES.SESSION_STATUS, { sessionId: session.id, status: 'starting' });
+
+      await this.sessionManager.continueSession(
+        session.id,
+        effectivePrompt,
+        workingDirectory,
+        { systemPrompt: effectiveSystemPrompt, fileAttachments: sessionAttachments, model: session.pendingModel }
+      );
+    } else {
+      // Fresh session - initial run
+      // First, create the user message so it appears in the conversation
+
+      // Get the active conversation
+      const activeConv = conversations.getActiveBySessionId(session.id);
+      if (!activeConv) {
+        throw new Error(`No active conversation found for session ${session.id}`);
+      }
+
+      // Create the initial user message
+      const userMessage = messages.create(session.id, 'user', prompt, { toolUse: null, conversationId: activeConv.id });
+
+      // Broadcast the new message so UI updates
+      broadcastToSession(session.id, WS_MESSAGE_TYPES.MESSAGE_CREATED, {
+        sessionId: session.id,
+        message: userMessage,
+      });
+
+      // Update status from 'scheduled' to 'starting' and clear pendingPrompt
+      sessions.update(session.id, {
+        status: 'starting',
+        scheduledAt: null,
+        pendingPrompt: null,
+      });
+      broadcastToSession(session.id, WS_MESSAGE_TYPES.SESSION_STATUS, { sessionId: session.id, status: 'starting' });
+
+      await this.sessionManager.runSession(
+        session.id,
+        effectivePrompt,
+        workingDirectory,
+        { systemPrompt: effectiveSystemPrompt, fileAttachments: sessionAttachments, model: session.pendingModel }
+      );
+    }
+  }
+
+  /**
+   * Reschedule a session with a delay
+   * @param {string} sessionId - Session ID to reschedule
+   * @param {string} reason - Reason for rescheduling
+   * @returns {boolean} True if rescheduled, false if limits reached
+   */
+  async rescheduleSession(sessionId, reason) {
+    const session = sessions.getById(sessionId);
+    if (!session) {
+      console.error(`[SchedulerService] Session not found: ${sessionId}`);
+      return false;
+    }
+
+    // Check reschedule limits
+    if (this.hasReachedLimits(session)) {
+      console.log(`[SchedulerService] Session ${sessionId} has reached reschedule limits`);
+      sessions.update(sessionId, {
+        status: 'error',
+        error: `Reschedule limits reached. ${reason}`,
+      });
+      broadcastToSession(sessionId, WS_MESSAGE_TYPES.SESSION_STATUS, { sessionId, status: 'error' });
+      return false;
+    }
+
+    // Get the last user message to use as pendingPrompt for restart
+    const sessionMessages = messages.getBySessionId(sessionId);
+    const lastUserMessage = [...sessionMessages].reverse().find(msg => msg.role === 'user');
+
+    if (!lastUserMessage) {
+      console.error(`[SchedulerService] No user message found for session ${sessionId}`);
+      sessions.update(sessionId, {
+        status: 'error',
+        error: `Cannot reschedule: No user message found. ${reason}`,
+      });
+      broadcastToSession(sessionId, WS_MESSAGE_TYPES.SESSION_STATUS, { sessionId, status: 'error' });
+      return false;
+    }
+
+    // Calculate new scheduled time
+    const newScheduledAt = Date.now() + session.rescheduleDelayMinutes * 60 * 1000;
+    const delayMinutes = session.rescheduleDelayMinutes;
+    const newRescheduleCount = session.rescheduleCount + 1;
+
+    console.log(
+      `[SchedulerService] Rescheduling session ${sessionId} for ${delayMinutes} minutes from now (attempt ${newRescheduleCount})`
+    );
+
+    // Update session to scheduled status with new time and pendingPrompt
+    sessions.update(sessionId, {
+      status: 'scheduled',
+      scheduledAt: newScheduledAt,           // Fixed: camelCase
+      rescheduleCount: newRescheduleCount,   // Fixed: camelCase
+      pendingPrompt: lastUserMessage.content, // Set prompt for scheduler
+      error: `Rescheduled (${newRescheduleCount}x): ${reason}`,
+    });
+
+    broadcastToSession(sessionId, WS_MESSAGE_TYPES.SESSION_STATUS, { sessionId, status: 'scheduled' });
+
+    return true;
+  }
+
+  /**
+   * Check if a session has reached its reschedule limits
+   * @param {object} session - Session to check
+   * @returns {boolean} True if limits reached
+   */
+  hasReachedLimits(session) {
+    // Check max reschedule count
+    if (session.maxRescheduleCount !== null && session.rescheduleCount >= session.maxRescheduleCount) {
+      console.log(
+        `[SchedulerService] Max reschedule count reached: ${session.rescheduleCount}/${session.maxRescheduleCount}`
+      );
+      return true;
+    }
+
+    // Check max total tokens
+    if (session.maxTotalTokens !== null) {
+      const totalTokens = session.inputTokens + session.outputTokens;
+      if (totalTokens >= session.maxTotalTokens) {
+        console.log(
+          `[SchedulerService] Max total tokens reached: ${totalTokens.toLocaleString()}/${session.maxTotalTokens.toLocaleString()}`
+        );
+        return true;
+      }
+    }
+
+    return false;
+  }
+
+  /**
+   * Check if a session should be proactively rescheduled based on token threshold
+   * @param {object} session - Session to check
+   * @returns {boolean} True if should reschedule
+   */
+  shouldProactivelyReschedule(session) {
+    if (!session.rescheduleAtTokenCount) {
+      return false;
+    }
+
+    const totalTokens = session.inputTokens + session.outputTokens;
+    return totalTokens >= session.rescheduleAtTokenCount;
+  }
+}
+
+// Singleton instance
+export const schedulerService = new SchedulerService();
+
+// Export class for testing
+export { SchedulerService };

package/packages/server/src/services/sessionDuplicator.js

@@ -0,0 +1,63 @@
+import {
+  sessions,
+  conversations,
+  messages,
+  canvasItems,
+  sessionNotes,
+  sessionSummaries,
+  projects,
+} from '../db/index.js';
+
+/**
+ * Duplicates a session including all related data.
+ * Handles git setup based on the source session's configuration.
+ *
+ * @param {string} sourceSessionId - ID of session to duplicate
+ * @param {object} options - Duplication options
+ * @param {string} [options.name] - Custom name for new session
+ * @returns {Promise<object>} The new session with all data duplicated
+ */
+export async function duplicateSession(sourceSessionId, options = {}) {
+  // 1. Get source session and project
+  const sourceSession = sessions.getById(sourceSessionId);
+  if (!sourceSession) {
+    throw new Error(`Session not found: ${sourceSessionId}`);
+  }
+
+  const project = projects.getById(sourceSession.projectId);
+  if (!project) {
+    throw new Error(`Project not found: ${sourceSession.projectId}`);
+  }
+
+  // 2. Duplicate session record (without git worktree path)
+  const newSession = sessions.duplicate(sourceSessionId, {
+    name: options.name,
+  });
+
+  try {
+    // 3. Duplicate conversations and get ID mapping
+    const conversationMapping = conversations.duplicateForSession(
+      sourceSessionId,
+      newSession.id
+    );
+
+    // 4. Duplicate messages using conversation mapping
+    messages.duplicateForConversations(conversationMapping, newSession.id);
+
+    // 5. Duplicate canvas items
+    canvasItems.duplicateForSession(sourceSessionId, newSession.id);
+
+    // 6. Duplicate session notes
+    sessionNotes.duplicateForSession(sourceSessionId, newSession.id);
+
+    // 7. Duplicate session summary (if exists)
+    sessionSummaries.duplicateForSession(sourceSessionId, newSession.id);
+
+    // Return the updated session
+    return sessions.getById(newSession.id);
+  } catch (error) {
+    // Cleanup: delete the new session if duplication fails
+    sessions.delete(newSession.id);
+    throw error;
+  }
+}

package/packages/server/src/services/sessionErrors.js

@@ -0,0 +1,173 @@
+import { sessions, messages } from '../database.js';
+import { schedulerService } from './schedulerService.js';
+
+/**
+ * Check if error message matches token limit patterns
+ * @param {string} message - Error message to check
+ * @returns {boolean} True if matches token limit error
+ */
+export function matchesTokenLimitError(message) {
+  const patterns = [
+    'token',
+    'context length',
+    'max_tokens',
+    'context window',
+    'limit',           // catches "You've hit your limit"
+    'quota',
+    'rate limit',
+    'exceeded',        // catches usage exceeded messages
+    'cap',             // catches usage cap messages
+  ];
+
+  return patterns.some(pattern => message.includes(pattern));
+}
+
+/**
+ * Check if error message matches service error patterns
+ * @param {string} message - Error message to check
+ * @returns {boolean} True if matches service error
+ */
+export function matchesServiceError(message) {
+  const patterns = [
+    'overloaded',
+    'rate limit',
+    '503',
+    '529',
+    'unavailable',
+    'service unavailable',
+    'too many requests',
+  ];
+
+  return patterns.some(pattern => message.includes(pattern));
+}
+
+/**
+ * Get the last assistant message for a session
+ * @param {string} sessionId - Session ID
+ * @returns {object|null} Last assistant message or null
+ */
+function getLastAssistantMessage(sessionId) {
+  try {
+    const sessionMessages = messages.getBySessionId(sessionId);
+    const assistantMessages = sessionMessages.filter(msg => msg.role === 'assistant');
+    return assistantMessages.length > 0 ? assistantMessages[assistantMessages.length - 1] : null;
+  } catch (error) {
+    console.error('[SessionManager] Error getting last assistant message:', error);
+    return null;
+  }
+}
+
+/**
+ * Check if error message matches a rescheduling trigger and log the result
+ * @param {object} session - Session object
+ * @param {string} message - Message to check (lowercase)
+ * @param {string} source - Source description for logging (e.g., "error", "assistant message")
+ * @returns {boolean} True if matches a rescheduling trigger
+ */
+function checkRescheduleTrigger(session, message, source) {
+  if (session.rescheduleOnTokenLimit && matchesTokenLimitError(message)) {
+    console.log(`[SessionManager] Token limit detected in ${source}, rescheduling`);
+    console.log(`[SessionManager] ${source}:`, message);
+    console.log('[SessionManager] Session config: rescheduleOnTokenLimit=true, rescheduleDelayMinutes=', session.rescheduleDelayMinutes);
+    return true;
+  }
+
+  if (session.rescheduleOnServiceError && matchesServiceError(message)) {
+    console.log(`[SessionManager] Service error detected in ${source}, rescheduling`);
+    console.log(`[SessionManager] ${source}:`, message);
+    console.log('[SessionManager] Session config: rescheduleOnServiceError=true, rescheduleDelayMinutes=', session.rescheduleDelayMinutes);
+    return true;
+  }
+
+  return false;
+}
+
+/**
+ * Log when a rescheduling check is skipped
+ * @param {string} setting - The setting name that was disabled
+ */
+function logSkippedReschedule(setting) {
+  console.log(`[SessionManager] ${setting} is false, skipping ${setting.replace('reschedule', '').toLowerCase()} rescheduling`);
+}
+
+/**
+ * Check if an error should trigger automatic rescheduling
+ * @param {object} session - Session object
+ * @param {Error} error - Error that occurred
+ * @param {string} sessionId - Session ID
+ * @returns {boolean} True if should reschedule
+ */
+export function shouldRescheduleOnError(session, error, sessionId = null) {
+  // Check if auto-reschedule is enabled first (master switch)
+  if (!session.autoRescheduleEnabled) {
+    console.log('[SessionManager] autoRescheduleEnabled is false, skipping all rescheduling');
+    return false;
+  }
+
+  const errorMessage = error.message.toLowerCase();
+
+  // Log skipped checks for debugging
+  if (!session.rescheduleOnTokenLimit) logSkippedReschedule('rescheduleOnTokenLimit');
+  if (!session.rescheduleOnServiceError) logSkippedReschedule('rescheduleOnServiceError');
+
+  // Check error message for rescheduling triggers
+  if (checkRescheduleTrigger(session, errorMessage, 'error')) {
+    return true;
+  }
+
+  // Also check last assistant message if available
+  if (sessionId) {
+    const lastAssistantMessage = getLastAssistantMessage(sessionId);
+    if (lastAssistantMessage) {
+      const messageContent = lastAssistantMessage.content.toLowerCase();
+      if (checkRescheduleTrigger(session, messageContent, 'assistant message')) {
+        return true;
+      }
+    }
+  }
+
+  console.log('[SessionManager] Error does not match any rescheduling triggers');
+  console.log('[SessionManager] Session config: rescheduleOnTokenLimit=', session.rescheduleOnTokenLimit, ', rescheduleOnServiceError=', session.rescheduleOnServiceError);
+  return false;
+}
+
+/**
+ * Check if session should be proactively rescheduled based on token count
+ * Called after processing each message to check token thresholds
+ * @param {string} sessionId - Session ID
+ * @returns {Promise<boolean>} True if rescheduled
+ */
+export async function _checkProactiveReschedule(sessionId) {
+  const session = sessions.getById(sessionId);
+  if (!session || !session.rescheduleAtTokenCount) {
+    return false;
+  }
+
+  // Check if auto-reschedule is enabled first (master switch)
+  if (!session.autoRescheduleEnabled) {
+    console.log('[SessionManager] autoRescheduleEnabled is false, skipping proactive rescheduling');
+    return false;
+  }
+
+  const totalTokens = session.inputTokens + session.outputTokens;
+  if (totalTokens >= session.rescheduleAtTokenCount) {
+    console.log(
+      `[SessionManager] Proactive token threshold reached: ${totalTokens.toLocaleString()}/${session.rescheduleAtTokenCount.toLocaleString()}`
+    );
+
+    // Check if we've reached limits
+    if (schedulerService.hasReachedLimits(session)) {
+      console.log('[SessionManager] Cannot reschedule - limits reached');
+      return false;
+    }
+
+    // Gracefully reschedule
+    await schedulerService.rescheduleSession(
+      sessionId,
+      `Token threshold reached (${totalTokens.toLocaleString()} tokens)`
+    );
+    return true;
+  }
+
+  return false;
+}