agentgui 1.0.831 → 1.0.833

package/CHANGELOG.md

@@ -1,4 +1,13 @@
+## [Unreleased]
+
+### Refactor
+- Split database.js (651L) into database.js (81L) + database-schema.js (176L) + database-migrations.js (150L) + database-migrations-acp.js (134L); all files ≤200L; no circular imports; migration functions receive db as parameter
+- Split claude-runner.js (1267L) into claude-runner.js (56L, AgentRunner class+helpers), claude-runner-direct.js (117L, runDirect method), claude-runner-acp.js (156L, runACP+_runACPOnce methods), claude-runner-agents.js (105L, AgentRegistry+registrations using acp-protocol.js), claude-runner-run.js (50L, runClaudeWithStreaming export); server.js updated to import from claude-runner-run.js
+
 ## 2026-04-12
+- refactor: reduce speech-manager.js from 207L to 200L by removing excess blank lines
+- refactor: split ws-handlers-session.js (209L) into ws-handlers-session.js (94L) + ws-handlers-session2.js (106L); agent.auth/authstat/update handlers moved to session2; server.js imports and calls both
+- refactor: split ws-handlers-conv.js (283L) into ws-handlers-conv.js (139L, conv.ls/tags/new/get/upd/del/del.all/full/chunks/chunks.earlier/reorder) and ws-handlers-conv2.js (169L, conv.export/import/sync/search/prune/cancel/inject/steer); removed 2 comment lines; server.js imports and calls both
 - refactor: split client.js (3212L) into 22 files ≤200L each; all 122 methods preserved including 2 extracted helpers (_setupUIButtonEvents, _setupUIWindowEvents, _loadConvRender); index.html updated with correct load order
 - refactor: split streaming-renderer.js (2193L) into 15 files ≤200L each; all 75 prototype methods and 8 static methods preserved; index.html updated with correct load order
 

package/database-migrations-acp.js

@@ -0,0 +1,133 @@
+import fs from 'fs';
+
+export function migrateACPSchema(db) {
+  try {
+    console.log('[Migration] Running ACP schema migration...');
+    const convColsACP = db.prepare("PRAGMA table_info(conversations)").all().map(c => c.name);
+    if (!convColsACP.includes('metadata')) {
+      db.exec('ALTER TABLE conversations ADD COLUMN metadata TEXT DEFAULT "{}"');
+      console.log('[Migration] Added metadata column to conversations');
+    }
+    const sessColsACP = db.prepare("PRAGMA table_info(sessions)").all().map(c => c.name);
+    for (const [col] of [['run_id'],['input'],['config'],['interrupt'],['claudeSessionId']]) {
+      if (!sessColsACP.includes(col)) {
+        db.exec(`ALTER TABLE sessions ADD COLUMN ${col} TEXT`);
+        console.log(`[Migration] Added ${col} column to sessions`);
+      }
+    }
+    db.exec(`
+      CREATE TABLE IF NOT EXISTS thread_states (
+        id TEXT PRIMARY KEY, thread_id TEXT NOT NULL,
+        checkpoint_id TEXT NOT NULL, state_data TEXT NOT NULL, created_at INTEGER NOT NULL,
+        FOREIGN KEY (thread_id) REFERENCES conversations(id) ON DELETE CASCADE
+      );
+      CREATE INDEX IF NOT EXISTS idx_thread_states_thread ON thread_states(thread_id);
+      CREATE INDEX IF NOT EXISTS idx_thread_states_checkpoint ON thread_states(checkpoint_id);
+      CREATE INDEX IF NOT EXISTS idx_thread_states_created ON thread_states(created_at);
+      CREATE TABLE IF NOT EXISTS checkpoints (
+        id TEXT PRIMARY KEY, thread_id TEXT NOT NULL,
+        checkpoint_name TEXT, sequence INTEGER NOT NULL, created_at INTEGER NOT NULL,
+        FOREIGN KEY (thread_id) REFERENCES conversations(id) ON DELETE CASCADE
+      );
+      CREATE INDEX IF NOT EXISTS idx_checkpoints_thread ON checkpoints(thread_id);
+      CREATE INDEX IF NOT EXISTS idx_checkpoints_sequence ON checkpoints(thread_id, sequence);
+      CREATE UNIQUE INDEX IF NOT EXISTS idx_checkpoints_unique ON checkpoints(thread_id, sequence);
+      CREATE TABLE IF NOT EXISTS run_metadata (
+        run_id TEXT PRIMARY KEY, thread_id TEXT, agent_id TEXT NOT NULL,
+        status TEXT NOT NULL, input TEXT, config TEXT, webhook_url TEXT,
+        created_at INTEGER NOT NULL, updated_at INTEGER NOT NULL,
+        FOREIGN KEY (thread_id) REFERENCES conversations(id) ON DELETE CASCADE,
+        FOREIGN KEY (run_id) REFERENCES sessions(id) ON DELETE CASCADE
+      );
+      CREATE INDEX IF NOT EXISTS idx_run_metadata_thread ON run_metadata(thread_id);
+      CREATE INDEX IF NOT EXISTS idx_run_metadata_agent ON run_metadata(agent_id);
+      CREATE INDEX IF NOT EXISTS idx_run_metadata_status ON run_metadata(status);
+      CREATE INDEX IF NOT EXISTS idx_run_metadata_created ON run_metadata(created_at);
+    `);
+    console.log('[Migration] ACP schema migration complete');
+  } catch (err) {
+    console.error('[Migration] ACP schema migration error:', err.message);
+  }
+}
+
+export function migrateBackfillMessages(db) {
+  try {
+    const emptyImported = db.prepare(`
+      SELECT c.id, c.sourcePath FROM conversations c
+      LEFT JOIN messages m ON c.id = m.conversationId
+      WHERE c.sourcePath IS NOT NULL AND c.status != 'deleted'
+      GROUP BY c.id HAVING COUNT(m.id) = 0
+    `).all();
+    if (emptyImported.length === 0) return;
+    console.log(`[Migration] Backfilling messages for ${emptyImported.length} imported conversation(s)`);
+    const insertMsg = db.prepare(`INSERT OR IGNORE INTO messages (id, conversationId, role, content, created_at) VALUES (?, ?, ?, ?, ?)`);
+    const backfill = db.transaction(() => {
+      for (const conv of emptyImported) {
+        if (!fs.existsSync(conv.sourcePath)) continue;
+        try {
+          const lines = fs.readFileSync(conv.sourcePath, 'utf-8').split('\n');
+          let count = 0;
+          for (const line of lines) {
+            if (!line.trim()) continue;
+            try {
+              const obj = JSON.parse(line);
+              const msgId = obj.uuid || `msg-${Date.now()}-${Math.random().toString(36).substr(2,9)}`;
+              const ts = obj.timestamp ? new Date(obj.timestamp).getTime() : Date.now();
+              if (obj.type === 'user' && obj.message?.content) {
+                const raw = obj.message.content;
+                const text = typeof raw === 'string' ? raw
+                  : Array.isArray(raw) ? raw.filter(c => c.type === 'text').map(c => c.text).join('\n')
+                  : JSON.stringify(raw);
+                if (text && !text.startsWith('[{"tool_use_id"')) { insertMsg.run(msgId, conv.id, 'user', text, ts); count++; }
+              } else if (obj.type === 'assistant' && obj.message?.content) {
+                const raw = obj.message.content;
+                const text = Array.isArray(raw)
+                  ? raw.filter(c => c.type === 'text' && c.text).map(c => c.text).join('\n\n')
+                  : typeof raw === 'string' ? raw : '';
+                if (text) { insertMsg.run(msgId, conv.id, 'assistant', text, ts); count++; }
+              }
+            } catch (_) {}
+          }
+          if (count > 0) console.log(`[Migration] Backfilled ${count} messages for conversation ${conv.id}`);
+        } catch (e) {
+          console.error(`[Migration] Error backfilling ${conv.id}:`, e.message);
+        }
+      }
+    });
+    backfill();
+  } catch (err) {
+    console.error('[Migration] Backfill error:', err.message);
+  }
+}
+
+export function migrateFTS(db) {
+  try {
+    const hasFts = db.prepare("SELECT name FROM sqlite_master WHERE type='table' AND name='messages_fts'").get();
+    if (!hasFts) {
+      db.exec("CREATE VIRTUAL TABLE messages_fts USING fts5(content, conversationId UNINDEXED, role UNINDEXED, content_rowid='rowid')");
+      const msgs = db.prepare("SELECT rowid, content, conversationId, role FROM messages").all();
+      if (msgs.length > 0) {
+        const ins = db.prepare("INSERT INTO messages_fts(rowid, content, conversationId, role) VALUES (?, ?, ?, ?)");
+        const tx = db.transaction(() => { for (const m of msgs) ins.run(m.rowid, m.content, m.conversationId, m.role); });
+        tx();
+        console.log(`[Migration] FTS5 index created with ${msgs.length} messages`);
+      }
+    }
+  } catch (err) {
+    console.error('[Migration] FTS5 error:', err.message);
+  }
+}
+
+export function migrateAutoVacuum(db) {
+  try {
+    const autoVacuum = db.prepare('PRAGMA auto_vacuum').get();
+    const mode = autoVacuum?.auto_vacuum ?? autoVacuum;
+    if (mode !== 2) {
+      console.log('[Migration] Enabling incremental auto_vacuum (one-time VACUUM)...');
+      db.exec('PRAGMA auto_vacuum = INCREMENTAL');
+      console.log('[Migration] auto_vacuum = INCREMENTAL enabled (VACUUM skipped)');
+    }
+  } catch (err) {
+    console.error('[Migration] auto_vacuum setup error:', err.message);
+  }
+}

package/database-migrations.js

@@ -0,0 +1,149 @@
+import fs from 'fs';
+
+export function migrateFromJson(db, oldJsonPath) {
+  if (!fs.existsSync(oldJsonPath)) return;
+  try {
+    const content = fs.readFileSync(oldJsonPath, 'utf-8');
+    const data = JSON.parse(content);
+    const migrationStmt = db.transaction(() => {
+      if (data.conversations) {
+        for (const id in data.conversations) {
+          const conv = data.conversations[id];
+          db.prepare(
+            `INSERT OR REPLACE INTO conversations (id, agentId, title, created_at, updated_at, status) VALUES (?, ?, ?, ?, ?, ?)`
+          ).run(conv.id, conv.agentId, conv.title || null, conv.created_at, conv.updated_at, conv.status || 'active');
+        }
+      }
+      if (data.messages) {
+        for (const id in data.messages) {
+          const msg = data.messages[id];
+          const contentStr = typeof msg.content === 'string' ? msg.content : JSON.stringify(msg.content);
+          db.prepare(
+            `INSERT OR REPLACE INTO messages (id, conversationId, role, content, created_at) VALUES (?, ?, ?, ?, ?)`
+          ).run(msg.id, msg.conversationId, msg.role, contentStr, msg.created_at);
+        }
+      }
+      if (data.sessions) {
+        for (const id in data.sessions) {
+          const sess = data.sessions[id];
+          const responseStr = sess.response ? (typeof sess.response === 'string' ? sess.response : JSON.stringify(sess.response)) : null;
+          const errorStr = sess.error ? (typeof sess.error === 'string' ? sess.error : JSON.stringify(sess.error)) : null;
+          db.prepare(
+            `INSERT OR REPLACE INTO sessions (id, conversationId, status, started_at, completed_at, response, error) VALUES (?, ?, ?, ?, ?, ?, ?)`
+          ).run(sess.id, sess.conversationId, sess.status, sess.started_at, sess.completed_at || null, responseStr, errorStr);
+        }
+      }
+      if (data.events) {
+        for (const id in data.events) {
+          const evt = data.events[id];
+          const dataStr = typeof evt.data === 'string' ? evt.data : JSON.stringify(evt.data || {});
+          db.prepare(
+            `INSERT OR REPLACE INTO events (id, type, conversationId, sessionId, data, created_at) VALUES (?, ?, ?, ?, ?, ?)`
+          ).run(evt.id, evt.type, evt.conversationId || null, evt.sessionId || null, dataStr, evt.created_at);
+        }
+      }
+      if (data.idempotencyKeys) {
+        for (const key in data.idempotencyKeys) {
+          const entry = data.idempotencyKeys[key];
+          const valueStr = typeof entry.value === 'string' ? entry.value : JSON.stringify(entry.value || {});
+          const ttl = typeof entry.ttl === 'number' ? entry.ttl : (entry.ttl ? parseInt(entry.ttl) : 0);
+          db.prepare(
+            `INSERT OR REPLACE INTO idempotencyKeys (key, value, created_at, ttl) VALUES (?, ?, ?, ?)`
+          ).run(key, valueStr, entry.created_at, ttl);
+        }
+      }
+    });
+    migrationStmt();
+    fs.renameSync(oldJsonPath, `${oldJsonPath}.migrated`);
+    console.log('Migrated data from JSON to SQLite');
+  } catch (e) {
+    console.error('Error during migration:', e.message);
+  }
+}
+
+export function migrateToACP(db) {
+  try {
+    const migrate = db.transaction(() => {
+      db.exec(`
+        CREATE TABLE IF NOT EXISTS thread_states (
+          id TEXT PRIMARY KEY, thread_id TEXT NOT NULL, checkpoint_id TEXT,
+          state_data TEXT NOT NULL, created_at INTEGER NOT NULL,
+          FOREIGN KEY (thread_id) REFERENCES conversations(id) ON DELETE CASCADE,
+          FOREIGN KEY (checkpoint_id) REFERENCES checkpoints(id) ON DELETE SET NULL
+        )
+      `);
+      db.exec(`
+        CREATE TABLE IF NOT EXISTS checkpoints (
+          id TEXT PRIMARY KEY, thread_id TEXT NOT NULL, checkpoint_name TEXT NOT NULL,
+          sequence INTEGER NOT NULL, created_at INTEGER NOT NULL,
+          FOREIGN KEY (thread_id) REFERENCES conversations(id) ON DELETE CASCADE
+        )
+      `);
+      db.exec(`
+        CREATE TABLE IF NOT EXISTS run_metadata (
+          id TEXT PRIMARY KEY, run_id TEXT NOT NULL UNIQUE, thread_id TEXT,
+          agent_id TEXT NOT NULL, status TEXT NOT NULL DEFAULT 'pending',
+          input TEXT, config TEXT, webhook_url TEXT,
+          created_at INTEGER NOT NULL, updated_at INTEGER NOT NULL,
+          FOREIGN KEY (thread_id) REFERENCES conversations(id) ON DELETE CASCADE
+        )
+      `);
+      const convColNames = db.prepare("PRAGMA table_info(conversations)").all().map(c => c.name);
+      if (!convColNames.includes('metadata')) db.exec('ALTER TABLE conversations ADD COLUMN metadata TEXT');
+      const sessColNames = db.prepare("PRAGMA table_info(sessions)").all().map(c => c.name);
+      for (const [colName, colType] of Object.entries({ run_id: 'TEXT', input: 'TEXT', config: 'TEXT', interrupt: 'TEXT' })) {
+        if (!sessColNames.includes(colName)) db.exec(`ALTER TABLE sessions ADD COLUMN ${colName} ${colType}`);
+      }
+      db.exec(`
+        CREATE INDEX IF NOT EXISTS idx_thread_states_thread ON thread_states(thread_id);
+        CREATE INDEX IF NOT EXISTS idx_thread_states_checkpoint ON thread_states(checkpoint_id);
+        CREATE INDEX IF NOT EXISTS idx_thread_states_created ON thread_states(created_at);
+        CREATE INDEX IF NOT EXISTS idx_checkpoints_thread ON checkpoints(thread_id);
+        CREATE INDEX IF NOT EXISTS idx_checkpoints_sequence ON checkpoints(thread_id, sequence);
+        CREATE UNIQUE INDEX IF NOT EXISTS idx_checkpoints_unique_seq ON checkpoints(thread_id, sequence);
+        CREATE INDEX IF NOT EXISTS idx_run_metadata_run_id ON run_metadata(run_id);
+        CREATE INDEX IF NOT EXISTS idx_run_metadata_thread ON run_metadata(thread_id);
+        CREATE INDEX IF NOT EXISTS idx_run_metadata_status ON run_metadata(status);
+        CREATE INDEX IF NOT EXISTS idx_run_metadata_agent ON run_metadata(agent_id);
+        CREATE INDEX IF NOT EXISTS idx_run_metadata_created ON run_metadata(created_at);
+        CREATE INDEX IF NOT EXISTS idx_sessions_run_id ON sessions(run_id);
+      `);
+    });
+    migrate();
+  } catch (err) {
+    console.error('[Migration] ACP schema migration error:', err.message);
+  }
+}
+
+export function migrateConversationColumns(db) {
+  try {
+    const columnNames = db.prepare("PRAGMA table_info(conversations)").all().map(r => r.name);
+    const requiredColumns = {
+      agentType: 'TEXT', source: 'TEXT DEFAULT "gui"', externalId: 'TEXT',
+      firstPrompt: 'TEXT', messageCount: 'INTEGER DEFAULT 0', projectPath: 'TEXT',
+      gitBranch: 'TEXT', sourcePath: 'TEXT', lastSyncedAt: 'INTEGER',
+      workingDirectory: 'TEXT', claudeSessionId: 'TEXT', isStreaming: 'INTEGER DEFAULT 0',
+      model: 'TEXT', subAgent: 'TEXT', pinned: 'INTEGER DEFAULT 0',
+      tags: 'TEXT', sortOrder: 'INTEGER DEFAULT 0'
+    };
+    let addedColumns = false;
+    for (const [colName, colDef] of Object.entries(requiredColumns)) {
+      if (!columnNames.includes(colName)) {
+        db.exec(`ALTER TABLE conversations ADD COLUMN ${colName} ${colDef}`);
+        console.log(`[Migration] Added column ${colName} to conversations table`);
+        addedColumns = true;
+      }
+    }
+    if (addedColumns) {
+      try {
+        db.exec(`CREATE INDEX IF NOT EXISTS idx_conversations_external ON conversations(externalId)`);
+        db.exec(`CREATE INDEX IF NOT EXISTS idx_conversations_agent_type ON conversations(agentType)`);
+        db.exec(`CREATE INDEX IF NOT EXISTS idx_conversations_source ON conversations(source)`);
+      } catch (e) {
+        console.warn('[Migration] Index creation warning:', e.message);
+      }
+    }
+  } catch (err) {
+    console.error('[Migration] Error:', err.message);
+  }
+}

package/database-schema.js

@@ -0,0 +1,175 @@
+import fs from 'fs';
+
+export function initSchema(db) {
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS conversations (
+      id TEXT PRIMARY KEY,
+      agentId TEXT NOT NULL,
+      title TEXT,
+      created_at INTEGER NOT NULL,
+      updated_at INTEGER NOT NULL,
+      status TEXT DEFAULT 'active'
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_conversations_agent ON conversations(agentId);
+    CREATE INDEX IF NOT EXISTS idx_conversations_updated ON conversations(updated_at DESC);
+
+    CREATE TABLE IF NOT EXISTS messages (
+      id TEXT PRIMARY KEY,
+      conversationId TEXT NOT NULL,
+      role TEXT NOT NULL,
+      content TEXT NOT NULL,
+      created_at INTEGER NOT NULL,
+      FOREIGN KEY (conversationId) REFERENCES conversations(id)
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_messages_conversation ON messages(conversationId);
+
+    CREATE TABLE IF NOT EXISTS sessions (
+      id TEXT PRIMARY KEY,
+      conversationId TEXT NOT NULL,
+      status TEXT NOT NULL,
+      started_at INTEGER NOT NULL,
+      completed_at INTEGER,
+      response TEXT,
+      error TEXT,
+      FOREIGN KEY (conversationId) REFERENCES conversations(id)
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_sessions_conversation ON sessions(conversationId);
+    CREATE INDEX IF NOT EXISTS idx_sessions_status ON sessions(conversationId, status);
+
+    CREATE TABLE IF NOT EXISTS events (
+      id TEXT PRIMARY KEY,
+      type TEXT NOT NULL,
+      conversationId TEXT,
+      sessionId TEXT,
+      data TEXT NOT NULL,
+      created_at INTEGER NOT NULL,
+      FOREIGN KEY (conversationId) REFERENCES conversations(id),
+      FOREIGN KEY (sessionId) REFERENCES sessions(id)
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_events_conversation ON events(conversationId);
+
+    CREATE TABLE IF NOT EXISTS idempotencyKeys (
+      key TEXT PRIMARY KEY,
+      value TEXT NOT NULL,
+      created_at INTEGER NOT NULL,
+      ttl INTEGER NOT NULL
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_idempotency_created ON idempotencyKeys(created_at);
+
+    CREATE TABLE IF NOT EXISTS stream_updates (
+      id TEXT PRIMARY KEY,
+      sessionId TEXT NOT NULL,
+      conversationId TEXT NOT NULL,
+      updateType TEXT NOT NULL,
+      content TEXT NOT NULL,
+      sequence INTEGER NOT NULL,
+      created_at INTEGER NOT NULL,
+      FOREIGN KEY (sessionId) REFERENCES sessions(id),
+      FOREIGN KEY (conversationId) REFERENCES conversations(id)
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_stream_updates_session ON stream_updates(sessionId);
+    CREATE INDEX IF NOT EXISTS idx_stream_updates_created ON stream_updates(created_at);
+
+    CREATE TABLE IF NOT EXISTS chunks (
+      id TEXT PRIMARY KEY,
+      sessionId TEXT NOT NULL,
+      conversationId TEXT NOT NULL,
+      sequence INTEGER NOT NULL,
+      type TEXT NOT NULL,
+      data BLOB NOT NULL,
+      created_at INTEGER NOT NULL,
+      FOREIGN KEY (sessionId) REFERENCES sessions(id),
+      FOREIGN KEY (conversationId) REFERENCES conversations(id)
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_chunks_session ON chunks(sessionId, sequence);
+    CREATE INDEX IF NOT EXISTS idx_chunks_conversation ON chunks(conversationId, sequence);
+    CREATE UNIQUE INDEX IF NOT EXISTS idx_chunks_unique ON chunks(sessionId, sequence);
+    CREATE INDEX IF NOT EXISTS idx_chunks_conv_created ON chunks(conversationId, created_at);
+    CREATE INDEX IF NOT EXISTS idx_chunks_sess_created ON chunks(sessionId, created_at);
+
+    CREATE TABLE IF NOT EXISTS voice_cache (
+      id TEXT PRIMARY KEY,
+      conversationId TEXT NOT NULL,
+      text TEXT NOT NULL,
+      audioBlob BLOB,
+      byteSize INTEGER NOT NULL,
+      created_at INTEGER NOT NULL,
+      expires_at INTEGER NOT NULL,
+      FOREIGN KEY (conversationId) REFERENCES conversations(id)
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_voice_cache_conv ON voice_cache(conversationId);
+    CREATE INDEX IF NOT EXISTS idx_voice_cache_expires ON voice_cache(expires_at);
+
+    CREATE TABLE IF NOT EXISTS tool_installations (
+      id TEXT PRIMARY KEY,
+      tool_id TEXT NOT NULL UNIQUE,
+      version TEXT,
+      installed_at INTEGER,
+      status TEXT NOT NULL DEFAULT 'not_installed',
+      last_check_at INTEGER,
+      error_message TEXT,
+      update_available INTEGER DEFAULT 0,
+      latest_version TEXT,
+      created_at INTEGER NOT NULL,
+      updated_at INTEGER NOT NULL
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_tool_installations_status ON tool_installations(status);
+    CREATE INDEX IF NOT EXISTS idx_tool_installations_last_check ON tool_installations(last_check_at);
+
+    CREATE TABLE IF NOT EXISTS tool_install_history (
+      id TEXT PRIMARY KEY,
+      tool_id TEXT NOT NULL,
+      action TEXT NOT NULL,
+      started_at INTEGER NOT NULL,
+      completed_at INTEGER,
+      status TEXT NOT NULL,
+      error_message TEXT,
+      created_at INTEGER NOT NULL,
+      FOREIGN KEY (tool_id) REFERENCES tool_installations(tool_id)
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_tool_install_history_tool ON tool_install_history(tool_id);
+    CREATE INDEX IF NOT EXISTS idx_tool_install_history_completed ON tool_install_history(completed_at);
+
+    CREATE TABLE IF NOT EXISTS workflow_runs (
+      id TEXT PRIMARY KEY,
+      workflowName TEXT NOT NULL,
+      workflowId TEXT,
+      runId TEXT,
+      sha TEXT,
+      branch TEXT,
+      status TEXT,
+      conclusion TEXT,
+      htmlUrl TEXT,
+      triggeredAt INTEGER NOT NULL,
+      completedAt INTEGER,
+      created_at INTEGER NOT NULL
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_workflow_runs_name ON workflow_runs(workflowName);
+    CREATE INDEX IF NOT EXISTS idx_workflow_runs_sha ON workflow_runs(sha);
+    CREATE INDEX IF NOT EXISTS idx_workflow_runs_completed ON workflow_runs(completedAt);
+
+    CREATE TABLE IF NOT EXISTS oauth_tokens (
+      id TEXT PRIMARY KEY,
+      provider TEXT NOT NULL,
+      token TEXT NOT NULL,
+      email TEXT,
+      expires_at INTEGER,
+      created_at INTEGER NOT NULL,
+      updated_at INTEGER NOT NULL
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_oauth_tokens_provider ON oauth_tokens(provider);
+
+  `);
+}