myrlin-workbook 0.9.32 → 0.9.33

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "myrlin-workbook",
-  "version": "0.9.32",
+  "version": "0.9.33",
   "description": "Browser-based project manager for Claude Code sessions - session discovery, multi-terminal, cost tracking, docs, and kanban board",
   "main": "src/index.js",
   "bin": {

package/src/web/pty-manager.js

@@ -116,6 +116,105 @@ function cwdFromJsonl(sessionId) {
 // Maximum scrollback buffer size in total characters
 const MAX_SCROLLBACK_CHARS = 100 * 1024; // 100KB
 
+/**
+ * Watch one or more directories for the appearance of a *.jsonl file that is
+ * not in the pre-call snapshot. Emits exactly one result.
+ *
+ * Hybrid strategy:
+ *   1. fs.watch is registered on each candidate dir that exists at call time.
+ *      'rename' events for new .jsonl files resolve immediately.
+ *   2. At t+timeoutMs, a final rescan diffs the live directory listing against
+ *      the snapshot and picks the freshest by birthtime/mtime. Catches macOS
+ *      FSEvents drops and the cold-start case where the candidate dir didn't
+ *      exist when fs.watch was first attempted.
+ *   3. cleanup() is idempotent and runs on match, timeout, or explicit cancel.
+ *
+ * @param {object} opts
+ * @param {() => string[]} opts.candidateDirsFn - returns relative dir names
+ *   under claudeProjectsDir. Re-evaluated at rescan time.
+ * @param {Set<string>} opts.snapshot - "<dirName>/<file>" keys to ignore.
+ * @param {number} opts.timeoutMs - final-rescan deadline.
+ * @param {string} opts.claudeProjectsDir - absolute path resolving relative
+ *   names from candidateDirsFn.
+ * @param {(err: Error|null, hit: {dirName: string, file: string, bornAt: number}|null) => void} onResult
+ * @returns {() => void} cancel function (idempotent)
+ */
+function waitForNewJsonl({ candidateDirsFn, snapshot, timeoutMs, claudeProjectsDir }, onResult) {
+  let done = false;
+  const watchers = [];
+  let timer = null;
+
+  const cleanup = () => {
+    if (done) return;
+    done = true;
+    if (timer) { clearTimeout(timer); timer = null; }
+    while (watchers.length) {
+      const w = watchers.pop();
+      try { w.close(); } catch (_) {}
+    }
+  };
+
+  const resolve = (err, hit) => {
+    if (done) return;
+    cleanup();
+    try { onResult(err, hit); } catch (_) {}
+  };
+
+  const tryAcceptFile = (dirName, file) => {
+    if (!file || !file.endsWith('.jsonl')) return false;
+    if (snapshot.has(dirName + '/' + file)) return false;
+    let stat;
+    try { stat = fs.statSync(path.join(claudeProjectsDir, dirName, file)); } catch (_) { return false; }
+    const bornAt = stat.birthtimeMs || stat.mtimeMs;
+    resolve(null, { dirName, file, bornAt });
+    return true;
+  };
+
+  // Register watchers on each candidate dir that exists at call time. Failures
+  // (EMFILE / ENOSPC / ENOENT) silently fall through to the timeout rescan,
+  // which is exactly today's contract.
+  for (const dirName of candidateDirsFn()) {
+    try {
+      const watcher = fs.watch(path.join(claudeProjectsDir, dirName), (event, file) => {
+        if (done || event !== 'rename') return;
+        tryAcceptFile(dirName, file);
+      });
+      if (typeof watcher.on === 'function') {
+        watcher.on('error', () => { /* swallow; rescan will catch */ });
+      }
+      watchers.push(watcher);
+    } catch (_) {
+      // Fall through to rescan
+    }
+  }
+
+  // Final-rescan deadline. Also handles the cold-start case where no
+  // candidate dir existed at call time (the dir gets created during the wait).
+  timer = setTimeout(() => {
+    if (done) return;
+    const fresh = [];
+    for (const dirName of candidateDirsFn()) {
+      let entries;
+      try { entries = fs.readdirSync(path.join(claudeProjectsDir, dirName)); } catch (_) { continue; }
+      for (const f of entries) {
+        if (!f.endsWith('.jsonl')) continue;
+        if (snapshot.has(dirName + '/' + f)) continue;
+        let stat;
+        try { stat = fs.statSync(path.join(claudeProjectsDir, dirName, f)); } catch (_) { continue; }
+        fresh.push({ dirName, file: f, bornAt: stat.birthtimeMs || stat.mtimeMs });
+      }
+    }
+    if (fresh.length === 0) {
+      resolve(null, null);
+      return;
+    }
+    fresh.sort((a, b) => b.bornAt - a.bornAt);
+    resolve(null, fresh[0]);
+  }, timeoutMs);
+
+  return cleanup;
+}
+
 /**
  * Represents a single PTY session with its process, clients, and scrollback.
  */
@@ -195,32 +294,19 @@ class PtySessionManager {
     let fullCommand = command;
     if (resumeSessionId) {
       fullCommand += ' --resume ' + resumeSessionId;
-    } else if (cwd && !newSession) {
-      // Only add --continue when there is actually conversation history for this
-      // working directory. `claude --continue` exits with code 1 ("No conversation
-      // found to continue") on a fresh directory — e.g. a brand-new git worktree.
-      // Scan ~/.claude/projects/ for any JSONL file whose encoded path matches cwd.
-      let hasHistory = false;
-      try {
-        const claudeDir = path.join(os.homedir(), '.claude', 'projects');
-        if (fs.existsSync(claudeDir)) {
-          const normalizedCwd = cwd.replace(/[/\\]/g, path.sep);
-          const match = fs.readdirSync(claudeDir).find(d => {
-            try {
-              return decodeURIComponent(d).replace(/[/\\]/g, path.sep) === normalizedCwd;
-            } catch (_) { return false; }
-          });
-          if (match) {
-            const projDir = path.join(claudeDir, match);
-            hasHistory = fs.readdirSync(projDir).some(f => f.endsWith('.jsonl'));
-          }
-        }
-      } catch (_) { /* filesystem error — fall through, don't add --continue */ }
-      if (hasHistory) {
-        fullCommand += ' --continue';
-      }
-      // If no history, run bare `claude` — starts a fresh session without error.
     }
+    // Otherwise run bare `claude` — start a fresh transcript.
+    //
+    // Auto-`--continue` was previously added whenever the cwd had any prior
+    // Claude history. That silently bound a brand-new Myrlin session to
+    // whichever transcript was most recent in that directory — frequently a
+    // different Myrlin session's, or one from running `claude` directly. The
+    // post-spawn UUID detector then persisted the wrong UUID as resumeSessionId
+    // and the misbinding became permanent.
+    //
+    // Resume is now driven strictly by an explicit resumeSessionId. To
+    // continue a past transcript, use the project panel's "Open in Terminal"
+    // (which sets resumeSessionId), or attach the session via Discover.
     if (bypassPermissions) {
       fullCommand += ' --dangerously-skip-permissions';
     }
@@ -471,19 +557,19 @@ class PtySessionManager {
 
     console.log(`[PTY] Spawned session ${sessionId} (PID: ${ptyProcess.pid}) cmd: "${fullCommand}" cwd: "${cwd || process.cwd()}"`);
 
-    // ── Async: detect Claude session UUID from newest JSONL after spawn ──
+    // ── Async: detect Claude session UUID from new JSONL after spawn ──
     // Claude Code creates a JSONL file in ~/.claude/projects/<encoded-cwd>/<uuid>.jsonl.
-    // After a short delay, scan for the newest file and backfill resumeSessionId
-    // so future restarts use the precise --resume <uuid> instead of --continue.
+    // We snapshot the set of existing JSONLs synchronously at spawn time and
+    // hand off to waitForNewJsonl, which fires on fs.watch events and falls
+    // back to a final rescan at t+8s. Snapshot diff prevents binding to a
+    // pre-existing transcript whose mtime drifted; fs.watch makes the binding
+    // sub-second on the happy path.
     if (resolvedCwd && !resumeSessionId) {
-      setTimeout(() => {
+      const claudeDir = path.join(os.homedir(), '.claude', 'projects');
+      const findCandidateDirs = () => {
         try {
-          const claudeDir = path.join(os.homedir(), '.claude', 'projects');
-          if (!fs.existsSync(claudeDir)) return;
-
-          // Claude encodes the cwd path as a directory name under ~/.claude/projects/
-          // Try multiple encoding patterns: URL-encoded, slash-replaced
-          const candidates = fs.readdirSync(claudeDir).filter(d => {
+          if (!fs.existsSync(claudeDir)) return [];
+          return fs.readdirSync(claudeDir).filter(d => {
             try {
               const decoded = decodeURIComponent(d);
               const normalizedDecoded = decoded.replace(/[/\\]/g, path.sep);
@@ -493,36 +579,57 @@ class PtySessionManager {
               return false;
             }
           });
+        } catch (_) {
+          return [];
+        }
+      };
 
-          if (candidates.length === 0) return;
-
-          const projDir = path.join(claudeDir, candidates[0]);
-          const jsonls = fs.readdirSync(projDir)
-            .filter(f => f.endsWith('.jsonl'))
-            .map(f => {
-              try {
-                return { name: f, mtime: fs.statSync(path.join(projDir, f)).mtimeMs };
-              } catch (_) {
-                return null;
-              }
-            })
-            .filter(Boolean)
-            .sort((a, b) => b.mtime - a.mtime);
-
-          if (jsonls.length === 0) return;
+      // Pre-spawn snapshot of JSONLs that already existed in candidate dirs.
+      // Keys are "<dirName>/<file>" so identical UUIDs in sibling dirs stay distinct.
+      const preSnapshot = new Set();
+      for (const dirName of findCandidateDirs()) {
+        try {
+          for (const f of fs.readdirSync(path.join(claudeDir, dirName))) {
+            if (f.endsWith('.jsonl')) preSnapshot.add(dirName + '/' + f);
+          }
+        } catch (_) {}
+      }
 
-          const uuid = jsonls[0].name.replace('.jsonl', '');
+      const cancelWatch = waitForNewJsonl(
+        { candidateDirsFn: findCandidateDirs, snapshot: preSnapshot, timeoutMs: 8000, claudeProjectsDir: claudeDir },
+        (err, hit) => {
+          if (err || !hit) {
+            console.log(`[PTY] No new JSONL appeared for ${sessionId}; skipping resumeSessionId backfill`);
+            return;
+          }
+          const uuid = hit.file.replace('.jsonl', '');
           console.log(`[PTY] Detected Claude session UUID for ${sessionId}: ${uuid}`);
 
-          // Save to store so future restarts use --resume <uuid>
+          // Save to store so future restarts use --resume <uuid>.
+          // Defensive: refuse to backfill if another Myrlin session already
+          // owns this UUID. That shouldn't be possible now that the snapshot
+          // diff filters pre-existing JSONLs, but the check is cheap and
+          // prevents two sessions from ever pointing at the same transcript.
+          let backfilled = false;
           try {
             const store = getStore();
-            if (store.getSession(sessionId)) {
+            const conflict = store.getAllSessionsList().find(s =>
+              s.id !== sessionId && s.resumeSessionId === uuid
+            );
+            if (conflict) {
+              console.warn(
+                `[PTY] Refusing to backfill resumeSessionId=${uuid} for session ${sessionId}: ` +
+                `already owned by session ${conflict.id} ("${conflict.name || ''}")`
+              );
+            } else if (store.getSession(sessionId)) {
               store.updateSession(sessionId, { resumeSessionId: uuid });
               console.log(`[PTY] Backfilled resumeSessionId=${uuid} for session ${sessionId}`);
+              backfilled = true;
             }
           } catch (_) {}
 
+          if (!backfilled) return;
+
           // Also store on the session object for layout saves
           session.detectedResumeId = uuid;
 
@@ -534,10 +641,9 @@ class PtySessionManager {
               if (ws.readyState === 1) ws.send(backfillMsg);
             } catch (_) {}
           }
-        } catch (err) {
-          console.log(`[PTY] UUID detection failed for ${sessionId}: ${err.message}`);
         }
-      }, 8000); // Wait 8s for Claude to create the JSONL file
+      );
+      session._cancelWatch = cancelWatch;
     }
 
     return session;
@@ -720,6 +826,12 @@ class PtySessionManager {
       session.pingInterval = null;
     }
 
+    // Cancel any in-flight JSONL watcher (idempotent if it already resolved)
+    if (typeof session._cancelWatch === 'function') {
+      try { session._cancelWatch(); } catch (_) {}
+      session._cancelWatch = null;
+    }
+
     // Kill the PTY process
     if (session.alive) {
       try {
@@ -828,4 +940,4 @@ class PtySessionManager {
   }
 }
 
-module.exports = { PtySessionManager };
+module.exports = { PtySessionManager, __test: { waitForNewJsonl } };