claude-simple 0.2.17 → 0.2.18

package/client.js

@@ -4,16 +4,97 @@ 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 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: 1, next: {}, pending: [] };
+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: 1, next: parsed.next || {}, pending: Array.isArray(parsed.pending) ? parsed.pending.slice(-20000) : [] };
+    }
+  } 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 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 +104,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 +150,25 @@ 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();
   });
 
   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;
+    }
+
     // ── HTTP proxy ────────────────────────────────────────────────────────────
     if (msg.type === 'http-req') {
       try {
@@ -170,14 +258,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 +291,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 +310,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()) {