@johpaz/hive 1.1.0

package/packages/core/src/storage/sqlite.ts

@@ -0,0 +1,387 @@
+import { Database } from "bun:sqlite";
+import { logger } from "../utils/logger.ts";
+import * as path from "node:path";
+import { existsSync, mkdirSync } from "node:fs";
+import { getHiveDir } from "../config/loader.ts";
+import { SCHEMA, PROJECTS_SCHEMA, CONTEXT_ENGINE_SCHEMA } from "./schema.ts";
+
+function getDbPath(): string {
+    return path.join(getHiveDir(), "data", "hive.db");
+}
+
+export function getDbPathLazy(): string {
+    return getDbPath();
+}
+
+let _db: Database | null = null;
+
+export interface ChatMessageRow {
+    id: string;
+    session_id: string;
+    thread_id: string;
+    role: string;
+    content: string;
+    created_at: string;
+}
+
+export interface NoteRow {
+    id: string;
+    title: string;
+    content: string;
+    createdAt: string;
+    updatedAt: string;
+}
+
+export function getDb(): Database {
+    if (!_db) throw new Error("DB no inicializada. Llama initializeDatabase() primero.");
+    return _db;
+}
+
+
+export function initializeDatabase(): Database {
+    const hiveDir = getHiveDir();
+    const dir = path.join(hiveDir, "data");
+    if (!existsSync(dir)) {
+        mkdirSync(dir, { recursive: true });
+    }
+
+    const dbPath = getDbPath();
+    const dbFileExists = existsSync(dbPath);
+
+    _db = new Database(dbPath, { create: true });
+
+    // Use type assertion to avoid deprecated signature with bindings
+    (_db as any).exec(SCHEMA);
+    (_db as any).exec(PROJECTS_SCHEMA);
+    (_db as any).exec(CONTEXT_ENGINE_SCHEMA);
+
+    ensureSchemaSync();
+
+    return _db;
+}
+
+function ensureColumnExists(tableName: string, columnName: string, columnDefinition: string): void {
+    if (!_db) return;
+    try {
+        const info = _db.query(`PRAGMA table_info(${tableName})`).all() as any[];
+        const exists = info.some((col: any) => col.name === columnName);
+
+        if (!exists) {
+            logger.info(`🛠️  Añadiendo columna faltante '${columnName}' a la tabla '${tableName}'`);
+            _db.exec(`ALTER TABLE ${tableName} ADD COLUMN ${columnName} ${columnDefinition}`);
+        }
+    } catch (err) {
+        logger.warn(`⚠️  No se pudo verificar/añadir la columna '${columnName}' en '${tableName}':`, { error: (err as Error).message });
+    }
+}
+
+function ensureSchemaSync(): void {
+    if (!_db) return;
+
+    // Sync mcp_servers
+    ensureColumnExists("mcp_servers", "tools_count", "INTEGER DEFAULT 0");
+    ensureColumnExists("mcp_servers", "status", "TEXT NOT NULL DEFAULT 'disconnected'");
+    ensureColumnExists("mcp_servers", "env_encrypted", "TEXT");
+    ensureColumnExists("mcp_servers", "env_iv", "TEXT");
+    ensureColumnExists("mcp_servers", "headers_encrypted", "TEXT");
+    ensureColumnExists("mcp_servers", "headers_iv", "TEXT");
+
+    // Sync providers
+    ensureColumnExists("providers", "api_key_encrypted", "TEXT");
+    ensureColumnExists("providers", "api_key_iv", "TEXT");
+    ensureColumnExists("providers", "headers_encrypted", "TEXT");
+    ensureColumnExists("providers", "headers_iv", "TEXT");
+    ensureColumnExists("providers", "num_ctx", "INTEGER");
+    ensureColumnExists("providers", "num_gpu", "INTEGER DEFAULT -1");
+
+    // Sync agents (new Context Engine columns — safe no-ops if already present)
+    ensureColumnExists("agents", "headers_encrypted", "TEXT");
+    ensureColumnExists("agents", "headers_iv", "TEXT");
+    ensureColumnExists("agents", "system_prompt", "TEXT");
+    ensureColumnExists("agents", "role", "TEXT NOT NULL DEFAULT 'coordinator'");
+    ensureColumnExists("agents", "tools_json", "TEXT");
+    ensureColumnExists("agents", "skills_json", "TEXT");
+    ensureColumnExists("agents", "parent_id", "TEXT");
+    ensureColumnExists("agents", "max_iterations", "INTEGER NOT NULL DEFAULT 10");
+    ensureColumnExists("agents", "updated_at", "INTEGER NOT NULL DEFAULT (unixepoch())");
+
+    // Sync tasks (new Context Engine columns)
+    ensureColumnExists("tasks", "priority", "INTEGER NOT NULL DEFAULT 0");
+    ensureColumnExists("tasks", "depends_on", "TEXT");
+    ensureColumnExists("tasks", "error", "TEXT");
+    ensureColumnExists("tasks", "completed_at", "INTEGER");
+
+    // Sync cron_jobs
+    ensureColumnExists("cron_jobs", "max_runs", "INTEGER");
+    ensureColumnExists("cron_jobs", "run_count", "INTEGER NOT NULL DEFAULT 0");
+    ensureColumnExists("cron_jobs", "expires_at", "INTEGER");
+
+    // hive_capabilities: create if not exists (applied via CONTEXT_ENGINE_SCHEMA IF NOT EXISTS)
+    // No column migrations needed — table is seeded fresh each startup via INSERT OR REPLACE
+}
+
+
+export class DatabaseService {
+    private log = logger.child("sqlite");
+
+    private get db(): Database {
+        if (!_db) {
+            initializeDatabase();
+        }
+        return _db!;
+    }
+
+    public addMessage(sessionId: string, role: string, content: string, metadata?: Record<string, unknown>): void {
+        const stmt = this.db.query(`
+      INSERT INTO messages (id, session_id, thread_id, role, content, metadata) 
+      VALUES ($id, $sessionId, $threadId, $role, $content, $metadata)
+    `);
+
+        try {
+            const id = crypto.randomUUID();
+            stmt.run({
+                $id: id,
+                $sessionId: sessionId,
+                $threadId: sessionId,
+                $role: role,
+                $content: content,
+                $metadata: metadata ? JSON.stringify(metadata) : null
+            });
+            this.log.debug(`Message added for session ${sessionId}`);
+        } catch (error: any) {
+            this.log.error(`Failed to add message: ${error.message}`);
+        }
+    }
+
+    public getMessages(sessionId: string, limit: number = 100): ChatMessageRow[] {
+        const stmt = this.db.query(`
+      SELECT * FROM messages 
+      WHERE session_id = $sessionId 
+      ORDER BY created_at DESC 
+      LIMIT $limit
+    `);
+
+        try {
+            const rows = stmt.all({
+                $sessionId: sessionId,
+                $limit: limit
+            }) as ChatMessageRow[];
+
+            return rows.reverse();
+        } catch (error: any) {
+            this.log.error(`Failed to get messages: ${error.message}`);
+            return [];
+        }
+    }
+
+    public close(): void {
+        if (_db) {
+            _db.close();
+            _db = null;
+        }
+    }
+
+    public writeNote(title: string, content: string): NoteRow {
+        const stmt = this.db.query(`
+            INSERT INTO notes (id, title, content) 
+            VALUES ($id, $title, $content)
+            ON CONFLICT(title) DO UPDATE SET 
+                content = excluded.content,
+                updatedAt = CURRENT_TIMESTAMP
+            RETURNING *
+        `);
+        return stmt.get({
+            $id: crypto.randomUUID(),
+            $title: title,
+            $content: content
+        }) as NoteRow;
+    }
+
+    public readNote(title: string): NoteRow | null {
+        const stmt = this.db.query(`SELECT * FROM notes WHERE title = $title`);
+        return stmt.get({ $title: title }) as NoteRow | null;
+    }
+
+    public listNotes(): NoteRow[] {
+        const stmt = this.db.query(`SELECT * FROM notes ORDER BY updatedAt DESC`);
+        return stmt.all() as NoteRow[];
+    }
+
+    public searchNotes(queryText: string): NoteRow[] {
+        const stmt = this.db.query(`
+            SELECT * FROM notes 
+            WHERE title LIKE $query OR content LIKE $query
+            ORDER BY updatedAt DESC
+        `);
+        return stmt.all({ $query: `%${queryText}%` }) as NoteRow[];
+    }
+
+    public deleteNote(title: string): boolean {
+        const stmt = this.db.query(`DELETE FROM notes WHERE title = $title`);
+        const result = stmt.run({ $title: title });
+        return result.changes > 0;
+    }
+
+    public updateMCPServer(id: string, updates: any): void {
+        const fields = [];
+        const values: any = { $id: id };
+
+        if (updates.enabled !== undefined) {
+            fields.push("enabled = $enabled");
+            values.$enabled = updates.enabled ? 1 : 0;
+        }
+        if (updates.active !== undefined) {
+            fields.push("active = $active");
+            values.$active = updates.active ? 1 : 0;
+        }
+        if (updates.status !== undefined) {
+            fields.push("status = $status");
+            values.$status = updates.status;
+        }
+        if (updates.tools_count !== undefined) {
+            fields.push("tools_count = $tools_count");
+            values.$tools_count = updates.tools_count;
+        }
+        if (updates.transport !== undefined) {
+            fields.push("transport = $transport");
+            values.$transport = updates.transport;
+        }
+        if (updates.command !== undefined) {
+            fields.push("command = $command");
+            values.$command = updates.command;
+        }
+        if (updates.args !== undefined) {
+            fields.push("args = $args");
+            values.$args = JSON.stringify(updates.args);
+        }
+        if (updates.url !== undefined) {
+            fields.push("url = $url");
+            values.$url = updates.url;
+        }
+        if (updates.env_encrypted !== undefined) {
+            fields.push("env_encrypted = $env_encrypted");
+            values.$env_encrypted = updates.env_encrypted;
+        }
+        if (updates.env_iv !== undefined) {
+            fields.push("env_iv = $env_iv");
+            values.$env_iv = updates.env_iv;
+        }
+        if (updates.headers_encrypted !== undefined) {
+            fields.push("headers_encrypted = $headers_encrypted");
+            values.$headers_encrypted = updates.headers_encrypted;
+        }
+        if (updates.headers_iv !== undefined) {
+            fields.push("headers_iv = $headers_iv");
+            values.$headers_iv = updates.headers_iv;
+        }
+
+        if (fields.length === 0) return;
+
+        const query = `UPDATE mcp_servers SET ${fields.join(", ")} WHERE id = $id`;
+        try {
+            this.db.query(query).run(values);
+            this.log.debug(`MCP server ${id} updated in DB`);
+        } catch (error: any) {
+            this.log.error(`Failed to update MCP server ${id}: ${error.message}`);
+        }
+    }
+
+    public listMCPServers(): any[] {
+        try {
+            return this.db.query("SELECT * FROM mcp_servers").all();
+        } catch (error: any) {
+            this.log.error(`Failed to list MCP servers: ${error.message}`);
+            return [];
+        }
+    }
+
+    public createTask(task: {
+        project_id: string;
+        agent_id?: string | null;
+        parent_task_id?: number | null;
+        name: string;
+        description?: string | null;
+    }): number {
+        const result = this.db.query(`
+            INSERT INTO tasks (project_id, agent_id, parent_task_id, name, description)
+            VALUES (?, ?, ?, ?, ?)
+        `).run(
+            task.project_id,
+            task.agent_id ?? null,
+            task.parent_task_id ?? null,
+            task.name,
+            task.description ?? null
+        );
+        return Number(result.lastInsertRowid);
+    }
+
+    public updateTask(taskId: number, updates: {
+        status?: string;
+        progress?: number;
+        result?: string;
+        agent_id?: string | null;
+    }): boolean {
+        const fields: string[] = ["updated_at = unixepoch()"];
+        const values: any[] = [];
+
+        if (updates.status !== undefined) { fields.push("status = ?"); values.push(updates.status); }
+        if (updates.progress !== undefined) { fields.push("progress = ?"); values.push(updates.progress); }
+        if (updates.result !== undefined) { fields.push("result = ?"); values.push(updates.result); }
+        if (updates.agent_id !== undefined) { fields.push("agent_id = ?"); values.push(updates.agent_id); }
+
+        values.push(taskId);
+        const res = this.db.query(`UPDATE tasks SET ${fields.join(", ")} WHERE id = ?`).run(...values);
+        return res.changes > 0;
+    }
+
+    public getTasksByProject(projectId: string): any[] {
+        return this.db.query(
+            "SELECT * FROM tasks WHERE project_id = ? ORDER BY id ASC"
+        ).all(projectId) as any[];
+    }
+
+    public getProjectWithTasks(projectId: string): any | null {
+        const project = this.db.query("SELECT * FROM projects WHERE id = ?").get(projectId) as any;
+        if (!project) return null;
+        project.tasks = this.getTasksByProject(projectId);
+        return project;
+    }
+
+    public recalcProjectProgress(projectId: string): number {
+        const row = this.db.query(
+            "SELECT AVG(progress) as avg_progress FROM tasks WHERE project_id = ?"
+        ).get(projectId) as any;
+        const avg = Math.round(row?.avg_progress ?? 0);
+        this.db.query("UPDATE projects SET progress = ?, updated_at = unixepoch() WHERE id = ?").run(avg, projectId);
+        return avg;
+    }
+
+    public saveMCPServer(server: any): void {
+        try {
+            this.db.query(`
+                INSERT OR REPLACE INTO mcp_servers (id, name, transport, command, args, url, env_encrypted, env_iv, headers_encrypted, headers_iv, enabled, active, builtin, tools_count, status)
+                VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+            `).run(
+                server.id || server.name,
+                server.name,
+                server.transport,
+                server.command || null,
+                JSON.stringify(server.args || []),
+                server.url || null,
+                server.env_encrypted || null,
+                server.env_iv || null,
+                server.headers_encrypted || null,
+                server.headers_iv || null,
+                server.enabled ? 1 : 0,
+                server.active ? 1 : 0,
+                server.builtin ? 1 : 0,
+                server.tools_count || 0,
+                server.status || "disconnected"
+            );
+        } catch (error: any) {
+            this.log.error(`Failed to save MCP server ${server.name}: ${error.message}`);
+        }
+    }
+}
+
+export const dbService = new DatabaseService();

package/packages/core/src/storage/usage.ts

@@ -0,0 +1,212 @@
+import { getDb } from "./sqlite";
+import { randomUUID } from "crypto";
+import { logger } from "../utils/logger";
+
+const log = logger.child("usage");
+
+const MODEL_PRICING: Record<string, { inputPer1M: number; outputPer1M: number }> = {
+  "claude-sonnet-4-6": { inputPer1M: 3, outputPer1M: 15 },
+  "claude-opus-4-6": { inputPer1M: 15, outputPer1M: 75 },
+  "claude-haiku-4-6": { inputPer1M: 0.8, outputPer1M: 4 },
+  "gpt-5.2": { inputPer1M: 2.5, outputPer1M: 10 },
+  "gpt-5.1": { inputPer1M: 5, outputPer1M: 15 },
+  "gpt-5.2-codex": { inputPer1M: 3, outputPer1M: 15 },
+  "o4-mini": { inputPer1M: 1.1, outputPer1M: 4.4 },
+  "gemini-3-flash-preview": { inputPer1M: 0.075, outputPer1M: 0.3 },
+  "gemini-2.5-flash": { inputPer1M: 0.1, outputPer1M: 0.4 },
+  "gemini-2.5-pro": { inputPer1M: 1.25, outputPer1M: 5 },
+  "gemini-3.1-pro-preview": { inputPer1M: 1.25, outputPer1M: 5 },
+  "deepseek-chat": { inputPer1M: 0.14, outputPer1M: 0.28 },
+  "deepseek-reasoner": { inputPer1M: 0.14, outputPer1M: 0.28 },
+  "deepseek-coder": { inputPer1M: 0.14, outputPer1M: 0.28 },
+  "kimi-k2.5": { inputPer1M: 0.5, outputPer1M: 2 },
+  "kimi-k2-thinking": { inputPer1M: 0.5, outputPer1M: 2 },
+  "kimi-k2-turbo-preview": { inputPer1M: 0.3, outputPer1M: 1.5 },
+  "meta-llama/llama-3.3-70b-instruct": { inputPer1M: 0.88, outputPer1M: 0.88 },
+  "google/gemini-2.0-flash-exp:free": { inputPer1M: 0, outputPer1M: 0 },
+  "deepseek/deepseek-r1:free": { inputPer1M: 0, outputPer1M: 0 },
+  "anthropic/claude-sonnet-4-6": { inputPer1M: 3, outputPer1M: 15 },
+  "llama3.3:8b": { inputPer1M: 0, outputPer1M: 0 },
+  "qwen2.5:7b": { inputPer1M: 0, outputPer1M: 0 },
+  "mistral:7b": { inputPer1M: 0, outputPer1M: 0 },
+  "phi4:14b": { inputPer1M: 0, outputPer1M: 0 },
+};
+
+function calculateCost(model: string, inputTokens: number, outputTokens: number): number {
+  const pricing = MODEL_PRICING[model] || { inputPer1M: 0, outputPer1M: 0 };
+  const inputCost = (inputTokens / 1_000_000) * pricing.inputPer1M;
+  const outputCost = (outputTokens / 1_000_000) * pricing.outputPer1M;
+  return inputCost + outputCost;
+}
+
+export interface UsageRecord {
+  id: string;
+  provider: string;
+  model: string;
+  input_tokens: number;
+  output_tokens: number;
+  cost_usd: number;
+  latency_ms: number | null;
+  toon_saved_tokens: number;
+  toon_saved_cost: number;
+  created_at: number;
+}
+
+export interface UsageSummary {
+  totalTokens: number;
+  totalInputTokens: number;
+  totalOutputTokens: number;
+  totalCostUsd: number;
+  toonSavedTokens: number;
+  toonSavedCost: number;
+  toonSavingsPercent: number;
+  byProvider: Record<string, { tokens: number; costUsd: number; inputTokens: number; outputTokens: number }>;
+  byModel: Record<string, { tokens: number; costUsd: number; provider: string; inputTokens: number; outputTokens: number }>;
+  recentRecords: UsageRecord[];
+}
+
+export function recordUsage(options: {
+  provider: string;
+  model: string;
+  inputTokens: number;
+  outputTokens: number;
+  latencyMs?: number;
+  toonSavedTokens?: number;
+  toonSavedCost?: number;
+}): void {
+  try {
+    const db = getDb();
+    const costUsd = calculateCost(options.model, options.inputTokens, options.outputTokens);
+    
+    db.prepare(`
+      INSERT INTO usage_records (id, provider, model, input_tokens, output_tokens, cost_usd, latency_ms, toon_saved_tokens, toon_saved_cost, created_at)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `).run(
+      randomUUID(),
+      options.provider,
+      options.model,
+      options.inputTokens,
+      options.outputTokens,
+      costUsd,
+      options.latencyMs || null,
+      options.toonSavedTokens || 0,
+      options.toonSavedCost || 0,
+      Math.floor(Date.now() / 1000)
+    );
+    log.info(`[USAGE RECORDED] provider=${options.provider} model=${options.model} input=${options.inputTokens} output=${options.outputTokens} cost=$${costUsd.toFixed(4)} toonSaved=${options.toonSavedTokens || 0}`);
+  } catch (error) {
+    console.error("Failed to record usage:", error);
+  }
+}
+
+export function getUsageStats(hours: number = 24): UsageSummary {
+  log.info(`[USAGE STATS] Fetching stats for last ${hours} hours`);
+  const db = getDb();
+  const since = Math.floor(Date.now() / 1000) - (hours * 3600);
+
+  const totals = db.prepare(`
+    SELECT 
+      COALESCE(SUM(input_tokens), 0) as total_input,
+      COALESCE(SUM(output_tokens), 0) as total_output,
+      COALESCE(SUM(cost_usd), 0) as total_cost,
+      COALESCE(SUM(toon_saved_tokens), 0) as toon_saved_tokens,
+      COALESCE(SUM(toon_saved_cost), 0) as toon_saved_cost
+    FROM usage_records
+    WHERE created_at >= ?
+  `).get(since) as { total_input: number; total_output: number; total_cost: number; toon_saved_tokens: number; toon_saved_cost: number };
+
+  const byProvider = db.prepare(`
+    SELECT 
+      provider,
+      COALESCE(SUM(input_tokens), 0) as input_tokens,
+      COALESCE(SUM(output_tokens), 0) as output_tokens,
+      COALESCE(SUM(cost_usd), 0) as cost_usd
+    FROM usage_records
+    WHERE created_at >= ?
+    GROUP BY provider
+  `).all(since) as Array<{ provider: string; input_tokens: number; output_tokens: number; cost_usd: number }>;
+
+  const byModel = db.prepare(`
+    SELECT 
+      model,
+      provider,
+      COALESCE(SUM(input_tokens), 0) as input_tokens,
+      COALESCE(SUM(output_tokens), 0) as output_tokens,
+      COALESCE(SUM(cost_usd), 0) as cost_usd
+    FROM usage_records
+    WHERE created_at >= ?
+    GROUP BY model
+    ORDER BY cost_usd DESC
+  `).all(since) as Array<{ model: string; provider: string; input_tokens: number; output_tokens: number; cost_usd: number }>;
+
+  const recentRecords = db.prepare(`
+    SELECT * FROM usage_records
+    WHERE created_at >= ?
+    ORDER BY created_at DESC
+    LIMIT 20
+  `).all(since) as UsageRecord[];
+
+  const providerMap: UsageSummary["byProvider"] = {};
+  for (const p of byProvider) {
+    providerMap[p.provider] = {
+      inputTokens: p.input_tokens,
+      outputTokens: p.output_tokens,
+      tokens: p.input_tokens + p.output_tokens,
+      costUsd: p.cost_usd
+    };
+  }
+
+  const modelMap: UsageSummary["byModel"] = {};
+  for (const m of byModel) {
+    modelMap[m.model] = {
+      provider: m.provider,
+      inputTokens: m.input_tokens,
+      outputTokens: m.output_tokens,
+      tokens: m.input_tokens + m.output_tokens,
+      costUsd: m.cost_usd
+    };
+  }
+
+  const totalTokens = totals.total_input + totals.total_output;
+  const toonSavingsPercent = totalTokens > 0 
+    ? (totals.toon_saved_tokens / totalTokens) * 100 
+    : 0;
+
+  return {
+    totalTokens,
+    totalInputTokens: totals.total_input,
+    totalOutputTokens: totals.total_output,
+    totalCostUsd: totals.total_cost,
+    toonSavedTokens: totals.toon_saved_tokens,
+    toonSavedCost: totals.toon_saved_cost,
+    toonSavingsPercent,
+    byProvider: providerMap,
+    byModel: modelMap,
+    recentRecords
+  };
+}
+
+export function getProviderPricing(provider: string, model: string): { inputPer1M: number; outputPer1M: number } {
+  return MODEL_PRICING[model] || { inputPer1M: 0, outputPer1M: 0 };
+}
+
+export function estimateCostForTokens(model: string, tokens: number): number {
+  const pricing = MODEL_PRICING[model] || { inputPer1M: 0, outputPer1M: 0 };
+  return (tokens / 1_000_000) * pricing.inputPer1M;
+}
+
+// Pending TOON savings — set before LLM invoke, consumed in handleLLMEnd callback
+let pendingToonTokens = 0;
+let pendingToonCost = 0;
+
+export function setPendingToonSavings(tokens: number, cost: number): void {
+  pendingToonTokens = tokens;
+  pendingToonCost = cost;
+}
+
+export function consumePendingToonSavings(): { tokens: number; cost: number } {
+  const result = { tokens: pendingToonTokens, cost: pendingToonCost };
+  pendingToonTokens = 0;
+  pendingToonCost = 0;
+  return result;
+}

package/packages/core/src/tools/bridge-events.ts

@@ -0,0 +1,74 @@
+/**
+ * Bridge events pub/sub — allows tools (terminal, codebridge) to emit events
+ * that get forwarded to UI clients connected to /bridge-events WebSocket.
+ */
+
+export interface BridgeEvent {
+  type: BridgeEventType;
+  data: BridgeEventData;
+  timestamp: number;
+}
+
+export type BridgeEventType =
+  | "bridge:cmd_start"
+  | "bridge:cmd_output"
+  | "bridge:cmd_done"
+  | "bridge:cmd_error"
+  | "agent:started"
+  | "agent:output"
+  | "agent:finished"
+  | "agent:error"
+  | "agent:cancelled";
+
+export interface BridgeCmdStartData {
+  processId: string;
+  command: string;
+  cwd?: string;
+  name?: string;
+}
+
+export interface BridgeCmdOutputData {
+  processId: string;
+  chunk: string;
+  stream: "stdout" | "stderr";
+}
+
+export interface BridgeCmdDoneData {
+  processId: string;
+  exitCode: number;
+  success: boolean;
+}
+
+export interface BridgeCmdErrorData {
+  processId: string;
+  message: string;
+}
+
+export type BridgeEventData =
+  | BridgeCmdStartData
+  | BridgeCmdOutputData
+  | BridgeCmdDoneData
+  | BridgeCmdErrorData
+  | Record<string, unknown>;
+
+const subscribers = new Set<{ send: (data: string) => void }>();
+
+export function subscribeBridge(ws: { send: (data: string) => void }) {
+  subscribers.add(ws);
+}
+
+export function unsubscribeBridge(ws: { send: (data: string) => void }) {
+  subscribers.delete(ws);
+}
+
+export function emitBridge(type: BridgeEventType, data: BridgeEventData) {
+  const event: BridgeEvent = { type, data, timestamp: Date.now() };
+  const payload = JSON.stringify(event);
+  for (const ws of subscribers) {
+    try {
+      ws.send(payload);
+    } catch {
+      subscribers.delete(ws);
+    }
+  }
+}