claude-simple 0.2.17 → 0.2.19

package/client.js

@@ -4,16 +4,243 @@ import { startAutoUpdate } from './src/auto-update.js';
 import { WebSocket } from 'ws';
 import os from 'os';
 import crypto from 'crypto';
+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
 const MACHINE_ID    = process.env.MACHINE_ID || os.hostname();
 const MACHINE_TOKEN = process.env.MACHINE_TOKEN;  // shared secret with gateway
 const LOCAL_PORT    = parseInt(process.env.LOCAL_PORT || '13000');
+const SYNC_DIR      = process.env.EDGE_SYNC_DIR || path.join(os.homedir(), '.claude-simple-edge');
+const SYNC_FILE     = path.join(SYNC_DIR, 'hub-stream-outbox.json');
 
 if (!GATEWAY_URL)    { console.error('GATEWAY_URL is required'); process.exit(1); }
 if (!MACHINE_TOKEN)  { console.error('MACHINE_TOKEN is required'); process.exit(1); }
 
+// 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: 2, next: {}, pending: [], catalog: {}, catalogPending: null, catalogSeq: 0 };
+let syncWrite = Promise.resolve();
+let syncSent = new Set();
+
+async function loadSyncState() {
+  try {
+    const parsed = JSON.parse(await fs.readFile(SYNC_FILE, 'utf8'));
+    if (parsed && typeof parsed === 'object') {
+      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 */ }
+}
+
+function persistSyncState() {
+  const snapshot = JSON.stringify(syncState);
+  syncWrite = syncWrite.then(async () => {
+    await fs.mkdir(SYNC_DIR, { recursive: true, mode: 0o700 });
+    await fs.writeFile(`${SYNC_FILE}.tmp`, snapshot, { mode: 0o600 });
+    await fs.rename(`${SYNC_FILE}.tmp`, SYNC_FILE);
+  }).catch(e => console.error('[sync] persist failed:', e.message));
+  return syncWrite;
+}
+
+function syncKey(sessionId, agent) { return `${MACHINE_ID}:${agent}:${sessionId}`; }
+
+function queueSyncFrame({ sessionId, agent, cwd, frame }) {
+  if (!sessionId || !agent || !frame) return 0;
+  const key = syncKey(sessionId, agent);
+  const seq = (Number(syncState.next[key]) || 0) + 1;
+  syncState.next[key] = seq;
+  syncState.pending.push({ sessionId, agent, cwd: cwd || '', seq, frame, ts: Date.now() });
+  if (syncState.pending.length > 20000) syncState.pending.splice(0, syncState.pending.length - 20000);
+  void persistSyncState().then(flushSyncOutbox);
+  return seq;
+}
+
+function flushSyncOutbox() {
+  if (controlWs?.readyState !== WebSocket.OPEN) return;
+  for (const event of syncState.pending) {
+    const id = `${event.agent}:${event.sessionId}:${event.seq}`;
+    if (syncSent.has(id)) continue;
+    syncSent.add(id);
+    sendControl({ type: 'sync-event', data: JSON.stringify(event) });
+  }
+}
+
+function acknowledgeSync(data) {
+  const upto = Number(data?.upto) || 0;
+  if (!data?.sessionId || !data?.agent || !upto) return;
+  const before = syncState.pending.length;
+  syncState.pending = syncState.pending.filter(e => !(e.sessionId === data.sessionId && e.agent === data.agent && e.seq <= upto));
+  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;
+  try { frame = JSON.parse(text); } catch { return text; }
+  if (frame.type === 'ping' || frame.type === 'pong' || frame.type === 'hub-turn-finished') return text;
+  const inspect = (value) => {
+    if (!value || typeof value !== 'object') return;
+    if (value.type === 'batch' && Array.isArray(value.items)) { value.items.forEach(inspect); return; }
+    if (value.sessionId) tunnel.sessionId = value.sessionId;
+    if (value.agent) tunnel.agent = value.agent;
+  };
+  inspect(frame);
+  if (!tunnel.sessionId || !tunnel.agent) return text;
+  const seq = queueSyncFrame({ sessionId: tunnel.sessionId, agent: tunnel.agent, cwd: tunnel.cwd, frame: text });
+  if (!seq) return text;
+  frame.hubSeq = seq;
+  return JSON.stringify(frame);
+}
+
 // ─── Start local app (only binds to 127.0.0.1) ───────────────────────────────
+await loadSyncState();
 await init();
 const { server } = createApp();
 await new Promise(resolve => server.listen(LOCAL_PORT, '127.0.0.1', resolve));
@@ -23,7 +250,7 @@ console.log(`[client] Local app listening on 127.0.0.1:${LOCAL_PORT}`);
 // Requires global install + systemd Restart= (or equivalent) for full apply.
 startAutoUpdate({ role: 'edge-client', isBusy: hasBusyAgent });
 
-// ─── Active WS tunnels: tunnelId → local WebSocket ───────────────────────────
+// ─── Active WS tunnels: socket + session identity for resumable frames ───────
 const tunnels = new Map();
 
 // ─── Gateway connection ───────────────────────────────────────────────────────
@@ -69,18 +296,32 @@ function connect() {
 
   controlWs.on('open', () => {
     reconnectDelay = 1000;
+    syncSent = new Set();
     console.log(`[client] Connected. Registering as "${MACHINE_ID}"`);
     sendControl({
       type: 'register',
       machineId: MACHINE_ID,
       meta: { hostname: os.hostname(), platform: os.platform() },
     });
+    flushSyncOutbox();
+    flushCatalogOutbox();
+    startSessionCatalogWatch();
+    scheduleSessionCatalogRefresh(0);
   });
 
   controlWs.on('message', async (raw) => {
     let msg;
     try { msg = JSON.parse(raw.toString()); } catch { return; }
 
+    if (msg.type === 'sync-ack') {
+      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') {
       try {
@@ -170,14 +411,22 @@ function connect() {
       const { tunnelId, path, query } = msg;
       const localUrl = `ws://127.0.0.1:${LOCAL_PORT}${path}${query || ''}`;
       const localWs  = new WebSocket(localUrl);
+      const params = new URLSearchParams(String(query || '').replace(/^\?/, ''));
+      const tunnel = {
+        ws: localWs,
+        path,
+        sessionId: params.get('sessionId') || '',
+        agent: params.get('agent') || '',
+        cwd: params.get('cwd') || '',
+      };
 
       localWs.on('open', () => {
-        tunnels.set(tunnelId, localWs);
+        tunnels.set(tunnelId, tunnel);
         sendControl({ type: 'ws-ready', tunnelId });
       });
 
       localWs.on('message', (data) => {
-        sendControl({ type: 'ws-msg', tunnelId, data: data.toString() });
+        sendControl({ type: 'ws-msg', tunnelId, data: stampRuntimeFrame(tunnel, data.toString()) });
       });
 
       localWs.on('close', () => {
@@ -195,16 +444,16 @@ function connect() {
 
     // ── WS tunnel message (gateway → local) ───────────────────────────────────
     if (msg.type === 'ws-msg') {
-      const localWs = tunnels.get(msg.tunnelId);
-      if (localWs?.readyState === WebSocket.OPEN) localWs.send(msg.data);
+      const tunnel = tunnels.get(msg.tunnelId);
+      if (tunnel?.ws?.readyState === WebSocket.OPEN) tunnel.ws.send(msg.data);
       return;
     }
 
     // ── WS tunnel close (gateway side closed) ─────────────────────────────────
     if (msg.type === 'ws-close') {
-      const localWs = tunnels.get(msg.tunnelId);
+      const tunnel = tunnels.get(msg.tunnelId);
       tunnels.delete(msg.tunnelId);
-      if (localWs?.readyState === WebSocket.OPEN) localWs.close();
+      if (tunnel?.ws?.readyState === WebSocket.OPEN) tunnel.ws.close();
       return;
     }
 
@@ -214,6 +463,7 @@ function connect() {
   });
 
   controlWs.on('close', () => {
+    syncSent = new Set();
     console.log(`[client] Disconnected. Reconnecting in ${reconnectDelay}ms ...`);
     // Close all open tunnels
     for (const localWs of tunnels.values()) {