claude-code-session-manager 0.28.0 → 0.30.0

package/src/main/pluginInstall.cjs

@@ -20,13 +20,29 @@ const { ipcMain } = require('electron');
 const pty = require('node-pty');
 const path = require('node:path');
 const os = require('node:os');
-const { cleanChildEnv } = require('./lib/cleanEnv.cjs');
+const fs = require('node:fs');
+const { cleanChildEnv, pathWithUserBins } = require('./lib/cleanEnv.cjs');
 const { resolveClaudeBin } = require('./lib/claudeBin.cjs');
 const { sendIfAlive } = require('./lib/sendToRenderer.cjs');
 const { schemas } = require('./ipcSchemas.cjs');
 
 const SLUG_RE = /^[a-z0-9\-/]+$/;
+// Marketplace name: same shape as a plugin slug. Marketplace source (`add`):
+// a GitHub `owner/repo` (case-sensitive) or a dotted/hyphenated path segment.
+// Deliberately excludes whitespace, flags (leading `-`), and shell metachars.
+const MKT_NAME_RE = /^[a-z0-9\-/]+$/;
+const MKT_ADD_RE = /^[A-Za-z0-9][A-Za-z0-9._\-]*\/[A-Za-z0-9._\-]+$/;
+// Sentinel: register the marketplace that ships inside this app's own files
+// (the npx distribution). Resolved to an absolute path in-process so the
+// renderer never supplies a filesystem path. Works offline — no GitHub/npm.
+const BUNDLED_ADD = 'bundled';
 const MAX_LINE_BYTES = 16 * 1024;
+
+/** Absolute path to the packaged marketplace root (package dir holding
+ *  `.claude-plugin/marketplace.json`). src/main/ → ../../ */
+function bundledMarketplaceDir() {
+  return path.join(__dirname, '..', '..');
+}
 const KILL_AFTER_MS = 5 * 60 * 1000; // 5 min hard ceiling per install
 const KILL_GRACE_MS = 5_000;          // SIGTERM → SIGKILL escalation window
 
@@ -41,52 +57,43 @@ function send(channel, payload) {
   sendIfAlive(mainWindow, channel, payload);
 }
 
-function install({ slug }) {
-  if (typeof slug !== 'string' || !SLUG_RE.test(slug) || slug.length > 128) {
-    return Promise.resolve({ ok: false, exitCode: -1, error: 'invalid slug' });
-  }
-  if (inFlight.has(slug)) {
-    return Promise.resolve({ ok: false, exitCode: -1, error: 'install already in progress' });
-  }
+function childEnv() {
+  return cleanChildEnv({
+    PATH: pathWithUserBins(),
+    TERM: 'xterm-256color',
+    FORCE_COLOR: '0', // strip ANSI so the renderer doesn't have to.
+  });
+}
 
+/**
+ * Run one `claude plugin …` pty step, streaming output under `slug` and
+ * resolving with the exit code. `register`/`unregister` thread the live proc
+ * into the inFlight map so plugins:abort can kill whichever step is current.
+ */
+function runStep({ slug, args, register, unregister }) {
   return new Promise((resolve) => {
-    const home = os.homedir();
-    const extraPath = [
-      path.join(home, '.local', 'bin'),
-      path.join(home, '.npm-global', 'bin'),
-      '/usr/local/bin',
-      '/usr/bin',
-      '/bin',
-    ].join(':');
-    const env = cleanChildEnv({
-      PATH: `${extraPath}:${process.env.PATH || ''}`,
-      TERM: 'xterm-256color',
-      FORCE_COLOR: '0', // strip ANSI so the renderer doesn't have to.
-    });
-
     const claudeBin = resolveClaudeBin();
     let proc;
     try {
-      proc = pty.spawn(claudeBin, ['plugin', 'install', slug], {
+      proc = pty.spawn(claudeBin, args, {
         name: 'xterm-256color',
         cols: 120,
         rows: 30,
-        cwd: home,
-        env,
+        cwd: os.homedir(),
+        env: childEnv(),
       });
     } catch (err) {
       resolve({ ok: false, exitCode: -1, error: `spawn failed: ${err?.message ?? String(err)}` });
       return;
     }
 
-    inFlight.set(slug, proc);
+    register(proc);
 
     let lineBuf = '';
     let settled = false;
 
     const killTimer = setTimeout(() => {
       try { proc.kill('SIGTERM'); } catch { /* */ }
-      // Escalate to SIGKILL after KILL_GRACE_MS if the pty hasn't exited.
       const escalate = setTimeout(() => {
         try { proc.kill('SIGKILL'); } catch { /* already dead */ }
       }, KILL_GRACE_MS);
@@ -96,11 +103,11 @@ function install({ slug }) {
 
     // Belt-and-suspenders: if onExit never fires (broken pty event path after
     // SIGKILL — analogous to anthropics/claude-code #61735's unreachable pts),
-    // force-release the inFlight lock so the slug isn't permanently stuck.
+    // force-resolve so the step (and its inFlight lock) isn't permanently stuck.
     const deadman = setTimeout(() => {
       if (settled) return;
       settled = true;
-      inFlight.delete(slug);
+      unregister();
       resolve({ ok: false, exitCode: -1, error: 'install hung — pty onExit never fired' });
     }, KILL_AFTER_MS + KILL_GRACE_MS + 30_000);
     if (deadman.unref) deadman.unref();
@@ -113,7 +120,6 @@ function install({ slug }) {
         lineBuf = lineBuf.slice(nl + 1);
         send('plugins:install-progress', { slug, line });
       }
-      // Guard runaway buffers without newlines.
       if (lineBuf.length > MAX_LINE_BYTES) {
         send('plugins:install-progress', { slug, line: lineBuf });
         lineBuf = '';
@@ -129,13 +135,81 @@ function install({ slug }) {
         send('plugins:install-progress', { slug, line: lineBuf });
         lineBuf = '';
       }
-      inFlight.delete(slug);
+      unregister();
       const code = typeof exitCode === 'number' ? exitCode : -1;
       resolve({ ok: code === 0, exitCode: code });
     });
   });
 }
 
+/**
+ * Install a plugin. Without `marketplace`, runs `claude plugin install <slug>`
+ * (official catalog is pre-registered). With `marketplace: { add, name }`,
+ * first runs `claude plugin marketplace add <add>` to register the source, then
+ * installs `<slug>@<name>` — this is what a non-official plugin (e.g. the
+ * bundled session-manager-dev) needs on a fresh machine.
+ */
+async function install({ slug, marketplace }) {
+  if (typeof slug !== 'string' || !SLUG_RE.test(slug) || slug.length > 128) {
+    return { ok: false, exitCode: -1, error: 'invalid slug' };
+  }
+  let mkt = null;
+  if (marketplace != null) {
+    const { add, name } = marketplace;
+    const addValid = typeof add === 'string' && add.length <= 200 &&
+      (add === BUNDLED_ADD || MKT_ADD_RE.test(add));
+    if (!addValid || typeof name !== 'string' || !MKT_NAME_RE.test(name) || name.length > 128) {
+      return { ok: false, exitCode: -1, error: 'invalid marketplace' };
+    }
+    // Resolve the `bundled` sentinel to the app's own packaged marketplace dir.
+    let addArg = add;
+    if (add === BUNDLED_ADD) {
+      const dir = bundledMarketplaceDir();
+      if (!fs.existsSync(path.join(dir, '.claude-plugin', 'marketplace.json'))) {
+        return { ok: false, exitCode: -1, error: 'bundled marketplace not found' };
+      }
+      addArg = dir;
+    }
+    mkt = { add: addArg, name };
+  }
+  if (inFlight.has(slug)) {
+    return { ok: false, exitCode: -1, error: 'install already in progress' };
+  }
+
+  // Reserve the slug for the whole sequence; each step swaps in its live proc.
+  inFlight.set(slug, null);
+  const register = (proc) => inFlight.set(slug, proc);
+  const release = () => inFlight.delete(slug);
+  // Between steps the slug stays reserved (set to null) so a concurrent call
+  // can't slip in; runStep's unregister only clears the per-step proc handle.
+  const unregisterStep = () => inFlight.set(slug, null);
+
+  try {
+    if (mkt) {
+      const added = await runStep({
+        slug,
+        args: ['plugin', 'marketplace', 'add', mkt.add],
+        register,
+        unregister: unregisterStep,
+      });
+      // Tolerate "already added" — the add command exits non-zero when the
+      // marketplace is already registered; fall through to install regardless.
+      if (!added.ok) {
+        send('plugins:install-progress', { slug, line: `[marketplace add exit ${added.exitCode} — continuing to install]` });
+      }
+    }
+    const installTarget = mkt ? `${slug}@${mkt.name}` : slug;
+    return await runStep({
+      slug,
+      args: ['plugin', 'install', installTarget],
+      register,
+      unregister: unregisterStep,
+    });
+  } finally {
+    release();
+  }
+}
+
 function registerPluginInstallHandlers() {
   ipcMain.handle('plugins:install', async (_e, payload) => {
     // safeParse to preserve the existing `{ ok:false, exitCode:-1, error }`
@@ -145,7 +219,7 @@ function registerPluginInstallHandlers() {
     if (!parsed.success) {
       return { ok: false, exitCode: -1, error: 'invalid slug' };
     }
-    return install({ slug: parsed.data.slug });
+    return install({ slug: parsed.data.slug, marketplace: parsed.data.marketplace });
   });
 
   // plugins:abort — send SIGKILL to a stuck install and release the inFlight
@@ -164,4 +238,4 @@ function registerPluginInstallHandlers() {
   });
 }
 
-module.exports = { registerPluginInstallHandlers, attachWindow };
+module.exports = { registerPluginInstallHandlers, attachWindow, install, bundledMarketplaceDir };

package/src/main/pty.cjs

@@ -4,7 +4,7 @@ const path = require('node:path');
 const os = require('node:os');
 const fs = require('node:fs');
 const { addAllowedRoot } = require('./config.cjs');
-const { cleanChildEnv } = require('./lib/cleanEnv.cjs');
+const { cleanChildEnv, pathWithUserBins } = require('./lib/cleanEnv.cjs');
 const { checkInsideHome } = require('./lib/insideHome.cjs');
 const { sendIfAlive } = require('./lib/sendToRenderer.cjs');
 
@@ -62,18 +62,11 @@ class PtyManager {
       return { pid: existing.proc.pid, cwd: existing.cwd, reattached: true };
     }
 
-    // Prefer `claude` on PATH; extend PATH with common user bin dirs since
-    // Electron can launch with a stripped environment.
-    const extraPath = [
-      path.join(os.homedir(), '.local', 'bin'),
-      path.join(os.homedir(), '.npm-global', 'bin'),
-      '/usr/local/bin',
-      '/usr/bin',
-      '/bin',
-    ].join(':');
-
+    // Prefer `claude` on PATH; extend PATH with common user + Homebrew bin dirs
+    // since Electron can launch with a stripped environment (Apple Silicon
+    // Homebrew is /opt/homebrew, absent from the default Electron PATH).
     const env = cleanChildEnv({
-      PATH: `${extraPath}:${process.env.PATH || ''}`,
+      PATH: pathWithUserBins(),
       TERM: 'xterm-256color',
       COLORTERM: 'truecolor',
       FORCE_COLOR: '1',

package/src/main/scheduler.cjs

@@ -48,7 +48,7 @@ const { randomUUID } = require('node:crypto');
 const { execFile } = require('node:child_process');
 const { ipcMain } = require('electron');
 const billing = require('./usage.cjs');
-const { cleanChildEnv } = require('./lib/cleanEnv.cjs');
+const { cleanChildEnv, pathWithUserBins } = require('./lib/cleanEnv.cjs');
 const supervisor = require('./supervisor.cjs');
 const { resolveClaudeBin } = require('./lib/claudeBin.cjs');
 const { readTail } = require('./lib/fileTail.cjs');
@@ -921,7 +921,9 @@ async function executeJob(job, runDir, defaultCwd, onPid) {
     // Strip Claude Code env and secrets that leak in when session-manager is
     // launched from a `claude` shell. CLAUDE_EFFORT=xhigh forces Opus and
     // overrides `--model sonnet`, so scheduled jobs burn Opus credits silently.
-    const childEnv = cleanChildEnv();
+    // PATH must include Homebrew/user bins or the job's node/git children ENOENT
+    // when Electron was launched from Finder/Dock on macOS (stripped PATH).
+    const childEnv = cleanChildEnv({ PATH: pathWithUserBins() });
 
     // Track whether the agent has emitted a `result` event in its JSONL stream.
     // null until seen; then one of "success" | "error_max_turns" | … per the
@@ -1230,7 +1232,7 @@ DO NOT attempt the fix. ONLY write the file. When the file exists, exit immediat
   }
 
   const claudeBin = resolveClaudeBin();
-  const childEnv = cleanChildEnv();
+  const childEnv = cleanChildEnv({ PATH: pathWithUserBins() }); // Homebrew/user bins for macOS
 
   // Investigation needs only a deadman watchdog — no idle-tail or result-tail
   // since investigations are short-running Opus probes with a hard ceiling.
@@ -1685,6 +1687,34 @@ function pollRecoveryClearSource(pauseReason, hasCachedReset) {
 async function pollLoop() {
   try {
     await reapDeadRunningJobs().catch(() => {});
+
+    // Enterprise auth (Bedrock / Vertex / API-key / corporate gateway): there is
+    // no consumer 5-hour usage meter to poll. Don't hit an endpoint that will
+    // 404/time-out and eventually pause the queue on 'network' — treat usage as
+    // wide-open and fire on pending + memory alone. (Blackrock-style machines.)
+    if (!billing.usageMeterApplicable()) {
+      cachedUtilization = 0;
+      consecutiveFailures = 0;
+      backoffMs = 0;
+      backoffNextAt = null;
+      firstFailureAt = null;
+      firstNon429FailureAt = null;
+      lastFailureKind = null;
+      lastPollAt = Date.now();
+      lastPollOk = true;
+      persistSchedulerState();
+      let cur = await readQueue();
+      // Clear a stale auth/network pause inherited from a prior consumer-auth
+      // session so the queue isn't wedged. Never clears rate_limit/manual.
+      if (cur.paused && (cur.paused.reason === 'auth' || cur.paused.reason === 'network')) {
+        await clearPause('enterprise-auth');
+        cur = await readQueue(); // re-read so the cleared pause is visible to launch THIS cycle
+      }
+      await maybeLaunchWhenAvailable(cur);
+      await broadcast();
+      return; // finally re-arms the timer
+    }
+
     const r = await billing.fetchUsage();
 
     if (r.kind === 'ok') {
@@ -1701,9 +1731,12 @@ async function pollLoop() {
       persistSchedulerState();
 
       // Clear any pause that was waiting for a successful billing read.
-      const cur = await readQueue();
+      let cur = await readQueue();
       const clearSrc = pollRecoveryClearSource(cur.paused?.reason ?? null, !!cachedNextReset);
-      if (clearSrc) await clearPause(clearSrc);
+      if (clearSrc) {
+        await clearPause(clearSrc);
+        cur = await readQueue(); // re-read so the cleared pause launches work THIS cycle
+      }
 
       await maybeLaunchWhenAvailable(cur);
       await broadcast();

package/src/main/seedDevPlugin.cjs

@@ -0,0 +1,95 @@
+/**
+ * First-boot seeder for the bundled `session-manager-dev` plugin.
+ *
+ * The plugin (its 10 dev skills) ships inside the npx distribution. To make it
+ * a true default, the app installs it on first launch from its own bundled
+ * marketplace (offline — no GitHub/registry). Idempotent two ways:
+ *
+ *   1. A marker file (`~/.claude/session-manager/.dev-plugin-seeded`) records
+ *      seed state. Once the install SUCCEEDS we write `done` and never touch it
+ *      again, so a deliberate uninstall stays uninstalled. A FAILED attempt only
+ *      bumps an attempt counter and retries on the next few boots — a transient
+ *      first-boot failure (e.g. `claude` not yet on PATH, briefly offline) must
+ *      not permanently skip the default plugin. After MAX_ATTEMPTS we give up
+ *      (manual install via the Plugins library button is always available).
+ *   2. Before attempting, we check settings.json `enabledPlugins` — if the
+ *      plugin is already enabled (e.g. installed by hand), we just write the
+ *      marker and skip the install.
+ *
+ * Fire-and-forget: called post-window from index.cjs. Errors are logged, never
+ * thrown. Kill-switch: SM_SEED_DEV_PLUGIN_DISABLE=1.
+ */
+
+const fs = require('node:fs');
+const path = require('node:path');
+const os = require('node:os');
+const { install } = require('./pluginInstall.cjs');
+
+const PLUGIN_SLUG = 'session-manager-dev';
+const MARKETPLACE = { add: 'bundled', name: 'session-manager' };
+const ENABLED_KEY = `${PLUGIN_SLUG}@${MARKETPLACE.name}`;
+const MAX_ATTEMPTS = 3; // give a transient first-boot failure a few chances
+
+function markerPath() {
+  return path.join(os.homedir(), '.claude', 'session-manager', '.dev-plugin-seeded');
+}
+
+/** Read the marker → { done:boolean, attempts:number }. Absent = fresh. */
+function readMarker() {
+  try {
+    const raw = fs.readFileSync(markerPath(), 'utf8').trim();
+    const m = JSON.parse(raw);
+    return { done: !!m.done, attempts: Number(m.attempts) || 0 };
+  } catch {
+    return { done: false, attempts: 0 };
+  }
+}
+
+function alreadyEnabled() {
+  try {
+    const raw = fs.readFileSync(path.join(os.homedir(), '.claude', 'settings.json'), 'utf8');
+    const enabled = JSON.parse(raw)?.enabledPlugins;
+    return !!(enabled && enabled[ENABLED_KEY]);
+  } catch {
+    return false; // settings absent/unparseable — treat as not-enabled.
+  }
+}
+
+function writeMarker(state) {
+  try {
+    const p = markerPath();
+    fs.mkdirSync(path.dirname(p), { recursive: true });
+    fs.writeFileSync(p, JSON.stringify({ ...state, ts: new Date().toISOString() }) + '\n');
+  } catch (err) {
+    console.warn('[seedDevPlugin] could not write marker:', err?.message ?? err);
+  }
+}
+
+async function seedDevPlugin({ logger = console } = {}) {
+  if (process.env.SM_SEED_DEV_PLUGIN_DISABLE === '1') return;
+  const marker = readMarker();
+  if (marker.done) return;                       // succeeded before — leave it alone.
+  if (marker.attempts >= MAX_ATTEMPTS) return;   // gave up — manual install only.
+
+  try {
+    if (alreadyEnabled()) {
+      writeMarker({ done: true, attempts: marker.attempts });
+      return;
+    }
+    logger.log?.('[seedDevPlugin] installing bundled session-manager-dev plugin…');
+    const r = await install({ slug: PLUGIN_SLUG, marketplace: MARKETPLACE });
+    if (r.ok) {
+      logger.log?.('[seedDevPlugin] installed session-manager-dev@session-manager');
+      writeMarker({ done: true, attempts: marker.attempts });
+    } else {
+      // Failure: bump the attempt counter so the next boot can retry (bounded).
+      logger.warn?.(`[seedDevPlugin] install failed (exit ${r.exitCode})${r.error ? ` — ${r.error}` : ''}; attempt ${marker.attempts + 1}/${MAX_ATTEMPTS}`);
+      writeMarker({ done: false, attempts: marker.attempts + 1 });
+    }
+  } catch (err) {
+    logger.warn?.('[seedDevPlugin] error:', err?.message ?? err);
+    writeMarker({ done: false, attempts: marker.attempts + 1 });
+  }
+}
+
+module.exports = { seedDevPlugin };

package/src/main/usage.cjs

@@ -24,6 +24,39 @@ const { refreshIfNeeded, expiresAtMs } = require('./lib/credentials.cjs');
 const { writeJson } = require('./config.cjs');
 
 const USAGE_URL = 'https://api.anthropic.com/api/oauth/usage';
+
+/** A non-empty env value that isn't an explicit falsey string. */
+function envEnabled(v) {
+  return v != null && v !== '' && v !== '0' && String(v).toLowerCase() !== 'false';
+}
+
+/**
+ * Is the consumer 5-hour usage meter (/api/oauth/usage) even applicable here?
+ *
+ * That endpoint only exists for OAuth/subscription auth against
+ * api.anthropic.com. Enterprise auth modes have no such meter, so polling it
+ * just 404s/times-out — and the scheduler must NOT gate on (or pause for) it.
+ * Detected modes: Amazon Bedrock, Google Vertex, raw API-key, a custom auth
+ * token, or a non-Anthropic base URL (corporate gateway/proxy).
+ *
+ * Returns false → caller should treat usage as unavailable-by-design and fire
+ * work on its own (pending + memory) instead of waiting on a meter.
+ */
+function usageMeterApplicable(env = process.env) {
+  if (envEnabled(env.CLAUDE_CODE_USE_BEDROCK)) return false;
+  if (envEnabled(env.CLAUDE_CODE_USE_VERTEX)) return false;
+  if (env.ANTHROPIC_API_KEY) return false;
+  if (env.ANTHROPIC_AUTH_TOKEN) return false;
+  if (env.ANTHROPIC_BASE_URL) {
+    // Parse the host rather than substring-match, so a deceptive gateway like
+    // https://anthropic.com.attacker.example is correctly treated as enterprise.
+    let host;
+    try { host = new URL(env.ANTHROPIC_BASE_URL).hostname.toLowerCase(); }
+    catch { return false; } // unparseable custom URL → treat as a gateway
+    if (host !== 'anthropic.com' && !host.endsWith('.anthropic.com')) return false;
+  }
+  return true;
+}
 const CACHE_PATH = path.join(os.homedir(), '.claude', 'session-manager', 'billing-cache.json');
 // Coalesce the 4 renderer pollers (Overview/AppStatusBar/StatusBar/Usage). A
 // fresh ok-cache is served directly without touching the network. Auth/
@@ -164,4 +197,4 @@ function registerBillingHandlers() {
   });
 }
 
-module.exports = { registerBillingHandlers, fetchUsage, classifyUsageResponse };
+module.exports = { registerBillingHandlers, fetchUsage, classifyUsageResponse, usageMeterApplicable };

package/src/preload/api.d.ts

@@ -1025,8 +1025,14 @@ export interface SessionManagerAPI {
   };
   plugins: {
     /** Run `claude plugin install <slug>` in a hidden pty. Streams output
-     *  via `onInstallProgress`. Returns { ok, exitCode } on exit. */
-    install: (payload: { slug: string }) => Promise<PluginInstallResult>;
+     *  via `onInstallProgress`. Returns { ok, exitCode } on exit.
+     *  Pass `marketplace` for a non-official plugin: the source is registered
+     *  via `claude plugin marketplace add <add>` first, then `<slug>@<name>`
+     *  is installed. */
+    install: (payload: {
+      slug: string;
+      marketplace?: { add: string; name: string };
+    }) => Promise<PluginInstallResult>;
     onInstallProgress: (handler: (ev: PluginInstallProgressEvent) => void) => () => void;
   };
   clipboard: {