claude-code-session-manager 0.91.1 → 0.92.1

package/src/main/lib/epicSpawnPlan.cjs

@@ -8,11 +8,13 @@
  * conversation found"), the flag-swap retry then hit `--session-id` ("already in use"), and both
  * doors were locked.
  *
- * Chosen fix: (a) first — resolveEpicSpawnCwd({restore:true}) re-attaches the Epic's own branch
- * at the SAME recorded path (encoding unchanged), so the CLI sees the transcript again. When that
- * is impossible, (b): refuse BEFORE spawning with an actionable message naming the missing
- * worktree path, never claim a flag that cannot work. Reachability = "some existing transcript
- * lives under encodeCwd(spawn cwd)" and the spawn cwd is a real directory.
+ * Three-way decision: (1) re-attach — resolveEpicSpawnCwd({restore:true}) re-attaches the Epic's
+ * own branch at the SAME recorded path (encoding unchanged), so the CLI sees the transcript again;
+ * (2) project-cwd fallback — when that spawn cwd cannot see the transcript but the project cwd can
+ * (transcript filed under encodeCwd(project cwd)), spawn from the project cwd; nothing forks since
+ * it writes to the directory it already occupies; (3) refuse BEFORE spawning with a message stating
+ * the real cause, never claim a flag that cannot work. Reachable = "some existing transcript lives
+ * under encodeCwd(candidate cwd)" and the candidate is a real directory.
  *
  * Also refuses requests routed to a closed (`completed`) Epic, and keeps a per-session circuit
  * breaker: once a session is found unreachable, later requests are refused after ONE stat (is the
@@ -95,19 +97,32 @@ function planEpicSpawn({ cwd, claudeSessionId, fallbackResume = false, deps = {}
     useResume = !!resolved.existsAnywhere;
   } catch { /* keep the caller-supplied flag */ }
 
-  const execCwd = (deps.resolveSpawnCwd || resolveEpicSpawnCwd)({ cwd, claudeSessionId, deps: { restore: true, readActiveIndex: deps.readActiveIndex, statSync: deps.statSync, restoreWorktree: deps.restoreWorktree } });
+  let execCwd = (deps.resolveSpawnCwd || resolveEpicSpawnCwd)({ cwd, claudeSessionId, deps: { restore: true, readActiveIndex: deps.readActiveIndex, statSync: deps.statSync, restoreWorktree: deps.restoreWorktree } });
 
   if (resolved && resolved.existsAnywhere) {
     const projectsDir = path.join(deps.homeDir || os.homedir(), '.claude', 'projects');
-    const home = path.join(projectsDir, encodeCwd(execCwd));
-    const reachable = isDir(execCwd, statSync) && resolved.existingPaths.some((p) => path.dirname(p) === home);
-    if (!reachable) {
+    // O(candidates × existingPaths); both are tiny. Candidate order: chosen execCwd, then project cwd.
+    const findReachable = (dir) => {
+      if (!isDir(dir, statSync)) return null;
+      const home = path.join(projectsDir, encodeCwd(dir));
+      return resolved.existingPaths.find((p) => path.dirname(p) === home) || null;
+    };
+    let hit = findReachable(execCwd);
+    if (!hit && execCwd !== cwd) {
+      // The transcript may already live under the project encoding; spawning there writes back to
+      // the directory it occupies, so nothing forks.
+      hit = findReachable(cwd);
+      if (hit) execCwd = cwd;
+    }
+    if (!hit) {
       const missing = brokenDir || execCwd;
+      const wt = epic?.worktree;
+      const recovery = wt?.status === 'merged'
+        ? `That checkout was removed when the Epic was merged to main and its ${wt.branch || 'sm-epic/*'} branch was deleted, so it cannot be recreated. Start a new Epic.`
+        : `The checkout is gone and could not be re-attached (it may have been swept from its temp/state directory). Recreate it (git worktree add "${missing}" ${wt?.branch || '<sm-epic branch>'}) or start a new Epic.`;
       const message =
         `Session ${claudeSessionId} cannot be resumed: its transcript is at ${resolved.existingPaths[0]}, ` +
-        `which the CLI only finds when run from ${missing}, and that worktree no longer exists and could not be ` +
-        `re-attached (likely swept from /tmp). Recreate it (git worktree add "${missing}" ${epic?.worktree?.branch || '<sm-epic branch>'}) ` +
-        `or start a new Epic.`;
+        `which the CLI only finds when run from ${missing}. ${recovery}`;
       unreachable.set(claudeSessionId, { dir: missing, message });
       return { ok: false, code: 'session_unreachable', message };
     }

package/src/main/lib/epicTranscriptPath.cjs

@@ -5,8 +5,9 @@
  * transcript actually live?".
  *
  * The CLI writes `~/.claude/projects/<encodeCwd(spawn cwd)>/<id>.jsonl`, and an
- * Epic's spawn cwd is its isolated worktree dir (chatRunner.cjs via
- * resolveEpicSpawnCwd), NOT the project cwd. Turn 1 can still land under the
+ * Epic's spawn cwd is normally its isolated worktree dir (chatRunner.cjs and
+ * pty.cjs via epicSpawnPlan.cjs), falling back to the project cwd when the
+ * worktree is merged/gone. Turn 1 can still land under the
  * project encoding (the worktree mint is fire-and-forget), and the worktree dir
  * itself is routinely swept from /tmp while its transcript survives under
  * ~/.claude/projects. So candidates are built from the recorded `worktree.dir`

package/src/main/lib/epicWorktreeMerge.cjs

@@ -17,10 +17,10 @@
  * On success the worktree checkout is torn down (cleanupEpicWorktree) since
  * its content now safely lives on the main tree. On a real conflict, the
  * branch and worktree directory are left intact — never silently discarded
- * — so a human can still open a Terminal into `worktree.dir` (PRD 1033's
- * existing epicSpawnCwd.cjs wiring — it keys off `worktree.dir` alone, not
- * `worktree.status`, so a conflicted Epic's Terminal spawn keeps landing
- * there with no new code path needed) and resolve it manually before
+ * — so a human can still open a Terminal into `worktree.dir` (the spawn
+ * resolution in epicSpawnCwd.cjs is status-aware: `needs_merge_resolution`
+ * with an existing dir still lands there, while `merged`/`disabled` skip the
+ * re-attach and fall back to the project cwd) and resolve it manually before
  * re-running this same action.
  */
 

package/src/main/lib/updateCheck.cjs

@@ -0,0 +1,102 @@
+'use strict';
+
+/**
+ * updateCheck.cjs — bounded, offline-safe, opt-out "is a newer build published?" probe.
+ *
+ * getUpdateStatus() → { current, latest, behind }. Never throws/rejects; any failure
+ * (offline, DNS, non-200, bad JSON, timeout) → { current, latest: null, behind: false }.
+ * The request is a bare GET (no headers/cookies/query/body) so it carries nothing that
+ * identifies the user or machine. Disabled by SM_UPDATE_CHECK=0 or E2E mode (SM_E2E=1).
+ */
+
+const https = require('node:https');
+const fs = require('node:fs');
+const path = require('node:path');
+
+const CACHE_TTL_MS = 6 * 60 * 60 * 1000;
+const REQUEST_TIMEOUT_MS = 3000;
+const CACHE_FILE = 'update-check.json';
+
+/** Plain GET → parsed JSON. Rejects on non-200, bad JSON, or timeout. */
+function httpGetJson(url, timeoutMs) {
+  return new Promise((resolve, reject) => {
+    const req = https.get(url, { timeout: timeoutMs }, (res) => {
+      if (res.statusCode !== 200) {
+        res.resume();
+        reject(new Error(`HTTP ${res.statusCode}`));
+        return;
+      }
+      let body = '';
+      res.setEncoding('utf8');
+      res.on('data', (c) => {
+        body += c;
+        if (body.length > 65536) req.destroy(new Error('response too large'));
+      });
+      res.on('end', () => {
+        try { resolve(JSON.parse(body)); } catch (e) { reject(e); }
+      });
+      res.on('error', reject);
+    });
+    req.on('timeout', () => req.destroy(new Error('timeout')));
+    req.on('error', reject);
+  });
+}
+
+function parseTriple(v) {
+  const m = /^v?(\d+)\.(\d+)\.(\d+)/.exec(String(v || ''));
+  return m ? [Number(m[1]), Number(m[2]), Number(m[3])] : null;
+}
+
+/** True iff `current` is strictly older than `latest` (numeric major.minor.patch). */
+function isBehind(current, latest) {
+  const a = parseTriple(current);
+  const b = parseTriple(latest);
+  if (!a || !b) return false;
+  for (let i = 0; i < 3; i++) {
+    if (a[i] !== b[i]) return a[i] < b[i];
+  }
+  return false;
+}
+
+function readCache(file, now) {
+  try {
+    const c = JSON.parse(fs.readFileSync(file, 'utf8'));
+    if (c && typeof c.latest === 'string' && typeof c.checkedAt === 'number'
+      && now - c.checkedAt >= 0 && now - c.checkedAt < CACHE_TTL_MS) return c.latest;
+  } catch { /* missing/corrupt cache = miss */ }
+  return null;
+}
+
+function defaultPackageName() {
+  return require(path.join(__dirname, '..', '..', '..', 'package.json')).name;
+}
+
+async function getUpdateStatus({ deps } = {}) {
+  const d = deps || {};
+  let current = '';
+  try {
+    const app = d.app || require('electron').app;
+    current = app.getVersion();
+    const env = d.env || process.env;
+    if (env.SM_UPDATE_CHECK === '0' || env.SM_E2E === '1') return { current, latest: null, behind: false };
+
+    const now = (d.now || Date.now)();
+    const file = path.join(app.getPath('userData'), CACHE_FILE);
+    let latest = readCache(file, now);
+    if (latest == null) {
+      const name = (d.packageName || defaultPackageName)();
+      const url = `https://registry.npmjs.org/-/package/${name}/dist-tags`;
+      const tags = await (d.fetchJson || httpGetJson)(url, REQUEST_TIMEOUT_MS);
+      latest = tags && typeof tags.latest === 'string' ? tags.latest : null;
+      if (latest == null) return { current, latest: null, behind: false };
+      try {
+        await (d.writeJson || require('../config.cjs').writeJson)(file, { checkedAt: now, latest });
+      } catch { /* cache is best-effort */ }
+    }
+    return { current, latest, behind: isBehind(current, latest) };
+  } catch {
+    return { current, latest: null, behind: false };
+  }
+}
+
+module.exports = { getUpdateStatus, isBehind };

package/src/main/pty.cjs

@@ -22,6 +22,7 @@ const { cleanChildEnv, pathWithUserBins } = require('./lib/cleanEnv.cjs');
 const { checkInsideHome } = require('./lib/insideHome.cjs');
 const { sendIfAlive } = require('./lib/sendToRenderer.cjs');
 const opsErrorLog = require('./lib/opsErrorLog.cjs');
+const { planEpicSpawn } = require('./lib/epicSpawnPlan.cjs');
 const { resolveEpicSpawnCwd } = require('./lib/epicSpawnCwd.cjs');
 const telemetryCounters = require('./lib/telemetryCounters.cjs');
 
@@ -176,12 +177,37 @@ class PtyManager {
 
     const shell = process.env.SHELL || '/bin/bash';
     console.log('[pty] spawning shell', shell);
-    // Tab ID = claudeSessionId (see CLAUDE.md), so for an Epic-attached tab
-    // this resolves the Epic's own record in `cwd`'s active-index.json and
-    // returns its isolated worktree dir when one exists — `cwd` itself is
-    // NEVER repointed; only this actual PTY spawn option is. See
-    // epicSpawnCwd.cjs's header comment (the ops-root hazard) for why.
-    const spawnCwd = resolveEpicSpawnCwd({ cwd, claudeSessionId: tabId, deps: { restore: true } });
+    // Tab ID = claudeSessionId (see CLAUDE.md), and Chat/Terminal are two views over ONE session,
+    // so this asks the same decision function chatRunner.cjs does (epicSpawnPlan.cjs). `cwd`
+    // itself is NEVER repointed; only this actual PTY spawn option is (epicSpawnCwd.cjs's
+    // ops-root hazard). A refused plan is surfaced in-tab rather than spawning into a bad cwd.
+    // Split: Chat and Terminal share this one verdict function, but the Terminal additionally
+    // downgrades `epic_closed` to a plain shell — it opens `$SHELL -il` (no --resume, no
+    // transcript write), not a chat turn. That path uses the read-side resolver WITHOUT
+    // `deps.restore`, so opening a closed Epic's terminal never re-attaches a checkout.
+    const plan = planEpicSpawn({ cwd, claudeSessionId: tabId });
+    let spawnCwd;
+    if (plan.ok) {
+      spawnCwd = plan.execCwd;
+    } else if (plan.code === 'epic_closed') {
+      spawnCwd = resolveEpicSpawnCwd({ cwd, claudeSessionId: tabId });
+      sendIfAlive(
+        this.window,
+        `pty:data:${tabId}`,
+        `\r\nThis Epic is completed \u2014 opening a read-only shell in ${spawnCwd}. Start a new Epic for new work.\r\n`,
+      );
+    } else {
+      opsErrorLog.appendError({
+        cwd,
+        scope: 'pty',
+        tabId,
+        tags: ['spawn-refused', plan.code],
+        message: plan.message,
+      });
+      sendIfAlive(this.window, `pty:data:${tabId}`, `\r\n${plan.message}\r\n`);
+      setImmediate(() => sendIfAlive(this.window, `pty:exit:${tabId}`, { exitCode: 1, signal: undefined }));
+      return { pid: null, cwd, reattached: false, error: plan.message };
+    }
     if (spawnCwd !== cwd) {
       console.log(`[pty] tabId=${tabId} isolated in worktree ${spawnCwd}`);
     }

package/src/preload/api.d.ts

@@ -1541,6 +1541,8 @@ export interface ChatExternalSendEvent {
 export interface SessionManagerAPI {
   app: {
     version: () => Promise<string>;
+    /** Published-`latest` probe (cached 6h, opt-out SM_UPDATE_CHECK=0). Never rejects; offline → latest null. */
+    updateStatus: () => Promise<{ current: string; latest: string | null; behind: boolean }>;
     homeDir: () => Promise<string>;
     cwd: () => Promise<string>;
     engageRulesPath: () => Promise<string | null>;

package/src/preload/index.cjs

@@ -3,6 +3,7 @@ const { contextBridge, ipcRenderer } = require('electron');
 contextBridge.exposeInMainWorld('api', {
   app: {
     version: () => ipcRenderer.invoke('app:version'),
+    updateStatus: () => ipcRenderer.invoke('app:update-status'),
     homeDir: () => ipcRenderer.invoke('app:home-dir'),
     cwd: () => ipcRenderer.invoke('app:cwd'),
     engageRulesPath: () => ipcRenderer.invoke('app:engage-rules-path'),