heyio 0.42.0 → 1.0.0

package/dist/notify.js

@@ -1,106 +1,24 @@
-import { config } from "./config.js";
-import { createFeedEntry } from "./store/feed.js";
-const HEARTBEAT_PATTERNS = [
-    /^no active tasks?\.?$/i,
-    /^nothing to report\.?$/i,
-    /^all clear\.?$/i,
-    /^no updates?\.?$/i,
-    /^no changes?\.?$/i,
-    /^idle\.?$/i,
-    /^heartbeat\.?$/i,
-    /^ok\.?$/i,
-];
-export function isMeaningfulOutput(text) {
-    const trimmed = (text ?? "").trim();
-    if (trimmed.length < 20)
-        return false;
-    const firstLine = trimmed.split("\n").map((l) => l.trim()).find((l) => l.length > 0) ?? "";
-    if (HEARTBEAT_PATTERNS.some((re) => re.test(firstLine)))
-        return false;
-    return true;
-}
-let telegramSender;
-let tuiSender;
-let sseBroadcaster;
-export function setTelegramSender(fn) {
-    telegramSender = fn;
-}
-export function setTuiSender(fn) {
-    tuiSender = fn;
-}
-export function setSseBroadcaster(fn) {
-    sseBroadcaster = fn;
-}
-export function _resetNotifySendersForTests() {
-    telegramSender = undefined;
-    tuiSender = undefined;
-    sseBroadcaster = undefined;
-}
-export async function notifyBackground(input) {
-    const dispatched = { telegram: false, tui: false, sse: false };
-    const text = (input.text ?? "").trim();
-    if (text.length === 0)
-        return { dispatched, skipped: "empty" };
-    const mode = config.backgroundNotifyMode ?? "meaningful";
-    if (mode === "off")
-        return { dispatched, skipped: "off" };
-    if (mode === "meaningful" && !isMeaningfulOutput(text)) {
-        return { dispatched, skipped: "not-meaningful" };
-    }
-    const { source, title } = input;
-    const sourceRefJson = JSON.stringify(stripType(source));
-    let row;
-    try {
-        row = createFeedEntry({
-            type: "notification",
-            title,
-            body: text,
-            source_type: source.type,
-            source_ref: sourceRefJson === "{}" ? null : sourceRefJson,
-        });
-    }
-    catch (err) {
-        console.error("[notify] failed to persist notification:", err);
-        return { dispatched };
-    }
-    if (sseBroadcaster) {
+import { loadConfig } from "./config.js";
+import { postFeedItem } from "./store/feed.js";
+export async function notify(title, content, source) {
+    const config = loadConfig();
+    // Always post to feed
+    postFeedItem(source, title, content);
+    // Notify via Telegram if enabled
+    if (config.backgroundNotifyTelegram && config.telegramEnabled) {
         try {
-            sseBroadcaster({
-                id: row.id,
-                source: { type: source.type, ...stripType(source) },
-                title,
-                text,
-                createdAt: row.created_at,
-            });
-            dispatched.sse = true;
+            const { getBot } = await import("./telegram/bot.js");
+            const bot = getBot();
+            if (bot && config.authorizedUserId) {
+                const msg = `📬 *${title}*\n\n${content.slice(0, 1000)}`;
+                await bot.api.sendMessage(config.authorizedUserId, msg, {
+                    parse_mode: "Markdown",
+                });
+            }
         }
-        catch (err) {
-            console.error("[notify] sse broadcast failed:", err);
+        catch {
+            // Telegram notification failed silently
         }
     }
-    if (tuiSender && (config.backgroundNotifyTui ?? true)) {
-        try {
-            tuiSender({ title, text });
-            dispatched.tui = true;
-        }
-        catch (err) {
-            console.error("[notify] tui send failed:", err);
-        }
-    }
-    if (telegramSender && (config.backgroundNotifyTelegram ?? true)) {
-        try {
-            await telegramSender({ title, text });
-            dispatched.telegram = true;
-        }
-        catch (err) {
-            console.error("[notify] telegram send failed:", err);
-        }
-    }
-    return { id: row.id, dispatched };
-}
-function stripType(s) {
-    const { type: _t, ...rest } = s;
-    void _t;
-    return rest;
 }
 //# sourceMappingURL=notify.js.map

package/dist/paths.js

@@ -1,25 +1,14 @@
-import { homedir } from "os";
-import { join, dirname } from "path";
-import { fileURLToPath } from "url";
-import { readFileSync } from "fs";
-export const IO_HOME = join(homedir(), ".io");
-export const CONFIG_PATH = join(IO_HOME, "config.json");
-export const DB_PATH = join(IO_HOME, "io.db");
-export const WIKI_DIR = join(IO_HOME, "wiki");
-export const SKILLS_DIR = join(IO_HOME, "skills");
-export const SESSIONS_DIR = join(IO_HOME, "sessions");
-export const LOGS_DIR = join(IO_HOME, "logs");
-function resolveVersion() {
-    const __dirname = dirname(fileURLToPath(import.meta.url));
-    for (const rel of ["..", join("..", "..")]) {
-        try {
-            const pkg = JSON.parse(readFileSync(join(__dirname, rel, "package.json"), "utf-8"));
-            if (pkg.version)
-                return pkg.version;
-        }
-        catch { /* try next */ }
-    }
-    return "0.0.0";
-}
-export const IO_VERSION = resolveVersion();
+import { homedir } from "node:os";
+import { join } from "node:path";
+const IO_HOME = join(homedir(), ".io");
+export const PATHS = {
+    home: IO_HOME,
+    config: join(IO_HOME, "config.json"),
+    db: join(IO_HOME, "io.db"),
+    wiki: join(IO_HOME, "wiki"),
+    wikiPages: join(IO_HOME, "wiki", "pages"),
+    skills: join(IO_HOME, "skills"),
+    mcpConfig: join(IO_HOME, "mcp.json"),
+    sessions: join(IO_HOME, "sessions"),
+};
 //# sourceMappingURL=paths.js.map

package/dist/setup.js

@@ -0,0 +1,35 @@
+import { createInterface } from "node:readline";
+import { loadConfig, saveConfig } from "./config.js";
+import { PATHS } from "./paths.js";
+import { mkdirSync, existsSync } from "node:fs";
+export async function runSetup() {
+    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    const ask = (q) => new Promise((resolve) => rl.question(q, resolve));
+    console.log("\n🤖 IO Setup\n");
+    if (!existsSync(PATHS.home))
+        mkdirSync(PATHS.home, { recursive: true });
+    const config = loadConfig();
+    // Supabase (required for API auth)
+    console.log("— Supabase Auth (required for web/API access) —");
+    const supabaseUrl = await ask(`Supabase URL [${config.supabaseUrl ?? ""}]: `);
+    const supabaseAnonKey = await ask(`Supabase Anon Key [${config.supabaseAnonKey ? "****" : ""}]: `);
+    const authorizedEmail = await ask(`Authorized Email [${config.authorizedEmail ?? ""}]: `);
+    // Telegram (optional)
+    console.log("\n— Telegram Bot (optional) —");
+    const telegramBotToken = await ask(`Bot Token [${config.telegramBotToken ? "****" : ""}]: `);
+    const authorizedUserId = await ask(`Your Telegram User ID [${config.authorizedUserId ?? ""}]: `);
+    const telegramEnabled = await ask(`Enable Telegram? (y/n) [${config.telegramEnabled ? "y" : "n"}]: `);
+    saveConfig({
+        supabaseUrl: supabaseUrl || config.supabaseUrl,
+        supabaseAnonKey: supabaseAnonKey || config.supabaseAnonKey,
+        authorizedEmail: authorizedEmail || config.authorizedEmail,
+        telegramBotToken: telegramBotToken || config.telegramBotToken,
+        authorizedUserId: authorizedUserId
+            ? parseInt(authorizedUserId, 10)
+            : config.authorizedUserId,
+        telegramEnabled: telegramEnabled === "y" ? true : telegramEnabled === "n" ? false : config.telegramEnabled,
+    });
+    console.log(`\n✅ Configuration saved to ${PATHS.config}\n`);
+    rl.close();
+}
+//# sourceMappingURL=setup.js.map

package/dist/store/db.js

@@ -1,318 +1,132 @@
 import Database from "better-sqlite3";
-import { mkdirSync } from "fs";
-import { dirname } from "path";
-import { DB_PATH, IO_HOME } from "../paths.js";
-let db = null;
-let insertCount = 0;
-let dbPathOverride = null;
-/**
- * Override the DB path for tests. Closes the existing connection (if any)
- * so the next getDb() call opens a fresh DB at the given path.
- * Never call this in production code.
- */
-export function setDbPathForTests(path) {
-    if (db) {
-        db.close();
-        db = null;
-    }
-    dbPathOverride = path;
-}
+import { existsSync, mkdirSync } from "node:fs";
+import { dirname } from "node:path";
+import { PATHS } from "../paths.js";
+let db;
 export function getDb() {
     if (db)
         return db;
-    const resolvedPath = dbPathOverride ?? DB_PATH;
-    const resolvedHome = dbPathOverride ? dirname(resolvedPath) : IO_HOME;
-    mkdirSync(resolvedHome, { recursive: true });
-    db = new Database(resolvedPath);
+    const dir = dirname(PATHS.db);
+    if (!existsSync(dir))
+        mkdirSync(dir, { recursive: true });
+    db = new Database(PATHS.db);
     db.pragma("journal_mode = WAL");
+    db.pragma("foreign_keys = ON");
+    runMigrations(db);
+    return db;
+}
+function runMigrations(db) {
     db.exec(`
-    CREATE TABLE IF NOT EXISTS io_state (
+    CREATE TABLE IF NOT EXISTS meta (
       key TEXT PRIMARY KEY,
       value TEXT NOT NULL
     );
+  `);
+    const version = getSchemaVersion(db);
+    if (version < 1) {
+        db.exec(`
+      CREATE TABLE IF NOT EXISTS squads (
+        id TEXT PRIMARY KEY,
+        name TEXT NOT NULL,
+        universe TEXT NOT NULL,
+        repo_url TEXT,
+        rules TEXT DEFAULT '',
+        created_at TEXT NOT NULL DEFAULT (datetime('now')),
+        updated_at TEXT NOT NULL DEFAULT (datetime('now'))
+      );
 
-    CREATE TABLE IF NOT EXISTS squads (
-      id INTEGER PRIMARY KEY AUTOINCREMENT,
-      slug TEXT UNIQUE NOT NULL,
-      name TEXT NOT NULL,
-      project_path TEXT NOT NULL,
-      copilot_session_id TEXT,
-      model TEXT,
-      status TEXT NOT NULL DEFAULT 'idle',
-      created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
-      updated_at DATETIME DEFAULT CURRENT_TIMESTAMP
-    );
+      CREATE TABLE IF NOT EXISTS agents (
+        id TEXT PRIMARY KEY,
+        squad_id TEXT NOT NULL REFERENCES squads(id) ON DELETE CASCADE,
+        character_name TEXT NOT NULL,
+        role_title TEXT NOT NULL,
+        persona TEXT DEFAULT '',
+        is_lead INTEGER NOT NULL DEFAULT 0,
+        is_qa INTEGER NOT NULL DEFAULT 0,
+        is_test INTEGER NOT NULL DEFAULT 0,
+        status TEXT NOT NULL DEFAULT 'idle',
+        created_at TEXT NOT NULL DEFAULT (datetime('now'))
+      );
 
-    CREATE TABLE IF NOT EXISTS squad_decisions (
-      id INTEGER PRIMARY KEY AUTOINCREMENT,
-      squad_slug TEXT NOT NULL,
-      decision TEXT NOT NULL,
-      context TEXT,
-      created_at DATETIME DEFAULT CURRENT_TIMESTAMP
-    );
+      CREATE TABLE IF NOT EXISTS tasks (
+        id TEXT PRIMARY KEY,
+        squad_id TEXT NOT NULL REFERENCES squads(id) ON DELETE CASCADE,
+        instance_id TEXT,
+        agent_id TEXT REFERENCES agents(id) ON DELETE SET NULL,
+        description TEXT NOT NULL,
+        status TEXT NOT NULL DEFAULT 'pending',
+        result TEXT,
+        created_at TEXT NOT NULL DEFAULT (datetime('now')),
+        updated_at TEXT NOT NULL DEFAULT (datetime('now'))
+      );
 
-    CREATE TABLE IF NOT EXISTS conversation_log (
-      id INTEGER PRIMARY KEY AUTOINCREMENT,
-      role TEXT NOT NULL CHECK(role IN ('user', 'assistant', 'system')),
-      content TEXT NOT NULL,
-      source TEXT NOT NULL DEFAULT 'unknown',
-      ts DATETIME DEFAULT CURRENT_TIMESTAMP
-    );
+      CREATE TABLE IF NOT EXISTS instances (
+        id TEXT PRIMARY KEY,
+        squad_id TEXT NOT NULL REFERENCES squads(id) ON DELETE CASCADE,
+        branch TEXT NOT NULL,
+        worktree_path TEXT NOT NULL,
+        status TEXT NOT NULL DEFAULT 'active',
+        last_activity TEXT NOT NULL DEFAULT (datetime('now')),
+        created_at TEXT NOT NULL DEFAULT (datetime('now'))
+      );
 
-    CREATE TABLE IF NOT EXISTS agent_tasks (
-      task_id TEXT PRIMARY KEY,
-      agent_slug TEXT NOT NULL,
-      description TEXT NOT NULL,
-      status TEXT NOT NULL DEFAULT 'running',
-      result TEXT,
-      origin_channel TEXT,
-      started_at DATETIME DEFAULT CURRENT_TIMESTAMP,
-      completed_at DATETIME
-    );
-  `);
-    // Migrations for existing databases
-    const migrations = [
-        `ALTER TABLE squads ADD COLUMN model TEXT`,
-        `ALTER TABLE squads ADD COLUMN universe TEXT`,
-        `CREATE TABLE IF NOT EXISTS squad_agents (
-      id INTEGER PRIMARY KEY AUTOINCREMENT,
-      squad_slug TEXT NOT NULL,
-      character_name TEXT NOT NULL,
-      role_title TEXT NOT NULL,
-      charter TEXT,
-      model_tier TEXT NOT NULL DEFAULT 'medium',
-      personality TEXT,
-      copilot_session_id TEXT,
-      status TEXT NOT NULL DEFAULT 'idle',
-      created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
-      UNIQUE(squad_slug, character_name)
-    )`,
-        `ALTER TABLE squad_agents ADD COLUMN is_lead INTEGER NOT NULL DEFAULT 0`,
-        `ALTER TABLE squad_agents ADD COLUMN is_qa INTEGER NOT NULL DEFAULT 0`,
-        `CREATE TABLE IF NOT EXISTS squad_task_reviews (
-      id INTEGER PRIMARY KEY AUTOINCREMENT,
-      task_id TEXT NOT NULL,
-      squad_slug TEXT NOT NULL,
-      reviewer_character TEXT NOT NULL,
-      approved INTEGER NOT NULL DEFAULT 0,
-      comments TEXT,
-      created_at DATETIME DEFAULT CURRENT_TIMESTAMP
-    )`,
-        `CREATE TABLE IF NOT EXISTS squad_schedules (
-      id INTEGER PRIMARY KEY AUTOINCREMENT,
-      squad_slug TEXT NOT NULL,
-      name TEXT NOT NULL,
-      cron_expr TEXT NOT NULL,
-      agenda TEXT NOT NULL,
-      notes TEXT,
-      enabled INTEGER NOT NULL DEFAULT 1,
-      last_run_at DATETIME,
-      next_run_at DATETIME,
-      created_at DATETIME DEFAULT CURRENT_TIMESTAMP
-    )`,
-        `CREATE INDEX IF NOT EXISTS idx_squad_schedules_due
-       ON squad_schedules (enabled, next_run_at)`,
-        `CREATE TABLE IF NOT EXISTS io_schedules (
-      id INTEGER PRIMARY KEY AUTOINCREMENT,
-      name TEXT NOT NULL,
-      cron_expr TEXT NOT NULL,
-      prompt TEXT NOT NULL,
-      notes TEXT,
-      enabled INTEGER NOT NULL DEFAULT 1,
-      last_run_at DATETIME,
-      next_run_at DATETIME,
-      created_at DATETIME DEFAULT CURRENT_TIMESTAMP
-    )`,
-        `CREATE INDEX IF NOT EXISTS idx_io_schedules_due
-       ON io_schedules (enabled, next_run_at)`,
-        `CREATE VIEW IF NOT EXISTS agent_stats AS
-SELECT agent_slug,
-       COUNT(*)        AS task_count,
-       MAX(started_at) AS last_delegated_at
-FROM agent_tasks
-GROUP BY agent_slug`,
-        `CREATE TABLE IF NOT EXISTS background_notifications (
-      id INTEGER PRIMARY KEY AUTOINCREMENT,
-      source_type TEXT NOT NULL,
-      source_ref TEXT,
-      title TEXT NOT NULL,
-      text TEXT NOT NULL,
-      created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
-      read_at DATETIME
-    )`,
-        `CREATE INDEX IF NOT EXISTS idx_bg_notifications_unread ON background_notifications(read_at, created_at)`,
-        `CREATE TABLE IF NOT EXISTS schedule_runs (
-      id INTEGER PRIMARY KEY AUTOINCREMENT,
-      schedule_type TEXT NOT NULL,
-      schedule_id INTEGER NOT NULL,
-      schedule_name TEXT NOT NULL,
-      squad_slug TEXT,
-      status TEXT NOT NULL DEFAULT 'running',
-      error_text TEXT,
-      notification_id INTEGER,
-      started_at DATETIME DEFAULT CURRENT_TIMESTAMP,
-      completed_at DATETIME
-    )`,
-        `CREATE INDEX IF NOT EXISTS idx_schedule_runs_lookup ON schedule_runs(schedule_type, schedule_id, started_at)`,
-        `CREATE TABLE IF NOT EXISTS inbox_entries (
-      id INTEGER PRIMARY KEY AUTOINCREMENT,
-      title TEXT NOT NULL,
-      body TEXT NOT NULL,
-      created_at TEXT NOT NULL DEFAULT (datetime('now'))
-    )`,
-        `CREATE TABLE IF NOT EXISTS unified_feed (
-      id INTEGER PRIMARY KEY AUTOINCREMENT,
-      type TEXT NOT NULL CHECK(type IN ('inbox', 'notification')),
-      title TEXT NOT NULL,
-      body TEXT NOT NULL,
-      source_type TEXT,
-      source_ref TEXT,
-      created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
-      read_at DATETIME
-    )`,
-        `CREATE INDEX IF NOT EXISTS idx_unified_feed_type ON unified_feed(type, created_at)`,
-        `CREATE INDEX IF NOT EXISTS idx_unified_feed_unread ON unified_feed(read_at, created_at)`,
-        `ALTER TABLE squads ADD COLUMN color TEXT`,
-        `CREATE TABLE IF NOT EXISTS squad_instances (
-      id TEXT PRIMARY KEY,
-      master_squad_slug TEXT NOT NULL,
-      issue_ref TEXT,
-      worktree_path TEXT NOT NULL,
-      branch_name TEXT NOT NULL,
-      status TEXT NOT NULL DEFAULT 'pending',
-      context_snapshot TEXT,
-      created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
-      completed_at DATETIME
-    )`,
-        `CREATE TABLE IF NOT EXISTS instance_decisions (
-      id INTEGER PRIMARY KEY AUTOINCREMENT,
-      instance_id TEXT NOT NULL,
-      decision TEXT NOT NULL,
-      context TEXT,
-      merged_to_master INTEGER DEFAULT 0,
-      created_at DATETIME DEFAULT CURRENT_TIMESTAMP
-    )`,
-        `ALTER TABLE agent_tasks ADD COLUMN instance_id TEXT`,
-        `CREATE INDEX IF NOT EXISTS idx_instance_decisions_instance ON instance_decisions(instance_id, merged_to_master)`,
-        `ALTER TABLE unified_feed RENAME TO unified_feed_old`,
-        `CREATE TABLE unified_feed (
-  id INTEGER PRIMARY KEY AUTOINCREMENT,
-  type TEXT NOT NULL CHECK(type IN ('inbox', 'notification')),
-  title TEXT NOT NULL,
-  body TEXT NOT NULL,
-  source_type TEXT,
-  source_ref TEXT,
-  squad_slug TEXT,
-  instance_id TEXT,
-  task_id TEXT,
-  created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
-  read_at DATETIME
-)`,
-        `INSERT INTO unified_feed (id, type, title, body, source_type, source_ref, created_at, read_at)
-  SELECT id, CASE WHEN type='deliverable' THEN 'inbox' ELSE type END, title, body, source_type, source_ref, created_at, read_at
-  FROM unified_feed_old`,
-        `DROP TABLE unified_feed_old`,
-        `CREATE INDEX IF NOT EXISTS idx_unified_feed_type ON unified_feed(type, created_at)`,
-        `CREATE INDEX IF NOT EXISTS idx_unified_feed_unread ON unified_feed(read_at, created_at)`,
-        `ALTER TABLE squads ADD COLUMN color TEXT`,
-    ];
-    for (const migration of migrations) {
-        try {
-            db.exec(migration);
-        }
-        catch {
-            // Already applied — ignore
-        }
-    }
-    // One-time data migration: copy inbox_entries + background_notifications → unified_feed
-    try {
-        const migrated = db.prepare("SELECT value FROM io_state WHERE key = 'unified_feed_migrated'").get();
-        if (!migrated) {
-            db.exec(`
-        INSERT OR IGNORE INTO unified_feed (type, title, body, source_type, source_ref, created_at, read_at)
-        SELECT 'deliverable', title, body, NULL, NULL, created_at, NULL
-        FROM inbox_entries
-      `);
-            db.exec(`
-        INSERT OR IGNORE INTO unified_feed (type, title, body, source_type, source_ref, created_at, read_at)
-        SELECT 'notification', title, text, source_type, source_ref, created_at, read_at
-        FROM background_notifications
-      `);
-            db.prepare("INSERT OR REPLACE INTO io_state (key, value) VALUES ('unified_feed_migrated', '1')").run();
-        }
-    }
-    catch {
-        // Migration failed (e.g. old tables don't exist yet on a fresh install) — safe to ignore
-    }
-    // One-time migration: assign colors to existing squads that have none
-    try {
-        const colorMigrated = db.prepare("SELECT value FROM io_state WHERE key = 'squad_colors_migrated'").get();
-        if (!colorMigrated) {
-            const palette = [
-                "#ff6b35", "#ffd000", "#5fff87", "#c4a7ff", "#00d9ff",
-                "#ff9800", "#9c27b0", "#2196f3", "#e91e63", "#00bcd4",
-                "#8bc34a", "#ff5722",
-            ];
-            const uncolored = db.prepare("SELECT slug FROM squads WHERE color IS NULL ORDER BY id ASC").all();
-            const usedColors = new Set(db.prepare("SELECT color FROM squads WHERE color IS NOT NULL").all().map(r => r.color));
-            const update = db.prepare("UPDATE squads SET color = ? WHERE slug = ?");
-            let idx = 0;
-            for (const { slug } of uncolored) {
-                const available = palette.filter(c => !usedColors.has(c));
-                const color = available.length > 0 ? available[0] : palette[idx % palette.length];
-                update.run(color, slug);
-                usedColors.add(color);
-                idx++;
-            }
-            db.prepare("INSERT OR REPLACE INTO io_state (key, value) VALUES ('squad_colors_migrated', '1')").run();
-        }
-    }
-    catch {
-        // Safe to ignore on fresh install
+      CREATE TABLE IF NOT EXISTS feed_items (
+        id TEXT PRIMARY KEY,
+        source TEXT NOT NULL,
+        title TEXT NOT NULL,
+        content TEXT NOT NULL DEFAULT '',
+        read INTEGER NOT NULL DEFAULT 0,
+        created_at TEXT NOT NULL DEFAULT (datetime('now'))
+      );
+
+      CREATE TABLE IF NOT EXISTS schedules (
+        id TEXT PRIMARY KEY,
+        type TEXT NOT NULL CHECK(type IN ('squad', 'io')),
+        squad_id TEXT REFERENCES squads(id) ON DELETE CASCADE,
+        cron TEXT NOT NULL,
+        agenda TEXT NOT NULL DEFAULT '',
+        prompt TEXT NOT NULL DEFAULT '',
+        enabled INTEGER NOT NULL DEFAULT 1,
+        last_run TEXT,
+        created_at TEXT NOT NULL DEFAULT (datetime('now'))
+      );
+
+      CREATE TABLE IF NOT EXISTS session_state (
+        key TEXT PRIMARY KEY,
+        value TEXT NOT NULL
+      );
+
+      CREATE TABLE IF NOT EXISTS mcp_servers (
+        id TEXT PRIMARY KEY,
+        name TEXT NOT NULL,
+        type TEXT NOT NULL CHECK(type IN ('stdio', 'http')),
+        config TEXT NOT NULL DEFAULT '{}',
+        enabled INTEGER NOT NULL DEFAULT 1,
+        created_at TEXT NOT NULL DEFAULT (datetime('now'))
+      );
+
+      CREATE TABLE IF NOT EXISTS mcp_tools (
+        id TEXT PRIMARY KEY,
+        server_id TEXT NOT NULL REFERENCES mcp_servers(id) ON DELETE CASCADE,
+        name TEXT NOT NULL,
+        description TEXT DEFAULT '',
+        enabled INTEGER NOT NULL DEFAULT 1
+      );
+    `);
+        setSchemaVersion(db, 1);
     }
-    return db;
+}
+function getSchemaVersion(db) {
+    const row = db.prepare("SELECT value FROM meta WHERE key = 'schema_version'").get();
+    return row ? parseInt(row.value, 10) : 0;
+}
+function setSchemaVersion(db, version) {
+    db.prepare("INSERT OR REPLACE INTO meta (key, value) VALUES ('schema_version', ?)").run(String(version));
 }
 export function closeDb() {
     if (db) {
         db.close();
-        db = null;
+        db = undefined;
     }
 }
-export function getState(key) {
-    const row = getDb()
-        .prepare("SELECT value FROM io_state WHERE key = ?")
-        .get(key);
-    return row?.value;
-}
-export function setState(key, value) {
-    getDb()
-        .prepare("INSERT INTO io_state (key, value) VALUES (?, ?) ON CONFLICT(key) DO UPDATE SET value = excluded.value")
-        .run(key, value);
-}
-export function deleteState(key) {
-    getDb().prepare("DELETE FROM io_state WHERE key = ?").run(key);
-}
-export function logConversation(role, content, source) {
-    const database = getDb();
-    database
-        .prepare("INSERT INTO conversation_log (role, content, source) VALUES (?, ?, ?)")
-        .run(role, content, source);
-    insertCount++;
-    if (insertCount % 50 === 0) {
-        database
-            .prepare("DELETE FROM conversation_log WHERE id NOT IN (SELECT id FROM conversation_log ORDER BY id DESC LIMIT 1000)")
-            .run();
-    }
-}
-export function getRecentConversation(limit = 50) {
-    const rows = getDb()
-        .prepare("SELECT role, content, source, ts FROM conversation_log ORDER BY id DESC LIMIT ?")
-        .all(limit);
-    return rows.reverse().map((row) => ({
-        ...row,
-        content: row.content.length > 1500
-            ? row.content.slice(0, 1500) + "…"
-            : row.content,
-    }));
-}
 //# sourceMappingURL=db.js.map