circuschief 0.1.0

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

@@ -0,0 +1,181 @@
+import { sessions, messages, projects, conversations, attachments } from '../database.js';
+import { broadcastToSession, broadcastToProject } from '../websocket.js';
+import { WS_MESSAGE_TYPES } from '../../../shared/src/index.js';
+import * as slashCommandService from './slashCommandService.js';
+
+/**
+ * Validates that a session is a draft (waiting status with no assistant messages).
+ * @param {object} session - The session object
+ * @returns {{ valid: boolean, error?: string }}
+ */
+export function validateDraftSession(session) {
+  if (session.status !== 'waiting') {
+    return { valid: false, error: 'Session must be in waiting status to start' };
+  }
+
+  const allMessages = messages.getBySessionId(session.id);
+  const hasAssistantMessages = allMessages.some(msg => msg.role === 'assistant');
+  if (hasAssistantMessages) {
+    return { valid: false, error: 'Session is not a draft - it already has responses' };
+  }
+
+  return { valid: true };
+}
+
+/**
+ * Validate that a prompt is non-empty.
+ * @param {*} prompt
+ * @returns {boolean}
+ */
+function isValidPrompt(prompt) {
+  return prompt && typeof prompt === 'string' && prompt.trim() !== '';
+}
+
+/**
+ * Create the initial user message for a draft session.
+ * @param {object} session
+ * @param {string} promptToUse
+ * @returns {object} The created message
+ */
+function createInitialMessage(session, promptToUse) {
+  const activeConv = conversations.getActiveBySessionId(session.id);
+  if (!activeConv) {
+    throw new DraftSessionError('No active conversation found', 500);
+  }
+
+  const initialMessage = messages.create(session.id, 'user', promptToUse, { toolUse: null, conversationId: activeConv.id });
+  sessions.update(session.id, { pendingPrompt: null });
+
+  broadcastToSession(session.id, WS_MESSAGE_TYPES.MESSAGE_CREATED, {
+    sessionId: session.id,
+    message: initialMessage,
+  });
+
+  return initialMessage;
+}
+
+/**
+ * Update an existing initial message with a new prompt.
+ * @param {object} session
+ * @param {object} initialMessage
+ * @param {string} newPrompt
+ * @returns {object} The updated message
+ */
+function updateInitialMessage(session, initialMessage, newPrompt) {
+  const updatedMessage = messages.updateContent(initialMessage.id, newPrompt);
+
+  broadcastToSession(session.id, WS_MESSAGE_TYPES.MESSAGE_UPDATED, {
+    sessionId: session.id,
+    message: updatedMessage,
+  });
+
+  return updatedMessage;
+}
+
+/**
+ * Get or create the initial user message for a draft session.
+ * @param {object} session
+ * @param {object} options
+ * @returns {object} The initial message
+ */
+function getOrCreateInitialMessage(session, options) {
+  const allMessages = messages.getBySessionId(session.id);
+  const userMessages = allMessages.filter(msg => msg.role === 'user');
+
+  // No existing user messages - create one
+  if (userMessages.length === 0) {
+    const promptToUse = options.prompt || session.pendingPrompt;
+    if (!isValidPrompt(promptToUse)) {
+      throw new DraftSessionError('No initial prompt found', 400);
+    }
+    return createInitialMessage(session, promptToUse);
+  }
+
+  // Existing user message - optionally update it
+  let initialMessage = userMessages[0];
+  if (options.prompt !== undefined) {
+    if (!isValidPrompt(options.prompt)) {
+      throw new DraftSessionError('Prompt must be a non-empty string', 400);
+    }
+    initialMessage = updateInitialMessage(session, initialMessage, options.prompt);
+  }
+
+  return initialMessage;
+}
+
+/**
+ * Starts a draft session by resolving the prompt, creating messages if needed,
+ * and kicking off the session manager.
+ *
+ * @param {object} session - The session object (from req.session_)
+ * @param {object} options
+ * @param {string} [options.prompt] - Optional new prompt to use/override
+ * @param {string} [options.model] - Optional model override
+ * @returns {Promise<object>} The updated session
+ */
+export async function startDraft(session, options = {}) {
+  const project = projects.getById(session.projectId);
+  if (!project) {
+    throw new DraftSessionError('Project not found', 404);
+  }
+
+  // Use gitWorktree if set, otherwise use project's working directory
+  const workingDirectory = session.gitWorktree || project.workingDirectory;
+
+  // Model to use for this session (optional - SDK will use default if not provided)
+  const model = options.model || session.pendingModel || session.model || null;
+
+  // Get or create the initial user message
+  const initialMessage = getOrCreateInitialMessage(session, options);
+  const finalPrompt = initialMessage.content;
+
+  // Get session attachments for context
+  const sessionAttachments = attachments.getBySessionId(session.id);
+
+  // Update session status to starting and clear pendingModel (mirrors pendingPrompt cleanup above)
+  sessions.update(session.id, { status: 'starting', pendingModel: null });
+
+  // Resolve skill/command invocations so skill body goes into system prompt
+  const resolved = await slashCommandService.resolvePromptSkillOrCommand(
+    workingDirectory, finalPrompt, project.systemPrompt
+  );
+  const effectivePrompt = resolved ? resolved.userMessage : finalPrompt;
+  const effectiveSystemPrompt = resolved ? resolved.systemPrompt : project.systemPrompt;
+
+  // Start session manager (non-blocking)
+  const { runSession } = await import('./sessionManager.js');
+  runSession(session.id, effectivePrompt, workingDirectory, { systemPrompt: effectiveSystemPrompt, fileAttachments: sessionAttachments, model }).catch((error) => {
+    console.error('Session error:', error);
+    sessions.update(session.id, { status: 'error', error: error.message });
+  });
+
+  // Broadcast status update
+  broadcastToSession(session.id, WS_MESSAGE_TYPES.SESSION_STATUS, {
+    sessionId: session.id,
+    status: 'starting',
+  });
+
+  // Broadcast to project subscribers
+  broadcastToProject(session.projectId, WS_MESSAGE_TYPES.SESSION_UPDATED, {
+    projectId: session.projectId,
+    sessionId: session.id,
+    session: sessions.getById(session.id),
+  });
+
+  return sessions.getById(session.id);
+}
+
+/**
+ * Custom error class for draft session operations, includes HTTP status code.
+ */
+export class DraftSessionError extends Error {
+  /**
+   * @param {string} message
+   * @param {number} statusCode
+   */
+  constructor(message, statusCode) {
+    super(message);
+    this.name = 'DraftSessionError';
+    this.statusCode = statusCode;
+  }
+}

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

@@ -0,0 +1,134 @@
+import crypto from 'crypto';
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from 'fs';
+import { join } from 'path';
+import { homedir } from 'os';
+
+const ALGORITHM = 'aes-256-gcm';
+const KEY_LENGTH = 32; // 256 bits for AES-256
+const IV_LENGTH = 12; // 96 bits is recommended for GCM
+const SEPARATOR = ':';
+const PARTS_COUNT = 3;
+
+// Allow tests to override the key directory so they never touch the real ~/.circuschief/secret.key
+let _keyDirOverride = null;
+
+/**
+ * Get or generate the encryption key.
+ * Uses ~/.circuschief/secret.key file (auto-generated on first run)
+ * @returns {Buffer} - 32-byte encryption key
+ */
+function getEncryptionKey() {
+  const keyDir = _keyDirOverride || join(homedir(), '.circuschief');
+  const keyPath = join(keyDir, 'secret.key');
+
+  if (existsSync(keyPath)) {
+    const keyHex = readFileSync(keyPath, 'utf-8').trim();
+    // Validate the key is a 64-char hex string (32 bytes)
+    if (/^[0-9a-fA-F]{64}$/.test(keyHex)) {
+      return Buffer.from(keyHex, 'hex');
+    }
+    // Key is invalid, log warning and regenerate
+    console.warn(`[encryption] Invalid key file at ${keyPath}, regenerating...`);
+  }
+
+  // Generate a new key
+  const key = crypto.randomBytes(KEY_LENGTH);
+  mkdirSync(keyDir, { recursive: true });
+  writeFileSync(keyPath, key.toString('hex'), { mode: 0o600 });
+  return key;
+}
+
+// Lazily initialize the key so it's only loaded when first needed
+let _key = null;
+
+function getKey() {
+  if (!_key) {
+    _key = getEncryptionKey();
+  }
+  return _key;
+}
+
+/**
+ * Encrypt a plaintext string using AES-256-GCM.
+ * Returns a string in the format: <iv_hex>:<authTag_hex>:<ciphertext_hex>
+ * Returns the original value unchanged if it is null, undefined, or empty.
+ * @param {string|null|undefined} plaintext
+ * @returns {string|null|undefined}
+ */
+export function encrypt(plaintext) {
+  if (plaintext == null || plaintext === '') return plaintext;
+
+  const key = getKey();
+  const iv = crypto.randomBytes(IV_LENGTH);
+  const cipher = crypto.createCipheriv(ALGORITHM, key, iv);
+
+  const encrypted = Buffer.concat([
+    cipher.update(plaintext, 'utf-8'),
+    cipher.final(),
+  ]);
+  const authTag = cipher.getAuthTag();
+
+  return [iv.toString('hex'), authTag.toString('hex'), encrypted.toString('hex')].join(SEPARATOR);
+}
+
+/**
+ * Decrypt a ciphertext string that was encrypted with `encrypt()`.
+ * Gracefully handles plaintext values (legacy data not yet encrypted) by returning them as-is.
+ * Returns the original value unchanged if it is null, undefined, or empty.
+ * @param {string|null|undefined} ciphertext
+ * @returns {string|null|undefined}
+ */
+export function decrypt(ciphertext) {
+  if (ciphertext == null || ciphertext === '') return ciphertext;
+
+  // If the value doesn't look like our format, treat it as plaintext (legacy)
+  const parts = ciphertext.split(SEPARATOR);
+  if (parts.length !== PARTS_COUNT) return ciphertext;
+
+  // Validate hex format and expected lengths
+  // IV should be 24 hex chars (12 bytes), auth tag should be 32 hex chars (16 bytes)
+  const ivHex = parts[0];
+  const authTagHex = parts[1];
+
+  if (!/^[0-9a-fA-F]{24}$/.test(ivHex) || !/^[0-9a-fA-F]{32}$/.test(authTagHex)) {
+    return ciphertext; // Legacy plaintext
+  }
+
+  try {
+    const key = getKey();
+    const iv = Buffer.from(parts[0], 'hex');
+    const authTag = Buffer.from(parts[1], 'hex');
+    const encrypted = Buffer.from(parts[2], 'hex');
+
+    const decipher = crypto.createDecipheriv(ALGORITHM, key, iv);
+    decipher.setAuthTag(authTag);
+
+    return decipher.update(encrypted) + decipher.final('utf-8');
+  } catch {
+    // Decryption failed — value is likely legacy plaintext, return as-is
+    console.warn('[encryption] Failed to decrypt value — returning as-is (possible key mismatch or legacy plaintext)');
+    return ciphertext;
+  }
+}
+
+/**
+ * Reset the cached encryption key.
+ * Only intended for test isolation.
+ * @internal
+ */
+export function _resetKeyForTesting() {
+  _key = null;
+}
+
+/**
+ * Override the key directory so tests use an isolated temp path
+ * instead of the real ~/.circuschief/ directory.
+ * Pass null to restore the default behaviour.
+ * Only intended for test isolation.
+ * @param {string|null} dir
+ * @internal
+ */
+export function _setKeyDirForTesting(dir) {
+  _keyDirOverride = dir;
+  _key = null; // also clear the cached key so the new path takes effect
+}

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

@@ -0,0 +1,169 @@
+import { exec } from 'child_process';
+import { promisify } from 'util';
+
+const execAsync = promisify(exec);
+
+// Cache gh availability check
+let ghAvailable = null;
+
+/**
+ * Check if gh CLI is installed and authenticated
+ * @returns {Promise<boolean>}
+ */
+export async function isGhAvailable() {
+  if (ghAvailable !== null) return ghAvailable;
+  try {
+    await execAsync('gh --version');
+    await execAsync('gh auth status');
+    ghAvailable = true;
+  } catch {
+    ghAvailable = false;
+  }
+  return ghAvailable;
+}
+
+/**
+ * Reset the gh availability cache (useful for testing)
+ */
+export function resetGhAvailableCache() {
+  ghAvailable = null;
+}
+
+/**
+ * Extract repository information from a PR URL
+ * @param {string} prUrl - GitHub PR URL
+ * @returns {Object|null} - { owner, repo, number } or null if invalid
+ */
+export function extractPrInfo(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) return null;
+
+    return {
+      owner: match[1],
+      repo: match[2],
+      number: parseInt(match[3], 10),
+    };
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Validate that a PR URL belongs to the expected repository
+ * @param {string} prUrl - GitHub PR URL
+ * @param {string} expectedRepoUrl - Expected repository URL (https://github.com/owner/repo)
+ * @returns {Object} - { valid: boolean, mismatch: boolean, error: string|null }
+ */
+export function validatePrRepository(prUrl, expectedRepoUrl) {
+  if (!prUrl) {
+    return { valid: false, mismatch: false, error: 'No PR URL provided' };
+  }
+
+  const prInfo = extractPrInfo(prUrl);
+  if (!prInfo) {
+    return { valid: false, mismatch: false, error: 'Invalid PR URL format' };
+  }
+
+  // If no expected repo URL, we can't validate - accept it
+  if (!expectedRepoUrl) {
+    return { valid: true, mismatch: false, error: null };
+  }
+
+  // Extract owner/repo from expected repo URL
+  const expectedMatch = expectedRepoUrl.match(/^https:\/\/github\.com\/([^/]+)\/([^/]+)\/?$/);
+  if (!expectedMatch) {
+    return { valid: true, mismatch: false, error: null };
+  }
+
+  const expectedOwner = expectedMatch[1];
+  const expectedRepo = expectedMatch[2];
+
+  // Check if PR belongs to expected repository
+  if (prInfo.owner !== expectedOwner || prInfo.repo !== expectedRepo) {
+    return {
+      valid: false,
+      mismatch: true,
+      error: `PR from ${prInfo.owner}/${prInfo.repo} does not match expected ${expectedOwner}/${expectedRepo}`
+    };
+  }
+
+  return { valid: true, mismatch: false, error: null };
+}
+
+/**
+ * Get comprehensive PR info including state, merge conflicts, and CI status
+ * @param {string} prUrl - GitHub PR URL
+ * @returns {Promise<Object|null>} PR info or null if unavailable
+ */
+export async function getPrInfo(prUrl) {
+  if (!(await isGhAvailable())) return null;
+
+  try {
+    // First fetch basic PR info (this should always work)
+    const { stdout: basicStdout } = await execAsync(
+      `gh pr view "${prUrl}" --json state,mergedAt,mergeable,isDraft,title`
+    );
+    const data = JSON.parse(basicStdout);
+
+    // Determine PR state
+    let state = data.state.toLowerCase();
+    if (data.mergedAt) state = 'merged';
+    else if (data.isDraft) state = 'draft';
+
+    // Check for merge conflicts
+    // mergeable can be: 'MERGEABLE', 'CONFLICTING', 'UNKNOWN'
+    const hasMergeConflicts = data.mergeable === 'CONFLICTING';
+
+    // Try to fetch CI status separately (may fail due to token permissions)
+    let ciStatus = null;
+    let ciFailures = [];
+
+    try {
+      const { stdout: ciStdout } = await execAsync(
+        `gh pr view "${prUrl}" --json statusCheckRollup`
+      );
+      const ciData = JSON.parse(ciStdout);
+      const checks = ciData.statusCheckRollup || [];
+
+      if (checks.length > 0) {
+        // Get failed checks with their names
+        const failedChecks = checks.filter(
+          (c) => c.conclusion === 'FAILURE' || c.conclusion === 'TIMED_OUT'
+        );
+        ciFailures = failedChecks.map((c) => c.name || c.context || 'Unknown check');
+
+        // Determine overall CI status
+        const hasPending = checks.some(
+          (c) => c.status === 'IN_PROGRESS' || c.status === 'QUEUED' || c.status === 'PENDING'
+        );
+
+        if (failedChecks.length > 0) {
+          ciStatus = 'failure';
+        } else if (hasPending) {
+          ciStatus = 'pending';
+        } else {
+          ciStatus = 'success';
+        }
+      }
+    } catch (ciError) {
+      // CI status unavailable (likely token permissions) - continue without it
+      console.warn('[ghService] CI status unavailable:', ciError.message);
+    }
+
+    return {
+      state,
+      merged: Boolean(data.mergedAt),
+      hasMergeConflicts,
+      ciStatus,
+      ciFailures,
+      title: data.title || null,
+    };
+  } catch (error) {
+    console.warn('[ghService] Failed to get PR info:', error.message);
+    return null;
+  }
+}