claude-code-session-manager 0.104.2 → 0.106.0

package/src/main/lib/claudeBin.cjs

@@ -17,28 +17,53 @@ const os = require('node:os');
 
 let cached = null;
 
-function resolveClaudeBin() {
+/**
+ * @param {{ platform?: string, env?: Record<string, string|undefined>, homedir?: string,
+ *   accessSync?: (p: string, mode?: number) => void }} [opts] injectable for tests;
+ *   passing any opts bypasses the process-lifetime cache.
+ */
+function resolveClaudeBin(opts) {
   // Explicit override wins and is never cached — lets operators pin a binary
   // and lets tests point the runner at a controllable stub process.
   if (process.env.SM_CLAUDE_BIN) return process.env.SM_CLAUDE_BIN;
-  if (cached) return cached;
-  // Merged candidate list — was forked in scheduler vs pluginInstall before.
-  const home = os.homedir();
-  const candidates = [
-    path.join(home, '.claude', 'local', 'claude'),    // Claude Code bundled install
-    path.join(home, '.local', 'bin', 'claude'),       // user pip-style install
-    path.join(home, '.npm-global', 'bin', 'claude'),  // user npm-global
-    '/usr/local/bin/claude',
-    '/opt/homebrew/bin/claude',
-    '/usr/bin/claude',
-  ];
+  const injected = !!opts;
+  if (!injected && cached) return cached;
+  const platform = (opts && opts.platform) || process.platform;
+  const env = (opts && opts.env) || process.env;
+  const home = (opts && opts.homedir) || os.homedir();
+  const accessSync = (opts && opts.accessSync) || fs.accessSync;
+  const P = platform === 'win32' ? path.win32 : path.posix;
+  let candidates;
+  let mode;
+  if (platform === 'win32') {
+    const w = P;
+    candidates = [];
+    if (env.USERPROFILE) candidates.push(w.join(env.USERPROFILE, '.local', 'bin', 'claude.exe')); // native installer
+    if (env.APPDATA) candidates.push(w.join(env.APPDATA, 'npm', 'claude.cmd'));
+    if (env.LOCALAPPDATA) candidates.push(w.join(env.LOCALAPPDATA, 'Programs', 'claude', 'claude.exe'));
+    mode = fs.constants.F_OK; // X_OK is meaningless on Windows
+  } else {
+    // Merged candidate list — was forked in scheduler vs pluginInstall before.
+    candidates = [
+      P.join(home, '.claude', 'local', 'claude'),    // Claude Code bundled install
+      P.join(home, '.local', 'bin', 'claude'),       // user pip-style install
+      P.join(home, '.npm-global', 'bin', 'claude'),  // user npm-global
+      '/usr/local/bin/claude',
+      '/opt/homebrew/bin/claude',
+      '/usr/bin/claude',
+    ];
+    mode = fs.constants.X_OK;
+  }
   for (const c of candidates) {
-    try { fs.accessSync(c, fs.constants.X_OK); cached = c; return c; } catch { /* */ }
+    try { accessSync(c, mode); if (!injected) cached = c; return c; } catch { /* */ }
   }
-  cached = 'claude';
-  return cached;
+  if (!injected) cached = 'claude';
+  return 'claude';
 }
 
+/** Test hook — forget the cached resolution. */
+function __resetForTests() { cached = null; }
+
 // ---------- process naming ----------
 //
 // Every `claude` spawn goes through claudeSpawnTarget so GNOME System Monitor
@@ -57,9 +82,22 @@ const ROLE_ALIASES = { job: 'sm-claude-job', chat: 'sm-claude-chat', aux: 'sm-cl
  * @param {'job'|'chat'|'aux'} role
  * @param {string} [detail] argv0 label detail (job slug / epic session id)
  * @param {string} [realBin] defaults to resolveClaudeBin()
- * @returns {{ command: string, argv0?: string }} spread `argv0` into spawn options
+ * @param {string[]} [args] the claude argv; only needed so a Windows .cmd/.bat shim can be wrapped
+ * @param {{ platform?: string, env?: Record<string, string|undefined>, exists?: (p: string) => boolean }} [winOpts] injectable for tests
+ * @returns {{ command: string, argv0?: string, args?: string[], windowsVerbatimArguments?: boolean }}
+ *   spread `argv0` into spawn options; when `args` is present spawn with it instead of the caller's argv
  */
-function claudeSpawnTarget(role, detail, realBin = resolveClaudeBin()) {
+function claudeSpawnTarget(role, detail, realBin = resolveClaudeBin(), args = [], winOpts = {}) {
+  const base = baseSpawnTarget(role, detail, realBin);
+  const platform = winOpts.platform || process.platform;
+  if (platform !== 'win32' || !/\.(cmd|bat)$/i.test(base.command)) return base;
+  // Node refuses to spawn a .cmd/.bat without a shell (EINVAL) — wrap in cmd.exe argv.
+  const { resolveSpawn } = require('./winSpawn.cjs');
+  const wrapped = resolveSpawn(base.command, args, { platform, ...(winOpts.env ? { env: winOpts.env } : {}), ...(winOpts.exists ? { exists: winOpts.exists } : {}) });
+  return { ...base, ...wrapped };
+}
+
+function baseSpawnTarget(role, detail, realBin) {
   if (process.env.SM_CLAUDE_BIN) return { command: realBin };
   const alias = ROLE_ALIASES[role];
   if (!alias) return { command: realBin };
@@ -109,8 +147,8 @@ function probeClaudeVersion({ now = Date.now(), execFileImpl } = {}) {
       // it, and the binary must never be handed the caller's working tree —
       // a stub `claude` (tests point SM_CLAUDE_BIN at one) that writes
       // markers or commits into process.cwd() once did so in the real repo.
-      const target = claudeSpawnTarget('aux', 'version', bin);
-      execFile(target.command, ['--version'], { timeout: VERSION_PROBE_TIMEOUT_MS, windowsHide: true, cwd: os.tmpdir(), ...(target.argv0 ? { argv0: target.argv0 } : {}) }, (err, stdout) => {
+      const target = claudeSpawnTarget('aux', 'version', bin, ['--version']);
+      execFile(target.command, target.args || ['--version'], { timeout: VERSION_PROBE_TIMEOUT_MS, windowsHide: true, cwd: os.tmpdir(), ...(target.argv0 ? { argv0: target.argv0 } : {}), ...(target.windowsVerbatimArguments ? { windowsVerbatimArguments: true } : {}) }, (err, stdout) => {
         if (err) return done(null);
         const m = /(\d+\.\d+\.\d+[^\s]*)/.exec(String(stdout || ''));
         done(m ? m[1] : (String(stdout || '').trim() || null));
@@ -127,4 +165,4 @@ function resetClaudeVersionCache() {
   versionCache = { at: 0, value: null, inflight: null };
 }
 
-module.exports = { resolveClaudeBin, claudeSpawnTarget, probeClaudeVersion, resetClaudeVersionCache };
+module.exports = { resolveClaudeBin, __resetForTests, claudeSpawnTarget, probeClaudeVersion, resetClaudeVersionCache };

package/src/main/lib/cleanEnv.cjs

@@ -11,12 +11,26 @@ const SECRET_KEY_RE = /^(?:.*_)?(TOKEN|API_?KEY|SECRET|PASSWORD|AUTHORIZATION|CO
  * so pty.cjs and pluginInstall.cjs can't drift (one of them was missing
  * /opt/homebrew and broke plugin install on Apple Silicon).
  */
-function userBinDirs() {
-  const home = os.homedir();
+function userBinDirs(opts) {
+  const platform = (opts && opts.platform) || process.platform;
+  const P = platform === 'win32' ? path.win32 : path.posix;
+  if (platform === 'win32') {
+    const env = (opts && opts.env) || process.env;
+    const w = P;
+    const dirs = [];
+    if (env.USERPROFILE) dirs.push(w.join(env.USERPROFILE, '.local', 'bin'));
+    if (env.APPDATA) dirs.push(w.join(env.APPDATA, 'npm'));
+    if (env.ProgramFiles) {
+      dirs.push(w.join(env.ProgramFiles, 'Git', 'cmd'));
+      dirs.push(w.join(env.ProgramFiles, 'nodejs'));
+    }
+    return dirs;
+  }
+  const home = (opts && opts.homedir) || os.homedir();
   return [
-    path.join(home, '.claude', 'local'),
-    path.join(home, '.local', 'bin'),
-    path.join(home, '.npm-global', 'bin'),
+    P.join(home, '.claude', 'local'),
+    P.join(home, '.local', 'bin'),
+    P.join(home, '.npm-global', 'bin'),
     '/opt/homebrew/bin',
     '/opt/homebrew/sbin',
     '/usr/local/bin',
@@ -29,10 +43,20 @@ function userBinDirs() {
  *  value to put in a spawned child's PATH so `claude`, node, git, etc. resolve
  *  on macOS even under a stripped Finder/Dock PATH. Appended (not prepended) so
  *  a user's version manager (nvm/asdf/volta/mise) earlier in PATH still wins and
- *  isn't shadowed by /opt/homebrew. */
-function pathWithUserBins() {
-  const base = process.env.PATH || '';
-  return base ? `${base}:${userBinDirs().join(':')}` : userBinDirs().join(':');
+ *  isn't shadowed by /opt/homebrew. Windows: ';' delimiter, and PATH is read
+ *  case-insensitively (the variable is usually `Path`). */
+function pathWithUserBins(opts) {
+  const platform = (opts && opts.platform) || process.platform;
+  const env = (opts && opts.env) || process.env;
+  const win = platform === 'win32';
+  const delim = (win ? path.win32 : path.posix).delimiter;
+  let base = env.PATH || '';
+  if (win && !base) {
+    const key = Object.keys(env).find((k) => k.toUpperCase() === 'PATH');
+    base = (key && env[key]) || '';
+  }
+  const dirs = userBinDirs({ ...(opts || {}), platform, env }).join(delim);
+  return base && dirs ? `${base}${delim}${dirs}` : base || dirs;
 }
 
 /**

package/src/main/lib/customerFeedbackAdminRoutes.cjs

@@ -0,0 +1,94 @@
+// @ts-check
+/**
+ * customerFeedbackAdminRoutes.cjs — loopback admin HTTP routes so an agent
+ * session (via the scheduler MCP) can inspect and resolve customer feedback
+ * through customerFeedbackInbox.cjs:
+ *   GET  /admin/customer-feedback/inbox?pull=1&includeHidden=1 -> { ok, items, pulled? }
+ *   POST /admin/customer-feedback/status {id, status, note?}   -> { ok, item }
+ *
+ * Deliberately NO route that mints an Epic (SINGLE-CREATOR LAW, epicMint.cjs).
+ * Responses never carry the owner token — the inbox lib redacts it from errors.
+ */
+'use strict';
+
+const { readBody, sendJson } = require('./localAdminHttp.cjs');
+
+/** @param {any} dep */
+function getInbox(dep) {
+  return dep || require('./customerFeedbackInbox.cjs');
+}
+
+/** @param {any} inboxDep */
+function inboxHandler(inboxDep) {
+  return async (/** @type {any} */ _req, /** @type {any} */ res, /** @type {URLSearchParams} */ query) => {
+    const inbox = getInbox(inboxDep);
+    const wantPull = query.get('pull') === '1';
+    const includeHidden = query.get('includeHidden') === '1';
+    /** @type {any} */
+    let pulled;
+    if (wantPull) {
+      pulled = await inbox.pull();
+      if (!pulled.ok) {
+        sendJson(res, 200, { ok: false, error: pulled.error });
+        return;
+      }
+    }
+    const result = await inbox.list({ includeHidden });
+    if (!result.ok) {
+      sendJson(res, 200, { ok: false, error: result.error });
+      return;
+    }
+    sendJson(res, 200, { ok: true, items: result.items, ...(wantPull ? { pulled: { fetched: pulled.fetched, pages: pulled.pages } } : {}) });
+  };
+}
+
+/** @param {any} inboxDep */
+function statusHandler(inboxDep) {
+  return async (/** @type {any} */ req, /** @type {any} */ res) => {
+    const inbox = getInbox(inboxDep);
+    let raw;
+    try {
+      raw = await readBody(req);
+    } catch (/** @type {any} */ e) {
+      sendJson(res, 400, { ok: false, error: `request body rejected: ${e?.message ?? 'unreadable'}` });
+      return;
+    }
+    /** @type {any} */
+    let body;
+    try {
+      body = raw ? JSON.parse(raw) : {};
+    } catch {
+      sendJson(res, 400, { ok: false, error: 'invalid JSON body' });
+      return;
+    }
+    if (!body || typeof body !== 'object' || typeof body.id !== 'string' || !body.id) {
+      sendJson(res, 400, { ok: false, error: 'id is required' });
+      return;
+    }
+    if (typeof body.status !== 'string' || !inbox.STATUSES.includes(body.status)) {
+      sendJson(res, 400, { ok: false, error: `status must be one of: ${inbox.STATUSES.join(', ')}` });
+      return;
+    }
+    if (body.note !== undefined && body.note !== null && typeof body.note !== 'string') {
+      sendJson(res, 400, { ok: false, error: 'note must be a string' });
+      return;
+    }
+    const result = await inbox.setStatus(body.id, body.status, body.note ?? undefined);
+    if (!result.ok) {
+      sendJson(res, 200, { ok: false, error: result.error });
+      return;
+    }
+    sendJson(res, 200, { ok: true, item: result.item });
+  };
+}
+
+/**
+ * @param {any} adminHttp
+ * @param {{ inbox?: any }} [opts] test seam
+ */
+function registerAdminRoute(adminHttp, opts = {}) {
+  adminHttp.registerRoute('GET', '/admin/customer-feedback/inbox', inboxHandler(opts.inbox));
+  adminHttp.registerRoute('POST', '/admin/customer-feedback/status', statusHandler(opts.inbox));
+}
+
+module.exports = { registerAdminRoute };

package/src/main/lib/customerFeedbackClient.cjs

@@ -0,0 +1,261 @@
+// @ts-check
+/**
+ * customerFeedbackClient — customer side of in-app feedback.
+ *
+ * Validates a submission, POSTs it to the bilko.run per-project feedback API, records it in a
+ * machine-global store (~/.claude/session-manager/customer-feedback.json) so the user can see what
+ * they sent, and refreshes each item's resolution status via a receipt-based lookup endpoint that
+ * may not exist on the host yet (404 degrades to `unsupported`).
+ *
+ * Sends no identity: client = {app, version, platform} only. Deliberately NOT gated on
+ * SM_TELEMETRY — feedback is an explicit user action.
+ */
+'use strict';
+
+const path = require('node:path');
+const fsp = require('node:fs/promises');
+const atomicFs = require('./atomicFs.cjs');
+const schedulerPaths = require('./schedulerPaths.cjs');
+
+const FEEDBACK_SLUG = 'session-manager';
+const TAGS = /** @type {const} */ (['bug', 'feature', 'discussion']);
+const MAX_TITLE = 120;
+const MAX_BODY = 4000;
+const MAX_ITEMS = 500;
+const MAX_LOOKUP = 100;
+const TIMEOUT_MS = 15000;
+const SCHEMA_VERSION = 1;
+const RATE_LIMIT_ERROR = 'Too many submissions — try again in a minute.';
+
+/**
+ * @typedef {{ id: string, receipt: string|null, tag: string, title: string, body: string,
+ *   submittedAt: number, status: string, statusNote: string|null,
+ *   statusAt: number|string|null, seenStatusAt: number|string|null }} FeedbackItem
+ * @typedef {{ fetchImpl?: typeof fetch, storeFile?: string, now?: () => number, appVersion?: string }} Deps
+ */
+
+function resolveFeedbackBase() {
+  return (process.env.SM_FEEDBACK_ENDPOINT || 'https://bilko.run').replace(/\/+$/, '');
+}
+
+/** @param {string} tag */
+function toWireType(tag) {
+  return tag === 'discussion' ? 'feedback' : tag;
+}
+
+/** @param {string} type */
+function fromWireType(type) {
+  return type === 'feedback' ? 'discussion' : type;
+}
+
+/**
+ * @param {{ title?: unknown, body?: unknown, tag?: unknown }} input
+ * @returns {{ ok: true, value: { title: string, body: string, tag: string } } | { ok: false, error: string }}
+ */
+function validateSubmission(input) {
+  const src = input || {};
+  const title = typeof src.title === 'string' ? src.title.trim() : '';
+  const body = typeof src.body === 'string' ? src.body.trim() : '';
+  const tag = src.tag;
+  if (!title) return { ok: false, error: 'Please enter a title.' };
+  if (title.length > MAX_TITLE) return { ok: false, error: `Title must be ${MAX_TITLE} characters or fewer.` };
+  if (!body) return { ok: false, error: 'Please enter a description.' };
+  if (body.length > MAX_BODY) return { ok: false, error: `Description must be ${MAX_BODY} characters or fewer.` };
+  if (typeof tag !== 'string' || !TAGS.includes(/** @type {any} */ (tag))) {
+    return { ok: false, error: `Tag must be one of: ${TAGS.join(', ')}.` };
+  }
+  return { ok: true, value: { title, body, tag } };
+}
+
+function defaultStoreFile() {
+  return path.join(schedulerPaths.schedulerHome(), 'customer-feedback.json');
+}
+
+function defaultVersion() {
+  try {
+    const electron = require('electron');
+    if (electron && electron.app && typeof electron.app.getVersion === 'function') return electron.app.getVersion();
+  } catch { /* not running under Electron */ }
+  try {
+    return String(require('../../../package.json').version || 'unknown');
+  } catch {
+    return 'unknown';
+  }
+}
+
+/** @param {Deps} [deps] */
+function ctx(deps) {
+  const d = deps || {};
+  return {
+    fetchImpl: d.fetchImpl || globalThis.fetch,
+    storeFile: d.storeFile || defaultStoreFile(),
+    now: d.now || Date.now,
+    appVersion: d.appVersion || defaultVersion(),
+  };
+}
+
+/** @param {string} file @returns {Promise<FeedbackItem[]>} */
+async function readItems(file) {
+  try {
+    const data = JSON.parse(await fsp.readFile(file, 'utf8'));
+    if (data && Array.isArray(data.items)) return data.items.filter((/** @type {unknown} */ i) => i && typeof i === 'object');
+  } catch { /* missing or corrupt reads as empty */ }
+  return [];
+}
+
+let writeQueue = Promise.resolve();
+/**
+ * Serialized read-modify-write: each mutation reads the freshest on-disk items.
+ * @param {string} file
+ * @param {(items: FeedbackItem[]) => FeedbackItem[]} mutate
+ */
+function mutateStore(file, mutate) {
+  const run = async () => {
+    const next = mutate(await readItems(file));
+    const capped = next.slice(0, MAX_ITEMS);
+    await atomicFs.writeJsonAtomic(file, { schemaVersion: SCHEMA_VERSION, items: capped }, { mode: 0o600 });
+    return capped;
+  };
+  const tail = writeQueue.then(run, run);
+  writeQueue = tail.then(() => {}, () => {});
+  return tail;
+}
+
+/** Items newest-first (store order). @param {Deps} [deps] */
+async function list(deps) {
+  return readItems(ctx(deps).storeFile);
+}
+
+/** @param {Response} res @param {string} fallback */
+async function errorText(res, fallback) {
+  try {
+    /** @type {any} */
+    const j = await res.json();
+    if (j && typeof j.error === 'string' && j.error) return j.error;
+  } catch { /* no body */ }
+  return fallback;
+}
+
+/**
+ * @param {{ title?: unknown, body?: unknown, tag?: unknown }} input
+ * @param {Deps} [deps]
+ * @returns {Promise<{ ok: true, item: FeedbackItem } | { ok: false, error: string }>}
+ */
+async function submit(input, deps) {
+  const v = validateSubmission(input);
+  if (!v.ok) return v;
+  const c = ctx(deps);
+  const { title, body, tag } = v.value;
+  try {
+    const res = await c.fetchImpl(`${resolveFeedbackBase()}/api/projects/${FEEDBACK_SLUG}/feedback`, {
+      method: 'POST',
+      headers: { 'content-type': 'application/json' },
+      body: JSON.stringify({
+        target: { kind: 'page', id: 'desktop-app', label: 'Session Manager desktop' },
+        type: toWireType(tag),
+        title,
+        description: body,
+        client: { app: 'session-manager', version: c.appVersion, platform: process.platform },
+      }),
+      signal: AbortSignal.timeout(TIMEOUT_MS),
+    });
+    if (res.status === 429) return { ok: false, error: RATE_LIMIT_ERROR };
+    if (res.status !== 201) return { ok: false, error: await errorText(res, `Feedback service returned ${res.status}.`) };
+    /** @type {any} */
+    const j = await res.json().catch(() => null);
+    if (!j || typeof j.id !== 'string' || !j.id) return { ok: false, error: 'Feedback service returned an unexpected response.' };
+    /** @type {FeedbackItem} */
+    const item = {
+      id: j.id,
+      receipt: typeof j.receipt === 'string' && j.receipt ? j.receipt : null,
+      tag,
+      title,
+      body,
+      submittedAt: c.now(),
+      status: 'open',
+      statusNote: null,
+      statusAt: null,
+      seenStatusAt: null,
+    };
+    await mutateStore(c.storeFile, (items) => [item, ...items]);
+    return { ok: true, item };
+  } catch (e) {
+    return { ok: false, error: `Could not reach the feedback service: ${e instanceof Error ? e.message : String(e)}` };
+  }
+}
+
+/**
+ * @param {Deps} [deps]
+ * @returns {Promise<{ ok: true, updated: number, unsupported?: true } | { ok: false, error: string }>}
+ */
+async function refreshStatuses(deps) {
+  const c = ctx(deps);
+  const lookup = (await readItems(c.storeFile))
+    .filter((i) => typeof i.receipt === 'string' && i.receipt)
+    .slice(0, MAX_LOOKUP)
+    .map((i) => ({ id: i.id, receipt: i.receipt }));
+  if (lookup.length === 0) return { ok: true, updated: 0 };
+  try {
+    const res = await c.fetchImpl(`${resolveFeedbackBase()}/api/projects/${FEEDBACK_SLUG}/feedback/status-lookup`, {
+      method: 'POST',
+      headers: { 'content-type': 'application/json' },
+      body: JSON.stringify({ items: lookup }),
+      signal: AbortSignal.timeout(TIMEOUT_MS),
+    });
+    if (res.status === 404) return { ok: true, updated: 0, unsupported: true };
+    if (!res.ok) return { ok: false, error: await errorText(res, `Feedback service returned ${res.status}.`) };
+    /** @type {any} */
+    const j = await res.json().catch(() => null);
+    const entries = j && Array.isArray(j.items) ? j.items : [];
+    /** @type {Map<string, any>} */
+    const byId = new Map();
+    for (const e of entries) if (e && typeof e.id === 'string') byId.set(e.id, e);
+    let updated = 0;
+    await mutateStore(c.storeFile, (items) => {
+      updated = 0;
+      return items.map((it) => {
+        const e = byId.get(it.id);
+        if (!e || typeof e.status !== 'string') return it;
+        updated++;
+        return {
+          ...it,
+          status: e.status,
+          statusNote: typeof e.note === 'string' ? e.note : null,
+          statusAt: e.statusAt ?? null,
+        };
+      });
+    });
+    return { ok: true, updated };
+  } catch (e) {
+    return { ok: false, error: `Could not reach the feedback service: ${e instanceof Error ? e.message : String(e)}` };
+  }
+}
+
+/** @param {string[]} [ids] omit to mark everything seen @param {Deps} [deps] */
+async function markSeen(ids, deps) {
+  const c = ctx(deps);
+  const only = Array.isArray(ids) ? new Set(ids) : null;
+  return mutateStore(c.storeFile, (items) =>
+    items.map((it) => (!only || only.has(it.id) ? { ...it, seenStatusAt: it.statusAt ?? null } : it)));
+}
+
+/** @param {FeedbackItem[]} items */
+function unseenCount(items) {
+  return (items || []).filter((i) => i.statusAt != null && i.statusAt !== i.seenStatusAt).length;
+}
+
+module.exports = {
+  FEEDBACK_SLUG,
+  TAGS,
+  MAX_TITLE,
+  MAX_BODY,
+  resolveFeedbackBase,
+  toWireType,
+  fromWireType,
+  validateSubmission,
+  submit,
+  list,
+  refreshStatuses,
+  markSeen,
+  unseenCount,
+};