@nocoo/pika 0.2.1

package/dist/bin.js

@@ -0,0 +1,3429 @@
+#!/usr/bin/env bun
+// @bun
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+var __require = import.meta.require;
+
+// ../core/src/types.ts
+var SOURCES;
+var init_types = __esm(() => {
+  SOURCES = [
+    "claude-code",
+    "codex",
+    "gemini-cli",
+    "opencode",
+    "vscode-copilot"
+  ];
+});
+
+// ../../package.json
+var package_default;
+var init_package = __esm(() => {
+  package_default = {
+    name: "pika",
+    version: "0.2.1",
+    private: true,
+    workspaces: [
+      "packages/*"
+    ],
+    scripts: {
+      dev: "bun run --cwd packages/web dev",
+      build: "bun run --filter '*' build",
+      test: "vitest run",
+      "test:watch": "vitest",
+      "test:coverage": "vitest run --coverage",
+      lint: "tsc --noEmit && tsc --noEmit -p packages/web/tsconfig.json",
+      "lint:typecheck": "tsc --noEmit && tsc --noEmit -p packages/web/tsconfig.json",
+      "sync-versions": "bun scripts/sync-versions.ts --write",
+      prepare: "husky"
+    },
+    devDependencies: {
+      "@vitest/coverage-v8": "^3.1.1",
+      husky: "^9.1.7",
+      typescript: "^5.8.2",
+      vitest: "^3.1.1"
+    },
+    overrides: {
+      undici: ">=7.24.0",
+      cookie: ">=0.7.0"
+    }
+  };
+});
+
+// ../core/src/version.ts
+var PIKA_VERSION;
+var init_version = __esm(() => {
+  init_package();
+  PIKA_VERSION = package_default.version;
+});
+
+// ../core/src/constants.ts
+var PARSER_REVISION = 2, SCHEMA_VERSION = 1, METADATA_BATCH_SIZE = 50, LOGIN_TIMEOUT_MS = 120000, CONFIG_DIR = "pika", CONFIG_FILE = "config.json", DEV_CONFIG_FILE = "config.dev.json", PARSE_ERRORS_FILE = "parse-errors.jsonl", MAX_UPLOAD_RETRIES = 2, INITIAL_BACKOFF_MS = 1000, CONTENT_UPLOAD_CONCURRENCY = 2, MAX_CONTENT_UPLOAD_BYTES, MAX_METADATA_BODY_BYTES, MAX_DECOMPRESSED_CONTENT_BYTES;
+var init_constants = __esm(() => {
+  MAX_CONTENT_UPLOAD_BYTES = 50 * 1024 * 1024;
+  MAX_METADATA_BODY_BYTES = 2 * 1024 * 1024;
+  MAX_DECOMPRESSED_CONTENT_BYTES = 256 * 1024 * 1024;
+});
+
+// ../core/src/validation.ts
+var init_validation = __esm(() => {
+  init_types();
+  init_constants();
+});
+
+// ../core/src/chunking.ts
+var init_chunking = __esm(() => {
+  init_constants();
+});
+
+// ../core/src/title.ts
+function getFirstUserMessage(messages) {
+  for (const msg of messages) {
+    if (msg.role === "user" && msg.content.trim().length > 0) {
+      return msg.content.trim();
+    }
+  }
+  return null;
+}
+function generateTitle(projectName, firstUserMessage) {
+  if (!firstUserMessage)
+    return null;
+  const normalized = firstUserMessage.replace(/\s+/g, " ").trim();
+  if (normalized.length === 0)
+    return null;
+  let prefix = "";
+  if (projectName) {
+    const segments = projectName.split("/").filter(Boolean);
+    const lastSegment = segments[segments.length - 1];
+    if (lastSegment) {
+      prefix = `[${lastSegment}] `;
+    }
+  }
+  const budget = MAX_TITLE_LENGTH - prefix.length;
+  if (budget <= 0) {
+    return truncateAtWord(normalized, MAX_TITLE_LENGTH);
+  }
+  const truncated = truncateAtWord(normalized, budget);
+  return `${prefix}${truncated}`;
+}
+function truncateAtWord(text, maxLen) {
+  if (text.length <= maxLen)
+    return text;
+  const cutoff = maxLen - 1;
+  const lastSpace = text.lastIndexOf(" ", cutoff);
+  if (lastSpace > 0) {
+    return text.slice(0, lastSpace) + "\u2026";
+  }
+  return text.slice(0, cutoff) + "\u2026";
+}
+var MAX_TITLE_LENGTH = 80;
+
+// ../core/src/index.ts
+var init_src = __esm(() => {
+  init_types();
+  init_version();
+  init_constants();
+  init_validation();
+  init_chunking();
+});
+
+// src/config/manager.ts
+import { readFileSync, writeFileSync, mkdirSync, existsSync } from "fs";
+import { join } from "path";
+import { randomUUID } from "crypto";
+
+class ConfigManager {
+  configDir;
+  isDev;
+  constructor(configDir, isDev = false) {
+    this.configDir = configDir;
+    this.isDev = isDev;
+  }
+  get configPath() {
+    const fileName = this.isDev ? DEV_CONFIG_FILE : CONFIG_FILE;
+    return join(this.configDir, fileName);
+  }
+  read() {
+    try {
+      const content = readFileSync(this.configPath, "utf-8");
+      return JSON.parse(content);
+    } catch {
+      return {};
+    }
+  }
+  write(partial) {
+    if (!existsSync(this.configDir)) {
+      mkdirSync(this.configDir, { recursive: true });
+    }
+    const existing = this.read();
+    const merged = { ...existing, ...partial };
+    writeFileSync(this.configPath, JSON.stringify(merged, null, 2) + `
+`, {
+      mode: 384
+    });
+  }
+  getToken() {
+    return this.read().token;
+  }
+  isLoggedIn() {
+    return !!this.getToken();
+  }
+  getApiUrl() {
+    return this.isDev ? DEV_API_URL : PROD_API_URL;
+  }
+  getDeviceId() {
+    const config = this.read();
+    if (config.deviceId)
+      return config.deviceId;
+    const deviceId = randomUUID();
+    this.write({ deviceId });
+    return deviceId;
+  }
+}
+var PROD_API_URL = "https://pika.hexly.ai", DEV_API_URL = "https://pika.dev.hexly.ai";
+var init_manager = __esm(() => {
+  init_src();
+});
+
+// src/storage/cursor-store.ts
+import { readFile, writeFile, mkdir } from "fs/promises";
+import { join as join2, dirname } from "path";
+function emptyState() {
+  return { version: 1, files: {}, updatedAt: null };
+}
+
+class CursorStore {
+  filePath;
+  constructor(storeDir) {
+    this.filePath = join2(storeDir, CURSORS_FILE2);
+  }
+  async load() {
+    try {
+      const raw = await readFile(this.filePath, "utf-8");
+      return JSON.parse(raw);
+    } catch {
+      return emptyState();
+    }
+  }
+  async save(state) {
+    const dir = dirname(this.filePath);
+    await mkdir(dir, { recursive: true });
+    await writeFile(this.filePath, JSON.stringify(state, null, 2) + `
+`);
+  }
+}
+var CURSORS_FILE2 = "cursors.json";
+var init_cursor_store = () => {};
+
+// src/utils/file-changed.ts
+function fileUnchanged(prev, curr) {
+  if (!prev)
+    return false;
+  if (prev.mtimeMs === undefined || prev.size === undefined)
+    return false;
+  return prev.inode === curr.inode && prev.mtimeMs === curr.mtimeMs && prev.size === curr.size;
+}
+
+// src/utils/hash-project-ref.ts
+import { createHash } from "crypto";
+function hashProjectRef(raw) {
+  if (!raw)
+    return null;
+  return createHash("sha256").update(raw).digest("hex").slice(0, PROJECT_REF_HASH_LENGTH);
+}
+var PROJECT_REF_HASH_LENGTH = 16;
+var init_hash_project_ref = () => {};
+
+// src/parsers/claude.ts
+import { createReadStream } from "fs";
+import { stat } from "fs/promises";
+import { createInterface } from "readline";
+function extractUserContent(content) {
+  if (typeof content === "string")
+    return content;
+  if (!Array.isArray(content))
+    return "";
+  const textParts = [];
+  for (const block of content) {
+    if (block.type === "text" && typeof block.text === "string") {
+      textParts.push(block.text);
+    }
+  }
+  return textParts.join(`
+`);
+}
+function toNonNegInt(value) {
+  if (typeof value !== "number" || !Number.isFinite(value) || value < 0)
+    return 0;
+  return Math.floor(value);
+}
+function processAssistantContent(content, timestamp, model, usage) {
+  const messages = [];
+  const textParts = [];
+  for (const block of content) {
+    if (block.type === "text" && typeof block.text === "string") {
+      textParts.push(block.text);
+    } else if (block.type === "tool_use") {
+      if (textParts.length > 0) {
+        messages.push({
+          role: "assistant",
+          content: textParts.join(`
+`),
+          model,
+          inputTokens: usage ? toNonNegInt(usage.input_tokens) : undefined,
+          outputTokens: usage ? toNonNegInt(usage.output_tokens) : undefined,
+          cachedTokens: usage ? toNonNegInt(usage.cache_read_input_tokens) : undefined,
+          timestamp
+        });
+        textParts.length = 0;
+      }
+      messages.push({
+        role: "tool",
+        content: "",
+        toolName: typeof block.name === "string" ? block.name : undefined,
+        toolInput: block.input != null ? JSON.stringify(block.input) : undefined,
+        timestamp
+      });
+    }
+  }
+  if (textParts.length > 0 || messages.length === 0) {
+    messages.push({
+      role: "assistant",
+      content: textParts.join(`
+`),
+      model,
+      inputTokens: usage ? toNonNegInt(usage.input_tokens) : undefined,
+      outputTokens: usage ? toNonNegInt(usage.output_tokens) : undefined,
+      cachedTokens: usage ? toNonNegInt(usage.cache_read_input_tokens) : undefined,
+      timestamp
+    });
+  }
+  return messages;
+}
+function processToolResults(content, timestamp) {
+  const messages = [];
+  for (const block of content) {
+    if (block.type === "tool_result") {
+      const resultContent = typeof block.content === "string" ? block.content : block.content != null ? JSON.stringify(block.content) : "";
+      messages.push({
+        role: "tool",
+        content: resultContent,
+        toolResult: resultContent,
+        timestamp
+      });
+    }
+  }
+  return messages;
+}
+function processLine(line, sessions) {
+  let obj;
+  try {
+    obj = JSON.parse(line);
+  } catch {
+    return;
+  }
+  const sessionId = obj.sessionId;
+  if (!sessionId || typeof sessionId !== "string")
+    return;
+  const type = obj.type;
+  if (type !== "user" && type !== "assistant")
+    return;
+  const timestamp = typeof obj.timestamp === "string" ? obj.timestamp : null;
+  if (!timestamp)
+    return;
+  const message = obj.message;
+  if (!message)
+    return;
+  let accum = sessions.get(sessionId);
+  if (!accum) {
+    accum = {
+      sessionId,
+      messages: [],
+      lines: [],
+      startedAt: null,
+      lastMessageAt: null,
+      lastModel: null,
+      totalInputTokens: 0,
+      totalOutputTokens: 0,
+      totalCachedTokens: 0
+    };
+    sessions.set(sessionId, accum);
+  }
+  accum.lines.push(line);
+  if (!accum.startedAt || timestamp < accum.startedAt) {
+    accum.startedAt = timestamp;
+  }
+  if (!accum.lastMessageAt || timestamp > accum.lastMessageAt) {
+    accum.lastMessageAt = timestamp;
+  }
+  if (type === "user") {
+    const content = message.content;
+    if (Array.isArray(content)) {
+      const hasToolResults = content.some((b) => b.type === "tool_result");
+      if (hasToolResults) {
+        accum.messages.push(...processToolResults(content, timestamp));
+      } else {
+        accum.messages.push({
+          role: "user",
+          content: extractUserContent(content),
+          timestamp
+        });
+      }
+    } else {
+      accum.messages.push({
+        role: "user",
+        content: extractUserContent(content),
+        timestamp
+      });
+    }
+  } else if (type === "assistant") {
+    const model = typeof message.model === "string" ? message.model.trim() : undefined;
+    if (model)
+      accum.lastModel = model;
+    const content = message.content;
+    if (Array.isArray(content)) {
+      const msgs = processAssistantContent(content, timestamp, model, message.usage);
+      accum.messages.push(...msgs);
+    }
+    if (message.usage) {
+      accum.totalInputTokens += toNonNegInt(message.usage.input_tokens);
+      accum.totalOutputTokens += toNonNegInt(message.usage.output_tokens);
+      accum.totalCachedTokens += toNonNegInt(message.usage.cache_read_input_tokens);
+    }
+  }
+}
+function buildParseResult(accum, filePath) {
+  const startedAt = accum.startedAt ?? new Date().toISOString();
+  const lastMessageAt = accum.lastMessageAt ?? startedAt;
+  const durationMs = new Date(lastMessageAt).getTime() - new Date(startedAt).getTime();
+  const canonical = {
+    sessionKey: `claude:${accum.sessionId}`,
+    source: "claude-code",
+    parserRevision: PARSER_REVISION,
+    schemaVersion: SCHEMA_VERSION,
+    startedAt,
+    lastMessageAt,
+    durationSeconds: Math.max(0, Math.floor(durationMs / 1000)),
+    projectRef: extractProjectRef(filePath),
+    projectName: extractProjectName(filePath),
+    model: accum.lastModel,
+    title: generateTitle(extractProjectName(filePath), getFirstUserMessage(accum.messages)),
+    messages: accum.messages,
+    totalInputTokens: accum.totalInputTokens,
+    totalOutputTokens: accum.totalOutputTokens,
+    totalCachedTokens: accum.totalCachedTokens,
+    snapshotAt: new Date().toISOString()
+  };
+  const raw = {
+    sessionKey: `claude:${accum.sessionId}`,
+    source: "claude-code",
+    parserRevision: PARSER_REVISION,
+    collectedAt: new Date().toISOString(),
+    sourceFiles: [
+      {
+        path: filePath,
+        format: "jsonl",
+        content: accum.lines.join(`
+`)
+      }
+    ]
+  };
+  return { canonical, raw };
+}
+function extractProjectRef(filePath) {
+  const parts = filePath.split("/");
+  const projectsIdx = parts.lastIndexOf("projects");
+  if (projectsIdx < 0 || projectsIdx + 1 >= parts.length - 1)
+    return null;
+  const dirName = parts[projectsIdx + 1];
+  if (!dirName)
+    return null;
+  return hashProjectRef(dirName);
+}
+function extractProjectName(filePath) {
+  const parts = filePath.split("/");
+  const projectsIdx = parts.lastIndexOf("projects");
+  if (projectsIdx < 0 || projectsIdx + 1 >= parts.length - 1)
+    return null;
+  const dirName = parts[projectsIdx + 1];
+  if (!dirName)
+    return null;
+  return dirName.replace(/-/g, "/");
+}
+async function parseClaudeFileMulti(filePath, startOffset = 0) {
+  const st = await stat(filePath).catch(() => null);
+  if (!st || !st.isFile() || st.size === 0)
+    return [];
+  if (startOffset >= st.size)
+    return [];
+  const sessions = new Map;
+  const stream = createReadStream(filePath, {
+    encoding: "utf8",
+    start: 0
+  });
+  const rl = createInterface({ input: stream, crlfDelay: Infinity });
+  try {
+    for await (const line of rl) {
+      if (!line)
+        continue;
+      processLine(line, sessions);
+    }
+  } finally {
+    rl.close();
+    stream.destroy();
+  }
+  const results = [];
+  for (const accum of sessions.values()) {
+    if (accum.messages.length === 0)
+      continue;
+    results.push(buildParseResult(accum, filePath));
+  }
+  return results;
+}
+var init_claude = __esm(() => {
+  init_src();
+  init_hash_project_ref();
+});
+
+// src/drivers/session/claude.ts
+import { readdir, stat as stat2 } from "fs/promises";
+import { join as join3 } from "path";
+async function discoverClaudeFiles(claudeDir) {
+  const projectsDir = join3(claudeDir, "projects");
+  try {
+    await stat2(projectsDir);
+  } catch {
+    return [];
+  }
+  const results = [];
+  await walkJsonl(projectsDir, results);
+  return results;
+}
+async function walkJsonl(dir, results) {
+  let entries;
+  try {
+    entries = await readdir(dir, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  for (const entry of entries) {
+    const fullPath = join3(dir, entry.name);
+    if (entry.isDirectory()) {
+      await walkJsonl(fullPath, results);
+    } else if (entry.isFile() && entry.name.endsWith(".jsonl")) {
+      results.push(fullPath);
+    }
+  }
+}
+var claudeSessionDriver;
+var init_claude2 = __esm(() => {
+  init_claude();
+  claudeSessionDriver = {
+    source: "claude-code",
+    async discover(opts) {
+      if (!opts.claudeDir)
+        return [];
+      return discoverClaudeFiles(opts.claudeDir);
+    },
+    shouldSkip(cursor, fingerprint) {
+      return fileUnchanged(cursor, fingerprint);
+    },
+    resumeState(cursor, fingerprint) {
+      if (!cursor || cursor.inode !== fingerprint.inode) {
+        return { kind: "byte-offset", startOffset: 0 };
+      }
+      if (cursor.offset > fingerprint.size) {
+        return { kind: "byte-offset", startOffset: 0 };
+      }
+      return { kind: "byte-offset", startOffset: cursor.offset };
+    },
+    async parse(filePath, resume) {
+      return parseClaudeFileMulti(filePath, resume.startOffset);
+    },
+    buildCursor(fingerprint, _results) {
+      return {
+        inode: fingerprint.inode,
+        mtimeMs: fingerprint.mtimeMs,
+        size: fingerprint.size,
+        offset: fingerprint.size,
+        updatedAt: new Date().toISOString()
+      };
+    }
+  };
+});
+
+// src/parsers/codex.ts
+import { createReadStream as createReadStream2 } from "fs";
+import { stat as stat3 } from "fs/promises";
+import { basename } from "path";
+import { createInterface as createInterface2 } from "readline";
+function toNonNegInt2(value) {
+  if (typeof value !== "number" || !Number.isFinite(value) || value < 0)
+    return 0;
+  return Math.floor(value);
+}
+function extractSessionIdFromFilename(filePath) {
+  const name = basename(filePath);
+  const match = name.match(/^rollout-\d{4}-\d{2}-\d{2}T\d{2}-\d{2}-\d{2}-(.+)\.jsonl$/);
+  if (!match)
+    return null;
+  return match[1];
+}
+function extractProjectRef2(cwd) {
+  if (!cwd)
+    return null;
+  return hashProjectRef(cwd);
+}
+function extractProjectName2(cwd) {
+  if (!cwd)
+    return null;
+  const parts = cwd.split("/").filter(Boolean);
+  return parts.length > 0 ? parts[parts.length - 1] : null;
+}
+function extractContentFromBlocks(blocks) {
+  const parts = [];
+  for (const block of blocks) {
+    if (typeof block === "object" && block !== null && "text" in block && typeof block.text === "string") {
+      parts.push(block.text);
+    }
+  }
+  return parts.join(`
+`);
+}
+function processLine2(line, accum) {
+  let obj;
+  try {
+    obj = JSON.parse(line);
+  } catch {
+    return;
+  }
+  if (!obj || typeof obj.type !== "string")
+    return;
+  const timestamp = typeof obj.timestamp === "string" ? obj.timestamp : null;
+  accum.lines.push(line);
+  if (timestamp) {
+    if (!accum.startedAt || timestamp < accum.startedAt) {
+      accum.startedAt = timestamp;
+    }
+    if (!accum.lastMessageAt || timestamp > accum.lastMessageAt) {
+      accum.lastMessageAt = timestamp;
+    }
+  }
+  const payload = obj.payload;
+  if (!payload || typeof payload !== "object")
+    return;
+  switch (obj.type) {
+    case "session_meta":
+      processSessionMeta(payload, accum);
+      break;
+    case "turn_context":
+      processTurnContext(payload, accum);
+      break;
+    case "event_msg":
+      processEventMsg(payload, timestamp, accum);
+      break;
+    case "response_item":
+      processResponseItem(payload, timestamp, accum);
+      break;
+  }
+}
+function processSessionMeta(payload, accum) {
+  if (typeof payload.id === "string") {
+    accum.sessionId = payload.id;
+  }
+  if (typeof payload.cwd === "string") {
+    accum.cwd = payload.cwd;
+  }
+  if (typeof payload.timestamp === "string") {
+    if (!accum.startedAt || payload.timestamp < accum.startedAt) {
+      accum.startedAt = payload.timestamp;
+    }
+  }
+}
+function processTurnContext(payload, accum) {
+  if (typeof payload.model === "string") {
+    accum.lastModel = payload.model;
+  }
+  if (typeof payload.cwd === "string" && !accum.cwd) {
+    accum.cwd = payload.cwd;
+  }
+}
+function processEventMsg(payload, timestamp, accum) {
+  const subtype = payload.type;
+  if (typeof subtype !== "string")
+    return;
+  const ts = timestamp ?? new Date().toISOString();
+  switch (subtype) {
+    case "user_message": {
+      const message = typeof payload.message === "string" ? payload.message : null;
+      if (message) {
+        accum.messages.push({
+          role: "user",
+          content: message,
+          timestamp: ts
+        });
+      }
+      break;
+    }
+    case "agent_message": {
+      const message = typeof payload.message === "string" ? payload.message : null;
+      if (message) {
+        accum.messages.push({
+          role: "assistant",
+          content: message,
+          model: accum.lastModel ?? undefined,
+          timestamp: ts
+        });
+      }
+      break;
+    }
+    case "token_count": {
+      const info = payload.info;
+      if (info?.total_token_usage) {
+        const usage = info.total_token_usage;
+        accum.totalInputTokens = toNonNegInt2(usage.input_tokens);
+        accum.totalOutputTokens = toNonNegInt2(usage.output_tokens);
+        accum.totalCachedTokens = toNonNegInt2(usage.cached_input_tokens);
+      }
+      break;
+    }
+  }
+}
+function processResponseItem(payload, timestamp, accum) {
+  const subtype = payload.type;
+  if (typeof subtype !== "string")
+    return;
+  const ts = timestamp ?? new Date().toISOString();
+  switch (subtype) {
+    case "message": {
+      const role = payload.role;
+      const content = payload.content;
+      if (role === "user" || role === "assistant") {
+        let text = "";
+        if (Array.isArray(content)) {
+          text = extractContentFromBlocks(content);
+        } else if (typeof content === "string") {
+          text = content;
+        }
+        if (text) {
+          accum.messages.push({
+            role: role === "user" ? "user" : "assistant",
+            content: text,
+            model: role === "assistant" ? accum.lastModel ?? undefined : undefined,
+            timestamp: ts
+          });
+        }
+      }
+      break;
+    }
+    case "function_call": {
+      const name = typeof payload.name === "string" ? payload.name : undefined;
+      const args = typeof payload.arguments === "string" ? payload.arguments : undefined;
+      accum.messages.push({
+        role: "tool",
+        content: "",
+        toolName: name,
+        toolInput: args,
+        timestamp: ts
+      });
+      break;
+    }
+    case "function_call_output": {
+      const output = typeof payload.output === "string" ? payload.output : "";
+      accum.messages.push({
+        role: "tool",
+        content: output,
+        toolResult: output,
+        timestamp: ts
+      });
+      break;
+    }
+  }
+}
+function buildParseResult2(accum, filePath) {
+  const startedAt = accum.startedAt ?? new Date().toISOString();
+  const lastMessageAt = accum.lastMessageAt ?? startedAt;
+  const durationMs = new Date(lastMessageAt).getTime() - new Date(startedAt).getTime();
+  const sessionKey = `codex:${accum.sessionId}`;
+  const canonical = {
+    sessionKey,
+    source: "codex",
+    parserRevision: PARSER_REVISION,
+    schemaVersion: SCHEMA_VERSION,
+    startedAt,
+    lastMessageAt,
+    durationSeconds: Math.max(0, Math.floor(durationMs / 1000)),
+    projectRef: extractProjectRef2(accum.cwd),
+    projectName: extractProjectName2(accum.cwd),
+    model: accum.lastModel,
+    title: generateTitle(extractProjectName2(accum.cwd), getFirstUserMessage(accum.messages)),
+    messages: accum.messages,
+    totalInputTokens: accum.totalInputTokens,
+    totalOutputTokens: accum.totalOutputTokens,
+    totalCachedTokens: accum.totalCachedTokens,
+    snapshotAt: new Date().toISOString()
+  };
+  const raw = {
+    sessionKey,
+    source: "codex",
+    parserRevision: PARSER_REVISION,
+    collectedAt: new Date().toISOString(),
+    sourceFiles: [
+      {
+        path: filePath,
+        format: "jsonl",
+        content: accum.lines.join(`
+`)
+      }
+    ]
+  };
+  return { canonical, raw };
+}
+function buildEmptyResult(filePath) {
+  const now = new Date().toISOString();
+  const sessionId = extractSessionIdFromFilename(filePath) ?? "unknown";
+  const sessionKey = `codex:${sessionId}`;
+  return {
+    canonical: {
+      sessionKey,
+      source: "codex",
+      parserRevision: PARSER_REVISION,
+      schemaVersion: SCHEMA_VERSION,
+      startedAt: now,
+      lastMessageAt: now,
+      durationSeconds: 0,
+      projectRef: null,
+      projectName: null,
+      model: null,
+      title: null,
+      messages: [],
+      totalInputTokens: 0,
+      totalOutputTokens: 0,
+      totalCachedTokens: 0,
+      snapshotAt: now
+    },
+    raw: {
+      sessionKey,
+      source: "codex",
+      parserRevision: PARSER_REVISION,
+      collectedAt: now,
+      sourceFiles: [{ path: filePath, format: "jsonl", content: "" }]
+    }
+  };
+}
+async function parseCodexFile(filePath, startOffset = 0) {
+  const st = await stat3(filePath).catch(() => null);
+  if (!st || !st.isFile() || st.size === 0)
+    return buildEmptyResult(filePath);
+  if (startOffset >= st.size)
+    return buildEmptyResult(filePath);
+  const filenameId = extractSessionIdFromFilename(filePath) ?? "unknown";
+  const accum = {
+    sessionId: filenameId,
+    messages: [],
+    lines: [],
+    startedAt: null,
+    lastMessageAt: null,
+    lastModel: null,
+    cwd: null,
+    totalInputTokens: 0,
+    totalOutputTokens: 0,
+    totalCachedTokens: 0
+  };
+  const stream = createReadStream2(filePath, {
+    encoding: "utf8",
+    start: 0
+  });
+  const rl = createInterface2({ input: stream, crlfDelay: Infinity });
+  try {
+    for await (const line of rl) {
+      if (!line)
+        continue;
+      processLine2(line, accum);
+    }
+  } finally {
+    rl.close();
+    stream.destroy();
+  }
+  if (accum.messages.length === 0)
+    return buildEmptyResult(filePath);
+  return buildParseResult2(accum, filePath);
+}
+var init_codex = __esm(() => {
+  init_src();
+  init_hash_project_ref();
+});
+
+// src/drivers/session/codex.ts
+import { readdir as readdir2, stat as stat4 } from "fs/promises";
+import { join as join4 } from "path";
+async function walkFiltered(dir, results, filter) {
+  let entries;
+  try {
+    entries = await readdir2(dir, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  for (const entry of entries) {
+    const fullPath = join4(dir, entry.name);
+    if (entry.isDirectory()) {
+      await walkFiltered(fullPath, results, filter);
+    } else if (entry.isFile() && filter(entry.name)) {
+      results.push(fullPath);
+    }
+  }
+}
+async function discoverCodexFiles(codexSessionsDir) {
+  try {
+    await stat4(codexSessionsDir);
+  } catch {
+    return [];
+  }
+  const results = [];
+  await walkFiltered(codexSessionsDir, results, (name) => name.startsWith("rollout-") && name.endsWith(".jsonl"));
+  return results;
+}
+var codexSessionDriver;
+var init_codex2 = __esm(() => {
+  init_codex();
+  codexSessionDriver = {
+    source: "codex",
+    async discover(opts) {
+      if (!opts.codexSessionsDir)
+        return [];
+      return discoverCodexFiles(opts.codexSessionsDir);
+    },
+    shouldSkip(cursor, fingerprint) {
+      return fileUnchanged(cursor, fingerprint);
+    },
+    resumeState(cursor, fingerprint) {
+      if (!cursor || cursor.inode !== fingerprint.inode) {
+        return { kind: "codex", startOffset: 0, lastTotalTokens: 0, lastModel: null };
+      }
+      if (cursor.offset > fingerprint.size) {
+        return { kind: "codex", startOffset: 0, lastTotalTokens: 0, lastModel: null };
+      }
+      return {
+        kind: "codex",
+        startOffset: cursor.offset,
+        lastTotalTokens: cursor.lastTotalTokens,
+        lastModel: cursor.lastModel
+      };
+    },
+    async parse(filePath, resume) {
+      const result = await parseCodexFile(filePath, resume.startOffset);
+      return [result];
+    },
+    buildCursor(fingerprint, results) {
+      let lastTotalTokens = 0;
+      let lastModel = null;
+      if (results.length > 0) {
+        const session = results[0].canonical;
+        lastTotalTokens = session.totalInputTokens + session.totalOutputTokens;
+        lastModel = session.model;
+      }
+      return {
+        inode: fingerprint.inode,
+        mtimeMs: fingerprint.mtimeMs,
+        size: fingerprint.size,
+        offset: fingerprint.size,
+        lastTotalTokens,
+        lastModel,
+        updatedAt: new Date().toISOString()
+      };
+    }
+  };
+});
+
+// src/parsers/gemini.ts
+import { readFile as readFile2, stat as stat5 } from "fs/promises";
+function toNonNegInt3(value) {
+  if (typeof value !== "number" || !Number.isFinite(value) || value < 0)
+    return 0;
+  return Math.floor(value);
+}
+function extractUserContent2(content) {
+  if (!Array.isArray(content))
+    return "";
+  const parts = [];
+  for (const item of content) {
+    if (typeof item === "object" && item !== null && "text" in item && typeof item.text === "string") {
+      parts.push(item.text);
+    }
+  }
+  return parts.join(`
+`);
+}
+function extractProjectRef3(projectHash) {
+  if (!projectHash)
+    return null;
+  return hashProjectRef(projectHash);
+}
+function extractProjectName3(_projectHash) {
+  return null;
+}
+function processUserMessage(msg, accum) {
+  const text = extractUserContent2(msg.content);
+  if (!text)
+    return;
+  accum.messages.push({
+    role: "user",
+    content: text,
+    timestamp: msg.timestamp ?? new Date().toISOString()
+  });
+}
+function processGeminiMessage(msg, accum) {
+  const ts = msg.timestamp ?? new Date().toISOString();
+  if (typeof msg.model === "string") {
+    accum.lastModel = msg.model;
+  }
+  if (typeof msg.content === "string" && msg.content.length > 0) {
+    accum.messages.push({
+      role: "assistant",
+      content: msg.content,
+      model: msg.model ?? accum.lastModel ?? undefined,
+      timestamp: ts
+    });
+  }
+  if (Array.isArray(msg.toolCalls)) {
+    for (const tc of msg.toolCalls) {
+      processToolCall(tc, accum, ts);
+    }
+  }
+  if (msg.tokens) {
+    accum.totalInputTokens += toNonNegInt3(msg.tokens.input);
+    accum.totalOutputTokens += toNonNegInt3(msg.tokens.output);
+    accum.totalCachedTokens += toNonNegInt3(msg.tokens.cached);
+  }
+}
+function processToolCall(tc, accum, parentTs) {
+  const ts = tc.timestamp ?? parentTs;
+  const toolName = tc.name ?? tc.displayName;
+  accum.messages.push({
+    role: "tool",
+    content: "",
+    toolName: toolName ?? undefined,
+    toolInput: tc.args ? JSON.stringify(tc.args) : undefined,
+    timestamp: ts
+  });
+  if (Array.isArray(tc.result)) {
+    for (const item of tc.result) {
+      const output = item.functionResponse?.response?.output;
+      if (typeof output === "string") {
+        accum.messages.push({
+          role: "tool",
+          content: output,
+          toolName: toolName ?? undefined,
+          toolResult: output,
+          timestamp: ts
+        });
+      }
+    }
+  }
+}
+function buildParseResult3(session, accum, filePath, rawContent, sourceMessageCount) {
+  const sessionId = session.sessionId ?? "unknown";
+  const sessionKey = `gemini:${sessionId}`;
+  const startedAt = session.startTime ?? new Date().toISOString();
+  const lastMessageAt = session.lastUpdated ?? startedAt;
+  const durationMs = new Date(lastMessageAt).getTime() - new Date(startedAt).getTime();
+  const canonical = {
+    sessionKey,
+    source: "gemini-cli",
+    parserRevision: PARSER_REVISION,
+    schemaVersion: SCHEMA_VERSION,
+    startedAt,
+    lastMessageAt,
+    durationSeconds: Math.max(0, Math.floor(durationMs / 1000)),
+    projectRef: extractProjectRef3(session.projectHash),
+    projectName: extractProjectName3(session.projectHash),
+    model: accum.lastModel,
+    title: generateTitle(extractProjectName3(session.projectHash), getFirstUserMessage(accum.messages)),
+    messages: accum.messages,
+    totalInputTokens: accum.totalInputTokens,
+    totalOutputTokens: accum.totalOutputTokens,
+    totalCachedTokens: accum.totalCachedTokens,
+    snapshotAt: new Date().toISOString()
+  };
+  const raw = {
+    sessionKey,
+    source: "gemini-cli",
+    parserRevision: PARSER_REVISION,
+    collectedAt: new Date().toISOString(),
+    sourceFiles: [
+      {
+        path: filePath,
+        format: "json",
+        content: rawContent
+      }
+    ]
+  };
+  return { canonical, raw, sourceMessageCount };
+}
+function buildEmptyResult2(filePath) {
+  const now = new Date().toISOString();
+  const sessionKey = "gemini:unknown";
+  return {
+    canonical: {
+      sessionKey,
+      source: "gemini-cli",
+      parserRevision: PARSER_REVISION,
+      schemaVersion: SCHEMA_VERSION,
+      startedAt: now,
+      lastMessageAt: now,
+      durationSeconds: 0,
+      projectRef: null,
+      projectName: null,
+      model: null,
+      title: null,
+      messages: [],
+      totalInputTokens: 0,
+      totalOutputTokens: 0,
+      totalCachedTokens: 0,
+      snapshotAt: now
+    },
+    raw: {
+      sessionKey,
+      source: "gemini-cli",
+      parserRevision: PARSER_REVISION,
+      collectedAt: now,
+      sourceFiles: [{ path: filePath, format: "json", content: "" }]
+    },
+    sourceMessageCount: 0
+  };
+}
+async function parseGeminiFile(filePath, startIndex = 0) {
+  const st = await stat5(filePath).catch(() => null);
+  if (!st || !st.isFile() || st.size === 0)
+    return buildEmptyResult2(filePath);
+  let rawContent;
+  try {
+    rawContent = await readFile2(filePath, "utf8");
+  } catch {
+    return buildEmptyResult2(filePath);
+  }
+  let session;
+  try {
+    session = JSON.parse(rawContent);
+  } catch {
+    return buildEmptyResult2(filePath);
+  }
+  if (!session || typeof session !== "object")
+    return buildEmptyResult2(filePath);
+  const messages = session.messages;
+  if (!Array.isArray(messages) || messages.length === 0) {
+    return buildEmptyResult2(filePath);
+  }
+  if (startIndex >= messages.length)
+    return buildEmptyResult2(filePath);
+  const accum = {
+    messages: [],
+    totalInputTokens: 0,
+    totalOutputTokens: 0,
+    totalCachedTokens: 0,
+    lastModel: null
+  };
+  for (let i = 0;i < messages.length; i++) {
+    const msg = messages[i];
+    if (!msg || typeof msg !== "object" || typeof msg.type !== "string") {
+      continue;
+    }
+    switch (msg.type) {
+      case "user":
+        processUserMessage(msg, accum);
+        break;
+      case "gemini":
+        processGeminiMessage(msg, accum);
+        break;
+    }
+  }
+  if (accum.messages.length === 0)
+    return buildEmptyResult2(filePath);
+  return buildParseResult3(session, accum, filePath, rawContent, messages.length);
+}
+var init_gemini = __esm(() => {
+  init_src();
+  init_hash_project_ref();
+});
+
+// src/drivers/session/gemini.ts
+import { readdir as readdir3, stat as stat6 } from "fs/promises";
+import { join as join5 } from "path";
+async function discoverGeminiFiles(geminiDir) {
+  const tmpDir = join5(geminiDir, "tmp");
+  try {
+    await stat6(tmpDir);
+  } catch {
+    return [];
+  }
+  const results = [];
+  let projectDirs;
+  try {
+    projectDirs = await readdir3(tmpDir, { withFileTypes: true });
+  } catch {
+    return [];
+  }
+  for (const projEntry of projectDirs) {
+    if (!projEntry.isDirectory())
+      continue;
+    const chatsDir = join5(tmpDir, projEntry.name, "chats");
+    let chatFiles;
+    try {
+      chatFiles = await readdir3(chatsDir, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+    for (const chatEntry of chatFiles) {
+      if (chatEntry.isFile() && chatEntry.name.startsWith("session-") && chatEntry.name.endsWith(".json")) {
+        results.push(join5(chatsDir, chatEntry.name));
+      }
+    }
+  }
+  return results;
+}
+var geminiSessionDriver;
+var init_gemini2 = __esm(() => {
+  init_gemini();
+  geminiSessionDriver = {
+    source: "gemini-cli",
+    async discover(opts) {
+      if (!opts.geminiDir)
+        return [];
+      return discoverGeminiFiles(opts.geminiDir);
+    },
+    shouldSkip(cursor, fingerprint) {
+      return fileUnchanged(cursor, fingerprint);
+    },
+    resumeState(cursor, fingerprint) {
+      if (!cursor || cursor.inode !== fingerprint.inode) {
+        return {
+          kind: "array-index",
+          startIndex: 0,
+          lastTotalTokens: 0,
+          lastModel: null
+        };
+      }
+      if (cursor.size > fingerprint.size) {
+        return {
+          kind: "array-index",
+          startIndex: 0,
+          lastTotalTokens: 0,
+          lastModel: null
+        };
+      }
+      return {
+        kind: "array-index",
+        startIndex: cursor.messageIndex,
+        lastTotalTokens: cursor.lastTotalTokens,
+        lastModel: cursor.lastModel
+      };
+    },
+    async parse(filePath, resume) {
+      const result = await parseGeminiFile(filePath, resume.startIndex);
+      return [result];
+    },
+    buildCursor(fingerprint, results) {
+      let lastTotalTokens = 0;
+      let lastModel = null;
+      let messageIndex = 0;
+      if (results.length > 0) {
+        const session = results[0].canonical;
+        lastTotalTokens = session.totalInputTokens + session.totalOutputTokens;
+        lastModel = session.model;
+        const geminiResult = results[0];
+        messageIndex = geminiResult.sourceMessageCount;
+      }
+      return {
+        inode: fingerprint.inode,
+        mtimeMs: fingerprint.mtimeMs,
+        size: fingerprint.size,
+        messageIndex,
+        lastTotalTokens,
+        lastModel,
+        updatedAt: new Date().toISOString()
+      };
+    }
+  };
+});
+
+// src/parsers/opencode.ts
+import { readFile as readFile3, readdir as readdir4 } from "fs/promises";
+import { join as join6 } from "path";
+function toNonNegInt4(value) {
+  if (typeof value !== "number" || !Number.isFinite(value) || value < 0)
+    return 0;
+  return Math.floor(value);
+}
+function msToIso(ms) {
+  if (typeof ms !== "number" || !Number.isFinite(ms) || ms <= 0) {
+    return new Date().toISOString();
+  }
+  return new Date(ms).toISOString();
+}
+function extractProjectRef4(projectId) {
+  if (!projectId)
+    return null;
+  return hashProjectRef(projectId);
+}
+function extractProjectName4(directory) {
+  if (!directory || typeof directory !== "string")
+    return null;
+  return directory;
+}
+function processTextPart(part, role, model, ts, accum) {
+  if (!part.text || typeof part.text !== "string" || part.text.length === 0)
+    return;
+  if (part.synthetic)
+    return;
+  const canonicalRole = role === "user" ? "user" : "assistant";
+  accum.messages.push({
+    role: canonicalRole,
+    content: part.text,
+    model: canonicalRole === "assistant" ? model : undefined,
+    timestamp: ts
+  });
+}
+function processToolPart(part, ts, accum) {
+  if (!part.state)
+    return;
+  const toolName = part.tool ?? undefined;
+  const input = part.state.input ? JSON.stringify(part.state.input) : undefined;
+  if (part.state.status === "completed") {
+    const output = part.state.output ?? part.state.metadata?.output ?? "";
+    accum.messages.push({
+      role: "tool",
+      content: "",
+      toolName,
+      toolInput: input,
+      timestamp: ts
+    });
+    if (typeof output === "string" && output.length > 0) {
+      accum.messages.push({
+        role: "tool",
+        content: output,
+        toolName,
+        toolResult: output,
+        timestamp: ts
+      });
+    }
+  } else if (part.state.status === "running") {
+    accum.messages.push({
+      role: "tool",
+      content: "",
+      toolName,
+      toolInput: input,
+      timestamp: ts
+    });
+  }
+}
+function processMessage(msg, parts, accum) {
+  const ts = msToIso(msg.time?.created);
+  const role = msg.role;
+  if (role === "assistant" && typeof msg.modelID === "string") {
+    accum.lastModel = msg.modelID;
+  }
+  const model = msg.modelID ?? accum.lastModel ?? undefined;
+  for (const part of parts) {
+    if (!part || typeof part !== "object" || typeof part.type !== "string")
+      continue;
+    switch (part.type) {
+      case "text":
+        processTextPart(part, role, model, ts, accum);
+        break;
+      case "tool":
+        processToolPart(part, ts, accum);
+        break;
+    }
+  }
+  if (role === "assistant" && msg.tokens) {
+    accum.totalInputTokens += toNonNegInt4(msg.tokens.input);
+    accum.totalOutputTokens += toNonNegInt4(msg.tokens.output);
+    accum.totalCachedTokens += toNonNegInt4(msg.tokens.cache?.read);
+  }
+}
+function buildParseResult4(session, accum, rawContent, rawFormat, rawPath) {
+  const sessionKey = `opencode:${session.id}`;
+  const startedAt = msToIso(session.time?.created);
+  const lastMessageAt = msToIso(session.time?.updated);
+  const durationMs = new Date(lastMessageAt).getTime() - new Date(startedAt).getTime();
+  const canonical = {
+    sessionKey,
+    source: "opencode",
+    parserRevision: PARSER_REVISION,
+    schemaVersion: SCHEMA_VERSION,
+    startedAt,
+    lastMessageAt,
+    durationSeconds: Math.max(0, Math.floor(durationMs / 1000)),
+    projectRef: extractProjectRef4(session.projectID),
+    projectName: extractProjectName4(session.directory),
+    model: accum.lastModel,
+    title: session.title ?? null,
+    messages: accum.messages,
+    totalInputTokens: accum.totalInputTokens,
+    totalOutputTokens: accum.totalOutputTokens,
+    totalCachedTokens: accum.totalCachedTokens,
+    snapshotAt: new Date().toISOString()
+  };
+  const raw = {
+    sessionKey,
+    source: "opencode",
+    parserRevision: PARSER_REVISION,
+    collectedAt: new Date().toISOString(),
+    sourceFiles: [
+      {
+        path: rawPath,
+        format: rawFormat,
+        content: rawContent
+      }
+    ]
+  };
+  return { canonical, raw };
+}
+function buildEmptyResult3(sessionId, rawPath) {
+  const now = new Date().toISOString();
+  const sessionKey = `opencode:${sessionId}`;
+  return {
+    canonical: {
+      sessionKey,
+      source: "opencode",
+      parserRevision: PARSER_REVISION,
+      schemaVersion: SCHEMA_VERSION,
+      startedAt: now,
+      lastMessageAt: now,
+      durationSeconds: 0,
+      projectRef: null,
+      projectName: null,
+      model: null,
+      title: null,
+      messages: [],
+      totalInputTokens: 0,
+      totalOutputTokens: 0,
+      totalCachedTokens: 0,
+      snapshotAt: now
+    },
+    raw: {
+      sessionKey,
+      source: "opencode",
+      parserRevision: PARSER_REVISION,
+      collectedAt: now,
+      sourceFiles: [{ path: rawPath, format: "json", content: "" }]
+    }
+  };
+}
+async function loadJsonFileWithRaw(filePath) {
+  try {
+    const raw = await readFile3(filePath, "utf8");
+    return { parsed: JSON.parse(raw), raw };
+  } catch {
+    return null;
+  }
+}
+async function loadPartsForMessageWithRaw(partDir, messageId) {
+  const msgPartDir = join6(partDir, messageId);
+  let entries;
+  try {
+    entries = await readdir4(msgPartDir);
+  } catch {
+    return { parts: [], sourceFiles: [] };
+  }
+  const parts = [];
+  const sourceFiles = [];
+  for (const entry of entries.sort()) {
+    if (!entry.endsWith(".json"))
+      continue;
+    const filePath = join6(msgPartDir, entry);
+    const loaded = await loadJsonFileWithRaw(filePath);
+    if (loaded && typeof loaded.parsed.type === "string") {
+      parts.push(loaded.parsed);
+      sourceFiles.push({ path: filePath, format: "json", content: loaded.raw });
+    }
+  }
+  return { parts, sourceFiles };
+}
+function parseOpenCodeMessages(session, messages, rawFormat, rawPath) {
+  if (!messages || messages.length === 0) {
+    return buildEmptyResult3(session.id, rawPath);
+  }
+  const accum = {
+    messages: [],
+    totalInputTokens: 0,
+    totalOutputTokens: 0,
+    totalCachedTokens: 0,
+    lastModel: null
+  };
+  for (const msg of messages) {
+    if (!msg || typeof msg !== "object" || typeof msg.role !== "string")
+      continue;
+    const parts = msg.parts ?? [];
+    processMessage(msg, parts, accum);
+  }
+  if (accum.messages.length === 0) {
+    return buildEmptyResult3(session.id, rawPath);
+  }
+  const rawContent = JSON.stringify(messages);
+  return buildParseResult4(session, accum, rawContent, rawFormat, rawPath);
+}
+async function parseOpenCodeJsonSession(sessionJsonPath, messageDir, partDir) {
+  const sessionLoaded = await loadJsonFileWithRaw(sessionJsonPath);
+  if (!sessionLoaded || typeof sessionLoaded.parsed !== "object" || !sessionLoaded.parsed.id) {
+    return buildEmptyResult3("unknown", sessionJsonPath);
+  }
+  const session = sessionLoaded.parsed;
+  const rawSourceFiles = [
+    { path: sessionJsonPath, format: "json", content: sessionLoaded.raw }
+  ];
+  const sessionMsgDir = join6(messageDir, session.id);
+  let msgEntries;
+  try {
+    msgEntries = await readdir4(sessionMsgDir);
+  } catch {
+    return buildEmptyResult3(session.id, sessionJsonPath);
+  }
+  const messages = [];
+  for (const entry of msgEntries.sort()) {
+    if (!entry.endsWith(".json"))
+      continue;
+    const msgPath = join6(sessionMsgDir, entry);
+    const msgLoaded = await loadJsonFileWithRaw(msgPath);
+    if (!msgLoaded || typeof msgLoaded.parsed.role !== "string")
+      continue;
+    const msg = msgLoaded.parsed;
+    rawSourceFiles.push({ path: msgPath, format: "json", content: msgLoaded.raw });
+    const partsResult = await loadPartsForMessageWithRaw(partDir, msg.id);
+    msg.parts = partsResult.parts;
+    rawSourceFiles.push(...partsResult.sourceFiles);
+    messages.push(msg);
+  }
+  messages.sort((a, b) => (a.time?.created ?? 0) - (b.time?.created ?? 0));
+  const result = parseOpenCodeMessages(session, messages, "json", sessionJsonPath);
+  result.raw.sourceFiles = rawSourceFiles;
+  return result;
+}
+function parseOpenCodeSqliteSession(session, messages, dbPath, rawSourceFiles) {
+  const result = parseOpenCodeMessages(session, messages, "sqlite-export", dbPath);
+  if (rawSourceFiles && rawSourceFiles.length > 0) {
+    result.raw.sourceFiles = rawSourceFiles;
+  }
+  return result;
+}
+var init_opencode = __esm(() => {
+  init_src();
+  init_hash_project_ref();
+});
+
+// src/drivers/session/opencode.ts
+import { readdir as readdir5, stat as stat8 } from "fs/promises";
+import { join as join7, dirname as dirname2, basename as basename2 } from "path";
+async function discoverOpenCodeJsonFiles(messageDir, ctx, inodeToFilePath) {
+  const storageDir = dirname2(messageDir);
+  const sessionDir = join7(storageDir, "session");
+  try {
+    await stat8(sessionDir);
+  } catch {
+    return [];
+  }
+  let projectDirs;
+  try {
+    projectDirs = await readdir5(sessionDir, { withFileTypes: true });
+  } catch {
+    return [];
+  }
+  const results = [];
+  const msgDirMtimes = {};
+  for (const projEntry of projectDirs) {
+    if (!projEntry.isDirectory())
+      continue;
+    const projDir = join7(sessionDir, projEntry.name);
+    let sessionFiles;
+    try {
+      sessionFiles = await readdir5(projDir, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+    for (const fileEntry of sessionFiles) {
+      if (fileEntry.isFile() && fileEntry.name.startsWith("ses_") && fileEntry.name.endsWith(".json")) {
+        const filePath = join7(projDir, fileEntry.name);
+        results.push(filePath);
+        if (inodeToFilePath) {
+          try {
+            const fileStat = await stat8(filePath);
+            inodeToFilePath.set(fileStat.ino, filePath);
+          } catch {}
+        }
+        const sessionId = basename2(fileEntry.name, ".json");
+        const sessionMsgDir = join7(messageDir, sessionId);
+        try {
+          const msgStat = await stat8(sessionMsgDir);
+          msgDirMtimes[filePath] = msgStat.mtimeMs;
+        } catch {}
+      }
+    }
+  }
+  if (ctx) {
+    ctx.openCodeMsgDirMtimes = msgDirMtimes;
+  }
+  return results;
+}
+function createOpenCodeJsonDriver(syncCtx) {
+  const inodeToFilePath = new Map;
+  return {
+    source: "opencode",
+    async discover(opts) {
+      if (!opts.openCodeMessageDir)
+        return [];
+      inodeToFilePath.clear();
+      return discoverOpenCodeJsonFiles(opts.openCodeMessageDir, syncCtx, inodeToFilePath);
+    },
+    shouldSkip(cursor, fingerprint) {
+      if (!fileUnchanged(cursor, fingerprint))
+        return false;
+      if (cursor && syncCtx?.openCodeMsgDirMtimes) {
+        const filePath = inodeToFilePath.get(fingerprint.inode);
+        if (filePath) {
+          const currentMsgMtime = syncCtx.openCodeMsgDirMtimes[filePath];
+          if (cursor.messageDirMtimeMs === undefined)
+            return false;
+          if (currentMsgMtime !== undefined && currentMsgMtime !== cursor.messageDirMtimeMs) {
+            return false;
+          }
+          if (cursor.messageDirMtimeMs === undefined && currentMsgMtime !== undefined) {
+            return false;
+          }
+        }
+      }
+      return true;
+    },
+    resumeState(_cursor, _fingerprint) {
+      return { kind: "opencode-json" };
+    },
+    async parse(filePath, _resume) {
+      const sessionDir = dirname2(filePath);
+      const projectSessionDir = dirname2(sessionDir);
+      const storageDir = dirname2(projectSessionDir);
+      const messageDir = join7(storageDir, "message");
+      const partDir = join7(storageDir, "part");
+      const result = await parseOpenCodeJsonSession(filePath, messageDir, partDir);
+      if (syncCtx) {
+        if (!syncCtx.openCodeSessionState) {
+          syncCtx.openCodeSessionState = new Map;
+        }
+        syncCtx.openCodeSessionState.set(result.canonical.sessionKey, {
+          lastMessageAt: result.canonical.lastMessageAt,
+          totalMessages: result.canonical.messages.length
+        });
+      }
+      return [result];
+    },
+    buildCursor(fingerprint, _results) {
+      const filePath = inodeToFilePath.get(fingerprint.inode);
+      const messageDirMtimeMs = filePath && syncCtx?.openCodeMsgDirMtimes ? syncCtx.openCodeMsgDirMtimes[filePath] : undefined;
+      return {
+        inode: fingerprint.inode,
+        mtimeMs: fingerprint.mtimeMs,
+        size: fingerprint.size,
+        messageDirMtimeMs,
+        updatedAt: new Date().toISOString()
+      };
+    }
+  };
+}
+var init_opencode2 = __esm(() => {
+  init_opencode();
+});
+
+// src/parsers/vscode-copilot.ts
+import { readFile as readFile4, stat as stat9 } from "fs/promises";
+import { dirname as dirname3, join as join8 } from "path";
+function toNonNegInt5(value) {
+  if (typeof value !== "number" || !Number.isFinite(value) || value < 0)
+    return 0;
+  return Math.floor(value);
+}
+function normalizeTimestamp(value) {
+  if (typeof value === "string") {
+    const d = new Date(value);
+    return Number.isNaN(d.getTime()) ? null : value;
+  }
+  if (typeof value === "number" && Number.isFinite(value) && value > 0) {
+    return new Date(value).toISOString();
+  }
+  return null;
+}
+function applySnapshot(op, state) {
+  const v = op.v;
+  if (!v || typeof v !== "object")
+    return;
+  if (typeof v.sessionId === "string") {
+    state.sessionId = v.sessionId;
+  }
+  if (typeof v.creationDate === "string") {
+    state.creationDate = v.creationDate;
+  }
+  if (typeof v.customTitle === "string") {
+    state.customTitle = v.customTitle;
+  }
+  if (Array.isArray(v.requests)) {
+    for (const req of v.requests) {
+      if (req && typeof req === "object") {
+        state.requests.push(normalizeRequest(req));
+      }
+    }
+  }
+  const inputState = v.inputState;
+  if (inputState && typeof inputState.selectedModel === "string") {
+    state.selectedModel = inputState.selectedModel;
+  }
+}
+function normalizeRequest(raw) {
+  return {
+    requestId: typeof raw.requestId === "string" ? raw.requestId : undefined,
+    timestamp: typeof raw.timestamp === "number" ? raw.timestamp : undefined,
+    modelId: typeof raw.modelId === "string" ? raw.modelId : undefined,
+    message: raw.message,
+    response: Array.isArray(raw.response) ? raw.response : [],
+    result: raw.result,
+    modelState: raw.modelState
+  };
+}
+function applySet(op, state) {
+  const k = op.k;
+  if (!Array.isArray(k) || k.length === 0)
+    return;
+  if (k.length === 1 && k[0] === "customTitle") {
+    if (typeof op.v === "string") {
+      state.customTitle = op.v;
+    }
+    return;
+  }
+  if (k.length === 2 && k[0] === "inputState" && k[1] === "selectedModel") {
+    if (typeof op.v === "string") {
+      state.selectedModel = op.v;
+    }
+    return;
+  }
+  if (k.length === 3 && k[0] === "requests" && typeof k[1] === "number") {
+    const idx = k[1];
+    if (idx < 0 || idx >= state.requests.length)
+      return;
+    const field = k[2];
+    if (field === "result") {
+      state.requests[idx].result = op.v;
+    } else if (field === "modelState") {
+      state.requests[idx].modelState = op.v;
+    }
+    return;
+  }
+}
+function applyAppend(op, state) {
+  const k = op.k;
+  if (!Array.isArray(k) || k.length === 0)
+    return;
+  if (k.length === 1 && k[0] === "requests") {
+    if (op.v && typeof op.v === "object" && !Array.isArray(op.v)) {
+      state.requests.push(normalizeRequest(op.v));
+    }
+    return;
+  }
+  if (k.length === 3 && k[0] === "requests" && typeof k[1] === "number" && k[2] === "response") {
+    const idx = k[1];
+    if (idx < 0 || idx >= state.requests.length)
+      return;
+    const req = state.requests[idx];
+    if (!req.response)
+      req.response = [];
+    if (op.v && typeof op.v === "object") {
+      req.response.push(op.v);
+    }
+    return;
+  }
+}
+function replayCrdt(ops) {
+  const state = {
+    sessionId: null,
+    creationDate: null,
+    customTitle: null,
+    selectedModel: null,
+    requests: []
+  };
+  for (const op of ops) {
+    switch (op.kind) {
+      case 0:
+        applySnapshot(op, state);
+        break;
+      case 1:
+        applySet(op, state);
+        break;
+      case 2:
+        applyAppend(op, state);
+        break;
+    }
+  }
+  return state;
+}
+function extractRequestMessages(req, fallbackModel, accum) {
+  const ts = req.timestamp ? new Date(req.timestamp).toISOString() : new Date().toISOString();
+  const model = req.modelId ?? fallbackModel ?? undefined;
+  if (req.modelId)
+    accum.lastModel = req.modelId;
+  const userText = req.message?.text;
+  if (typeof userText === "string" && userText.length > 0) {
+    accum.messages.push({
+      role: "user",
+      content: userText,
+      timestamp: ts
+    });
+  }
+  if (Array.isArray(req.response)) {
+    const textParts = [];
+    for (const chunk of req.response) {
+      if (!chunk || typeof chunk !== "object")
+        continue;
+      if (chunk.kind === "thinking") {
+        continue;
+      }
+      if (chunk.kind === "toolInvocationSerialized") {
+        if (textParts.length > 0) {
+          accum.messages.push({
+            role: "assistant",
+            content: textParts.join(""),
+            model,
+            timestamp: ts
+          });
+          textParts.length = 0;
+        }
+        accum.messages.push({
+          role: "tool",
+          content: "",
+          toolName: typeof chunk.toolId === "string" ? chunk.toolId : undefined,
+          toolInput: typeof chunk.invocationMessage === "string" ? chunk.invocationMessage : undefined,
+          timestamp: ts
+        });
+        if (typeof chunk.result === "string" && chunk.result.length > 0) {
+          accum.messages.push({
+            role: "tool",
+            content: chunk.result,
+            toolName: typeof chunk.toolId === "string" ? chunk.toolId : undefined,
+            toolResult: chunk.result,
+            timestamp: ts
+          });
+        }
+        continue;
+      }
+      if (typeof chunk.value === "string") {
+        textParts.push(chunk.value);
+      }
+    }
+    if (textParts.length > 0) {
+      accum.messages.push({
+        role: "assistant",
+        content: textParts.join(""),
+        model,
+        timestamp: ts
+      });
+    }
+  }
+  if (req.result?.metadata) {
+    accum.totalInputTokens += toNonNegInt5(req.result.metadata.promptTokens);
+    accum.totalOutputTokens += toNonNegInt5(req.result.metadata.outputTokens);
+  }
+}
+async function extractWorkspaceFolder(sessionFilePath) {
+  try {
+    const chatSessionsDir = dirname3(sessionFilePath);
+    const workspaceDir = dirname3(chatSessionsDir);
+    const workspaceJsonPath = join8(workspaceDir, "workspace.json");
+    const content = await readFile4(workspaceJsonPath, "utf8");
+    const data = JSON.parse(content);
+    if (typeof data?.folder === "string") {
+      const folder = data.folder.replace(/^file:\/\//, "");
+      return decodeURIComponent(folder) || null;
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+function extractProjectRef5(folder) {
+  if (!folder)
+    return null;
+  return hashProjectRef(folder);
+}
+function extractProjectName5(folder) {
+  if (!folder)
+    return null;
+  const parts = folder.split("/").filter(Boolean);
+  return parts.length > 0 ? parts[parts.length - 1] : null;
+}
+function buildParseResult5(state, accum, filePath, rawContent, workspaceFolder) {
+  const sessionId = state.sessionId ?? "unknown";
+  const sessionKey = `copilot:${sessionId}`;
+  let startedAt;
+  let lastMessageAt;
+  if (state.creationDate) {
+    startedAt = state.creationDate;
+  } else if (state.requests.length > 0 && state.requests[0].timestamp) {
+    startedAt = new Date(state.requests[0].timestamp).toISOString();
+  } else {
+    startedAt = new Date().toISOString();
+  }
+  const lastReq = state.requests[state.requests.length - 1];
+  const normalizedCompletedAt = normalizeTimestamp(lastReq?.modelState?.completedAt);
+  if (normalizedCompletedAt) {
+    lastMessageAt = normalizedCompletedAt;
+  } else if (lastReq?.timestamp) {
+    lastMessageAt = new Date(lastReq.timestamp).toISOString();
+  } else {
+    lastMessageAt = startedAt;
+  }
+  const durationMs = new Date(lastMessageAt).getTime() - new Date(startedAt).getTime();
+  const canonical = {
+    sessionKey,
+    source: "vscode-copilot",
+    parserRevision: PARSER_REVISION,
+    schemaVersion: SCHEMA_VERSION,
+    startedAt,
+    lastMessageAt,
+    durationSeconds: Math.max(0, Math.floor(durationMs / 1000)),
+    projectRef: extractProjectRef5(workspaceFolder),
+    projectName: extractProjectName5(workspaceFolder),
+    model: accum.lastModel ?? state.selectedModel,
+    title: state.customTitle,
+    messages: accum.messages,
+    totalInputTokens: accum.totalInputTokens,
+    totalOutputTokens: accum.totalOutputTokens,
+    totalCachedTokens: 0,
+    snapshotAt: new Date().toISOString()
+  };
+  const raw = {
+    sessionKey,
+    source: "vscode-copilot",
+    parserRevision: PARSER_REVISION,
+    collectedAt: new Date().toISOString(),
+    sourceFiles: [
+      {
+        path: filePath,
+        format: "jsonl",
+        content: rawContent
+      }
+    ]
+  };
+  return { canonical, raw };
+}
+function buildEmptyResult4(filePath) {
+  const now = new Date().toISOString();
+  const sessionKey = "copilot:unknown";
+  return {
+    canonical: {
+      sessionKey,
+      source: "vscode-copilot",
+      parserRevision: PARSER_REVISION,
+      schemaVersion: SCHEMA_VERSION,
+      startedAt: now,
+      lastMessageAt: now,
+      durationSeconds: 0,
+      projectRef: null,
+      projectName: null,
+      model: null,
+      title: null,
+      messages: [],
+      totalInputTokens: 0,
+      totalOutputTokens: 0,
+      totalCachedTokens: 0,
+      snapshotAt: now
+    },
+    raw: {
+      sessionKey,
+      source: "vscode-copilot",
+      parserRevision: PARSER_REVISION,
+      collectedAt: now,
+      sourceFiles: [{ path: filePath, format: "jsonl", content: "" }]
+    }
+  };
+}
+function parseCrdtOps(content) {
+  const ops = [];
+  const lines = content.split(`
+`);
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed)
+      continue;
+    try {
+      const parsed = JSON.parse(trimmed);
+      if (typeof parsed?.kind === "number") {
+        ops.push(parsed);
+      }
+    } catch {}
+  }
+  return ops;
+}
+function extractMessages(state, processedIds = new Set) {
+  const accum = {
+    messages: [],
+    totalInputTokens: 0,
+    totalOutputTokens: 0,
+    lastModel: state.selectedModel
+  };
+  const newRequestIds = [];
+  for (const req of state.requests) {
+    const id = req.requestId;
+    extractRequestMessages(req, state.selectedModel, accum);
+    if (id && !processedIds.has(id))
+      newRequestIds.push(id);
+  }
+  return { accum, newRequestIds };
+}
+async function parseVscodeCopilotFile(filePath, startOffset = 0, processedRequestIds = [], workspaceFolder = null) {
+  const st = await stat9(filePath).catch(() => null);
+  if (!st || !st.isFile() || st.size === 0)
+    return { ...buildEmptyResult4(filePath), newRequestIds: [] };
+  if (startOffset >= st.size)
+    return { ...buildEmptyResult4(filePath), newRequestIds: [] };
+  let rawContent;
+  try {
+    rawContent = await readFile4(filePath, "utf8");
+  } catch {
+    return { ...buildEmptyResult4(filePath), newRequestIds: [] };
+  }
+  const ops = parseCrdtOps(rawContent);
+  if (ops.length === 0)
+    return { ...buildEmptyResult4(filePath), newRequestIds: [] };
+  const state = replayCrdt(ops);
+  if (state.requests.length === 0)
+    return { ...buildEmptyResult4(filePath), newRequestIds: [] };
+  const processedSet = new Set(processedRequestIds);
+  const { accum, newRequestIds } = extractMessages(state, processedSet);
+  if (accum.messages.length === 0)
+    return { ...buildEmptyResult4(filePath), newRequestIds: [] };
+  const folder = workspaceFolder ?? await extractWorkspaceFolder(filePath);
+  return { ...buildParseResult5(state, accum, filePath, rawContent, folder), newRequestIds };
+}
+var init_vscode_copilot = __esm(() => {
+  init_src();
+  init_hash_project_ref();
+});
+
+// src/drivers/session/vscode-copilot.ts
+import { readdir as readdir6 } from "fs/promises";
+import { join as join9 } from "path";
+async function collectJsonl(dir) {
+  let entries;
+  try {
+    entries = await readdir6(dir, { withFileTypes: true });
+  } catch {
+    return [];
+  }
+  const results = [];
+  for (const entry of entries) {
+    if (entry.isFile() && entry.name.endsWith(".jsonl")) {
+      results.push(join9(dir, entry.name));
+    }
+  }
+  return results;
+}
+async function discoverInBaseDir(baseDir) {
+  const results = [];
+  const wsDir = join9(baseDir, "workspaceStorage");
+  try {
+    const wsDirEntries = await readdir6(wsDir, { withFileTypes: true });
+    for (const entry of wsDirEntries) {
+      if (!entry.isDirectory())
+        continue;
+      const chatDir = join9(wsDir, entry.name, "chatSessions");
+      const files = await collectJsonl(chatDir);
+      results.push(...files);
+    }
+  } catch {}
+  const globalDir = join9(baseDir, "globalStorage", "emptyWindowChatSessions");
+  const globalFiles = await collectJsonl(globalDir);
+  results.push(...globalFiles);
+  return results;
+}
+var lastNewRequestIds, lastProcessedRequestIds, vscodeCopilotSessionDriver;
+var init_vscode_copilot2 = __esm(() => {
+  init_vscode_copilot();
+  lastNewRequestIds = [];
+  lastProcessedRequestIds = [];
+  vscodeCopilotSessionDriver = {
+    source: "vscode-copilot",
+    async discover(opts) {
+      if (!opts.vscodeCopilotDirs || opts.vscodeCopilotDirs.length === 0) {
+        return [];
+      }
+      const results = [];
+      for (const baseDir of opts.vscodeCopilotDirs) {
+        const files = await discoverInBaseDir(baseDir);
+        results.push(...files);
+      }
+      return results;
+    },
+    shouldSkip(cursor, fingerprint) {
+      return fileUnchanged(cursor, fingerprint);
+    },
+    resumeState(cursor, fingerprint) {
+      if (!cursor || cursor.inode !== fingerprint.inode) {
+        return { kind: "vscode-copilot", startOffset: 0, processedRequestIds: [] };
+      }
+      if (cursor.offset > fingerprint.size) {
+        return { kind: "vscode-copilot", startOffset: 0, processedRequestIds: [] };
+      }
+      return {
+        kind: "vscode-copilot",
+        startOffset: cursor.offset,
+        processedRequestIds: cursor.processedRequestIds
+      };
+    },
+    async parse(filePath, resume) {
+      const workspaceFolder = await extractWorkspaceFolder(filePath);
+      const result = await parseVscodeCopilotFile(filePath, resume.startOffset, resume.processedRequestIds, workspaceFolder);
+      lastNewRequestIds = result.newRequestIds;
+      lastProcessedRequestIds = resume.processedRequestIds;
+      if (result.canonical.messages.length === 0)
+        return [];
+      return [result];
+    },
+    buildCursor(fingerprint, _results) {
+      const allIds = [...lastProcessedRequestIds, ...lastNewRequestIds];
+      return {
+        inode: fingerprint.inode,
+        mtimeMs: fingerprint.mtimeMs,
+        size: fingerprint.size,
+        offset: fingerprint.size,
+        processedRequestIds: allIds,
+        updatedAt: new Date().toISOString()
+      };
+    }
+  };
+});
+
+// src/drivers/registry.ts
+import { stat as stat11 } from "fs/promises";
+import { homedir } from "os";
+import { join as join10 } from "path";
+function resolveDefaultPaths(home) {
+  const h = home ?? homedir();
+  return {
+    claudeDir: join10(h, ".claude"),
+    codexSessionsDir: join10(h, ".codex", "sessions"),
+    geminiDir: join10(h, ".gemini"),
+    openCodeDir: join10(h, ".local", "share", "opencode"),
+    vscodeCopilotDirs: [
+      join10(h, "Library", "Application Support", "Code", "User"),
+      join10(h, "Library", "Application Support", "Code - Insiders", "User")
+    ]
+  };
+}
+async function exists(path) {
+  try {
+    await stat11(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function buildDriverSet(overrides, syncCtx, sourceFilter) {
+  const paths = { ...resolveDefaultPaths(), ...overrides };
+  const [
+    claudeExists,
+    codexExists,
+    geminiExists,
+    openCodeExists,
+    openCodeDbExists,
+    ...vscodeDirExists
+  ] = await Promise.all([
+    exists(paths.claudeDir),
+    exists(paths.codexSessionsDir),
+    exists(paths.geminiDir),
+    exists(paths.openCodeDir),
+    exists(join10(paths.openCodeDir, "opencode.db")),
+    ...paths.vscodeCopilotDirs.map((d) => exists(d))
+  ]);
+  const discoverOpts = {};
+  if (claudeExists)
+    discoverOpts.claudeDir = paths.claudeDir;
+  if (codexExists)
+    discoverOpts.codexSessionsDir = paths.codexSessionsDir;
+  if (geminiExists)
+    discoverOpts.geminiDir = paths.geminiDir;
+  if (openCodeExists) {
+    discoverOpts.openCodeMessageDir = join10(paths.openCodeDir, "storage", "message");
+  }
+  if (openCodeDbExists) {
+    discoverOpts.openCodeDbPath = join10(paths.openCodeDir, "opencode.db");
+  }
+  const activeVscodeDirs = paths.vscodeCopilotDirs.filter((_, i) => vscodeDirExists[i]);
+  if (activeVscodeDirs.length > 0) {
+    discoverOpts.vscodeCopilotDirs = activeVscodeDirs;
+  }
+  const allowed = (source) => !sourceFilter || sourceFilter.has(source);
+  const fileDrivers = [];
+  if (claudeExists && allowed("claude-code"))
+    fileDrivers.push(claudeSessionDriver);
+  if (codexExists && allowed("codex"))
+    fileDrivers.push(codexSessionDriver);
+  if (geminiExists && allowed("gemini-cli"))
+    fileDrivers.push(geminiSessionDriver);
+  if (openCodeExists && allowed("opencode"))
+    fileDrivers.push(createOpenCodeJsonDriver(syncCtx));
+  if (activeVscodeDirs.length > 0 && allowed("vscode-copilot")) {
+    fileDrivers.push(vscodeCopilotSessionDriver);
+  }
+  return {
+    fileDrivers,
+    dbDriversAvailable: openCodeDbExists && allowed("opencode"),
+    discoverOpts,
+    paths
+  };
+}
+var init_registry = __esm(() => {
+  init_claude2();
+  init_codex2();
+  init_gemini2();
+  init_opencode2();
+  init_vscode_copilot2();
+});
+
+// src/drivers/session/opencode-sqlite.ts
+import { stat as stat12 } from "fs/promises";
+function shouldSkipForJson(sessionKey, sqliteLastMessageAt, sqliteTotalMessages, jsonState) {
+  if (!jsonState)
+    return false;
+  const info = jsonState.get(sessionKey);
+  if (!info)
+    return false;
+  return info.lastMessageAt >= sqliteLastMessageAt && info.totalMessages >= sqliteTotalMessages;
+}
+function querySessions(db) {
+  const rows = db.prepare("SELECT * FROM session ORDER BY rowid").all();
+  const sessions = [];
+  const rawRows = [];
+  for (const row of rows) {
+    if (!row.id)
+      continue;
+    const session = {
+      id: row.id,
+      projectID: row.project_id,
+      directory: row.directory,
+      title: row.title,
+      time: {
+        created: row.time_created,
+        updated: row.time_updated
+      }
+    };
+    sessions.push(session);
+    rawRows.push(row);
+  }
+  return { sessions, rawRows };
+}
+function queryMessagesForSession(db, sessionId, watermark, lastMessageIds) {
+  let rows;
+  if (watermark) {
+    rows = db.prepare("SELECT id, session_id, data, time_created FROM message WHERE session_id = ? AND time_created >= ? ORDER BY time_created").all(sessionId, watermark);
+  } else {
+    rows = db.prepare("SELECT id, session_id, data, time_created FROM message WHERE session_id = ? ORDER BY time_created").all(sessionId);
+  }
+  const messages = [];
+  for (const row of rows) {
+    if (lastMessageIds?.has(row.id))
+      continue;
+    try {
+      const data = JSON.parse(row.data);
+      if (!data || typeof data.role !== "string")
+        continue;
+      if (!data.id)
+        data.id = row.id;
+      messages.push(data);
+    } catch {
+      continue;
+    }
+  }
+  return messages;
+}
+function queryAllMessagesForSession(db, sessionId) {
+  const rows = db.prepare("SELECT id, session_id, data, time_created FROM message WHERE session_id = ? ORDER BY time_created").all(sessionId);
+  const messages = [];
+  const rawDataStrings = [];
+  for (const row of rows) {
+    try {
+      const data = JSON.parse(row.data);
+      if (!data || typeof data.role !== "string")
+        continue;
+      if (!data.id)
+        data.id = row.id;
+      messages.push(data);
+      rawDataStrings.push(row.data);
+    } catch {
+      continue;
+    }
+  }
+  return { messages, rawDataStrings };
+}
+function queryPartsForMessageWithRaw(db, messageId) {
+  const rows = db.prepare("SELECT data, message_id FROM part WHERE message_id = ? ORDER BY rowid").all(messageId);
+  const parts = [];
+  const rawDataStrings = [];
+  for (const row of rows) {
+    try {
+      const data = JSON.parse(row.data);
+      if (!data || typeof data.type !== "string")
+        continue;
+      parts.push(data);
+      rawDataStrings.push(row.data);
+    } catch {
+      continue;
+    }
+  }
+  return { parts, rawDataStrings };
+}
+function buildRawSourceFiles(session, sessionRow, messageRawStrings, messageIds, partRawStrings, dbPath) {
+  const files = [];
+  files.push({
+    path: `${dbPath}#session/${session.id}`,
+    format: "sqlite-export",
+    content: JSON.stringify(sessionRow)
+  });
+  for (let i = 0;i < messageIds.length; i++) {
+    const msgId = messageIds[i];
+    files.push({
+      path: `${dbPath}#message/${msgId}`,
+      format: "sqlite-export",
+      content: messageRawStrings[i]
+    });
+    const partStrings = partRawStrings.get(msgId);
+    if (partStrings) {
+      for (let j = 0;j < partStrings.length; j++) {
+        files.push({
+          path: `${dbPath}#part/${msgId}/${j}`,
+          format: "sqlite-export",
+          content: partStrings[j]
+        });
+      }
+    }
+  }
+  return files;
+}
+function createOpenCodeSqliteDriver(openDb, dbPath) {
+  return {
+    source: "opencode",
+    async run(prevCursor, ctx) {
+      let dbStat;
+      try {
+        dbStat = await stat12(dbPath);
+      } catch {
+        return {
+          results: [],
+          cursor: prevCursor ?? {
+            inode: 0,
+            lastTimeCreated: "",
+            lastMessageIds: [],
+            updatedAt: new Date().toISOString()
+          },
+          rowCount: 0
+        };
+      }
+      const inodeMatch = prevCursor && prevCursor.inode === dbStat.ino;
+      const watermark = inodeMatch ? prevCursor.lastTimeCreated || null : null;
+      const prevMessageIds = inodeMatch && prevCursor.lastMessageIds ? new Set(prevCursor.lastMessageIds) : null;
+      let db;
+      try {
+        db = openDb(dbPath, { readonly: true });
+      } catch {
+        return {
+          results: [],
+          cursor: prevCursor ?? {
+            inode: dbStat.ino,
+            lastTimeCreated: "",
+            lastMessageIds: [],
+            updatedAt: new Date().toISOString()
+          },
+          rowCount: 0
+        };
+      }
+      try {
+        const { sessions, rawRows: sessionRawRows } = querySessions(db);
+        const results = [];
+        let totalRows = 0;
+        let maxTimeCreated = watermark ?? "";
+        for (let si = 0;si < sessions.length; si++) {
+          const session = sessions[si];
+          const sessionRawRow = sessionRawRows[si];
+          const newMessages = queryMessagesForSession(db, session.id, watermark, prevMessageIds);
+          totalRows += newMessages.length;
+          if (newMessages.length === 0 && watermark) {
+            continue;
+          }
+          const { messages: allMessages, rawDataStrings: messageRawStrings } = queryAllMessagesForSession(db, session.id);
+          const messageIds = [];
+          const partRawMap = new Map;
+          for (const msg of allMessages) {
+            const { parts, rawDataStrings: partRawStrings } = queryPartsForMessageWithRaw(db, msg.id);
+            msg.parts = parts;
+            messageIds.push(msg.id);
+            if (partRawStrings.length > 0) {
+              partRawMap.set(msg.id, partRawStrings);
+            }
+          }
+          const rawSourceFiles = buildRawSourceFiles(session, sessionRawRow, messageRawStrings, messageIds, partRawMap, dbPath);
+          const result = parseOpenCodeSqliteSession(session, allMessages, dbPath, rawSourceFiles);
+          const sessionKey = result.canonical.sessionKey;
+          if (shouldSkipForJson(sessionKey, result.canonical.lastMessageAt, result.canonical.messages.length, ctx.openCodeSessionState)) {
+            continue;
+          }
+          results.push(result);
+          if (!ctx.openCodeSessionState) {
+            ctx.openCodeSessionState = new Map;
+          }
+          ctx.openCodeSessionState.set(sessionKey, {
+            lastMessageAt: result.canonical.lastMessageAt,
+            totalMessages: result.canonical.messages.length
+          });
+          for (const msg of newMessages) {
+            const tc = msg.time?.created;
+            if (typeof tc === "number" && tc > 0) {
+              const iso = new Date(tc).toISOString();
+              if (iso > maxTimeCreated) {
+                maxTimeCreated = iso;
+              }
+            }
+          }
+        }
+        const boundaryIds = [];
+        if (maxTimeCreated) {
+          for (const session of sessions) {
+            const rows = db.prepare("SELECT id FROM message WHERE session_id = ? AND time_created = ?").all(session.id, maxTimeCreated);
+            for (const row of rows) {
+              boundaryIds.push(row.id);
+            }
+          }
+        }
+        const newCursor = {
+          inode: dbStat.ino,
+          lastTimeCreated: maxTimeCreated,
+          lastMessageIds: boundaryIds,
+          updatedAt: new Date().toISOString()
+        };
+        return { results, cursor: newCursor, rowCount: totalRows };
+      } finally {
+        try {
+          db.close();
+        } catch {}
+      }
+    }
+  };
+}
+var init_opencode_sqlite = __esm(() => {
+  init_opencode();
+});
+
+// src/upload/engine.ts
+import { createHash as createHash2 } from "crypto";
+function sha256(input) {
+  return createHash2("sha256").update(input, "utf-8").digest("hex");
+}
+function toSessionSnapshot(canonical, raw) {
+  const canonicalJson = JSON.stringify(canonical);
+  const rawJson = JSON.stringify(raw);
+  const contentHash = sha256(canonicalJson);
+  const rawHash = sha256(rawJson);
+  let userMessages = 0;
+  let assistantMessages = 0;
+  for (const msg of canonical.messages) {
+    if (msg.role === "user")
+      userMessages++;
+    else if (msg.role === "assistant")
+      assistantMessages++;
+  }
+  const snapshot = {
+    sessionKey: canonical.sessionKey,
+    source: canonical.source,
+    startedAt: canonical.startedAt,
+    lastMessageAt: canonical.lastMessageAt,
+    durationSeconds: canonical.durationSeconds,
+    userMessages,
+    assistantMessages,
+    totalMessages: canonical.messages.length,
+    totalInputTokens: canonical.totalInputTokens,
+    totalOutputTokens: canonical.totalOutputTokens,
+    totalCachedTokens: canonical.totalCachedTokens,
+    projectRef: canonical.projectRef,
+    projectName: canonical.projectName,
+    model: canonical.model,
+    title: canonical.title,
+    contentHash,
+    rawHash,
+    parserRevision: canonical.parserRevision,
+    schemaVersion: canonical.schemaVersion,
+    snapshotAt: canonical.snapshotAt
+  };
+  return {
+    snapshot,
+    precomputed: { canonicalJson, rawJson, contentHash, rawHash }
+  };
+}
+function splitBatches(items, size) {
+  const batches = [];
+  for (let i = 0;i < items.length; i += size) {
+    batches.push(items.slice(i, i + size));
+  }
+  return batches;
+}
+function defaultSleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function parseRetryAfter(value) {
+  if (!value)
+    return INITIAL_BACKOFF_MS;
+  const seconds = parseInt(value, 10);
+  if (!isNaN(seconds) && seconds >= 0) {
+    return seconds * 1000;
+  }
+  const date = new Date(value);
+  if (!isNaN(date.getTime())) {
+    const ms = date.getTime() - Date.now();
+    return Math.max(0, ms);
+  }
+  return INITIAL_BACKOFF_MS;
+}
+async function uploadBatch(snapshots, opts) {
+  const fetchFn = opts.fetch ?? globalThis.fetch;
+  const sleepFn = opts.sleep ?? defaultSleep;
+  const url = `${opts.apiUrl}/api/ingest/sessions`;
+  let lastStatus = 0;
+  for (let attempt = 0;attempt <= MAX_UPLOAD_RETRIES; attempt++) {
+    const response = await fetchFn(url, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${opts.apiKey}`
+      },
+      body: JSON.stringify({ userId: opts.userId, sessions: snapshots })
+    });
+    lastStatus = response.status;
+    if (response.ok) {
+      const body = await response.json();
+      return { ingested: body.ingested, conflicts: 0, errors: [] };
+    }
+    if (response.status === 401) {
+      throw new AuthError;
+    }
+    if (response.status === 409) {
+      const body = await response.json();
+      return {
+        ingested: 0,
+        conflicts: body.conflicts?.length ?? snapshots.length,
+        errors: []
+      };
+    }
+    if (response.status === 429) {
+      const retryAfter = parseRetryAfter(response.headers.get("Retry-After"));
+      await sleepFn(retryAfter);
+      continue;
+    }
+    if (response.status >= 400 && response.status < 500) {
+      const body = await response.text();
+      throw new ClientError(response.status, body);
+    }
+    if (response.status >= 500) {
+      if (attempt < MAX_UPLOAD_RETRIES) {
+        const backoff = INITIAL_BACKOFF_MS * Math.pow(2, attempt);
+        await sleepFn(backoff);
+        continue;
+      }
+    }
+  }
+  throw new RetryExhaustedError(lastStatus, MAX_UPLOAD_RETRIES + 1);
+}
+async function uploadMetadataBatches(snapshots, opts) {
+  if (snapshots.length === 0) {
+    return { totalIngested: 0, totalConflicts: 0, totalBatches: 0, errors: [] };
+  }
+  const batches = splitBatches(snapshots, METADATA_BATCH_SIZE);
+  const result = {
+    totalIngested: 0,
+    totalConflicts: 0,
+    totalBatches: batches.length,
+    errors: []
+  };
+  let nextIndex = 0;
+  async function worker() {
+    while (true) {
+      const idx = nextIndex++;
+      if (idx >= batches.length)
+        break;
+      const batchResult = await uploadBatch(batches[idx], opts);
+      result.totalIngested += batchResult.ingested;
+      result.totalConflicts += batchResult.conflicts;
+      result.errors.push(...batchResult.errors);
+    }
+  }
+  const workers = Array.from({ length: Math.min(METADATA_BATCH_CONCURRENCY, batches.length) }, () => worker());
+  await Promise.all(workers);
+  return result;
+}
+var AuthError, RetryExhaustedError, ClientError, METADATA_BATCH_CONCURRENCY = 4;
+var init_engine = __esm(() => {
+  init_src();
+  AuthError = class AuthError extends Error {
+    constructor(message = "API key invalid or expired. Run: pika login --force") {
+      super(message);
+      this.name = "AuthError";
+    }
+  };
+  RetryExhaustedError = class RetryExhaustedError extends Error {
+    statusCode;
+    attempts;
+    constructor(statusCode, attempts) {
+      super(`Upload failed after ${attempts} attempts (last status: ${statusCode})`);
+      this.statusCode = statusCode;
+      this.attempts = attempts;
+      this.name = "RetryExhaustedError";
+    }
+  };
+  ClientError = class ClientError extends Error {
+    statusCode;
+    body;
+    constructor(statusCode, body) {
+      super(`Upload failed with status ${statusCode}: ${body}`);
+      this.statusCode = statusCode;
+      this.body = body;
+      this.name = "ClientError";
+    }
+  };
+});
+
+// src/upload/content.ts
+import { gzip } from "zlib";
+import { promisify } from "util";
+async function gzipCompress(input) {
+  return gzipAsync(Buffer.from(input, "utf-8"));
+}
+function defaultSleep2(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function putWithRetry(url, body, headers, opts) {
+  const fetchFn = opts.fetch ?? globalThis.fetch;
+  const sleepFn = opts.sleep ?? defaultSleep2;
+  let lastStatus = 0;
+  for (let attempt = 0;attempt <= MAX_UPLOAD_RETRIES; attempt++) {
+    const response = await fetchFn(url, {
+      method: "PUT",
+      headers: {
+        "Content-Type": "application/octet-stream",
+        "Content-Encoding": "gzip",
+        Authorization: `Bearer ${opts.apiKey}`,
+        ...headers
+      },
+      body
+    });
+    lastStatus = response.status;
+    if (response.status === 200 || response.status === 201) {
+      return { uploaded: true };
+    }
+    if (response.status === 204) {
+      return { uploaded: false };
+    }
+    if (response.status === 401) {
+      throw new AuthError;
+    }
+    if (response.status === 409) {
+      const text = await response.text();
+      throw new ClientError(409, text);
+    }
+    if (response.status === 429) {
+      const retryAfter = parseRetryAfter(response.headers.get("Retry-After"));
+      await sleepFn(retryAfter);
+      continue;
+    }
+    if (response.status >= 400 && response.status < 500) {
+      const text = await response.text();
+      throw new ClientError(response.status, text);
+    }
+    if (response.status >= 500) {
+      if (attempt < MAX_UPLOAD_RETRIES) {
+        const backoff = INITIAL_BACKOFF_MS * Math.pow(2, attempt);
+        await sleepFn(backoff);
+        continue;
+      }
+    }
+  }
+  throw new RetryExhaustedError(lastStatus, MAX_UPLOAD_RETRIES + 1);
+}
+async function requestPresignedUrl(sessionKey, rawHash, opts) {
+  const fetchFn = opts.fetch ?? globalThis.fetch;
+  const response = await fetchFn(`${opts.apiUrl}/api/ingest/presign`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${opts.apiKey}`
+    },
+    body: JSON.stringify({ sessionKey, rawHash })
+  });
+  if (response.status === 401)
+    throw new AuthError;
+  if (!response.ok) {
+    const text = await response.text();
+    throw new ClientError(response.status, text);
+  }
+  const data = await response.json();
+  if (!data.url || !data.key) {
+    throw new ClientError(response.status, "Invalid presign response: missing url or key");
+  }
+  return data;
+}
+async function uploadToPresignedUrl(presignedUrl, body, opts) {
+  const fetchFn = opts.fetch ?? globalThis.fetch;
+  const sleepFn = opts.sleep ?? defaultSleep2;
+  let lastStatus = 0;
+  for (let attempt = 0;attempt <= MAX_UPLOAD_RETRIES; attempt++) {
+    const response = await fetchFn(presignedUrl, {
+      method: "PUT",
+      headers: {
+        "Content-Type": "application/gzip"
+      },
+      body
+    });
+    lastStatus = response.status;
+    if (response.status === 200 || response.status === 201) {
+      return;
+    }
+    if (response.status >= 500) {
+      if (attempt < MAX_UPLOAD_RETRIES) {
+        const backoff = INITIAL_BACKOFF_MS * Math.pow(2, attempt);
+        await sleepFn(backoff);
+        continue;
+      }
+    }
+    if (response.status >= 400 && response.status < 500) {
+      const text = await response.text();
+      throw new ClientError(response.status, text);
+    }
+  }
+  throw new RetryExhaustedError(lastStatus, MAX_UPLOAD_RETRIES + 1);
+}
+async function confirmRawUpload(sessionKey, rawHash, rawSize, opts) {
+  const fetchFn = opts.fetch ?? globalThis.fetch;
+  const response = await fetchFn(`${opts.apiUrl}/api/ingest/confirm-raw`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${opts.apiKey}`
+    },
+    body: JSON.stringify({ sessionKey, rawHash, rawSize })
+  });
+  if (response.status === 401)
+    throw new AuthError;
+  if (!response.ok) {
+    const text = await response.text();
+    throw new ClientError(response.status, text);
+  }
+}
+async function uploadRawDirect(sessionKey, rawHash, rawGzip, opts) {
+  const presign = await requestPresignedUrl(sessionKey, rawHash, opts);
+  await uploadToPresignedUrl(presign.url, rawGzip, opts);
+  await confirmRawUpload(sessionKey, rawHash, rawGzip.length, opts);
+  return true;
+}
+async function uploadSessionContent(canonical, raw, opts, precomputed) {
+  const canonicalJson = precomputed?.canonicalJson ?? JSON.stringify(canonical);
+  const rawJson = precomputed?.rawJson ?? JSON.stringify(raw);
+  const contentHash = precomputed?.contentHash ?? sha256(canonicalJson);
+  const rawHash = precomputed?.rawHash ?? sha256(rawJson);
+  const [canonicalGzip, rawGzip] = await Promise.all([
+    gzipCompress(canonicalJson),
+    gzipCompress(rawJson)
+  ]);
+  const sessionKey = encodeURIComponent(canonical.sessionKey);
+  const canonicalPromise = putWithRetry(`${opts.apiUrl}/api/ingest/content/${sessionKey}/canonical`, canonicalGzip, {
+    "X-Content-Hash": contentHash,
+    "X-Parser-Revision": String(canonical.parserRevision),
+    "X-Schema-Version": String(canonical.schemaVersion)
+  }, opts);
+  const rawPromise = (async () => {
+    try {
+      return await uploadRawDirect(canonical.sessionKey, rawHash, rawGzip, opts);
+    } catch (err) {
+      if (err instanceof AuthError)
+        throw err;
+      const rawResult = await putWithRetry(`${opts.apiUrl}/api/ingest/content/${sessionKey}/raw`, rawGzip, { "X-Raw-Hash": rawHash }, opts);
+      return rawResult.uploaded;
+    }
+  })();
+  const [canonicalResult, rawUploaded] = await Promise.all([
+    canonicalPromise,
+    rawPromise
+  ]);
+  return {
+    canonicalUploaded: canonicalResult.uploaded,
+    rawUploaded,
+    contentHash,
+    rawHash
+  };
+}
+async function uploadContentBatch(sessions, opts, concurrency = CONTENT_UPLOAD_CONCURRENCY) {
+  const result = {
+    uploaded: 0,
+    skipped: 0,
+    errors: []
+  };
+  if (sessions.length === 0)
+    return result;
+  let nextIndex = 0;
+  let authError = null;
+  async function worker() {
+    while (!authError) {
+      const idx = nextIndex++;
+      if (idx >= sessions.length)
+        break;
+      const { canonical, raw, precomputed } = sessions[idx];
+      try {
+        const contentResult = await uploadSessionContent(canonical, raw, opts, precomputed);
+        if (contentResult.canonicalUploaded || contentResult.rawUploaded) {
+          result.uploaded++;
+        } else {
+          result.skipped++;
+        }
+      } catch (err) {
+        if (err instanceof AuthError) {
+          authError = err;
+          return;
+        }
+        result.errors.push({
+          sessionKey: canonical.sessionKey,
+          error: err instanceof Error ? err.message : String(err)
+        });
+      }
+    }
+  }
+  const workers = Array.from({ length: Math.min(concurrency, sessions.length) }, () => worker());
+  await Promise.all(workers);
+  if (authError)
+    throw authError;
+  return result;
+}
+var gzipAsync;
+var init_content = __esm(() => {
+  init_src();
+  init_engine();
+  gzipAsync = promisify(gzip);
+});
+
+// src/commands/sync-pipeline.ts
+import { stat as stat13 } from "fs/promises";
+async function getFingerprint(filePath) {
+  const s = await stat13(filePath);
+  return {
+    inode: s.ino,
+    mtimeMs: s.mtimeMs,
+    size: s.size
+  };
+}
+async function runSyncPipeline(input, opts) {
+  const {
+    fileDrivers,
+    dbDriver,
+    discoverOpts,
+    syncCtx
+  } = input;
+  let cursorState = { ...input.cursorState, files: { ...input.cursorState.files } };
+  const allResults = [];
+  const parseErrors = [];
+  let totalFiles = 0;
+  let totalSkipped = 0;
+  const sessionKeyToFile = new Map;
+  const prevCursors = new Map;
+  const dbSourcedSessionKeys = new Set;
+  let prevDbCursor;
+  for (const driver of fileDrivers) {
+    const files = await driver.discover(discoverOpts);
+    for (const filePath of files) {
+      totalFiles++;
+      let fingerprint;
+      try {
+        fingerprint = await getFingerprint(filePath);
+      } catch {
+        continue;
+      }
+      const existingCursor = cursorState.files[filePath];
+      if (driver.shouldSkip(existingCursor, fingerprint)) {
+        totalSkipped++;
+        continue;
+      }
+      const resume = driver.resumeState(existingCursor, fingerprint);
+      try {
+        const results = await driver.parse(filePath, resume);
+        if (results.length > 0) {
+          allResults.push(...results);
+          prevCursors.set(filePath, cursorState.files[filePath]);
+          for (const r of results) {
+            sessionKeyToFile.set(r.canonical.sessionKey, filePath);
+          }
+          const newCursor = driver.buildCursor(fingerprint, results);
+          cursorState.files[filePath] = newCursor;
+        }
+      } catch (err) {
+        parseErrors.push({
+          timestamp: new Date().toISOString(),
+          source: driver.source,
+          filePath,
+          error: err instanceof Error ? err.message : String(err)
+        });
+      }
+    }
+  }
+  if (dbDriver) {
+    try {
+      prevDbCursor = cursorState.openCodeSqlite;
+      const dbResult = await dbDriver.run(prevDbCursor, syncCtx);
+      allResults.push(...dbResult.results);
+      for (const r of dbResult.results) {
+        dbSourcedSessionKeys.add(r.canonical.sessionKey);
+      }
+      cursorState.openCodeSqlite = dbResult.cursor;
+    } catch (err) {
+      parseErrors.push({
+        timestamp: new Date().toISOString(),
+        source: dbDriver.source,
+        filePath: discoverOpts.openCodeDbPath ?? "opencode.db",
+        error: err instanceof Error ? err.message : String(err)
+      });
+    }
+  }
+  cursorState.updatedAt = new Date().toISOString();
+  let uploadResult;
+  let contentResult;
+  if (opts.upload && allResults.length > 0) {
+    const transformed = allResults.map((r) => toSessionSnapshot(r.canonical, r.raw));
+    const snapshots = transformed.map((t) => t.snapshot);
+    const precomputedMap = new Map;
+    for (const t of transformed) {
+      precomputedMap.set(t.snapshot.sessionKey, t.precomputed);
+    }
+    const uploadOpts = {
+      apiUrl: opts.apiUrl,
+      apiKey: opts.apiKey,
+      userId: opts.userId,
+      fetch: opts.fetch,
+      sleep: opts.sleep
+    };
+    uploadResult = await uploadMetadataBatches(snapshots, uploadOpts);
+    const contentOpts = {
+      apiUrl: opts.apiUrl,
+      apiKey: opts.apiKey,
+      fetch: opts.fetch,
+      sleep: opts.sleep
+    };
+    contentResult = await uploadContentBatch(allResults.map((r) => ({
+      canonical: r.canonical,
+      raw: r.raw,
+      precomputed: precomputedMap.get(r.canonical.sessionKey)
+    })), contentOpts, opts.contentConcurrency);
+    if (contentResult.errors.length > 0) {
+      const rolledBackFiles = new Set;
+      let rollbackDbCursor = false;
+      for (const { sessionKey } of contentResult.errors) {
+        const filePath = sessionKeyToFile.get(sessionKey);
+        if (filePath && !rolledBackFiles.has(filePath)) {
+          rolledBackFiles.add(filePath);
+          const prev = prevCursors.get(filePath);
+          if (prev === undefined) {
+            delete cursorState.files[filePath];
+          } else {
+            cursorState.files[filePath] = prev;
+          }
+        }
+        if (dbSourcedSessionKeys.has(sessionKey)) {
+          rollbackDbCursor = true;
+        }
+      }
+      if (rollbackDbCursor) {
+        cursorState.openCodeSqlite = prevDbCursor;
+      }
+    }
+  }
+  return {
+    totalParsed: allResults.length,
+    totalFiles,
+    totalSkipped,
+    parseErrors,
+    uploadResult,
+    contentResult,
+    cursorState
+  };
+}
+var init_sync_pipeline = __esm(() => {
+  init_engine();
+  init_content();
+});
+
+// src/commands/sync.ts
+var exports_sync = {};
+__export(exports_sync, {
+  default: () => sync_default,
+  buildDbDriver: () => buildDbDriver
+});
+import { defineCommand } from "citty";
+import { join as join11 } from "path";
+import consola from "consola";
+async function buildDbDriver(driverSet, openDbOverride) {
+  if (!driverSet.dbDriversAvailable || !driverSet.discoverOpts.openCodeDbPath) {
+    return;
+  }
+  let openDb;
+  if (openDbOverride) {
+    openDb = openDbOverride;
+  } else {
+    const modId = "bun:sqlite";
+    const bunSqlite = await import(modId);
+    openDb = (path, opts) => new bunSqlite.Database(path, { readonly: opts?.readonly ?? true });
+  }
+  return createOpenCodeSqliteDriver(openDb, driverSet.discoverOpts.openCodeDbPath);
+}
+var sync_default;
+var init_sync = __esm(() => {
+  init_src();
+  init_manager();
+  init_cursor_store();
+  init_registry();
+  init_opencode_sqlite();
+  init_sync_pipeline();
+  sync_default = defineCommand({
+    meta: {
+      name: "sync",
+      description: "Parse local sessions and upload to Pika"
+    },
+    args: {
+      upload: {
+        type: "boolean",
+        default: true,
+        description: "Upload parsed sessions (default: true)"
+      },
+      dev: {
+        type: "boolean",
+        default: false,
+        description: "Use local dev server"
+      },
+      source: {
+        type: "string",
+        description: `Filter sources (comma-separated). Valid: ${SOURCES.join(", ")}`
+      }
+    },
+    async run({ args }) {
+      const isDev = args.dev;
+      const doUpload = args.upload;
+      let sourceFilter;
+      if (args.source) {
+        const requested = args.source.split(",").map((s) => s.trim());
+        const invalid = requested.filter((s) => !SOURCES.includes(s));
+        if (invalid.length > 0) {
+          consola.error(`Unknown source(s): ${invalid.join(", ")}. Valid: ${SOURCES.join(", ")}`);
+          process.exitCode = 1;
+          return;
+        }
+        sourceFilter = new Set(requested);
+        consola.info(`Filtering to source(s): ${requested.join(", ")}`);
+      }
+      const configDir = join11(process.env.HOME ?? process.env.USERPROFILE ?? "~", ".config", CONFIG_DIR);
+      const config = new ConfigManager(configDir, isDev);
+      if (doUpload && !config.isLoggedIn()) {
+        consola.error("Not logged in. Run: pika login");
+        process.exitCode = 1;
+        return;
+      }
+      const cursorStore = new CursorStore(configDir);
+      const cursorState = await cursorStore.load();
+      const syncCtx = {};
+      const driverSet = await buildDriverSet(undefined, syncCtx, sourceFilter);
+      if (driverSet.fileDrivers.length === 0 && !driverSet.dbDriversAvailable) {
+        consola.info("No AI tool sessions found");
+        return;
+      }
+      const dbDriver = await buildDbDriver(driverSet);
+      const sourceCount = driverSet.fileDrivers.length + (dbDriver ? 1 : 0);
+      consola.start(`Syncing ${sourceCount} source(s)...`);
+      const result = await runSyncPipeline({
+        fileDrivers: driverSet.fileDrivers,
+        dbDriver,
+        discoverOpts: driverSet.discoverOpts,
+        cursorState,
+        syncCtx
+      }, {
+        upload: doUpload,
+        apiUrl: config.getApiUrl(),
+        apiKey: config.getToken() ?? "",
+        userId: "cli"
+      });
+      await cursorStore.save(result.cursorState);
+      consola.success(`Parsed ${result.totalParsed} session(s) from ${result.totalFiles} file(s) (${result.totalSkipped} unchanged)`);
+      if (result.uploadResult) {
+        consola.success(`Uploaded ${result.uploadResult.totalIngested} session(s) in ${result.uploadResult.totalBatches} batch(es)`);
+        if (result.uploadResult.totalConflicts > 0) {
+          consola.warn(`${result.uploadResult.totalConflicts} session(s) had version conflicts (skipped)`);
+        }
+      }
+      if (result.contentResult) {
+        consola.success(`Content: ${result.contentResult.uploaded} uploaded, ${result.contentResult.skipped} skipped`);
+        if (result.contentResult.errors.length > 0) {
+          consola.warn(`${result.contentResult.errors.length} content upload error(s)`);
+        }
+      }
+      if (result.parseErrors.length > 0) {
+        consola.warn(`${result.parseErrors.length} parse error(s) in this run`);
+      }
+    }
+  });
+});
+
+// src/commands/login-flow.ts
+import http from "http";
+function performLogin(deps) {
+  return new Promise((resolve) => {
+    const { openBrowser, log, config, apiUrl, timeoutMs } = deps;
+    const server = http.createServer((req, res) => {
+      const url = new URL(req.url, `http://localhost`);
+      if (url.pathname !== "/callback") {
+        res.writeHead(404, { "Content-Type": "text/plain" });
+        res.end("Not found");
+        return;
+      }
+      const apiKey = url.searchParams.get("api_key");
+      const email = url.searchParams.get("email");
+      if (!apiKey) {
+        res.writeHead(400, { "Content-Type": "text/plain" });
+        res.end("Missing api_key");
+        cleanup();
+        resolve({ success: false, error: "No api_key received" });
+        return;
+      }
+      config.write({ token: apiKey });
+      res.writeHead(200, { "Content-Type": "text/html" });
+      res.end("<html><body><h1>Login successful!</h1><p>You can close this window.</p></body></html>");
+      cleanup();
+      resolve({ success: true, email: email || undefined });
+    });
+    server.listen(0, "127.0.0.1", () => {
+      const addr = server.address();
+      if (!addr || typeof addr === "string") {
+        cleanup();
+        resolve({ success: false, error: "Failed to start local server" });
+        return;
+      }
+      const callbackUrl = `http://127.0.0.1:${addr.port}/callback`;
+      const loginUrl = `${apiUrl}/api/auth/cli?callback=${encodeURIComponent(callbackUrl)}`;
+      openBrowser(loginUrl).catch(() => {
+        if (log) {
+          log(`Could not open browser. Open this URL manually:
+  ${loginUrl}`);
+        }
+      });
+    });
+    server.on("error", (err) => {
+      cleanup();
+      resolve({ success: false, error: `Local server error: ${err.message}` });
+    });
+    const timer = setTimeout(() => {
+      cleanup();
+      resolve({ success: false, error: "Login timeout \u2014 no response received" });
+    }, timeoutMs);
+    function cleanup() {
+      clearTimeout(timer);
+      server.close();
+    }
+  });
+}
+var init_login_flow = () => {};
+
+// src/commands/login.ts
+var exports_login = {};
+__export(exports_login, {
+  default: () => login_default
+});
+import { defineCommand as defineCommand2 } from "citty";
+import consola2 from "consola";
+import { join as join12 } from "path";
+import { homedir as homedir2, platform } from "os";
+function getBrowserCommand() {
+  switch (platform()) {
+    case "darwin":
+      return "open";
+    case "win32":
+      return "start";
+    default:
+      return "xdg-open";
+  }
+}
+var login_default;
+var init_login = __esm(() => {
+  init_src();
+  init_manager();
+  init_login_flow();
+  login_default = defineCommand2({
+    meta: {
+      name: "login",
+      description: "Connect CLI to dashboard via browser OAuth"
+    },
+    args: {
+      force: {
+        type: "boolean",
+        default: false,
+        description: "Force re-login even if already authenticated"
+      },
+      dev: {
+        type: "boolean",
+        default: false,
+        description: "Use local dev server"
+      }
+    },
+    async run({ args }) {
+      const configDir = join12(homedir2(), ".config", CONFIG_DIR);
+      const config = new ConfigManager(configDir, args.dev);
+      if (config.isLoggedIn() && !args.force) {
+        consola2.info("Already logged in. Use --force to re-authenticate.");
+        return;
+      }
+      consola2.start("Opening browser for authentication...");
+      const result = await performLogin({
+        openBrowser: async (url) => {
+          const { exec } = await import("child_process");
+          const cmd = getBrowserCommand();
+          return new Promise((resolve, reject) => {
+            exec(`${cmd} "${url}"`, (error) => {
+              if (error)
+                reject(error);
+              else
+                resolve();
+            });
+          });
+        },
+        log: (msg) => consola2.info(msg),
+        config,
+        apiUrl: config.getApiUrl(),
+        timeoutMs: LOGIN_TIMEOUT_MS
+      });
+      if (result.success) {
+        consola2.success(`Logged in as ${result.email || "unknown"}`);
+      } else {
+        consola2.error(result.error || "Login failed");
+      }
+    }
+  });
+});
+
+// src/commands/status-display.ts
+function inferSource(filePath) {
+  if (filePath.includes(".claude/"))
+    return "claude-code";
+  if (filePath.includes(".codex/"))
+    return "codex";
+  if (filePath.includes(".gemini/"))
+    return "gemini-cli";
+  if (filePath.includes("opencode/") || filePath.includes("opencode\\"))
+    return "opencode";
+  if (filePath.includes("workspaceStorage/") || filePath.includes("globalStorage/"))
+    return "vscode-copilot";
+  return null;
+}
+function formatTimeAgo(ms) {
+  if (ms < 0)
+    return "just now";
+  const seconds = Math.floor(ms / 1000);
+  if (seconds < 60)
+    return `${seconds}s ago`;
+  const minutes = Math.floor(seconds / 60);
+  if (minutes < 60)
+    return `${minutes}m ago`;
+  const hours = Math.floor(minutes / 60);
+  if (hours < 24)
+    return `${hours}h ago`;
+  const days = Math.floor(hours / 24);
+  return `${days}d ago`;
+}
+function buildStatus(input, now = new Date) {
+  const { loggedIn, cursorState, parseErrors } = input;
+  const lastSyncAt = cursorState.updatedAt;
+  let lastSyncAgo = null;
+  if (lastSyncAt) {
+    const elapsed = now.getTime() - new Date(lastSyncAt).getTime();
+    lastSyncAgo = formatTimeAgo(elapsed);
+  }
+  const sourceCounts = new Map;
+  for (const source of SOURCES) {
+    sourceCounts.set(source, 0);
+  }
+  for (const filePath of Object.keys(cursorState.files)) {
+    const source = inferSource(filePath);
+    if (source) {
+      sourceCounts.set(source, (sourceCounts.get(source) ?? 0) + 1);
+    }
+  }
+  const sourceStats = [];
+  for (const source of SOURCES) {
+    const count = sourceCounts.get(source) ?? 0;
+    if (count > 0) {
+      sourceStats.push({ source, fileCount: count });
+    }
+  }
+  const totalFiles = Object.keys(cursorState.files).length;
+  const hasOpenCodeDb = !!cursorState.openCodeSqlite;
+  return {
+    loggedIn,
+    lastSyncAt,
+    lastSyncAgo,
+    sourceStats,
+    totalFiles,
+    hasOpenCodeDb,
+    parseErrorCount: parseErrors.length,
+    recentErrors: parseErrors
+  };
+}
+function loadParseErrors(content) {
+  if (!content.trim())
+    return [];
+  const lines = content.trim().split(`
+`);
+  const errors = [];
+  for (const line of lines) {
+    if (!line.trim())
+      continue;
+    try {
+      const parsed = JSON.parse(line);
+      if (parsed.timestamp && parsed.source && parsed.error) {
+        errors.push(parsed);
+      }
+    } catch {}
+  }
+  return errors.slice(-MAX_RECENT_ERRORS).reverse();
+}
+function formatSourceLabel(source) {
+  const labels = {
+    "claude-code": "Claude Code",
+    codex: "Codex CLI",
+    "gemini-cli": "Gemini CLI",
+    opencode: "OpenCode",
+    "vscode-copilot": "VS Code Copilot"
+  };
+  return labels[source];
+}
+function formatStatusLines(output) {
+  const lines = [];
+  lines.push(output.loggedIn ? "Logged in: yes" : "Logged in: no");
+  if (output.lastSyncAt) {
+    lines.push(`Last sync: ${output.lastSyncAgo} (${output.lastSyncAt})`);
+  } else {
+    lines.push("Last sync: never");
+  }
+  if (output.sourceStats.length > 0 || output.hasOpenCodeDb) {
+    lines.push("");
+    lines.push("Sources:");
+    for (const s of output.sourceStats) {
+      lines.push(`  ${formatSourceLabel(s.source)}: ${s.fileCount} file(s)`);
+    }
+    if (output.hasOpenCodeDb) {
+      lines.push("  OpenCode (SQLite): active");
+    }
+    lines.push(`  Total tracked: ${output.totalFiles} file(s)`);
+  } else {
+    lines.push("");
+    lines.push("Sources: none tracked");
+  }
+  if (output.parseErrorCount > 0) {
+    lines.push("");
+    lines.push(`Parse errors: ${output.parseErrorCount}`);
+    for (const err of output.recentErrors) {
+      const ts = err.timestamp.slice(0, 19).replace("T", " ");
+      lines.push(`  [${ts}] ${err.source}: ${err.error}`);
+      if (err.filePath) {
+        lines.push(`    ${err.filePath}`);
+      }
+    }
+  }
+  return lines;
+}
+var MAX_RECENT_ERRORS = 5;
+var init_status_display = __esm(() => {
+  init_src();
+});
+
+// src/commands/status.ts
+var exports_status = {};
+__export(exports_status, {
+  default: () => status_default
+});
+import { defineCommand as defineCommand3 } from "citty";
+import { readFile as readFile5 } from "fs/promises";
+import { join as join13 } from "path";
+import consola3 from "consola";
+var status_default;
+var init_status = __esm(() => {
+  init_src();
+  init_manager();
+  init_cursor_store();
+  init_status_display();
+  status_default = defineCommand3({
+    meta: {
+      name: "status",
+      description: "Show sync status and session stats"
+    },
+    args: {
+      dev: {
+        type: "boolean",
+        default: false,
+        description: "Use local dev server"
+      }
+    },
+    async run({ args }) {
+      const isDev = args.dev;
+      const configDir = join13(process.env.HOME ?? process.env.USERPROFILE ?? "~", ".config", CONFIG_DIR);
+      const config = new ConfigManager(configDir, isDev);
+      const loggedIn = config.isLoggedIn();
+      const cursorStore = new CursorStore(configDir);
+      const cursorState = await cursorStore.load();
+      let parseErrors;
+      try {
+        const content = await readFile5(join13(configDir, PARSE_ERRORS_FILE), "utf-8");
+        parseErrors = loadParseErrors(content);
+      } catch {
+        parseErrors = [];
+      }
+      const output = buildStatus({ loggedIn, cursorState, parseErrors });
+      const lines = formatStatusLines(output);
+      for (const line of lines) {
+        if (line === "") {
+          consola3.log("");
+        } else {
+          consola3.log(line);
+        }
+      }
+    }
+  });
+});
+
+// src/bin.ts
+import { runMain } from "citty";
+
+// src/cli.ts
+init_src();
+import { defineCommand as defineCommand4 } from "citty";
+var main = defineCommand4({
+  meta: {
+    name: "pika",
+    version: PIKA_VERSION,
+    description: "Replay and search coding agent sessions"
+  },
+  subCommands: {
+    sync: () => Promise.resolve().then(() => (init_sync(), exports_sync)).then((m) => m.default),
+    login: () => Promise.resolve().then(() => (init_login(), exports_login)).then((m) => m.default),
+    status: () => Promise.resolve().then(() => (init_status(), exports_status)).then((m) => m.default)
+  }
+});
+
+// src/bin.ts
+runMain(main);