export-session.mjs

#!/usr/bin/env node
/**
 * export-session.mjs
 *
 * Converts an OpenCode session from the global SQLite database into a
 * proper .jsonl event-stream file compatible with the Replay Studio.
 *
 * Usage:
 *   node scripts/export-session.mjs --list
 *   node scripts/export-session.mjs --latest [output.jsonl]
 *   node scripts/export-session.mjs <session-id|date-fragment> [output.jsonl]
 *
 * Examples:
 *   node scripts/export-session.mjs --list
 *   node scripts/export-session.mjs --latest
 *   node scripts/export-session.mjs ses_1a9062eb8ffepj1DzblV4ruWwA
 *   node scripts/export-session.mjs "2026-05-23T235138" my-replay.jsonl
 */

import { execSync } from "node:child_process";
import { basename, resolve } from "node:path";
import { existsSync, readdirSync, readFileSync, statSync, writeFileSync } from "node:fs";

// ── Resolve DB path ────────────────────────────────────────────────────────
const homeDir = process.env.HOME || process.env.USERPROFILE || "";

function uniq(items) {
  return [...new Set(items.filter(Boolean))];
}

const opencodeDataDirs = uniq([
  process.env.OPENCODE_DATA_DIR,
  process.env.XDG_DATA_HOME ? resolve(process.env.XDG_DATA_HOME, "opencode") : null,
  homeDir ? resolve(homeDir, ".local", "share", "opencode") : null,
  process.env.APPDATA ? resolve(process.env.APPDATA, "opencode") : null,
  process.env.LOCALAPPDATA ? resolve(process.env.LOCALAPPDATA, "opencode") : null,
  homeDir ? resolve(homeDir, "Library", "Application Support", "opencode") : null,
]);

const dbCandidates = uniq(opencodeDataDirs.map(dir => resolve(dir, "opencode.db")));

const resolvedDb = dbCandidates.find(p => existsSync(p));
if (!resolvedDb) {
  console.error("❌ Could not find OpenCode database. Tried:");
  dbCandidates.forEach(p => console.error("   " + p));
  process.exit(1);
}

// ── sqlite3 helper ─────────────────────────────────────────────────────────
function queryRaw(sql) {
  return execSync(`sqlite3 -separator "|" "${resolvedDb}" "${sql.replace(/"/g, '\\"').replace(/\n/g, " ")}"`, {
    encoding: "utf-8",
    stdio: ["pipe", "pipe", "pipe"],
    maxBuffer: 100 * 1024 * 1024, // 100 MB
  }).trim();
}

function escapeSqlText(value) {
  return String(value).replace(/'/g, "''");
}

function parseSessionRow(row) {
  const firstPipe = row.indexOf("|");
  const lastPipe = row.lastIndexOf("|");
  if (firstPipe < 0 || lastPipe <= firstPipe) return null;
  return {
    id: row.slice(0, firstPipe),
    title: row.slice(firstPipe + 1, lastPipe),
    timeCreated: parseInt(row.slice(lastPipe + 1), 10),
  };
}

function fmtSessionTime(tsMs) {
  return new Date(parseInt(tsMs, 10)).toISOString().replace("T", " ").slice(0, 19);
}

function compactTimestampInfo(value) {
  const m = String(value).match(/^(\d{4}-\d{2}-\d{2})T?(\d{2})(\d{2})(?:(\d{2}))?$/);
  if (!m) return null;

  const [, day, hour, minute, rawSecond] = m;
  const second = rawSecond || "00";
  const iso = `${day}T${hour}:${minute}:${second}.000Z`;
  const targetMs = Date.parse(iso);
  if (Number.isNaN(targetMs)) return null;

  return {
    targetMs,
    sqlite: `${day} ${hour}:${minute}:${second}`,
    title: `${day}T${hour}:${minute}:${second}`,
    minuteSqlite: `${day} ${hour}:${minute}`,
    minuteTitle: `${day}T${hour}:${minute}`,
  };
}

function sessionSearchTerms(input, compact) {
  const terms = [String(input)];
  if (compact) {
    terms.push(compact.sqlite, compact.title, compact.minuteSqlite, compact.minuteTitle);
  }
  return [...new Set(terms.filter(Boolean))];
}

function printSessionChoices(input, matches) {
  console.log(`\n⚠️  Multiple sessions match "${input}". Pick one:\n`);
  for (const match of matches) {
    console.log(`  ${fmtSessionTime(match.timeCreated)}   ${match.id}   ${(match.title || "").slice(0, 55)}`);
  }
  console.log("\nRun again with the exact session ID.\n");
}

function logDirCandidates() {
  return uniq(opencodeDataDirs.flatMap(dir => [
    resolve(dir, "log"),
    resolve(dir, "logs"),
  ]));
}

function latestLogFile() {
  const files = [];
  for (const dir of logDirCandidates()) {
    if (!existsSync(dir)) continue;
    for (const name of readdirSync(dir)) {
      if (!name.toLowerCase().endsWith(".log")) continue;
      const path = resolve(dir, name);
      try {
        const st = statSync(path);
        if (st.isFile()) files.push({ path, mtimeMs: st.mtimeMs, size: st.size });
      } catch {}
    }
  }
  files.sort((a, b) => b.mtimeMs - a.mtimeMs);
  return files[0]?.path || null;
}

function sessionIdFromLog(path) {
  const text = readFileSync(path, "utf8");
  const matches = [...text.matchAll(/\b(?:id|session\.id)=(ses_[A-Za-z0-9]+)/g)];
  return matches.length ? matches[matches.length - 1][1] : null;
}

function logKeyFromPath(path) {
  return basename(path).replace(/\.log$/i, "");
}

// ── CLI args ───────────────────────────────────────────────────────────────
const args = process.argv.slice(2);

if (args.length === 0 || args[0] === "--help" || args[0] === "-h") {
  console.log(`
OpenCode Session → JSONL Exporter
───────────────────────────────────
Exports a session from the OpenCode SQLite database to the event-stream
.jsonl format compatible with the Replay Studio.

Usage:
  node scripts/export-session.mjs --list
      List all sessions.

  node scripts/export-session.mjs --latest
      Export the most recently changed OpenCode log session.

  node scripts/export-session.mjs <session-id|date> [output.jsonl]
      Export session. <date> can be "2026-05-23T22" or "2026-05-23T235138".

Examples:
  node scripts/export-session.mjs --list
  node scripts/export-session.mjs --latest
  node scripts/export-session.mjs ses_1a9062eb8ffepj1DzblV4ruWwA
  node scripts/export-session.mjs "2026-05-23T22" my-session.jsonl
`);
  process.exit(0);
}

// ── List mode ──────────────────────────────────────────────────────────────
if (args[0] === "--list" || args[0] === "-l") {
  const rows = queryRaw(
    "SELECT id, title, time_created FROM session ORDER BY time_created DESC LIMIT 50;"
  );
  if (!rows) { console.log("No sessions found."); process.exit(0); }

  console.log("\n📋 OpenCode Sessions (newest first):\n");
  console.log("  " + "─".repeat(100));
  for (const row of rows.split("\n")) {
    if (!row.trim()) continue;
    const parsed = parseSessionRow(row);
    if (!parsed) continue;
    const date = fmtSessionTime(parsed.timeCreated);
    const t = (parsed.title || "(untitled)").slice(0, 55).padEnd(57);
    console.log(`  ${date}   ${parsed.id}   ${t}`);
  }
  console.log("  " + "─".repeat(100));
  console.log(`\nTo export: node scripts/export-session.mjs <session-id>\n`);
  process.exit(0);
}

// ── Resolve session ID ─────────────────────────────────────────────────────
let sessionId = args[0];
let outputStem = sessionId;

if (sessionId === "--latest" || sessionId === "--last" || sessionId === "latest" || sessionId === "last") {
  const logPath = latestLogFile();
  if (!logPath) {
    console.error("❌ Could not find an OpenCode log file. Tried:");
    logDirCandidates().forEach(p => console.error("   " + p));
    process.exit(1);
  }

  outputStem = logKeyFromPath(logPath);
  const fromLog = sessionIdFromLog(logPath);
  sessionId = fromLog || outputStem;
  console.log(`🔍 Latest log: ${logPath}`);
  if (fromLog) console.log(`🔍 Session from log: ${fromLog}`);
}

const outputFile = args[1] || `${outputStem.replace(/[^a-zA-Z0-9_-]/g, "_")}.jsonl`;

if (!sessionId.startsWith("ses_")) {
  let logPathToCheck = null;
  for (const dir of logDirCandidates()) {
    const p = resolve(dir, sessionId + (sessionId.endsWith(".log") ? "" : ".log"));
    if (existsSync(p)) {
      logPathToCheck = p;
      break;
    }
  }

  if (logPathToCheck) {
    const fromLog = sessionIdFromLog(logPathToCheck);
    if (fromLog) {
      console.log(`🔍 Found log file: ${logPathToCheck}`);
      console.log(`🔍 Extracted session ID: ${fromLog}`);
      sessionId = fromLog;
    }
  }
}

if (!sessionId.startsWith("ses_")) {
  // Fuzzy date/title search
  const compact = compactTimestampInfo(sessionId);
  const terms = sessionSearchTerms(sessionId, compact);
  const where = terms.map(term => {
    const escaped = escapeSqlText(term);
    return `datetime(time_created/1000,'unixepoch') LIKE '%${escaped}%' OR title LIKE '%${escaped}%'`;
  }).join(" OR ");

  const matchRows = queryRaw(
    `SELECT id, title, time_created FROM session WHERE ${where} ORDER BY time_created DESC LIMIT 8;`
  );

  let matches = matchRows
    ? matchRows.split("\n").filter(r => r.trim()).map(parseSessionRow).filter(Boolean)
    : [];

  if (!matches.length && compact) {
    const windowMs = 2 * 60 * 1000;
    const nearRows = queryRaw(
      `SELECT id, title, time_created FROM session WHERE time_created BETWEEN ${compact.targetMs - windowMs} AND ${compact.targetMs + windowMs} ORDER BY ABS(time_created - ${compact.targetMs}) ASC LIMIT 8;`
    );
    matches = nearRows
      ? nearRows.split("\n").filter(r => r.trim()).map(parseSessionRow).filter(Boolean)
      : [];
  }

  if (!matches.length) {
    console.error(`❌ No sessions matching: "${sessionId}"\n   Tip: run --list to see all sessions.`);
    process.exit(1);
  }

  if (matches.length > 1) {
    if (compact) {
      matches.sort((a, b) =>
        Math.abs(a.timeCreated - compact.targetMs) - Math.abs(b.timeCreated - compact.targetMs)
      );
      const bestDelta = Math.abs(matches[0].timeCreated - compact.targetMs);
      if (bestDelta <= 2 * 60 * 1000) {
        sessionId = matches[0].id;
        const sign = matches[0].timeCreated >= compact.targetMs ? "+" : "-";
        console.log(`🔍 Closest session: ${sessionId}  (${fmtSessionTime(matches[0].timeCreated)}, ${sign}${(bestDelta / 1000).toFixed(1)}s)`);
      } else {
        printSessionChoices(sessionId, matches);
        process.exit(0);
      }
    } else {
      printSessionChoices(sessionId, matches);
      process.exit(0);
    }
  }

  if (!sessionId.startsWith("ses_")) {
    sessionId = matches[0].id;
    console.log(`🔍 Matched session: ${sessionId}  (${fmtSessionTime(matches[0].timeCreated)})`);
  }
}

// ── Fetch messages for session context ─────────────────────────────────────
console.log(`\n📦 Loading session: ${sessionId}`);

const msgRaw = queryRaw(
  `SELECT id, time_created, data FROM message WHERE session_id='${sessionId}' ORDER BY time_created ASC;`
);

// Build a map: messageId → { time_created, data }
const messageMap = new Map();
if (msgRaw) {
  for (const row of msgRaw.split("\n")) {
    if (!row.trim()) continue;
    // id|time_created|data  — data may contain pipes, so split only on first 2
    const firstPipe = row.indexOf("|");
    const secondPipe = row.indexOf("|", firstPipe + 1);
    if (firstPipe < 0 || secondPipe < 0) continue;
    const msgId = row.slice(0, firstPipe);
    const timeCreated = parseInt(row.slice(firstPipe + 1, secondPipe));
    const dataStr = row.slice(secondPipe + 1);
    try {
      messageMap.set(msgId, { time_created: timeCreated, data: JSON.parse(dataStr) });
    } catch {
      messageMap.set(msgId, { time_created: timeCreated, data: {} });
    }
  }
}

// ── Fetch all parts for the session ────────────────────────────────────────
const partRaw = queryRaw(
  `SELECT id, message_id, time_created, data FROM part WHERE session_id='${sessionId}' ORDER BY time_created ASC, rowid ASC;`
);

if (!partRaw) {
  console.error(`❌ No events found for session: ${sessionId}`);
  console.error(`   The session may exist but have no content parts.`);
  process.exit(1);
}

// ── Convert parts → JSONL event-stream ────────────────────────────────────
const lines = [];

// Map SQLite part type → JSONL envelope type
const typeMap = {
  "step-start":  "step_start",
  "step-finish": "step_finish",
  "tool":        "tool_use",
  "text":        "text",
  "reasoning":   "reasoning",
  "snapshot":    "snapshot",
  "error":       "error",
};

for (const row of partRaw.split("\n")) {
  if (!row.trim()) continue;

  // id|message_id|time_created|data  — data may contain pipes, split on first 3
  const p1 = row.indexOf("|");
  const p2 = row.indexOf("|", p1 + 1);
  const p3 = row.indexOf("|", p2 + 1);
  if (p1 < 0 || p2 < 0 || p3 < 0) continue;

  const partId    = row.slice(0, p1);
  const messageId = row.slice(p1 + 1, p2);
  const timeCreated = parseInt(row.slice(p2 + 1, p3));
  const dataStr   = row.slice(p3 + 1);

  let partData;
  try {
    partData = JSON.parse(dataStr);
  } catch {
    continue; // skip invalid JSON
  }

  const partType = partData.type || "unknown";
  const envelopeType = typeMap[partType] || partType;

  // Get message context
  const msgCtx = messageMap.get(messageId) || {};
  const msgData = msgCtx.data || {};

  // Build the full part object (enrich with IDs)
  const fullPart = {
    id:        partId,
    sessionID: sessionId,
    messageID: messageId,
    ...partData,
  };

  // For step-finish, attach cost/token data from the message if available
  if (partType === "step-finish" && msgData.tokens) {
    fullPart.cost   = msgData.cost   ?? fullPart.cost   ?? 0;
    if (!fullPart.tokens) {
      const t = msgData.tokens;
      fullPart.tokens = {
        input:  t.input  || 0,
        output: t.output || 0,
        cached: (t.cache?.read || 0),
      };
    }
  }

  const envelope = {
    type:      envelopeType,
    timestamp: timeCreated || (msgCtx.time_created || Date.now()),
    sessionID: sessionId,
    part:      fullPart,
  };

  // Attach message role context for user messages
  if (msgData.role === "user" && partType === "text") {
    envelope.role = "user";
  }

  lines.push(JSON.stringify(envelope));
}

if (lines.length === 0) {
  console.error(`❌ Session exists but no convertible parts were found.`);
  process.exit(1);
}

writeFileSync(outputFile, lines.join("\n") + "\n");
console.log(`✅ Exported ${lines.length} events → ${outputFile}\n`);

// Write temporary session data for studio.html
const dataJsPath = resolve(process.cwd(), "session-data.js");
const dataJsContent = `window.__OPENCODE_SESSION__ = { filename: ${JSON.stringify(outputFile)}, text: ${JSON.stringify(lines.join("\n") + "\n")} };`;
writeFileSync(dataJsPath, dataJsContent);

console.log(`🚀 Opening Replay Studio...`);
const studioUrl = `file:///${resolve(process.cwd(), "studio.html").replace(/\\/g, "/")}`;
const startCmd = process.platform === "darwin" ? `open "${studioUrl}"` : process.platform === "win32" ? `start "" "${studioUrl}"` : `xdg-open "${studioUrl}"`;
execSync(startCmd);