claude-code-session-manager 0.91.0 → 0.92.0

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,7 +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 { resolveEpicSpawnCwd } = require('./lib/epicSpawnCwd.cjs');
+const { planEpicSpawn } = require('./lib/epicSpawnPlan.cjs');
 const telemetryCounters = require('./lib/telemetryCounters.cjs');
 
 // Absolute path to the installed package root (src/main/ -> ../../), shown in
@@ -176,12 +176,24 @@ 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.
+    const plan = planEpicSpawn({ cwd, claudeSessionId: tabId });
+    if (!plan.ok) {
+      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 };
+    }
+    const spawnCwd = plan.execCwd;
     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'),