claude-simple 0.2.18 → 0.2.20

package/client.js

@@ -4,7 +4,7 @@ import { startAutoUpdate } from './src/auto-update.js';
 import { WebSocket } from 'ws';
 import os from 'os';
 import crypto from 'crypto';
-import { promises as fs } from 'fs';
+import { promises as fs, watch as watchFs } from 'fs';
 import path from 'path';
 
 const GATEWAY_URL   = process.env.GATEWAY_URL;    // e.g. wss://your-server.com/machine-connect
@@ -20,7 +20,7 @@ if (!MACHINE_TOKEN)  { console.error('MACHINE_TOKEN is required'); process.exit(
 // Hub ACKed stream outbox.  One sequence represents one already-batched UI
 // frame, not an individual token, keeping both radio traffic and local disk
 // use bounded.
-let syncState = { version: 1, next: {}, pending: [] };
+let syncState = { version: 2, next: {}, pending: [], catalog: {}, catalogPending: null, catalogSeq: 0 };
 let syncWrite = Promise.resolve();
 let syncSent = new Set();
 
@@ -28,7 +28,16 @@ async function loadSyncState() {
   try {
     const parsed = JSON.parse(await fs.readFile(SYNC_FILE, 'utf8'));
     if (parsed && typeof parsed === 'object') {
-      syncState = { version: 1, next: parsed.next || {}, pending: Array.isArray(parsed.pending) ? parsed.pending.slice(-20000) : [] };
+      syncState = {
+        version: 2,
+        next: parsed.next || {},
+        pending: Array.isArray(parsed.pending) ? parsed.pending.slice(-20000) : [],
+        // Keeping the last compact catalog locally means reconnects do not
+        // resend every session. Only file-driven changes become deltas.
+        catalog: parsed.catalog && typeof parsed.catalog === 'object' ? parsed.catalog : {},
+        catalogPending: parsed.catalogPending && typeof parsed.catalogPending === 'object' ? parsed.catalogPending : null,
+        catalogSeq: Number(parsed.catalogSeq) || 0,
+      };
     }
   } catch { /* first boot */ }
 }
@@ -74,6 +83,143 @@ function acknowledgeSync(data) {
   if (before !== syncState.pending.length) void persistSyncState();
 }
 
+function flushCatalogOutbox() {
+  const pending = syncState.catalogPending;
+  if (controlWs?.readyState !== WebSocket.OPEN || !pending) return;
+  sendControl({ type: 'sync-catalog', data: JSON.stringify({ id: pending.id, upserts: pending.upserts || [], removes: pending.removes || [] }) });
+}
+
+function acknowledgeCatalog(data) {
+  const pending = syncState.catalogPending;
+  if (!pending?.next || typeof pending.next !== 'object' || data?.id !== pending.id) return;
+  syncState.catalog = pending.next;
+  syncState.catalogPending = null;
+  void persistSyncState();
+}
+
+// ─── Session catalog sync ───────────────────────────────────────────────────
+// The Hub owns the durable catalog.  An Edge only sends a compact upsert/remove
+// delta after an on-disk session change; it never streams transcripts here.
+const SESSION_WATCH_ROOTS = [
+  ...String(process.env.CLAUDE_CONFIG_DIRS || path.join(os.homedir(), '.claude')).split(',')
+    .map(v => path.join(v.trim().replace(/^~/, os.homedir()), 'projects')),
+  path.join((process.env.CODEX_HOME || path.join(os.homedir(), '.codex')).replace(/^~/, os.homedir()), 'sessions'),
+  path.join((process.env.GROK_HOME || path.join(os.homedir(), '.grok')).replace(/^~/, os.homedir()), 'sessions'),
+  path.join((process.env.GEMINI_HOME || path.join(os.homedir(), '.gemini')).replace(/^~/, os.homedir()), 'antigravity-cli'),
+  path.join((process.env.CURSOR_HOME || path.join(os.homedir(), '.cursor')).replace(/^~/, os.homedir()), 'claude-simple-ui'),
+];
+const catalogRoots = [...new Set(SESSION_WATCH_ROOTS)];
+let catalogRefreshTimer = null;
+let catalogRefreshing = false;
+let catalogRefreshAgain = false;
+let catalogFallbackTimer = null;
+let catalogWatcherStarted = false;
+const catalogRootStats = new Map();
+
+function catalogKey(session) {
+  return `${session.agent || 'claude'}:${session.sessionId || ''}`;
+}
+
+function compactSession(session) {
+  const out = {};
+  // Deliberately whitelist the sidebar/session-open fields: no transcript,
+  // tool input, file path or arbitrary adapter data is retained on the Hub.
+  for (const key of ['sessionId', 'agent', 'cwd', 'projectName', 'display', 'configDir', 'updatedAt', 'createdAt', 'turnCount', 'totalTokens', 'hasMemory', 'model']) {
+    const value = session?.[key];
+    if (value !== undefined && value !== null && value !== '') out[key] = value;
+  }
+  return out;
+}
+
+async function refreshSessionCatalog() {
+  if (catalogRefreshing) {
+    catalogRefreshAgain = true;
+    return;
+  }
+  if (controlWs?.readyState !== WebSocket.OPEN) return;
+  catalogRefreshing = true;
+  try {
+    const res = await fetch(`http://127.0.0.1:${LOCAL_PORT}/api/sessions?limit=800`, {
+      headers: { 'X-Hub-Token': MACHINE_TOKEN, 'Accept-Encoding': 'identity' },
+    });
+    if (!res.ok) throw new Error(`session scan returned ${res.status}`);
+    const list = await res.json();
+    const next = {};
+    for (const raw of Array.isArray(list) ? list : []) {
+      const session = compactSession(raw);
+      const key = catalogKey(session);
+      if (session.sessionId) next[key] = session;
+    }
+    const before = syncState.catalog || {};
+    const upserts = Object.entries(next)
+      .filter(([key, value]) => JSON.stringify(before[key]) !== JSON.stringify(value))
+      .map(([, value]) => value);
+    const removes = Object.keys(before).filter(key => !next[key]);
+    if (upserts.length || removes.length) {
+      // Keep the outgoing delta on disk until the Hub confirms it. Retrying
+      // is safe because Hub-side upserts/removes are idempotent.
+      const id = ++syncState.catalogSeq;
+      syncState.catalogPending = { id, upserts, removes, next };
+      void persistSyncState();
+      flushCatalogOutbox();
+      console.log(`[catalog] synced +${upserts.length} -${removes.length}`);
+    }
+  } catch (e) {
+    console.error('[catalog] refresh failed:', e.message);
+  } finally {
+    catalogRefreshing = false;
+    if (catalogRefreshAgain) {
+      catalogRefreshAgain = false;
+      void refreshSessionCatalog();
+    }
+  }
+}
+
+function scheduleSessionCatalogRefresh(delay = 300) {
+  clearTimeout(catalogRefreshTimer);
+  catalogRefreshTimer = setTimeout(() => void refreshSessionCatalog(), delay);
+}
+
+async function rootFingerprint(root) {
+  // The fallback intentionally reads directory metadata only. It does not
+  // parse JSON/JSONL or walk the session tree. Native watches catch nested
+  // appends; this probe catches root replacement/remounts and dropped events.
+  try {
+    const stat = await fs.stat(root);
+    return `${stat.size}:${Math.floor(stat.mtimeMs)}:${Math.floor(stat.ctimeMs)}`;
+  } catch {
+    return 'missing';
+  }
+}
+
+function startSessionCatalogWatch() {
+  if (catalogWatcherStarted) return;
+  catalogWatcherStarted = true;
+  let watches = 0;
+  for (const root of catalogRoots) {
+    try {
+      const watcher = watchFs(root, { recursive: true }, () => scheduleSessionCatalogRefresh());
+      watcher.on('error', () => {});
+      watches++;
+    } catch {
+      // The 2-second metadata probe below covers platforms/filesystems where
+      // recursive native watching is unavailable (network mounts, older Linux).
+    }
+  }
+  // A cheap two-second probe also covers dropped native events. It only queues
+  // a real scan when a fingerprint differs, so quiet machines do no parsing.
+  catalogFallbackTimer = setInterval(async () => {
+    for (const root of catalogRoots) {
+      const next = await rootFingerprint(root);
+      const prev = catalogRootStats.get(root);
+      catalogRootStats.set(root, next);
+      if (prev !== undefined && prev !== next) scheduleSessionCatalogRefresh();
+    }
+  }, 2000);
+  console.log(`[catalog] watching ${watches}/${catalogRoots.length} roots; 2s metadata fallback enabled`);
+  scheduleSessionCatalogRefresh(0);
+}
+
 function stampRuntimeFrame(tunnel, text) {
   if (tunnel?.path !== '/ws/chat') return text;
   let frame;
@@ -158,6 +304,9 @@ function connect() {
       meta: { hostname: os.hostname(), platform: os.platform() },
     });
     flushSyncOutbox();
+    flushCatalogOutbox();
+    startSessionCatalogWatch();
+    scheduleSessionCatalogRefresh(0);
   });
 
   controlWs.on('message', async (raw) => {
@@ -168,6 +317,10 @@ function connect() {
       try { acknowledgeSync(JSON.parse(msg.data || '{}')); } catch { /* malformed ack */ }
       return;
     }
+    if (msg.type === 'sync-catalog-ack') {
+      try { acknowledgeCatalog(JSON.parse(msg.data || '{}')); } catch { /* malformed ack */ }
+      return;
+    }
 
     // ── HTTP proxy ────────────────────────────────────────────────────────────
     if (msg.type === 'http-req') {