combobulator 0.1.0

package/src/commands/doctor.js

@@ -0,0 +1,119 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { execFileSync } from 'node:child_process';
+import { DatabaseSync } from 'node:sqlite';
+import { PATHS, HOME, LAUNCHD_LABEL } from '../config.js';
+import { loadState } from '../state.js';
+
+// Diagnose the combobulate setup end-to-end. Walks every moving piece and
+// prints OK / WARN / FAIL for each, plus a one-line "what to do" hint.
+//
+// Designed to be the first thing you run when "sync isn't working." Detects:
+//   - daemon not running
+//   - watched paths missing
+//   - epoch in the future (clock skew or fresh install)
+//   - state file inconsistency
+//   - broken mirror rows in Codex
+//   - the daemon log mentioning recent errors
+export async function doctor() {
+  const checks = [];
+  let ok = 0, warn = 0, fail = 0;
+
+  const add = (status, label, detail = '') => {
+    checks.push({ status, label, detail });
+    if (status === 'OK') ok++;
+    else if (status === 'WARN') warn++;
+    else fail++;
+  };
+
+  // 1. launchd agent
+  if (fs.existsSync(PATHS.launchdPlist)) {
+    let listed = '';
+    try { listed = execFileSync('launchctl', ['list'], { encoding: 'utf8' }); } catch {}
+    const row = listed.split('\n').find((l) => l.endsWith(LAUNCHD_LABEL));
+    if (row) {
+      const [pid] = row.trim().split(/\s+/);
+      if (pid !== '-' && Number.isFinite(Number(pid))) {
+        add('OK', 'daemon', `running, pid=${pid}`);
+      } else {
+        add('WARN', 'daemon', `loaded but not running — try: launchctl kickstart -k gui/$(id -u)/${LAUNCHD_LABEL}`);
+      }
+    } else {
+      add('FAIL', 'daemon', 'plist present but not loaded — try: combobulate install');
+    }
+  } else {
+    add('FAIL', 'daemon', 'not installed — run: combobulate install');
+  }
+
+  // 2. watched source paths
+  add(fs.existsSync(PATHS.claudeProjects) ? 'OK' : 'WARN', 'claude path', PATHS.claudeProjects);
+  add(fs.existsSync(PATHS.codexSessions)  ? 'OK' : 'WARN', 'codex path',  PATHS.codexSessions);
+  add(fs.existsSync(PATHS.cursorDb)       ? 'OK' : 'WARN', 'cursor path', PATHS.cursorDb);
+
+  // 3. state file
+  let state;
+  try {
+    state = loadState();
+    const mirrorCount = Object.keys(state.mirrors || {}).length;
+    const epoch = new Date(state.epoch);
+    const now = Date.now();
+    if (epoch.getTime() > now + 60000) {
+      add('WARN', 'epoch', `${epoch.toISOString()} is in the future — clock skew?`);
+    } else {
+      add('OK', 'epoch', `${epoch.toISOString()} (${mirrorCount} mirrors tracked)`);
+    }
+    const sources = {};
+    for (const k of Object.keys(state.mirrors || {})) {
+      const s = k.split('/')[0];
+      sources[s] = (sources[s] || 0) + 1;
+    }
+    add('OK', 'sources', Object.entries(sources).map(([k, v]) => `${k}:${v}`).join(', ') || '(none yet)');
+  } catch (e) {
+    add('FAIL', 'state file', `${PATHS.combobulateState}: ${e.message}`);
+  }
+
+  // 4. Codex thread-row health
+  const codexDb = path.join(HOME, '.codex', 'state_5.sqlite');
+  if (fs.existsSync(codexDb)) {
+    try {
+      const db = new DatabaseSync(codexDb);
+      const unknown = db.prepare(`SELECT COUNT(*) AS n FROM threads WHERE source='unknown' AND archived=0`).get();
+      if (unknown.n > 0) {
+        add('WARN', 'codex threads', `${unknown.n} row(s) flagged 'unknown' — run: combobulate cleanup`);
+      } else {
+        add('OK', 'codex threads', 'all rows look healthy');
+      }
+      db.close();
+    } catch (e) {
+      add('WARN', 'codex threads', `couldn't read state_5.sqlite: ${e.message}`);
+    }
+  } else {
+    add('OK', 'codex threads', '(Codex not installed)');
+  }
+
+  // 5. recent log errors
+  if (fs.existsSync(PATHS.combobulateLog)) {
+    try {
+      const tail = fs.readFileSync(PATHS.combobulateLog, 'utf8').split('\n').slice(-100);
+      const errors = tail.filter((l) => l.includes(' ERROR ')).slice(-3);
+      if (errors.length) {
+        add('WARN', 'recent log', `${errors.length} error(s) in last 100 lines — see ${PATHS.combobulateLog}`);
+      } else {
+        add('OK', 'recent log', 'no errors in last 100 lines');
+      }
+    } catch (e) {
+      add('WARN', 'recent log', e.message);
+    }
+  }
+
+  // print results
+  console.log('\ncombobulate doctor');
+  console.log('==================');
+  for (const c of checks) {
+    const tag = c.status === 'OK' ? '\x1b[32mOK  \x1b[0m' : c.status === 'WARN' ? '\x1b[33mWARN\x1b[0m' : '\x1b[31mFAIL\x1b[0m';
+    const pad = c.label.padEnd(16);
+    console.log(`  ${tag}  ${pad} ${c.detail}`);
+  }
+  console.log(`\n${ok} ok, ${warn} warn, ${fail} fail.`);
+  if (fail > 0) process.exitCode = 1;
+}

package/src/commands/fix-codex-projects.js

@@ -0,0 +1,164 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { PATHS } from '../config.js';
+import { info, warn } from '../log.js';
+import { registerCodexWorkspaceRoot } from '../codex-registry.js';
+import { upsertCodexThread } from '../codex-thread-db.js';
+
+// Walk every combobulate-mirrored rollout file and ensure it's wired up to
+// Codex Desktop's UI: a row in state_5.sqlite's `threads` table (so the chat
+// shows in the per-cwd sidebar) AND the cwd in the JSON workspace-roots list
+// (belt-and-suspenders for fresh installs). Idempotent.
+export async function fixCodexProjects() {
+  if (!fs.existsSync(PATHS.codexSessions)) {
+    info('no codex sessions directory; nothing to do.');
+    return;
+  }
+
+  const rollouts = [];
+  walk(PATHS.codexSessions, rollouts);
+
+  let mirrorCount = 0;
+  let threadsUpserted = 0;
+  const cwds = new Set();
+
+  for (const f of rollouts) {
+    let meta;
+    try {
+      meta = peek(f);
+    } catch { continue; }
+    if (!meta?.isMirror) continue;
+    mirrorCount++;
+
+    if (meta.cwd) cwds.add(meta.cwd);
+
+    if (meta.sessionId && meta.cwd) {
+      const stat = fs.statSync(f);
+      const ok = upsertCodexThread({
+        sessionId: meta.sessionId,
+        rolloutPath: f,
+        cwd: meta.cwd,
+        title: meta.title || 'Synced from combobulate',
+        firstUserMessage: meta.firstUserMessage || '',
+        createdAtMs: meta.createdAtMs || stat.birthtimeMs || stat.mtimeMs,
+        updatedAtMs: stat.mtimeMs,
+      });
+      if (ok) threadsUpserted++;
+    }
+  }
+
+  info(`scanned ${rollouts.length} rollout file(s); ${mirrorCount} are combobulate mirrors.`);
+  info(`upserted ${threadsUpserted} thread row(s) into Codex Desktop's DB.`);
+
+  // Register each cwd as a Codex Desktop workspace root via `codex app <path>`.
+  // This is what makes the project appear in Codex's sidebar persistently.
+  // Note: each call may briefly steal focus to Codex Desktop as it switches
+  // to the registered workspace. Cwds already in workspace-roots are skipped.
+  let registered = 0;
+  for (const cwd of cwds) {
+    if (await registerCodexWorkspaceRoot(cwd)) registered++;
+  }
+  if (registered) {
+    info(`registered ${registered} new Codex Desktop workspace root(s).`);
+  } else if (cwds.size) {
+    info(`all ${cwds.size} cwd(s) were already registered with Codex Desktop.`);
+  }
+}
+
+function walk(dir, out) {
+  let entries;
+  try { entries = fs.readdirSync(dir, { withFileTypes: true }); } catch { return; }
+  for (const e of entries) {
+    const full = path.join(dir, e.name);
+    if (e.isDirectory()) walk(full, out);
+    else if (e.isFile() && e.name.endsWith('.jsonl') && e.name.startsWith('rollout-')) {
+      out.push(full);
+    }
+  }
+}
+
+// Read the first few lines of a rollout to detect if it's our mirror and
+// pull out the metadata we stuffed in the marker line + session_meta payload.
+// For older mirrors that didn't store title/firstUserMessage in the marker,
+// fall back to parsing the flattened transcript on line 3 (the response_item
+// user message) for the first **User:** chunk.
+function peek(filePath) {
+  const fd = fs.openSync(filePath, 'r');
+  try {
+    // Read enough to capture the marker + session_meta + (often) the flattened
+    // transcript. 64KB is plenty for a small chat; long chats truncate and we
+    // just fall back to the generic title.
+    const buf = Buffer.alloc(64 * 1024);
+    const n = fs.readSync(fd, buf, 0, buf.length, 0);
+    const lines = buf.subarray(0, n).toString('utf8').split('\n');
+    let isMirror = false;
+    let cwd = null;
+    let sessionId = null;
+    let title = null;
+    let firstUserMessage = null;
+    let createdAtMs = null;
+    let flattenedText = null;
+    for (let i = 0; i < Math.min(lines.length, 5); i++) {
+      const line = lines[i];
+      if (!line) continue;
+      let d;
+      try { d = JSON.parse(line); } catch { continue; }
+      // Legacy top-level marker (pre-v0.2 rollouts)
+      if (d.__combobulate_mirror__) {
+        isMirror = true;
+        if (d.title) title = d.title;
+        if (d.firstUserMessage) firstUserMessage = d.firstUserMessage;
+        if (d.cwd && !cwd) cwd = d.cwd;
+      }
+      if (d.type === 'session_meta') {
+        if (d.payload?.originator === 'combobulate') isMirror = true;
+        if (d.payload?.cwd) cwd = d.payload.cwd;
+        if (d.payload?.id) sessionId = d.payload.id;
+        if (d.payload?.timestamp) createdAtMs = Date.parse(d.payload.timestamp);
+        // New marker location: nested under session_meta.payload.combobulate
+        const c = d.payload?.combobulate;
+        if (c?.__combobulate_mirror__) {
+          isMirror = true;
+          if (c.title && !title) title = c.title;
+          if (c.firstUserMessage && !firstUserMessage) firstUserMessage = c.firstUserMessage;
+        }
+      }
+      if (d.type === 'response_item' && d.payload?.role === 'user' && d.payload?.content?.[0]?.text) {
+        flattenedText = d.payload.content[0].text;
+      }
+    }
+    if (isMirror && (!title || !firstUserMessage) && flattenedText) {
+      const extracted = extractFirstUserLine(flattenedText);
+      if (extracted) {
+        if (!firstUserMessage) firstUserMessage = extracted.slice(0, 2000);
+        if (!title || title === 'Synced from combobulate') title = extracted.split('\n')[0].slice(0, 200);
+      }
+    }
+    return { isMirror, cwd, sessionId, title, firstUserMessage, createdAtMs };
+  } finally {
+    fs.closeSync(fd);
+  }
+}
+
+// The flattened transcript looks like:
+//   [Synced from claude via combobulate]
+//   ... header ...
+//   ---
+//   **User:** <first message body — may span multiple lines until the next \n\n>
+//
+//   **Assistant:** ...
+// Iterate every **User:** chunk and return the first that looks like a real
+// human prompt — not a tool result, not an IDE injection.
+function extractFirstUserLine(text) {
+  const re = /\*\*User:\*\*\s+([\s\S]*?)(?=\n\n\*\*(?:User|Assistant):\*\*|$)/g;
+  let m;
+  while ((m = re.exec(text)) !== null) {
+    const body = m[1].trim();
+    if (!body) continue;
+    if (/^\[tool result\]/i.test(body)) continue;
+    if (/^<(ide_opened_file|system-reminder|command-(name|message)|environment_context)\b/i.test(body)) continue;
+    if (/^\[Pasted text/.test(body)) continue;
+    return body;
+  }
+  return null;
+}

package/src/commands/install.js

@@ -0,0 +1,87 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { execFileSync } from 'node:child_process';
+import { fileURLToPath } from 'node:url';
+import { PATHS, LAUNCHD_LABEL } from '../config.js';
+import { resetEpoch } from '../state.js';
+import { info, warn } from '../log.js';
+import { fixCodexProjects } from './fix-codex-projects.js';
+
+function findEntrypoint() {
+  // bin/combobulate.js relative to this file (src/commands/install.js -> ../../bin/combobulate.js)
+  return path.resolve(fileURLToPath(import.meta.url), '..', '..', '..', 'bin', 'combobulate.js');
+}
+
+function plistXml({ nodeBin, scriptPath, logPath }) {
+  return `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>Label</key>
+  <string>${LAUNCHD_LABEL}</string>
+  <key>ProgramArguments</key>
+  <array>
+    <string>${nodeBin}</string>
+    <string>${scriptPath}</string>
+    <string>daemon</string>
+  </array>
+  <key>RunAtLoad</key>
+  <true/>
+  <key>KeepAlive</key>
+  <true/>
+  <key>StandardOutPath</key>
+  <string>${logPath}</string>
+  <key>StandardErrorPath</key>
+  <string>${logPath}</string>
+  <key>ProcessType</key>
+  <string>Background</string>
+</dict>
+</plist>
+`;
+}
+
+export async function install() {
+  fs.mkdirSync(PATHS.combobulateDir, { recursive: true });
+  fs.mkdirSync(PATHS.combobulateSynced, { recursive: true });
+  fs.mkdirSync(path.dirname(PATHS.launchdPlist), { recursive: true });
+
+  const nodeBin = process.execPath;
+  const scriptPath = findEntrypoint();
+
+  if (!fs.existsSync(scriptPath)) {
+    throw new Error(`Cannot find CLI entrypoint at ${scriptPath}`);
+  }
+
+  // Reset the "epoch" — sessions from before install are considered pre-existing.
+  // Daemon only mirrors sessions newer than this.
+  resetEpoch();
+
+  const xml = plistXml({ nodeBin, scriptPath, logPath: PATHS.combobulateLog });
+  fs.writeFileSync(PATHS.launchdPlist, xml);
+  info(`wrote launchd plist at ${PATHS.launchdPlist}`);
+
+  // Reload via launchctl. We unload first (ignore failure if not loaded), then load.
+  try {
+    execFileSync('launchctl', ['unload', PATHS.launchdPlist], { stdio: 'ignore' });
+  } catch {}
+  try {
+    execFileSync('launchctl', ['load', PATHS.launchdPlist], { stdio: 'inherit' });
+    info('launchd agent loaded — daemon will start now and on every login.');
+  } catch (e) {
+    warn(`launchctl load failed: ${e.message}`);
+    warn('You can run the daemon manually with: combobulate daemon');
+  }
+
+  // Backfill any pre-existing mirrors into Codex Desktop's workspace registry,
+  // so a fresh install on top of prior state immediately shows up.
+  try {
+    await fixCodexProjects();
+  } catch (e) {
+    warn(`fix-codex-projects failed: ${e.message}`);
+  }
+
+  info('install complete.');
+  info(`  state:  ${PATHS.combobulateState}`);
+  info(`  log:    ${PATHS.combobulateLog}`);
+  info(`  synced: ${PATHS.combobulateSynced}`);
+}

package/src/commands/status.js

@@ -0,0 +1,50 @@
+import fs from 'node:fs';
+import { execFileSync } from 'node:child_process';
+import { PATHS, LAUNCHD_LABEL } from '../config.js';
+import { loadState } from '../state.js';
+
+export async function status() {
+  console.log('combobulate status');
+  console.log('==================');
+  console.log(`state file:  ${PATHS.combobulateState}`);
+  console.log(`log file:    ${PATHS.combobulateLog}`);
+  console.log(`synced cwd:  ${PATHS.combobulateSynced}`);
+  console.log(`plist:       ${PATHS.launchdPlist} ${fs.existsSync(PATHS.launchdPlist) ? '(present)' : '(missing)'}`);
+
+  // launchctl list returns the PID if loaded
+  let listed = '';
+  try {
+    listed = execFileSync('launchctl', ['list'], { encoding: 'utf8' });
+  } catch {}
+  const row = listed.split('\n').find((l) => l.endsWith(LAUNCHD_LABEL));
+  if (row) {
+    const [pid, _exit, label] = row.trim().split(/\s+/);
+    console.log(`launchd:     loaded as ${label}, pid=${pid === '-' ? 'not running' : pid}`);
+  } else {
+    console.log('launchd:     not loaded');
+  }
+
+  let state;
+  try { state = loadState(); } catch { state = null; }
+  if (state) {
+    const mirrors = Object.entries(state.mirrors || {});
+    console.log(`epoch:       ${new Date(state.epoch).toISOString()}`);
+    console.log(`mirrors:     ${mirrors.length} session(s) tracked`);
+    if (mirrors.length) {
+      const recent = mirrors
+        .map(([k, v]) => ({ k, ...v }))
+        .sort((a, b) => (b.lastSyncedAt || 0) - (a.lastSyncedAt || 0))
+        .slice(0, 5);
+      console.log('recent syncs:');
+      for (const r of recent) {
+        const targets = Object.keys(r.targets || {}).join('+');
+        console.log(`  ${new Date(r.lastSyncedAt || 0).toISOString()}  ${r.k}  -> ${targets}`);
+      }
+    }
+  }
+
+  console.log('\nWatched paths:');
+  console.log(`  claude:  ${PATHS.claudeProjects} ${fs.existsSync(PATHS.claudeProjects) ? '✓' : '✗'}`);
+  console.log(`  codex:   ${PATHS.codexSessions}  ${fs.existsSync(PATHS.codexSessions) ? '✓' : '✗'}`);
+  console.log(`  cursor:  ${PATHS.cursorDb}  ${fs.existsSync(PATHS.cursorDb) ? '✓' : '✗ (cursor not installed)'}`);
+}

package/src/commands/sync.js

@@ -0,0 +1,80 @@
+import fs from 'node:fs';
+import { PATHS } from '../config.js';
+import { info } from '../log.js';
+import { loadState, saveState, getMirror, setMirror, fingerprintMessages } from '../state.js';
+import { listClaudeSessions, readClaudeSession } from '../sources/claude.js';
+import { listCodexSessions, readCodexSession } from '../sources/codex.js';
+import { listCursorComposers, readCursorComposer } from '../sources/cursor.js';
+import { writeClaudeMirror } from '../sinks/claude.js';
+import { writeCodexMirror } from '../sinks/codex.js';
+
+// One-shot sync. Doesn't require the daemon. Useful for testing or running on demand.
+// `--all` ignores the epoch and tries every session newer than --since (default: 24h).
+export async function sync({ all = false, sinceHours = 24, limit = 20, dryRun = false } = {}) {
+  fs.mkdirSync(PATHS.combobulateDir, { recursive: true });
+  fs.mkdirSync(PATHS.combobulateSynced, { recursive: true });
+
+  const cutoff = all ? 0 : Date.now() - sinceHours * 3600 * 1000;
+  const state = loadState();
+
+  const sessions = [];
+
+  for (const meta of listClaudeSessions().slice(0, limit)) {
+    if (meta.mtime < cutoff) continue;
+    try {
+      const s = await readClaudeSession(meta.path);
+      if (!s.isMirror && s.messages.length) sessions.push(s);
+    } catch (e) { /* ignore */ }
+  }
+  for (const meta of listCodexSessions().slice(0, limit)) {
+    if (meta.mtime < cutoff) continue;
+    try {
+      const s = await readCodexSession(meta.path);
+      if (!s.isMirror && s.messages.length) sessions.push(s);
+    } catch (e) { /* ignore */ }
+  }
+  if (fs.existsSync(PATHS.cursorDb)) {
+    try {
+      const composers = await listCursorComposers();
+      for (const c of composers.slice(0, limit)) {
+        if (c.updatedAt < cutoff) continue;
+        const s = await readCursorComposer(c.id);
+        if (s && !s.isMirror && s.messages.length) sessions.push(s);
+      }
+    } catch (e) { info(`cursor scan failed: ${e.message}`); }
+  }
+
+  info(`found ${sessions.length} candidate session(s) to mirror`);
+
+  for (const s of sessions) {
+    const key = `${s.source}/${s.sessionId}`;
+    const fp = fingerprintMessages(s.messages);
+    const prev = getMirror(key);
+    if (prev && prev.sourceFingerprint === fp) {
+      info(`skip ${key} (no changes)`);
+      continue;
+    }
+    info(`mirror ${key} (${s.messages.length} msgs)`);
+    if (dryRun) continue;
+    const targets = prev?.targets || {};
+    if (s.source !== 'claude') {
+      const r = writeClaudeMirror(s, {
+        existingSessionId: targets.claude?.sessionId,
+        existingFilePath: targets.claude?.filePath,
+      });
+      targets.claude = r;
+      info(`  -> claude:${r.sessionId}`);
+    }
+    if (s.source !== 'codex') {
+      const r = writeCodexMirror(s, {
+        existingSessionId: targets.codex?.sessionId,
+        existingFilePath: targets.codex?.filePath,
+      });
+      targets.codex = r;
+      info(`  -> codex:${r.sessionId}`);
+    }
+    setMirror(key, { sourceFingerprint: fp, targets, lastSyncedAt: Date.now() });
+  }
+  saveState();
+  info('done.');
+}

package/src/commands/uninstall.js

@@ -0,0 +1,17 @@
+import fs from 'node:fs';
+import { execFileSync } from 'node:child_process';
+import { PATHS } from '../config.js';
+import { info } from '../log.js';
+
+export async function uninstall() {
+  if (fs.existsSync(PATHS.launchdPlist)) {
+    try {
+      execFileSync('launchctl', ['unload', PATHS.launchdPlist], { stdio: 'ignore' });
+    } catch {}
+    fs.unlinkSync(PATHS.launchdPlist);
+    info(`removed launchd plist at ${PATHS.launchdPlist}`);
+  } else {
+    info('no launchd plist to remove.');
+  }
+  info('uninstall complete. State at ~/.combobulate is preserved — delete it manually if you want a clean slate.');
+}

package/src/config.js

@@ -0,0 +1,38 @@
+import os from 'node:os';
+import path from 'node:path';
+
+export const HOME = os.homedir();
+
+export const PATHS = {
+  claudeDir: path.join(HOME, '.claude'),
+  claudeProjects: path.join(HOME, '.claude', 'projects'),
+  claudeHistory: path.join(HOME, '.claude', 'history.jsonl'),
+
+  codexDir: path.join(HOME, '.codex'),
+  codexSessions: path.join(HOME, '.codex', 'sessions'),
+  codexSessionIndex: path.join(HOME, '.codex', 'session_index.jsonl'),
+  codexHistory: path.join(HOME, '.codex', 'history.jsonl'),
+
+  cursorDb: path.join(HOME, 'Library', 'Application Support', 'Cursor', 'User', 'globalStorage', 'state.vscdb'),
+
+  combobulateDir: path.join(HOME, '.combobulate'),
+  combobulateState: path.join(HOME, '.combobulate', 'state.json'),
+  combobulateLog: path.join(HOME, '.combobulate', 'daemon.log'),
+  combobulatePid: path.join(HOME, '.combobulate', 'daemon.pid'),
+  combobulateSynced: path.join(HOME, '.combobulate', 'synced'),
+  launchdPlist: path.join(HOME, 'Library', 'LaunchAgents', 'com.combobulate.daemon.plist'),
+};
+
+export const LAUNCHD_LABEL = 'com.combobulate.daemon';
+
+export const POLL_INTERVAL_MS = 1500;
+
+// Mirror marker — embedded in every synced session so we don't mirror our own writes.
+export const MIRROR_MARKER = '__combobulate_mirror__';
+
+// Encode an absolute filesystem path the way Claude Code does for ~/.claude/projects/<encoded>/.
+// Claude replaces every '/' (and leading slash) with '-' and drops the leading dash on root.
+// E.g. /Users/madhavan/foo -> -Users-madhavan-foo
+export function encodeClaudeProjectDir(cwd) {
+  return cwd.replace(/[/.]/g, '-');
+}

package/src/daemon.js

@@ -0,0 +1,126 @@
+import fs from 'node:fs';
+import { PATHS, POLL_INTERVAL_MS } from './config.js';
+import { info, warn, error, debug } from './log.js';
+import { loadState, saveState, getMirror, setMirror, fingerprintMessages } from './state.js';
+import { listClaudeSessions, readClaudeSession } from './sources/claude.js';
+import { listCodexSessions, readCodexSession } from './sources/codex.js';
+import { listCursorComposers, readCursorComposer } from './sources/cursor.js';
+import { writeClaudeMirror } from './sinks/claude.js';
+import { writeCodexMirror } from './sinks/codex.js';
+
+// Mirror a single normalized session to every other tool. Skip self and skip mirrors.
+async function mirrorSession(session) {
+  if (session.isMirror) return;
+  if (!session.messages.length) return;
+
+  const sourceKey = `${session.source}/${session.sessionId}`;
+  const fp = fingerprintMessages(session.messages);
+  const prev = getMirror(sourceKey);
+  if (prev && prev.sourceFingerprint === fp) return; // nothing new
+
+  const targets = prev?.targets || {};
+
+  if (session.source !== 'claude') {
+    try {
+      const result = writeClaudeMirror(session, {
+        existingSessionId: targets.claude?.sessionId,
+        existingFilePath: targets.claude?.filePath,
+      });
+      targets.claude = result;
+      info(`mirrored ${sourceKey} -> claude:${result.sessionId}`);
+    } catch (e) {
+      error(`claude mirror failed for ${sourceKey}: ${e.message}`);
+    }
+  }
+
+  if (session.source !== 'codex') {
+    try {
+      const result = writeCodexMirror(session, {
+        existingSessionId: targets.codex?.sessionId,
+        existingFilePath: targets.codex?.filePath,
+      });
+      targets.codex = result;
+      info(`mirrored ${sourceKey} -> codex:${result.sessionId}`);
+    } catch (e) {
+      error(`codex mirror failed for ${sourceKey}: ${e.message}`);
+    }
+  }
+
+  setMirror(sourceKey, { sourceFingerprint: fp, targets, lastSyncedAt: Date.now() });
+}
+
+async function scanClaude(state) {
+  const sessions = listClaudeSessions();
+  for (const meta of sessions) {
+    if (meta.mtime < state.epoch) continue; // pre-existing
+    try {
+      const session = await readClaudeSession(meta.path);
+      await mirrorSession(session);
+    } catch (e) {
+      debug(`skip claude ${meta.path}: ${e.message}`);
+    }
+  }
+}
+
+async function scanCodex(state) {
+  const sessions = listCodexSessions();
+  for (const meta of sessions) {
+    if (meta.mtime < state.epoch) continue;
+    try {
+      const session = await readCodexSession(meta.path);
+      await mirrorSession(session);
+    } catch (e) {
+      debug(`skip codex ${meta.path}: ${e.message}`);
+    }
+  }
+}
+
+async function scanCursor(state) {
+  if (!fs.existsSync(PATHS.cursorDb)) return;
+  let composers;
+  try {
+    composers = await listCursorComposers();
+  } catch (e) {
+    debug(`cursor list failed: ${e.message}`);
+    return;
+  }
+  for (const c of composers) {
+    if (c.updatedAt < state.epoch) continue;
+    try {
+      const session = await readCursorComposer(c.id);
+      if (session) await mirrorSession(session);
+    } catch (e) {
+      debug(`skip cursor ${c.id}: ${e.message}`);
+    }
+  }
+}
+
+let running = false;
+async function tick() {
+  if (running) return;
+  running = true;
+  try {
+    const state = loadState();
+    await scanClaude(state);
+    await scanCodex(state);
+    await scanCursor(state);
+    saveState();
+  } catch (e) {
+    error(`tick failed: ${e.message}`);
+  } finally {
+    running = false;
+  }
+}
+
+export async function runDaemon() {
+  fs.mkdirSync(PATHS.combobulateDir, { recursive: true });
+  fs.mkdirSync(PATHS.combobulateSynced, { recursive: true });
+  fs.writeFileSync(PATHS.combobulatePid, String(process.pid));
+
+  process.on('SIGTERM', () => { info('SIGTERM, exiting'); process.exit(0); });
+  process.on('SIGINT', () => { info('SIGINT, exiting'); process.exit(0); });
+
+  info(`daemon started pid=${process.pid} interval=${POLL_INTERVAL_MS}ms`);
+  await tick();
+  setInterval(tick, POLL_INTERVAL_MS);
+}