session-persistence.js

const fs = require('fs');
const path = require('path');
const { spawn } = require('child_process');
const { createSessionQueryEnhancer } = require('./session-query-enhancer');
const { createSessionListAdapter } = require('./cache/adapters/session-list');
const { createSessionDetailAdapter } = require('./cache/adapters/session-detail');

const DB_PATH = path.join(process.env.HOME, '.local/share/opencode/opencode.db');

let sqliteQueue = Promise.resolve();

function sqliteJson(query) {
  const task = () => new Promise((resolve, reject) => {
    const proc = spawn('sqlite3', [DB_PATH, '-json', query]);
    let stdout = '';
    let stderr = '';
    proc.stdout.on('data', d => stdout += d);
    proc.stderr.on('data', d => stderr += d);
    proc.on('close', code => {
      if (code !== 0) return reject(new Error(stderr || `sqlite3 exited ${code}`));
      try {
        resolve(JSON.parse(stdout || '[]'));
      } catch (e) {
        reject(e);
      }
    });
  });

  const result = sqliteQueue.then(task, task);
  sqliteQueue = result.catch(() => {});
  return result;
}

const queryEnhancer = createSessionQueryEnhancer({ sqliteJson });
const getSessions = queryEnhancer.getEnrichedSessions;

async function getSession(sessionId) {
  const sid = sessionId.replace(/'/g, "''");
  const rows = await sqliteJson(
    `SELECT id, title, directory, time_created, time_updated, COALESCE(model, '') as model, COALESCE(agent, '') as agent FROM session WHERE id = '${sid}'`
  );
  return rows[0] || null;
}

async function getMessages(sessionId) {
  const sid = sessionId.replace(/'/g, "''");
  const rows = await sqliteJson(`
    SELECT m.id, m.time_created, m.data,
      (SELECT json_group_array(json_object('id', p.id, 'time_created', p.time_created, 'data', p.data))
       FROM part p WHERE p.message_id = m.id ORDER BY p.time_created) as parts
    FROM message m
    WHERE m.session_id = '${sid}'
    ORDER BY m.time_created
  `);

  return rows.map(row => {
    const msgData = JSON.parse(row.data || '{}');
    const parts = JSON.parse(row.parts || '[]').map(part => {
      try {
        return JSON.parse(part.data);
      } catch (e) {
        return { type: 'unknown', data: part.data };
      }
    });

    return {
      id: row.id,
      timeCreated: row.time_created,
      role: msgData.role || 'unknown',
      parts
    };
  });
}

const defaultDb = { getSessions, getSession, getMessages };

function sanitizeFileName(str) {
  return str.replace(/[\\/:*?"<>|]/g, '_').substring(0, 80);
}

function formatDate(ts) {
  return new Date(ts).toISOString();
}

function escapeYaml(str) {
  if (!str) return '';
  if (/[":\n]/.test(str)) return JSON.stringify(str);
  return str;
}

function createSessionPathPolicy({ sessionsDir } = {}) {
  const dir = sessionsDir || path.join(__dirname, '..', 'opencode-sessions');

  function resolveSessionPath(name) {
    const fullPath = path.join(dir, path.basename(name));
    const resolved = path.resolve(fullPath);
    const resolvedDir = path.resolve(dir);
    if (!resolved.startsWith(resolvedDir + path.sep)) return null;
    return resolved;
  }

  function getSessionFilePath(sessionId, title) {
    const safeTitle = sanitizeFileName(title || 'Untitled');
    const fileName = `${sessionId}--${safeTitle}.md`;
    return path.join(dir, fileName);
  }

  return { resolveSessionPath, getSessionFilePath, sessionsDir: dir };
}

function createSessionMarkdownRenderer() {
  function renderSessionMarkdown(session, messages) {
    let md = `---\n`;
    md += `session_id: ${session.id}\n`;
    md += `title: ${escapeYaml(session.title || 'Untitled')}\n`;
    md += `created: ${formatDate(session.time_created)}\n`;
    md += `updated: ${formatDate(session.time_updated)}\n`;
    md += `model: ${session.model || ''}\n`;
    md += `agent: ${session.agent || ''}\n`;
    md += `messages: ${messages.length}\n`;
    md += `---\n\n`;
    md += `# ${session.title || 'Untitled'}\n\n`;

    for (const msg of messages) {
      if (!msg.parts || msg.parts.length === 0) continue;

      const role = msg.role || 'unknown';
      const roleLabel = role.charAt(0).toUpperCase() + role.slice(1);
      md += `## ${roleLabel}\n\n`;

      for (const part of msg.parts) {
        switch (part.type) {
          case 'text': {
            if (part.text) md += `${part.text}\n\n`;
            break;
          }
          case 'reasoning': {
            if (part.text) {
              const quoted = part.text.split('\n').map(l => `> ${l}`).join('\n');
              md += `> **Thinking**\n${quoted}\n\n`;
            }
            break;
          }
          case 'tool': {
            md += `**Tool: ${part.tool}** (\`${part.callID || 'unknown'}\`)\n\n`;
            if (part.state && part.state.input) {
              let inputStr = typeof part.state.input === 'string'
                ? part.state.input
                : JSON.stringify(part.state.input, null, 2);
              if (inputStr.length > 5000) inputStr = inputStr.slice(0, 5000) + '\n... [truncated]';
              md += `\`\`\`json\n${inputStr}\n\`\`\`\n\n`;
            }
            if (part.state && part.state.output !== undefined) {
              let outputStr = typeof part.state.output === 'string'
                ? part.state.output
                : JSON.stringify(part.state.output, null, 2);
              if (outputStr.length > 8000) outputStr = outputStr.slice(0, 8000) + '\n... [truncated]';
              md += `\`\`\`\n${outputStr}\n\`\`\`\n\n`;
            }
            break;
          }
          // skip: step-start, step-finish, patch, file, subtask, compaction, retry
        }
      }
    }

    return md;
  }

  return { renderSessionMarkdown };
}

function createSessionPersistence({ db, cacheDb, files, markdown, paths, sessionsDir } = {}) {
  let adapter = db;
  if (!adapter && cacheDb) {
    const listAdapter = createSessionListAdapter({ cacheDb });
    const detailAdapter = createSessionDetailAdapter({ cacheDb });
    adapter = {
      getSessions: async () => listAdapter.getEnrichedSessions(),
      getSession: async (id) => {
        const session = detailAdapter.getSessionWithMessages(id);
        if (!session) return null;
        return {
          id: session.id,
          title: session.title,
          directory: session.directory,
          time_created: session.created,
          time_updated: session.updated,
          model: session.model,
          agent: session.agent
        };
      },
      getMessages: async (id) => {
        const session = detailAdapter.getSessionWithMessages(id);
        return session ? session.messages : [];
      }
    };
  }
  if (!adapter) {
    adapter = defaultDb;
  }
  const cache = cacheDb || null;
  const fileSystem = files || fs;
  const renderer = markdown || createSessionMarkdownRenderer();
  const pathPolicy = paths || createSessionPathPolicy({ sessionsDir });

  async function listSessions() {
    return adapter.getSessions();
  }

  async function getSessionWithMessages(id) {
    const session = await adapter.getSession(id);
    if (!session) return null;

    const messages = await adapter.getMessages(id);

    return {
      id: session.id,
      title: session.title || 'Untitled',
      directory: session.directory || null,
      created: session.time_created,
      updated: session.time_updated,
      model: session.model || null,
      agent: session.agent || null,
      messages
    };
  }

  async function ensureMarkdownFile(id) {
    const session = await adapter.getSession(id);
    if (!session) {
      throw new Error(`Session not found: ${id}`);
    }

    const filePath = pathPolicy.getSessionFilePath(session.id, session.title);
    const resolvedPath = pathPolicy.resolveSessionPath(filePath);
    if (!resolvedPath) {
      throw new Error('Access denied: path traversal detected');
    }

    if (!fileSystem.existsSync(pathPolicy.sessionsDir)) {
      fileSystem.mkdirSync(pathPolicy.sessionsDir, { recursive: true });
    }

    if (fileSystem.existsSync(resolvedPath)) {
      return { session, markdownPath: resolvedPath, created: false };
    }

    const messages = await adapter.getMessages(id);
    const md = renderer.renderSessionMarkdown(session, messages);
    fileSystem.writeFileSync(resolvedPath, md, 'utf-8');
    return { session, markdownPath: resolvedPath, created: true };
  }

  async function exportSession(id, toPath) {
    const session = await adapter.getSession(id);
    if (!session) {
      throw new Error(`Session not found: ${id}`);
    }

    const messages = await adapter.getMessages(id);
    const md = renderer.renderSessionMarkdown(session, messages);

    const filePath = toPath || pathPolicy.getSessionFilePath(session.id, session.title);
    const resolvedPath = pathPolicy.resolveSessionPath(filePath);
    if (!resolvedPath) {
      throw new Error('Access denied: path traversal detected');
    }

    if (!fileSystem.existsSync(pathPolicy.sessionsDir)) {
      fileSystem.mkdirSync(pathPolicy.sessionsDir, { recursive: true });
    }

    fileSystem.writeFileSync(resolvedPath, md, 'utf-8');

    // Write-through cache: update session time_updated to reflect activity
    if (cache) {
      const now = Date.now();
      cache.prepare('UPDATE session SET time_updated = ? WHERE id = ?').run(now, id);
    }

    return { markdownPath: resolvedPath };
  }

  async function appendUserMessage(id, text) {
    const session = await adapter.getSession(id);
    if (!session) {
      throw new Error(`Session not found: ${id}`);
    }

    const filePath = pathPolicy.getSessionFilePath(session.id, session.title);
    const resolvedPath = pathPolicy.resolveSessionPath(filePath);
    if (!resolvedPath) {
      throw new Error('Access denied: path traversal detected');
    }

    if (!fileSystem.existsSync(pathPolicy.sessionsDir)) {
      fileSystem.mkdirSync(pathPolicy.sessionsDir, { recursive: true });
    }

    if (!fileSystem.existsSync(resolvedPath)) {
      const messages = await adapter.getMessages(id);
      const md = renderer.renderSessionMarkdown(session, messages);
      fileSystem.writeFileSync(resolvedPath, md, 'utf-8');
    }

    const appendage = `## User\n\n${text.trim()}\n\n`;
    fileSystem.appendFileSync(resolvedPath, appendage, 'utf-8');

    // Write-through cache: update session time_updated to reflect activity
    if (cache) {
      const now = Date.now();
      cache.prepare('UPDATE session SET time_updated = ? WHERE id = ?').run(now, id);
    }

    return { session, markdownPath: resolvedPath };
  }

  async function exportAll(options = {}) {
    const overwrite = options.overwrite !== false;
    const onProgress = options.onProgress || (() => {});
    const targetDir = options.outDir || pathPolicy.sessionsDir;

    const targetPolicy = options.outDir
      ? createSessionPathPolicy({ sessionsDir: options.outDir })
      : pathPolicy;

    const sessions = await adapter.getSessions();
    const files = [];
    let exported = 0;
    const usedPaths = new Set();

    for (let i = 0; i < sessions.length; i++) {
      const session = sessions[i];

      const fullSession = await adapter.getSession(session.id);
      if (!fullSession) continue;

      const messages = await adapter.getMessages(session.id);
      const md = renderer.renderSessionMarkdown(fullSession, messages);

      let filePath = targetPolicy.getSessionFilePath(fullSession.id, fullSession.title);
      let resolvedPath = targetPolicy.resolveSessionPath(filePath);
      if (!resolvedPath) {
        throw new Error('Access denied: path traversal detected');
      }

      let uniquePath = resolvedPath;
      let counter = 1;
      while (usedPaths.has(uniquePath)) {
        const base = filePath.replace(/\.md$/, '');
        const newFilePath = `${base}-${counter}.md`;
        uniquePath = targetPolicy.resolveSessionPath(newFilePath);
        counter++;
      }
      usedPaths.add(uniquePath);

      if (!overwrite && fileSystem.existsSync(uniquePath)) {
        continue;
      }

      if (!fileSystem.existsSync(targetPolicy.sessionsDir)) {
        fileSystem.mkdirSync(targetPolicy.sessionsDir, { recursive: true });
      }

      fileSystem.writeFileSync(uniquePath, md, 'utf-8');

      files.push({ sessionId: fullSession.id, filePath: uniquePath });
      exported++;

      onProgress({
        session,
        index: i,
        total: sessions.length,
        filePath: uniquePath
      });
    }

    return { exported, files };
  }

  function getMessageCount(sessionId) {
    if (!cache) return 0;
    const result = cache.prepare('SELECT COUNT(*) as count FROM message WHERE session_id = ?').get(sessionId);
    return result ? result.count : 0;
  }

  return {
    listSessions,
    getSessionWithMessages,
    ensureMarkdownFile,
    exportSession,
    appendUserMessage,
    exportAll,
    getMessageCount
  };
}

module.exports = {
  createSessionPersistence,
  createSessionPathPolicy,
  createSessionMarkdownRenderer,
  sqliteJson
};