claude-code-session-manager 0.17.1 → 0.17.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-code-session-manager",
-  "version": "0.17.1",
+  "version": "0.17.2",
   "description": "Local cockpit for the Claude Code CLI — multi-tab terminal, full config surface, scheduler, voice dictation, and live observability.",
   "type": "module",
   "main": "src/main/index.cjs",

package/src/main/index.cjs

@@ -48,6 +48,52 @@ let rebooting = false;
 // powerSaveBlocker handle — keeps the system from suspending while the app runs
 // so the scheduler's polling and jobs aren't frozen. -1 = not held.
 let powerBlockerId = -1;
+// Linux-only backstop. Electron's `powerSaveBlocker('prevent-app-suspension')`
+// leans on org.gnome.SessionManager, which COSMIC (Pop!_OS 24.04+) doesn't
+// implement — under COSMIC it silently registers only a *delay*-mode logind
+// lock, which postpones suspend by seconds instead of blocking it, so the
+// machine idle-suspends with the app open. We spawn our own block-mode
+// `systemd-inhibit` child, which talks straight to logind and is
+// desktop-agnostic. Handle to the child so we can release it on quit.
+let systemdInhibitChild = null;
+
+function startSystemdInhibit() {
+  if (process.platform !== 'linux') return;
+  // Idempotent: if a live child already holds the lock, don't spawn a second.
+  if (systemdInhibitChild && systemdInhibitChild.exitCode === null && !systemdInhibitChild.killed) return;
+  try {
+    // `sleep:idle` blocks both explicit suspend and the idle-action timer.
+    // The holder is a poll on OUR pid rather than `sleep infinity`: when the
+    // main process dies — graceful quit, SIGKILL, OR an OOM crash — `kill -0`
+    // fails within one tick and the holder exits, releasing the lock. Without
+    // this the child reparents to init on a hard kill and the inhibitor leaks
+    // forever (one stranded lock per crash). 5s tick = worst-case 5s of stale
+    // lock after death, which errs toward "stay awake" — the safe direction.
+    const child = spawn('systemd-inhibit', [
+      '--what=sleep:idle',
+      '--who=Claude Session Manager',
+      '--why=Scheduler polling and claude -p jobs must survive idle',
+      '--mode=block',
+      'sh', '-c', `while kill -0 ${process.pid} 2>/dev/null; do sleep 5; done`,
+    ], { stdio: 'ignore', detached: false });
+    child.on('error', (e) => {
+      logs.writeLine({ scope: 'main', level: 'warn', message: 'systemd-inhibit spawn failed', meta: { error: e?.message } });
+    });
+    if (child.pid) {
+      systemdInhibitChild = child;
+      logs.writeLine({ scope: 'main', level: 'info', message: 'systemd-inhibit block lock held', meta: { pid: child.pid } });
+    }
+  } catch (e) {
+    logs.writeLine({ scope: 'main', level: 'warn', message: 'systemd-inhibit unavailable', meta: { error: e?.message } });
+  }
+}
+
+function stopSystemdInhibit() {
+  if (systemdInhibitChild) {
+    try { systemdInhibitChild.kill('SIGTERM'); } catch { /* */ }
+    systemdInhibitChild = null;
+  }
+}
 
 // Boot diagnostics — populated at app.whenReady so the renderer can poll their
 // state via IPC and surface toasts on the failure paths. The first-paint
@@ -878,6 +924,8 @@ app.whenReady().then(async () => {
   } catch (e) {
     logs.writeLine({ scope: 'main', level: 'warn', message: 'powerSaveBlocker failed', meta: { error: e?.message } });
   }
+  // Linux backstop — Electron's blocker no-ops under COSMIC (see above).
+  startSystemdInhibit();
 
   // OTEL: load persisted config and start the exporter only if `enabled`.
   // Failures are non-fatal — the app must keep working without telemetry.
@@ -904,6 +952,7 @@ app.on('will-quit', () => {
     try { powerSaveBlocker.stop(powerBlockerId); } catch { /* */ }
     powerBlockerId = -1;
   }
+  stopSystemdInhibit();
 });
 
 app.on('window-all-closed', () => {