cmdzero 0.8.3 → 0.8.5

package/overlay/overlay.js

@@ -1326,14 +1326,36 @@
     for (const rec of saved) addTweak(rec, true); // chronological replay → newest ends at the bottom
   })();
 
-  try {
-    const es = new EventSource(`${ORIGIN}/api/events`);
-    es.onmessage = (m) => {
-      const e = JSON.parse(m.data);
-      if (e.type === 'tweak') addTweak(e);
-      if (e.type === 'totals') showTotals(e.totals);
-    };
-  } catch { /* daemon offline */ }
+  // A restarted daemon leaves the EventSource holding a socket to a process that
+  // is gone: the browser keeps it in readyState OPEN, fires no error and never
+  // reconnects, so alerts stop arriving while the edits behind them still land
+  // on disk. Nothing surfaces that — the tray just quietly stops moving. The
+  // daemon pings every 15s, so silence well past that means the stream is a
+  // zombie; drop it and dial again.
+  const SSE_SILENCE_MS = 45000;
+  let es = null;
+  let lastSeen = Date.now();
+  function connectEvents() {
+    try {
+      if (es) es.close();
+      es = new EventSource(`${ORIGIN}/api/events`);
+      es.onopen = () => { lastSeen = Date.now(); };
+      es.onmessage = (m) => {
+        lastSeen = Date.now();
+        const e = JSON.parse(m.data);
+        if (e.type === 'tweak') addTweak(e);
+        if (e.type === 'totals') showTotals(e.totals);
+        // 'ping' needs no handling — arriving at all is the whole point.
+      };
+    } catch { /* daemon offline */ }
+  }
+  connectEvents();
+  setInterval(() => {
+    if (Date.now() - lastSeen > SSE_SILENCE_MS) {
+      lastSeen = Date.now(); // reset first, so a daemon that is still down doesn't reconnect every tick
+      connectEvents();
+    }
+  }, 5000);
   fetch(`${ORIGIN}/api/health`)
     .then((r) => r.json())
     .then((h) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cmdzero",
-  "version": "0.8.3",
+  "version": "0.8.5",
   "description": "Tweak your UI live in the browser and write the changes straight to source. Copy and Tailwind edits cost zero tokens; everything else routes to a right-sized model via headless claude.",
   "license": "MIT",
   "type": "module",

package/src/resolver.js

@@ -18,25 +18,32 @@ function walk(node, cb) {
   }
 }
 
-/** loc format: "<relative file>:<line 1-based>:<col 0-based>" (matches the babel stamp) */
+/**
+ * loc format: "<file>:<line 1-based>:<col 0-based>" (matches the babel stamp).
+ *
+ * The file arrives in one of three shapes, depending on who stamped it: the
+ * babel plugin emits a root-relative path, and the @cmdzero/react dev runtime
+ * passes on whatever the bundler handed jsxDEV — absolute under webpack, but
+ * "[project]/components/Foo.tsx" under Turbopack. Normalize that prefix away
+ * here, at the boundary every caller shares: /api/nl parses locs itself and
+ * resolves them straight against the root, so normalizing further in (say, in
+ * loadTarget) leaves that lane reaching for <root>/[project]/... and dying on
+ * ENOENT while the copy and style lanes look fine.
+ */
 export function parseLoc(loc) {
   const m = /^(.*):(\d+):(\d+)$/.exec(loc);
   if (!m) throw new Error(`bad loc: ${loc}`);
-  return { file: m[1], line: Number(m[2]), col: Number(m[3]) };
+  return { file: m[1].replace(/^\[project\]\//, ''), line: Number(m[2]), col: Number(m[3]) };
 }
 
 export function loadTarget(root, loc) {
   const parsed = parseLoc(loc);
   const { line, col } = parsed;
-  // Stamps come from three sources: the babel plugin (root-relative path,
-  // 0-based column) and the @cmdzero/react dev runtime (1-based column), which
-  // reports whatever the bundler handed jsxDEV — an absolute path under
-  // webpack, but "[project]/..." under Turbopack. Normalize the path and match
-  // either column convention.
-  const raw = parsed.file.replace(/^\[project\]\//, '');
-  // Resolve before the escape check: the guard has to see a normalized path,
-  // or a "foo/../../.." stamp walks straight past a leading-".." test.
-  const file = path.relative(root, path.resolve(root, raw));
+  // parseLoc has already normalized the path's shape; columns still come in two
+  // conventions (babel 0-based, the dev runtime 1-based) and are matched below.
+  // Resolve before the escape check: the guard has to see a normalized path, or
+  // a "foo/../../.." stamp walks straight past a leading-".." test.
+  const file = path.relative(root, path.resolve(root, parsed.file));
   if (file.startsWith('..') || path.isAbsolute(file)) {
     throw new Error('file outside root');
   }

package/src/server.js

@@ -28,11 +28,18 @@ function detectTailwind(root) {
   }
 }
 
-export function startServer({ root, port = 4100 }) {
+export function startServer({ root, port = 4100, heartbeatMs = 15000 }) {
   const undoStack = new Map(); // id -> { abs, before }
   const running = new Map(); // id -> child process (for cancellation)
   const sseClients = new Set();
-  let nextId = 1;
+  // Seeded from the clock, not 1. The overlay persists its alert history in
+  // localStorage and keys each row by tweak id, and that history outlives the
+  // daemon — so a counter starting over at 1 hands a fresh tweak the id of a row
+  // hydrated from an earlier session. addTweak() updates a known id in place, so
+  // the newest alert would silently overwrite that old row wherever it sits
+  // instead of appending to the bottom of the tray. Still ascending within a
+  // session; just never reissued across a restart.
+  let nextId = Date.now();
   const tailwind = detectTailwind(root);
   const telemetry = initTelemetry({ version: VERSION, tailwind });
 
@@ -98,7 +105,20 @@ export function startServer({ root, port = 4100 }) {
         });
         res.write('\n');
         sseClients.add(res);
-        req.on('close', () => sseClients.delete(res));
+        // Idle streams have to say something. A browser can't tell a quiet
+        // daemon from a dead one: the EventSource stays in readyState OPEN,
+        // never fires error and never reconnects, so every alert after a
+        // restart is dropped while the writes still land on disk. A ping the
+        // client can actually see (a comment would not reach onmessage) lets it
+        // notice the silence and reconnect.
+        const beat = setInterval(() => {
+          res.write(`data: ${JSON.stringify({ type: 'ping' })}\n\n`);
+        }, heartbeatMs);
+        beat.unref?.(); // never hold the process open for a heartbeat
+        req.on('close', () => {
+          clearInterval(beat);
+          sseClients.delete(res);
+        });
         return;
       }