circuschief 0.1.0

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

@@ -0,0 +1,204 @@
+import { sessions, sessionSummaries } from '../database.js';
+import { webSocketManager, broadcastToSession } from '../websocket.js';
+import { WS_MESSAGE_TYPES } from '../../../shared/src/index.js';
+import * as ghService from './ghService.js';
+
+// Default polling interval in milliseconds (1 minute)
+const DEFAULT_POLL_INTERVAL_MS = 60000;
+
+// PR states that don't need further polling (PR is done)
+const FINAL_PR_STATES = ['merged', 'closed'];
+
+// Session states that should have their PRs polled (allowlist for future-proofing)
+// Includes stopped because CI may still be running after session ends
+// When 'archived' is added, it won't be in this list
+const POLLABLE_SESSION_STATES = ['running', 'waiting', 'stopped'];
+
+// Time-based filtering constants
+// Sessions updated within this time are polled regardless of subscribers
+const RECENT_ACTIVITY_MS = 2 * 60 * 60 * 1000; // 2 hours
+// Maximum age for polling sessions (even with pending CI)
+const MAX_POLL_AGE_MS = 24 * 60 * 60 * 1000; // 24 hours
+
+// Polling interval handle
+let pollIntervalId = null;
+
+/**
+ * Start the PR status polling service
+ */
+export function start() {
+  if (pollIntervalId) {
+    console.log('[PrStatusService] Already running');
+    return;
+  }
+
+  console.log('[PrStatusService] Starting PR status polling');
+  pollIntervalId = setInterval(pollLoop, DEFAULT_POLL_INTERVAL_MS);
+
+  // Run immediately on start
+  pollLoop();
+}
+
+/**
+ * Stop the PR status polling service
+ */
+export function stop() {
+  if (pollIntervalId) {
+    clearInterval(pollIntervalId);
+    pollIntervalId = null;
+    console.log('[PrStatusService] Stopped PR status polling');
+  }
+}
+
+/**
+ * Get all sessions with PRs that should be checked
+ * Uses time-based filtering to poll recently active sessions without requiring subscribers
+ * @returns {Array<{sessionId: string, prUrl: string}>}
+ */
+export function getSessionsToCheck() {
+  // Get all sessions that have PR URLs
+  const sessionsWithPrs = sessions.getSessionsWithPrUrls();
+  const subscriptions = webSocketManager.getSessionSubscriptions();
+  const now = Date.now();
+  const result = [];
+
+  for (const session of sessionsWithPrs) {
+    // Skip if session is not in a pollable state (future-proofs for 'archived')
+    if (!POLLABLE_SESSION_STATES.includes(session.status)) continue;
+
+    // Skip if PR is in a final state (merged/closed)
+    const summary = sessionSummaries.getBySessionId(session.id);
+    if (summary?.prState && FINAL_PR_STATES.includes(summary.prState)) continue;
+
+    // Calculate session age based on updatedAt
+    const sessionAge = now - new Date(session.updatedAt).getTime();
+    const hasSubscribers = subscriptions.get(session.id)?.size > 0;
+
+    // Always poll sessions with active subscribers
+    if (hasSubscribers) {
+      result.push({ sessionId: session.id, prUrl: session.prUrl });
+      continue;
+    }
+
+    // Skip sessions older than max poll age
+    if (sessionAge > MAX_POLL_AGE_MS) continue;
+
+    // For sessions within recent activity window, poll without subscribers
+    if (sessionAge <= RECENT_ACTIVITY_MS) {
+      result.push({ sessionId: session.id, prUrl: session.prUrl });
+      continue;
+    }
+
+    // For older sessions without subscribers, only poll if CI is pending
+    if (summary?.ciStatus === 'pending') {
+      result.push({ sessionId: session.id, prUrl: session.prUrl });
+    }
+  }
+
+  return result;
+}
+
+/**
+ * Immediately check CI status for a specific session
+ * Used for on-demand checks when a session completes or PR URL is set
+ * @param {string} sessionId
+ * @returns {Promise<boolean>} Whether status was updated
+ */
+export async function checkSessionCiStatusNow(sessionId) {
+  const session = sessions.getById(sessionId);
+  if (!session?.prUrl) return false;
+  return checkPrStatus(sessionId, session.prUrl);
+}
+
+/**
+ * Normalize boolean values for comparison (handles null/undefined/false equivalence)
+ * SQLite stores booleans as 0/1, and the repository maps 0 to null in some cases.
+ * This ensures null, undefined, and false are all treated as equivalent.
+ * @param {boolean|null|undefined} value
+ * @returns {boolean}
+ */
+function normalizeBool(value) {
+  return Boolean(value);
+}
+
+/**
+ * Check and update PR status for a single session
+ * @param {string} sessionId
+ * @param {string} prUrl
+ * @returns {Promise<boolean>} Whether status was updated
+ */
+export async function checkPrStatus(sessionId, prUrl) {
+  try {
+    const prInfo = await ghService.getPrInfo(prUrl);
+    if (!prInfo) return false;
+
+    const currentSummary = sessionSummaries.getBySessionId(sessionId);
+
+    // Check if anything changed
+    // Note: Use normalizeBool for boolean fields because SQLite stores 0/1 and
+    // the repository maps 0 to null, so we need to treat null/false as equivalent
+    const hasChanged =
+      currentSummary?.prState !== prInfo.state ||
+      normalizeBool(currentSummary?.prMerged) !== normalizeBool(prInfo.merged) ||
+      normalizeBool(currentSummary?.hasMergeConflicts) !== normalizeBool(prInfo.hasMergeConflicts) ||
+      currentSummary?.ciStatus !== prInfo.ciStatus ||
+      JSON.stringify(currentSummary?.ciFailures || []) !== JSON.stringify(prInfo.ciFailures || []);
+
+    if (!hasChanged) return false;
+
+    // Build update data
+    const updateData = {
+      prState: prInfo.state,
+      prMerged: prInfo.merged,
+      hasMergeConflicts: prInfo.hasMergeConflicts,
+      ciStatus: prInfo.ciStatus,
+      ciFailures: prInfo.ciFailures,
+    };
+
+    // Don't create a summary just for PR tracking - only track if summary already exists
+    if (!currentSummary) {
+      return false;
+    }
+
+    // Update database
+    const updatedSummary = sessionSummaries.upsert(sessionId, updateData);
+
+    // Broadcast change
+    broadcastToSession(sessionId, WS_MESSAGE_TYPES.SESSION_SUMMARY_UPDATED, {
+      sessionId,
+      summary: updatedSummary,
+    });
+
+    console.log(`[PrStatusService] Updated PR status for session ${sessionId}: ${prInfo.state}`);
+    return true;
+  } catch (error) {
+    console.error(`[PrStatusService] Error checking PR for session ${sessionId}:`, error.message);
+    return false;
+  }
+}
+
+/**
+ * Main polling loop - called every interval
+ */
+async function pollLoop() {
+  const sessionsToCheck = getSessionsToCheck();
+
+  if (sessionsToCheck.length === 0) return;
+
+  console.log(`[PrStatusService] Checking ${sessionsToCheck.length} session(s) with PRs`);
+
+  // Check sequentially to avoid hammering GitHub API
+  for (const { sessionId, prUrl } of sessionsToCheck) {
+    await checkPrStatus(sessionId, prUrl);
+  }
+}
+
+// Export for testing
+export {
+  DEFAULT_POLL_INTERVAL_MS,
+  FINAL_PR_STATES,
+  POLLABLE_SESSION_STATES,
+  RECENT_ACTIVITY_MS,
+  MAX_POLL_AGE_MS,
+  pollLoop,
+};

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

@@ -0,0 +1,224 @@
+/**
+ * PR URL extraction, parsing, validation, and enrichment.
+ * Consolidates all PR-related functionality from summaryService.
+ */
+
+import { sessions, messages } from '../database.js';
+import { broadcastSessionUpdate } from './summaryBroadcast.js';
+import * as ghService from './ghService.js';
+
+/**
+ * Parse a GitHub PR URL into components
+ * @param {string} prUrl - GitHub PR URL
+ * @returns {Object|null} - { owner, repo, number } or null if invalid format
+ */
+export function parsePrUrl(prUrl) {
+  if (!prUrl) return null;
+
+  try {
+    // Match GitHub PR URL pattern: https://github.com/{owner}/{repo}/pull/{number}
+    const match = prUrl.match(/^https:\/\/github\.com\/([^/]+)\/([^/]+)\/pull\/(\d+)$/);
+    if (!match) {
+      console.warn(`[PrUrlService] Invalid PR URL format: ${prUrl}`);
+      return null;
+    }
+
+    return {
+      owner: match[1],
+      repo: match[2],
+      number: parseInt(match[3], 10),
+    };
+  } catch (error) {
+    console.warn(`[PrUrlService] Failed to parse PR URL ${prUrl}:`, error.message);
+    return null;
+  }
+}
+
+/**
+ * Validate that a PR URL belongs to the expected repository
+ * @param {string} prUrl - GitHub PR URL
+ * @param {string} expectedRepoUrl - Expected repository URL
+ * @returns {Object} - { valid: boolean, prComponents: Object|null, mismatch: boolean, error: string|null }
+ */
+export function validatePrUrl(prUrl, expectedRepoUrl) {
+  if (!prUrl) {
+    return { valid: false, prComponents: null, mismatch: false, error: 'No PR URL provided' };
+  }
+
+  // Parse the PR URL
+  const prComponents = parsePrUrl(prUrl);
+  if (!prComponents) {
+    return { valid: false, prComponents: null, mismatch: false, error: 'Invalid PR URL format' };
+  }
+
+  // If no expected repo URL, we can't validate the match - accept it but log a warning
+  if (!expectedRepoUrl) {
+    console.warn(`[PrUrlService] No expected repo URL to validate against PR: ${prUrl}`);
+    return { valid: true, prComponents, mismatch: false, error: null };
+  }
+
+  // Extract owner/repo from expected repo URL
+  const expectedMatch = expectedRepoUrl.match(/^https:\/\/github\.com\/([^/]+)\/([^/]+)\/?$/);
+  if (!expectedMatch) {
+    console.warn(`[PrUrlService] Invalid expected repo URL format: ${expectedRepoUrl}`);
+    return { valid: true, prComponents, mismatch: false, error: null };
+  }
+
+  const expectedOwner = expectedMatch[1];
+  const expectedRepo = expectedMatch[2];
+
+  // Validate that the PR belongs to the expected repository
+  const ownerMatch = prComponents.owner === expectedOwner;
+  const repoMatch = prComponents.repo === expectedRepo;
+
+  if (!ownerMatch || !repoMatch) {
+    console.warn(
+      `[PrUrlService] PR repository mismatch: ` +
+      `PR is from ${prComponents.owner}/${prComponents.repo}, ` +
+      `but expected ${expectedOwner}/${expectedRepo}`
+    );
+    return {
+      valid: false,
+      prComponents,
+      mismatch: true,
+      error: `PR from ${prComponents.owner}/${prComponents.repo} does not match expected ${expectedOwner}/${expectedRepo}`
+    };
+  }
+
+  return { valid: true, prComponents, mismatch: false, error: null };
+}
+
+/**
+ * Extract PR URL from session messages by scanning for GitHub PR links
+ * @param {string} sessionId - The session ID
+ * @returns {string|null} - The PR URL if found, null otherwise
+ */
+export function extractPrUrlFromMessages(sessionId) {
+  const allMessages = messages.getBySessionId(sessionId);
+  if (!allMessages || allMessages.length === 0) return null;
+
+  // Get recent messages (last 20) to scan for PR URLs
+  const recentMessages = allMessages.slice(-20);
+
+  // GitHub PR URL pattern: https://github.com/{owner}/{repo}/pull/{number}
+  const prUrlPattern = /https:\/\/github\.com\/[^/]+\/[^/]+\/pull\/\d+/g;
+
+  // Scan messages in reverse order (most recent first) to find the latest PR URL
+  for (let i = recentMessages.length - 1; i >= 0; i--) {
+    const message = recentMessages[i];
+    const matches = message.content?.match(prUrlPattern);
+
+    if (matches && matches.length > 0) {
+      // Return the most recent PR URL found
+      return matches[matches.length - 1];
+    }
+  }
+
+  return null;
+}
+
+/**
+ * Extract PR URL from recent messages immediately after a turn completes.
+ * This is lightweight (no Claude API call) - just scans messages for URLs.
+ * @param {string} sessionId - The session ID
+ */
+export async function extractPrUrlIfNeeded(sessionId) {
+  const session = sessions.getById(sessionId);
+  if (!session) return;
+
+  // Skip if session already has a PR URL
+  if (session.prUrl) return;
+
+  // Extract PR URL from messages
+  const prUrl = extractPrUrlFromMessages(sessionId);
+  if (prUrl) {
+    sessions.update(sessionId, { prUrl });
+    console.log(`[PrUrlService] Extracted PR URL for session ${sessionId}: ${prUrl}`);
+
+    // Set session name from PR title (async, fire-and-forget)
+    await setSessionNameFromPr(sessionId, prUrl);
+
+    // Broadcast session update so UI shows PR URL immediately
+    broadcastSessionUpdate(sessionId, session.projectId, sessions.getById(sessionId));
+
+    // Propagate PR URL to root session
+    if (session.parentSessionId) {
+      const rootId = sessions.getRootSessionId(sessionId);
+      const root = rootId && rootId !== sessionId ? sessions.getById(rootId) : null;
+      if (root && !root.prUrl) {
+        sessions.update(root.id, { prUrl });
+        console.log(`[PrUrlService] Propagated PR URL from session ${sessionId} to root ${root.id}: ${prUrl}`);
+
+        // Broadcast root session update
+        broadcastSessionUpdate(root.id, root.projectId, sessions.getById(root.id));
+      }
+    }
+  }
+}
+
+/**
+ * Validate and enrich PR URL data with GitHub PR status information
+ * @param {Object} summaryDataInput - Summary data to enrich (modified in place)
+ * @param {string} prUrl - PR URL to validate and enrich
+ * @param {string} projectRepoUrl - Expected repository URL for validation
+ * @param {string} sessionId - Session ID for logging
+ */
+export async function enrichPrData(summaryDataInput, prUrl, projectRepoUrl, sessionId) {
+  const summaryData = summaryDataInput;
+  const validation = validatePrUrl(prUrl, projectRepoUrl);
+
+  if (!validation.valid) {
+    console.warn(`[PrUrlService] PR URL validation failed for session ${sessionId}:`, validation.error);
+    summaryData.prUrl = null;
+    return;
+  }
+
+  try {
+    const prInfo = await ghService.getPrInfo(prUrl);
+    if (prInfo) {
+      summaryData.prState = prInfo.state;
+      summaryData.prMerged = prInfo.merged;
+      summaryData.hasMergeConflicts = prInfo.hasMergeConflicts;
+      summaryData.ciStatus = prInfo.ciStatus;
+      if (prInfo.ciFailures !== undefined) {
+        summaryData.ciFailures = prInfo.ciFailures;
+      }
+      // Add PR title to summary data
+      if (prInfo.title) {
+        summaryData.prTitle = prInfo.title;
+      }
+    }
+  } catch (error) {
+    console.warn(`[PrUrlService] Failed to get PR info for ${prUrl}:`, error.message);
+  }
+}
+
+/**
+ * Set session name from PR title when PR URL is associated.
+ * @param {string} sessionId - The session ID
+ * @param {string} prUrl - The PR URL
+ */
+export async function setSessionNameFromPr(sessionId, prUrl) {
+  const session = sessions.getById(sessionId);
+  if (!session || session.manuallyNamed) return; // Don't overwrite if manually named
+
+  try {
+    const prInfo = await ghService.getPrInfo(prUrl);
+    if (prInfo?.title) {
+      sessions.update(sessionId, {
+        name: prInfo.title,
+        manuallyNamed: true, // Protect from summary overwrites
+      });
+      console.log(`[PrUrlService] Set session ${sessionId} name from PR title: "${prInfo.title}"`);
+
+      // Broadcast the update
+      const updated = sessions.getById(sessionId);
+      broadcastSessionUpdate(sessionId, session.projectId, updated);
+    }
+  } catch (error) {
+    console.warn(`[PrUrlService] Failed to set session name from PR ${prUrl}:`, error.message);
+  }
+}
+
+// Backward-compatible alias for internal/test usage
+export { enrichPrData as _enrichPrData };

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

@@ -0,0 +1,81 @@
+import Anthropic from '@anthropic-ai/sdk';
+
+/**
+ * Test a provider configuration by making a minimal API call
+ * @param {Object} config - Provider configuration to test
+ * @param {string} [config.baseUrl] - Base URL for the provider
+ * @param {string} [config.authToken] - Auth token for the provider
+ * @param {string} [config.defaultSonnetModel] - Default Sonnet model ID
+ * @param {number} [config.apiTimeoutMs] - API timeout in milliseconds
+ * @returns {Promise<{success: boolean, message: string, details?: Object}>}
+ */
+export async function testProviderConnection(config) {
+  const { baseUrl, authToken, defaultSonnetModel, apiTimeoutMs } = config;
+
+  try {
+    // Build client options
+    const clientOptions = {};
+
+    if (baseUrl) {
+      clientOptions.baseURL = baseUrl;
+    }
+    if (authToken) {
+      clientOptions.apiKey = authToken;
+    }
+    if (apiTimeoutMs) {
+      clientOptions.timeout = apiTimeoutMs;
+    }
+
+    const client = new Anthropic(clientOptions);
+
+    // Use a minimal message to test connectivity
+    // This verifies: network, auth, and model availability
+    const testModel = defaultSonnetModel || 'claude-sonnet-4-20250514';
+
+    const response = await client.messages.create({
+      model: testModel,
+      max_tokens: 10,
+      messages: [{ role: 'user', content: 'Hi' }],
+    });
+
+    return {
+      success: true,
+      message: 'Connection successful',
+      details: {
+        model: response.model,
+        usage: response.usage,
+      },
+    };
+  } catch (error) {
+    return {
+      success: false,
+      message: getErrorMessage(error),
+      details: {
+        code: error.status || error.code,
+        type: error.type || error.name,
+      },
+    };
+  }
+}
+
+/**
+ * Get a human-readable error message from an error object
+ * @param {Error} error - The error object
+ * @returns {string} - Human-readable error message
+ * @private
+ */
+function getErrorMessage(error) {
+  if (error.status === 401) {
+    return 'Authentication failed. Check your auth token.';
+  }
+  if (error.status === 404) {
+    return 'Model not found. Check the model ID.';
+  }
+  if (error.code === 'ENOTFOUND' || error.code === 'ECONNREFUSED') {
+    return 'Could not connect to server. Check the base URL.';
+  }
+  if (error.code === 'ETIMEDOUT') {
+    return 'Connection timed out. Try increasing the timeout.';
+  }
+  return error.message || 'Unknown error occurred';
+}

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

@@ -0,0 +1,110 @@
+import { sessions } from '../database.js';
+import { broadcastToSession, broadcastToProject } from '../websocket.js';
+import { WS_MESSAGE_TYPES } from '../../../shared/src/index.js';
+
+/**
+ * Custom error class for schedule operations, includes HTTP status code.
+ */
+export class ScheduleError extends Error {
+  /**
+   * @param {string} message
+   * @param {number} statusCode
+   */
+  constructor(message, statusCode) {
+    super(message);
+    this.name = 'ScheduleError';
+    this.statusCode = statusCode;
+  }
+}
+
+/**
+ * Extract and transform scheduling options from request data.
+ * @param {object} scheduleData - Raw schedule data from request
+ * @returns {object} Transformed scheduling options
+ */
+function extractSchedulingOptions(scheduleData) {
+  const options = {};
+  const boolFields = ['autoRescheduleEnabled', 'rescheduleOnTokenLimit', 'rescheduleOnServiceError'];
+  const intFields = ['rescheduleDelayMinutes'];
+  const nullableIntFields = ['maxRescheduleCount', 'maxTotalTokens', 'rescheduleAtTokenCount'];
+
+  for (const field of boolFields) {
+    if (scheduleData[field] !== undefined) {
+      options[field] = Boolean(scheduleData[field]);
+    }
+  }
+  for (const field of intFields) {
+    if (scheduleData[field] !== undefined) {
+      options[field] = parseInt(scheduleData[field], 10);
+    }
+  }
+  for (const field of nullableIntFields) {
+    if (scheduleData[field] !== undefined) {
+      options[field] = scheduleData[field] ? parseInt(scheduleData[field], 10) : null;
+    }
+  }
+  if (scheduleData.pendingModel !== undefined) {
+    options.pendingModel = scheduleData.pendingModel;
+  }
+
+  return options;
+}
+
+/**
+ * Configures a schedule for a follow-up message on an existing session.
+ *
+ * @param {object} session - The session object (from req.session_)
+ * @param {object} scheduleData
+ * @param {number} scheduleData.scheduledAt - Future timestamp in ms
+ * @param {string} [scheduleData.pendingModel] - Model to use when scheduled run fires
+ * @param {boolean} [scheduleData.autoRescheduleEnabled] - Enable auto-rescheduling
+ * @param {number} [scheduleData.rescheduleDelayMinutes] - Delay between reschedules
+ * @param {boolean} [scheduleData.rescheduleOnTokenLimit] - Reschedule on token limit errors
+ * @param {boolean} [scheduleData.rescheduleOnServiceError] - Reschedule on service errors
+ * @param {number|null} [scheduleData.maxRescheduleCount] - Max number of reschedules
+ * @param {number|null} [scheduleData.maxTotalTokens] - Max total tokens before stopping
+ * @param {number|null} [scheduleData.rescheduleAtTokenCount] - Token count trigger for reschedule
+ * @returns {object} The updated session
+ */
+export function configureSchedule(session, scheduleData) {
+  // Validate session status
+  if (!['waiting', 'stopped', 'error'].includes(session.status)) {
+    throw new ScheduleError('Session must be in waiting, stopped, or error state to schedule', 400);
+  }
+
+  const { scheduledAt } = scheduleData;
+
+  // Validate scheduledAt is provided and in the future
+  if (!scheduledAt || scheduledAt <= Date.now()) {
+    throw new ScheduleError('scheduledAt must be a future timestamp', 400);
+  }
+
+  // Validate that pendingPrompt exists and is not empty
+  if (!session.pendingPrompt || session.pendingPrompt.trim() === '') {
+    throw new ScheduleError('pendingPrompt must be set before scheduling', 400);
+  }
+
+  // Build update data with scheduling options
+  const updateData = {
+    status: 'scheduled',
+    scheduledAt,
+    ...extractSchedulingOptions(scheduleData),
+  };
+
+  const updated = sessions.update(session.id, updateData);
+
+  // Broadcast status update
+  broadcastToSession(session.id, WS_MESSAGE_TYPES.SESSION_STATUS, {
+    sessionId: session.id,
+    status: 'scheduled',
+  });
+
+  // Broadcast session update to project subscribers
+  broadcastToProject(session.projectId, WS_MESSAGE_TYPES.SESSION_UPDATED, {
+    projectId: session.projectId,
+    sessionId: session.id,
+    session: updated,
+  });
+
+  return updated;
+}