@myrialabs/clopen 0.0.1

package/backend/lib/database/utils/migration-runner.ts

@@ -0,0 +1,118 @@
+import type { DatabaseConnection } from '$shared/types/database/connection';
+
+import { debug } from '$shared/utils/logger';
+interface Migration {
+	id: string;
+	description: string;
+	up: (db: DatabaseConnection) => void;
+	down: (db: DatabaseConnection) => void;
+}
+
+export class MigrationRunner {
+	private db: DatabaseConnection;
+	private migrations: Migration[] = [];
+
+	constructor(db: DatabaseConnection) {
+		this.db = db;
+		this.ensureMigrationsTable();
+	}
+
+	private ensureMigrationsTable(): void {
+		this.db.exec(`
+			CREATE TABLE IF NOT EXISTS migrations (
+				id TEXT PRIMARY KEY,
+				description TEXT NOT NULL,
+				executed_at TEXT NOT NULL
+			)
+		`);
+	}
+
+	addMigration(migration: Migration): void {
+		this.migrations.push(migration);
+	}
+
+	async runMigrations(): Promise<void> {
+		debug.log('database', '🔄 Running database migrations...');
+
+		// Get already executed migrations
+		const executedMigrations = this.db.prepare(`
+			SELECT id FROM migrations ORDER BY id
+		`).all() as { id: string }[];
+
+		const executedIds = new Set(executedMigrations.map(m => m.id));
+
+		// Sort migrations by ID to ensure order
+		const sortedMigrations = this.migrations.sort((a, b) => a.id.localeCompare(b.id));
+
+		let executedCount = 0;
+
+		for (const migration of sortedMigrations) {
+			if (!executedIds.has(migration.id)) {
+				debug.log('database', `📋 Running migration: ${migration.id} - ${migration.description}`);
+				
+				try {
+					// Execute migration
+					migration.up(this.db);
+
+					// Record migration as executed
+					this.db.prepare(`
+						INSERT INTO migrations (id, description, executed_at)
+						VALUES (?, ?, ?)
+					`).run(migration.id, migration.description, new Date().toISOString());
+
+					executedCount++;
+					debug.log('database', `✅ Migration ${migration.id} completed`);
+				} catch (error) {
+					debug.error('database', `❌ Migration ${migration.id} failed:`, error);
+					throw error;
+				}
+			}
+		}
+
+		if (executedCount === 0) {
+			debug.log('database', 'ℹ️  No new migrations to run');
+		} else {
+			debug.log('database', `✅ Executed ${executedCount} migrations successfully`);
+		}
+	}
+
+	async rollbackMigration(migrationId: string): Promise<void> {
+		debug.log('database', `🔄 Rolling back migration: ${migrationId}`);
+
+		const migration = this.migrations.find(m => m.id === migrationId);
+		if (!migration) {
+			throw new Error(`Migration ${migrationId} not found`);
+		}
+
+		try {
+			// Execute rollback
+			migration.down(this.db);
+
+			// Remove migration record
+			this.db.prepare(`
+				DELETE FROM migrations WHERE id = ?
+			`).run(migrationId);
+
+			debug.log('database', `✅ Migration ${migrationId} rolled back successfully`);
+		} catch (error) {
+			debug.error('database', `❌ Rollback of ${migrationId} failed:`, error);
+			throw error;
+		}
+	}
+
+	getExecutedMigrations(): string[] {
+		const migrations = this.db.prepare(`
+			SELECT id FROM migrations ORDER BY id
+		`).all() as { id: string }[];
+
+		return migrations.map(m => m.id);
+	}
+
+	getPendingMigrations(): string[] {
+		const executed = new Set(this.getExecutedMigrations());
+		return this.migrations
+			.filter(m => !executed.has(m.id))
+			.sort((a, b) => a.id.localeCompare(b.id))
+			.map(m => m.id);
+	}
+}

package/backend/lib/database/utils/seeder-runner.ts

@@ -0,0 +1,121 @@
+import type { DatabaseConnection } from '$shared/types/database/connection';
+
+import { debug } from '$shared/utils/logger';
+interface Seeder {
+	name: string;
+	description: string;
+	seed: (db: DatabaseConnection) => void;
+}
+
+export class SeederRunner {
+	private db: DatabaseConnection;
+	private seeders: Seeder[] = [];
+
+	constructor(db: DatabaseConnection) {
+		this.db = db;
+		this.ensureSeedersTable();
+	}
+
+	private ensureSeedersTable(): void {
+		this.db.exec(`
+			CREATE TABLE IF NOT EXISTS seeders (
+				name TEXT PRIMARY KEY,
+				description TEXT NOT NULL,
+				executed_at TEXT NOT NULL
+			)
+		`);
+	}
+
+	addSeeder(seeder: Seeder): void {
+		this.seeders.push(seeder);
+	}
+
+	async runSeeders(force: boolean = false): Promise<void> {
+		debug.log('database', '🌱 Running database seeders...');
+
+		// Get already executed seeders
+		const executedSeeders = this.db.prepare(`
+			SELECT name FROM seeders
+		`).all() as { name: string }[];
+
+		const executedNames = new Set(executedSeeders.map(s => s.name));
+
+		let executedCount = 0;
+
+		for (const seeder of this.seeders) {
+			if (!executedNames.has(seeder.name) || force) {
+				debug.log('database', `🌱 Running seeder: ${seeder.name} - ${seeder.description}`);
+				
+				try {
+					// Execute seeder
+					seeder.seed(this.db);
+
+					// Record seeder as executed (replace if force)
+					if (force && executedNames.has(seeder.name)) {
+						this.db.prepare(`
+							UPDATE seeders 
+							SET description = ?, executed_at = ?
+							WHERE name = ?
+						`).run(seeder.description, new Date().toISOString(), seeder.name);
+					} else {
+						this.db.prepare(`
+							INSERT OR REPLACE INTO seeders (name, description, executed_at)
+							VALUES (?, ?, ?)
+						`).run(seeder.name, seeder.description, new Date().toISOString());
+					}
+
+					executedCount++;
+					debug.log('database', `✅ Seeder ${seeder.name} completed`);
+				} catch (error) {
+					debug.error('database', `❌ Seeder ${seeder.name} failed:`, error);
+					throw error;
+				}
+			}
+		}
+
+		if (executedCount === 0) {
+			debug.log('database', 'ℹ️  No new seeders to run');
+		} else {
+			debug.log('database', `✅ Executed ${executedCount} seeders successfully`);
+		}
+	}
+
+	async runSpecificSeeder(seederName: string, force: boolean = false): Promise<void> {
+		const seeder = this.seeders.find(s => s.name === seederName);
+		if (!seeder) {
+			throw new Error(`Seeder ${seederName} not found`);
+		}
+
+		debug.log('database', `🌱 Running specific seeder: ${seederName}`);
+
+		try {
+			seeder.seed(this.db);
+
+			// Record seeder as executed
+			this.db.prepare(`
+				INSERT OR REPLACE INTO seeders (name, description, executed_at)
+				VALUES (?, ?, ?)
+			`).run(seeder.name, seeder.description, new Date().toISOString());
+
+			debug.log('database', `✅ Seeder ${seederName} completed`);
+		} catch (error) {
+			debug.error('database', `❌ Seeder ${seederName} failed:`, error);
+			throw error;
+		}
+	}
+
+	getExecutedSeeders(): string[] {
+		const seeders = this.db.prepare(`
+			SELECT name FROM seeders ORDER BY executed_at
+		`).all() as { name: string }[];
+
+		return seeders.map(s => s.name);
+	}
+
+	getPendingSeeders(): string[] {
+		const executed = new Set(this.getExecutedSeeders());
+		return this.seeders
+			.filter(s => !executed.has(s.name))
+			.map(s => s.name);
+	}
+}

package/backend/lib/engine/adapters/claude/environment.ts

@@ -0,0 +1,164 @@
+/**
+ * Environment configuration for Claude Code engine.
+ *
+ * Builds an env dictionary to pass via SDK Options.env
+ * instead of mutating process.env directly.
+ * This avoids global state race conditions when multiple projects
+ * stream concurrently.
+ */
+
+import { homedir } from 'os';
+import { join } from 'path';
+import { isWindows, findGitBash } from '../../../terminal/shell-utils.js';
+import { engineQueries } from '../../../database/queries';
+import { debug } from '$shared/utils/logger';
+
+let _ready = false;
+let _initPromise: Promise<void> | null = null;
+let _envOverrides: Record<string, string> = {};
+
+/**
+ * Returns the isolated Claude config directory under ~/.clopen/claude/user/
+ */
+export function getClaudeUserConfigDir(): string {
+  return join(homedir(), '.clopen', 'claude', 'user');
+}
+
+/**
+ * Resets environment state so the next setupEnvironmentOnce() re-reads
+ * the active account token from DB. Called after account switch/delete.
+ */
+export function resetEnvironment(): void {
+  _ready = false;
+  _initPromise = null;
+  _envOverrides = {};
+}
+
+/**
+ * Idempotent, concurrency-safe environment setup.
+ * Multiple concurrent calls share a single initialization promise.
+ */
+export async function setupEnvironmentOnce(): Promise<void> {
+  if (_ready) return;
+  if (_initPromise) return _initPromise;
+
+  _initPromise = _doSetup();
+  try {
+    await _initPromise;
+  } catch (error) {
+    _initPromise = null;
+    throw error;
+  }
+}
+
+/**
+ * Returns the env dictionary for SDK Options.env.
+ * Merges process.env with our overrides so the SDK subprocess
+ * inherits everything it needs.
+ *
+ * When accountId is provided, overrides the OAuth token with that
+ * specific account's token instead of the globally active account.
+ */
+export function getEngineEnv(accountId?: number): Record<string, string> {
+  const env: Record<string, string> = {};
+  // Copy process.env (filter out undefined values)
+  for (const [key, value] of Object.entries(process.env)) {
+    if (value !== undefined) {
+      env[key] = value;
+    }
+  }
+  // Apply our overrides
+  Object.assign(env, _envOverrides);
+
+  // Override with specific account token if requested
+  if (accountId !== undefined) {
+    try {
+      const accounts = engineQueries.getClaudeAccounts();
+      const account = accounts.find(a => a.id === accountId);
+      if (account) {
+        env['CLAUDE_CODE_OAUTH_TOKEN'] = account.oauth_token;
+        debug.log('engine', `Claude Code: Per-session account override → "${account.name}"`);
+      }
+    } catch {
+      // Ignore — fall back to default token from overrides
+    }
+  }
+
+  return env;
+}
+
+async function _doSetup(): Promise<void> {
+  const overrides: Record<string, string> = {};
+
+  // Bypass permissions for Claude Code
+  overrides['CLAUDE_CODE_PERMISSION_MODE'] = 'bypassPermissions';
+
+  // Isolate Claude config to ~/.clopen/claude/user/
+  const claudeUserDir = getClaudeUserConfigDir();
+  await ensureDirectory(claudeUserDir);
+  overrides['CLAUDE_CONFIG_DIR'] = claudeUserDir;
+
+  // Inject OAuth token from active account (if any)
+  try {
+    const activeAccount = engineQueries.getActiveClaudeAccount();
+    if (activeAccount) {
+      overrides['CLAUDE_CODE_OAUTH_TOKEN'] = activeAccount.oauth_token;
+      debug.log('engine', `✅ Claude Code: Using account "${activeAccount.name}"`);
+    }
+  } catch {
+    // DB may not be initialized yet during first startup
+    debug.warn('engine', '⚠️ Claude Code: Could not read active account (DB may not be ready)');
+  }
+
+  // Setup Git Bash on Windows
+  if (isWindows) {
+    const existingPath = process.env.CLAUDE_CODE_GIT_BASH_PATH;
+    if (existingPath) {
+      overrides['CLAUDE_CODE_GIT_BASH_PATH'] = existingPath;
+    } else {
+      const gitBashPath = await findGitBash();
+      if (gitBashPath) {
+        overrides['CLAUDE_CODE_GIT_BASH_PATH'] = gitBashPath;
+        debug.log('engine', '✅ Claude Code: Git Bash configured at:', gitBashPath);
+      } else {
+        debug.warn('engine', '⚠️ Claude Code: Git Bash not found - may have limited functionality on Windows');
+      }
+    }
+  }
+
+  // Terminal environment variables
+  overrides['FORCE_COLOR'] = '1';
+  overrides['COLORTERM'] = 'truecolor';
+  if (!process.env.TERM) {
+    overrides['TERM'] = 'xterm-256color';
+  }
+
+  _envOverrides = overrides;
+  _ready = true;
+  debug.log('engine', '✅ Environment configured (one-time setup)');
+}
+
+async function ensureDirectory(dirPath: string): Promise<void> {
+  try {
+    await Bun.file(dirPath).stat();
+  } catch {
+    // Directory doesn't exist, create via temp file workaround
+    const tempFile = join(dirPath, '.init');
+    await Bun.write(tempFile, '');
+    try {
+      if (await Bun.file(tempFile).exists()) {
+        if (process.platform === 'win32') {
+          await Bun.spawn(['cmd', '/c', 'del', '/f', '/q', tempFile.replace(/\//g, '\\')], {
+            stdout: 'ignore', stderr: 'ignore'
+          }).exited;
+        } else {
+          await Bun.spawn(['rm', '-f', tempFile], {
+            stdout: 'ignore', stderr: 'ignore'
+          }).exited;
+        }
+      }
+    } catch {
+      // Ignore cleanup errors
+    }
+  }
+}

package/backend/lib/engine/adapters/claude/error-handler.ts

@@ -0,0 +1,60 @@
+export function handleStreamError(error: unknown): void {
+  if (!(error instanceof Error)) {
+    throw error;
+  }
+
+  // Abort errors are expected during cancellation - don't re-throw
+  if (error.name === 'AbortError' || error.message.includes('aborted') || error.message.includes('abort')) {
+    return;
+  }
+
+  if (error.message.includes('error_max_turns') || error.message.includes('max_turns')) {
+    throw new Error('Unexpected conversation limit reached. This should not happen with unlimited turns enabled.');
+  }
+
+  if (error.message.includes('git-bash') || error.message.includes('requires git-bash')) {
+    throw new Error('Claude Code requires git-bash on Windows. Please ensure Git is installed and accessible.');
+  }
+
+  if (error.message.includes('ENOENT') || error.message.includes('spawn claude-code')) {
+    throw new Error('Claude Agent SDK not found. Please install it with: npm install @anthropic-ai/claude-agent-sdk');
+  }
+
+  if (error.message.includes('API key')) {
+    throw new Error('Claude Agent SDK requires an Anthropic API key. Please set ANTHROPIC_API_KEY environment variable.');
+  }
+
+  // Extract detailed error info from API errors (Anthropic SDK APIError has .status, .error)
+  const enriched = extractDetailedError(error);
+  throw new Error(enriched);
+}
+
+/**
+ * Extract detailed error info from an Error object.
+ * Handles Anthropic SDK's APIError which has .status and .error.message fields.
+ *
+ * Does NOT prepend error class names (e.g. "APIError", "UnknownError") —
+ * those are SDK implementation details, not useful for the end user.
+ * The stream-manager's normalizeErrorText() also strips them as a safety net.
+ */
+function extractDetailedError(error: Error): string {
+  const err = error as Record<string, any>;
+
+  // Use the message directly, stripping any redundant leading "Error: " prefix
+  let message = (err.message || '').replace(/^Error:\s*/, '');
+  if (!message) {
+    message = err.name && err.name !== 'Error' ? String(err.name) : 'Unknown error';
+  }
+
+  // Append status code if available (Anthropic APIError has .status)
+  if (err.status && !message.includes(String(err.status))) {
+    message += ` (status ${err.status})`;
+  }
+
+  // Append nested error body (Anthropic APIError has .error.message)
+  if (err.error?.message && !message.includes(err.error.message)) {
+    message += ` - ${err.error.message}`;
+  }
+
+  return message || error.message || 'Unknown error';
+}

package/backend/lib/engine/adapters/claude/index.ts

@@ -0,0 +1 @@
+export { ClaudeCodeEngine } from './stream';

package/backend/lib/engine/adapters/claude/path-utils.ts

@@ -0,0 +1,38 @@
+import { resolve } from 'path';
+
+export function normalizePath(projectPath: string): string {
+  let normalizedProjectPath = projectPath;
+
+  if (process.platform === 'win32') {
+    if (!projectPath.match(/^[A-Za-z]:\\/)) {
+      if (projectPath.startsWith('\\')) {
+        const currentDrive = process.cwd().substring(0, 2);
+        normalizedProjectPath = currentDrive + projectPath;
+      } else {
+        normalizedProjectPath = resolve(projectPath);
+      }
+    }
+
+    normalizedProjectPath = normalizedProjectPath.replace(/\//g, '\\');
+  }
+
+  return normalizedProjectPath;
+}
+
+export function changeWorkingDirectory(targetPath: string): string {
+  const originalCwd = process.cwd();
+
+  try {
+    process.chdir(targetPath);
+    return originalCwd;
+  } catch (error) {
+    throw new Error(`Cannot change working directory to ${targetPath}: ${error}`);
+  }
+}
+
+export function restoreWorkingDirectory(originalCwd: string): void {
+  try {
+    process.chdir(originalCwd);
+  } catch (error) {
+  }
+}

package/backend/lib/engine/adapters/claude/stream.ts

@@ -0,0 +1,177 @@
+/**
+ * Claude Code Engine Adapter
+ *
+ * Wraps the @anthropic-ai/claude-agent-sdk into the AIEngine interface.
+ * Messages are already in SDKMessage format — no conversion needed.
+ */
+
+
+import { query, type SDKMessage, type EngineSDKMessage, type Options, type Query, type SDKUserMessage } from '$shared/types/messaging';
+import type { PermissionMode } from "@anthropic-ai/claude-agent-sdk";
+import { normalizePath } from './path-utils';
+import { setupEnvironmentOnce, getEngineEnv } from './environment';
+import { handleStreamError } from './error-handler';
+import { getEnabledMcpServers, getAllowedMcpTools } from '../../../mcp';
+import type { AIEngine, EngineQueryOptions } from '../../types';
+import type { EngineModel } from '$shared/types/engine';
+import { CLAUDE_CODE_MODELS } from '$shared/constants/engines';
+
+import { debug } from '$shared/utils/logger';
+
+/** Type guard for AsyncIterable */
+function isAsyncIterable<T>(value: unknown): value is AsyncIterable<T> {
+  return value != null && typeof value === 'object' && Symbol.asyncIterator in value;
+}
+
+export class ClaudeCodeEngine implements AIEngine {
+  readonly name = 'claude-code' as const;
+  private _isInitialized = false;
+  private activeController: AbortController | null = null;
+  private activeQuery: Query | null = null;
+
+  get isInitialized(): boolean {
+    return this._isInitialized;
+  }
+
+  get isActive(): boolean {
+    return this.activeController !== null;
+  }
+
+  async initialize(): Promise<void> {
+    if (this._isInitialized) return;
+
+    // One-time environment setup (idempotent, concurrency-safe)
+    await setupEnvironmentOnce();
+
+    this._isInitialized = true;
+    debug.log('engine', '✅ Claude Code engine initialized');
+  }
+
+  async dispose(): Promise<void> {
+    await this.cancel();
+    this._isInitialized = false;
+  }
+
+  async getAvailableModels(): Promise<EngineModel[]> {
+    return CLAUDE_CODE_MODELS;
+  }
+
+  /**
+   * Stream query with real-time callbacks
+   */
+  async *streamQuery(options: EngineQueryOptions): AsyncGenerator<EngineSDKMessage, void, unknown> {
+    const {
+      projectPath,
+      prompt,
+      resume,
+      maxTurns = undefined,
+      model = 'sonnet',
+      includePartialMessages = false,
+      abortController,
+      claudeAccountId
+    } = options;
+
+    debug.log('chat', "Claude Code - Stream Query");
+    debug.log('chat', { prompt });
+
+    this.activeController = abortController || new AbortController();
+
+    const normalizedProjectPath = normalizePath(projectPath);
+
+    try {
+      // Get custom MCP servers and allowed tools
+      const mcpServers = getEnabledMcpServers();
+      const allowedMcpTools = getAllowedMcpTools();
+
+      debug.log('mcp', '📦 Loading custom MCP servers...');
+      debug.log('mcp', `Enabled servers: ${Object.keys(mcpServers).length}`);
+      debug.log('mcp', `Allowed tools: ${allowedMcpTools.length}`);
+
+      // SDK uses cwd from options — no process.chdir() needed.
+      // Environment is passed via env option — no process.env mutation.
+      // When claudeAccountId is specified, the env uses that account's token
+      // instead of the globally active account.
+      const sdkOptions: Options = {
+        permissionMode: 'bypassPermissions' as PermissionMode,
+        allowDangerouslySkipPermissions: true,
+        cwd: normalizedProjectPath,
+        env: getEngineEnv(claudeAccountId),
+        systemPrompt: { type: "preset", preset: "claude_code" },
+        settingSources: ["user", "project", "local"],
+        forkSession: true,
+        ...(model && { model }),
+        ...(resume && { resume }),
+        ...(maxTurns && { maxTurns }),
+        ...(includePartialMessages && { includePartialMessages }),
+        abortController: this.activeController,
+        ...(Object.keys(mcpServers).length > 0 && { mcpServers }),
+        ...(allowedMcpTools.length > 0 && { allowedTools: allowedMcpTools })
+      };
+
+      // Create async iterable from single message if needed
+      let promptIterable: AsyncIterable<SDKUserMessage>;
+
+      if (isAsyncIterable<SDKUserMessage>(prompt)) {
+        promptIterable = prompt;
+      } else {
+        promptIterable = (async function* () {
+          yield prompt as SDKUserMessage;
+        })();
+      }
+
+      const queryInstance = query({
+        prompt: promptIterable,
+        options: sdkOptions,
+      });
+
+      this.activeQuery = queryInstance;
+
+      for await (const message of queryInstance) {
+        yield message;
+      }
+
+    } catch (error) {
+      handleStreamError(error);
+    } finally {
+      this.activeController = null;
+      this.activeQuery = null;
+    }
+  }
+
+  /**
+   * Cancel active query
+   */
+  async cancel(): Promise<void> {
+    if (this.activeQuery && typeof this.activeQuery.interrupt === 'function') {
+      try {
+        await this.activeQuery.interrupt();
+      } catch {
+        // Ignore interrupt errors
+      }
+    }
+
+    if (this.activeController) {
+      this.activeController.abort();
+      this.activeController = null;
+    }
+    this.activeQuery = null;
+  }
+
+  /**
+   * Interrupt the active query
+   */
+  async interrupt(): Promise<void> {
+    if (this.activeQuery && typeof this.activeQuery.interrupt === 'function') {
+      await this.activeQuery.interrupt();
+    }
+  }
+
+  /**
+   * Change permission mode for active query
+   */
+  async setPermissionMode(mode: PermissionMode): Promise<void> {
+    if (this.activeQuery && typeof this.activeQuery.setPermissionMode === 'function') {
+      await this.activeQuery.setPermissionMode(mode);
+    }
+  }
+}

package/backend/lib/engine/adapters/opencode/index.ts

@@ -0,0 +1,2 @@
+export { OpenCodeEngine } from './stream';
+export { disposeOpenCodeClient } from './server';