server.js

const express = require('express');
const path = require('path');
const { createSessionPersistence } = require('./session-persistence');
const { createProcessRunner } = require('./process-runner');
const { createSearchEngine } = require('./search-engine');
const { createSessionRunner } = require('./session-runner');
const { createCacheDb } = require('./cache/db');
const { createMigrationRunner } = require('./cache/migrate');
const { createSessionSync } = require('./cache/sync/sessions');
const { createMessageSync } = require('./cache/sync/messages');
const { createPartSync } = require('./cache/sync/parts');
const { createFileWatcher } = require('./cache/watcher');

// Initialize cache database with auto-rebuild on corruption
function initializeCache() {
  const manager = createCacheDb();

  function isCorruptionError(err) {
    return err && err.message && (
      err.message.includes('database disk image is malformed') ||
      err.message.includes('file is not a database') ||
      err.message.includes('corrupt')
    );
  }

  try {
    const db = manager.open();
    const migrationRunner = createMigrationRunner({ db });
    migrationRunner.runMigrations();
    return { cacheDb: db, cacheDbManager: manager };
  } catch (err) {
    if (isCorruptionError(err)) {
      console.error(`[cache] Cache database is corrupt, rebuilding from source: ${err.message}`);
      const db = manager.rebuild();
      const migrationRunner = createMigrationRunner({ db });
      migrationRunner.runMigrations();
      return { cacheDb: db, cacheDbManager: manager };
    }
    throw err;
  }
}

const { cacheDb, cacheDbManager } = initializeCache();

// Sync data from opencode's database into cache
const sessionSync = createSessionSync({ cacheDb });
const messageSync = createMessageSync({ cacheDb });
const partSync = createPartSync({ cacheDb });

function runSyncWithLogging(syncer, tableName) {
  try {
    const result = syncer.syncAll();
    console.log(`[sync] ${tableName}: synced ${result.syncedCount} rows in ${result.durationMs}ms`);
    return result;
  } catch (err) {
    console.error(`[sync] ${tableName}: sync failed after 0 rows — ${err.message}`);
    return { syncedCount: 0, durationMs: 0, error: err.message };
  }
}

const sessionSyncResult = runSyncWithLogging(sessionSync, 'sessions');
const messageSyncResult = runSyncWithLogging(messageSync, 'messages');
const partSyncResult = runSyncWithLogging(partSync, 'parts');

const totalRows = sessionSyncResult.syncedCount + messageSyncResult.syncedCount + partSyncResult.syncedCount;
console.log(`Cache sync complete: ${totalRows} total rows (${sessionSyncResult.syncedCount} sessions, ${messageSyncResult.syncedCount} messages, ${partSyncResult.syncedCount} parts)`);

// Start file watcher for incremental syncs
const fileWatcher = createFileWatcher({
  cacheDb,
  syncers: { sessions: sessionSync, messages: messageSync, parts: partSync }
});
fileWatcher.setLastSyncTime(Date.now());
fileWatcher.start();

const sessions = createSessionPersistence({ cacheDb });
const runner = createProcessRunner();
const search = createSearchEngine({ cacheDb });
const sessionRunner = createSessionRunner();

const app = express();
const PORT = process.env.PORT || 3457;

app.use(express.json());
app.use(express.static(path.join(__dirname, 'public')));

// API: List sessions (from DB)
app.get('/api/sessions', async (req, res) => {
  try {
    const sessionList = await sessions.listSessions();
    res.json({ sessions: sessionList });
  } catch (err) {
    console.error('Error listing sessions:', err);
    res.status(500).json({ error: err.message });
  }
});

// API: Get session with structured messages (from DB)
app.get('/api/session/:id', async (req, res) => {
  try {
    const session = await sessions.getSessionWithMessages(req.params.id);
    if (!session) {
      return res.status(404).json({ error: 'Session not found' });
    }
    res.json(session);
  } catch (err) {
    console.error('Error getting session:', err);
    res.status(500).json({ error: err.message });
  }
});

// API: Get session message count (lightweight polling)
app.get('/api/session/:id/count', async (req, res) => {
  try {
    const messageCount = await sessions.getMessageCount(req.params.id);
    res.json({ messageCount });
  } catch (err) {
    console.error('Error getting message count:', err);
    res.status(500).json({ error: err.message });
  }
});

// API: Continue chat (append user message to file, then spawn opencode run)
app.post('/api/session/:id/continue', async (req, res) => {
  const { text } = req.body || {};
  if (!text || !text.trim()) {
    return res.status(400).json({ error: 'Text required' });
  }

  try {
    const { session, markdownPath } = await sessions.appendUserMessage(req.params.id, text);

    runner.runOpenCodeInBackground({
      sessionId: session.id,
      prompt: text.trim(),
      cwd: session.directory || process.env.HOME,
      logDir: path.dirname(markdownPath)
    });

    res.json({ success: true, processing: true });
  } catch (err) {
    if (err.message && err.message.includes('Session not found')) {
      return res.status(404).json({ error: 'Session not found' });
    }
    console.error('Error continuing session:', err);
    res.status(500).json({ error: err.message });
  }
});

// API: Open session in OpenCode terminal
app.post('/api/open/:id', async (req, res) => {
  const sessionId = req.params.id;
  const { terminal, shell } = req.body || {};

  try {
    const session = await sessions.getSessionWithMessages(sessionId);
    const cwd = session?.directory || process.env.HOME;

    runner.openSessionInTerminal({ sessionId, cwd, terminal, shell });
    res.json({ success: true, sessionId, directory: cwd });
  } catch (err) {
    res.status(500).json({ error: err.message });
  }
});

// API: Open a new session in OpenCode terminal
app.post('/api/open-new', async (req, res) => {
  const { terminal, shell } = req.body || {};

  try {
    const cwd = process.env.HOME;
    runner.openNewSessionInTerminal({ cwd, terminal, shell });
    res.json({ success: true, directory: cwd });
  } catch (err) {
    res.status(500).json({ error: err.message });
  }
});

// API: Search sessions
app.get('/api/search', async (req, res) => {
  try {
    const q = req.query.q;
    if (!q || !q.trim()) {
      return res.json({ results: [] });
    }
    const result = await search.searchSessions(q.trim());
    res.json(result);
  } catch (err) {
    console.error('Error searching sessions:', err);
    res.status(500).json({ error: err.message });
  }
});

// API: Create new session via opencode run
app.post('/api/session/new', async (req, res) => {
  try {
    const { prompt, directory, title } = req.body || {};
    if (!prompt || !prompt.trim()) {
      return res.status(400).json({ error: 'Prompt is required' });
    }

    const result = await sessionRunner.createSession({ prompt, directory, title });
    res.json(result);
  } catch (err) {
    console.error('Error creating session:', err);
    res.status(500).json({ error: err.message });
  }
});

app.listen(PORT, () => {
  console.log(`OpenCode Session Dashboard running at http://localhost:${PORT}`);
  console.log(`Sessions directory: ${process.env.SESSIONS_DIR || path.join(__dirname, '..', 'opencode-sessions')}`);
});