npm - claude-code-session-manager - Versions diffs - 0.3.2 → 0.5.0 - Mend

claude-code-session-manager 0.3.2 → 0.5.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (31) hide show

package/dist/index.html CHANGED Viewed

@@ -4,8 +4,8 @@
     <meta charset="UTF-8" />
     <meta name="viewport" content="width=device-width, initial-scale=1.0" />
     <title>Claude Session Manager</title>
-    <script type="module" crossorigin src="./assets/index-FnbJBSnE.js"></script>
-    <link rel="stylesheet" crossorigin href="./assets/index-BzbwWnyF.css">
+    <script type="module" crossorigin src="./assets/index-DUYNLg5N.js"></script>
+    <link rel="stylesheet" crossorigin href="./assets/index-QriiiRo1.css">
   </head>
   <body class="bg-bg text-fg font-mono antialiased">
     <div id="root"></div>

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "claude-code-session-manager",
-  "version": "0.3.2",
+  "version": "0.5.0",
   "description": "Local cockpit for Claude Code CLI sessions — terminal + full config surface.",
   "type": "module",
   "main": "src/main/index.cjs",
@@ -53,6 +53,12 @@
     "@electron/rebuild": "^3.7.0",
     "@huggingface/transformers": "^4.1.0",
     "@monaco-editor/react": "^4.6.0",
+    "@opentelemetry/api": "^1.9.0",
+    "@opentelemetry/exporter-trace-otlp-http": "^0.57.0",
+    "@opentelemetry/resources": "^1.30.0",
+    "@opentelemetry/sdk-trace-base": "^1.30.0",
+    "@opentelemetry/sdk-trace-node": "^1.30.0",
+    "@opentelemetry/semantic-conventions": "^1.28.0",
     "@ricky0123/vad-web": "^0.0.30",
     "@xterm/addon-fit": "^0.10.0",
     "@xterm/addon-web-links": "^0.11.0",

package/src/main/index.cjs CHANGED Viewed

@@ -1,5 +1,5 @@
 const { app, BrowserWindow, ipcMain, dialog, Menu, session, systemPreferences, globalShortcut } = require('electron');
-const { spawn, execFileSync } = require('node:child_process');
+const { spawn, execFile, execFileSync } = require('node:child_process');
 const path = require('node:path');
 const fs = require('node:fs');
 const os = require('node:os');
@@ -11,6 +11,10 @@ const billing = require('./usage.cjs');
 const logs = require('./logs.cjs');
 const voiceHotkey = require('./voiceHotkey.cjs');
 const voiceWizard = require('./voiceWizard.cjs');
+const scheduler = require('./scheduler.cjs');
+const watchers = require('./watchers.cjs');
+const otel = require('./otel.cjs');
+const otelSettings = require('./otelSettings.cjs');
 let mainWindow = null;
 let rebooting = false;
@@ -78,6 +82,7 @@ async function rebootApp() {
   ptyManager.killAll();
   configMgr.closeAllWatchers();
   transcripts.closeAll();
+  watchers.manager.killAll();
   // Rewrite persisted tabs with fresh session IDs so the next boot starts
   // new claude sessions instead of resuming old ones.
@@ -96,6 +101,8 @@ async function rebootApp() {
     voiceHotkey.init(mainWindow).catch((e) => {
       logs.writeLine({ scope: 'voice-hotkey', level: 'error', message: 'reinit failed', meta: { error: e?.message } });
     });
+    scheduler.attachWindow(mainWindow);
+    watchers.attachWindow(mainWindow);
     rebooting = false;
     return;
   }
@@ -185,6 +192,102 @@ ipcMain.handle('app:pick-directory', async () => {
 ipcMain.on('app:reboot-app', () => rebootApp());
+// Hooks tab "Test fire": run a hook command with a fake event payload piped
+// to stdin. shell:true is intentional — Claude Code's hook field is a shell
+// string. Timeout is enforced via SIGKILL on a timer because spawn's built-in
+// `timeout` option only sends SIGTERM, which a wedged shell may ignore.
+ipcMain.handle('app:test-fire-hook', async (_e, payload) => {
+  const command = typeof payload?.command === 'string' ? payload.command : '';
+  const env = payload && typeof payload.env === 'object' && payload.env !== null ? payload.env : null;
+  const stdin = typeof payload?.payload === 'string' ? payload.payload : '';
+  const requested = Number(payload?.timeoutMs);
+  const timeoutMs = Number.isFinite(requested) && requested > 0
+    ? Math.min(requested, 30_000)
+    : 5_000;
+  if (!command.trim()) {
+    return { exitCode: -1, stdout: '', stderr: 'empty command', durationMs: 0 };
+  }
+  return await new Promise((resolve) => {
+    const startedAt = Date.now();
+    let child;
+    try {
+      child = spawn(command, {
+        shell: true,
+        env: { ...process.env, ...(env ?? {}) },
+        stdio: ['pipe', 'pipe', 'pipe'],
+      });
+    } catch (err) {
+      resolve({
+        exitCode: -1,
+        stdout: '',
+        stderr: `spawn failed: ${err?.message ?? String(err)}`,
+        durationMs: Date.now() - startedAt,
+      });
+      return;
+    }
+    const stdoutChunks = [];
+    const stderrChunks = [];
+    let timedOut = false;
+    const killTimer = setTimeout(() => {
+      timedOut = true;
+      try { child.kill('SIGKILL'); } catch { /* already dead */ }
+    }, timeoutMs);
+    child.stdout.on('data', (b) => stdoutChunks.push(b));
+    child.stderr.on('data', (b) => stderrChunks.push(b));
+    child.on('error', (err) => {
+      clearTimeout(killTimer);
+      resolve({
+        exitCode: -1,
+        stdout: Buffer.concat(stdoutChunks).toString('utf8'),
+        stderr: `spawn error: ${err?.message ?? String(err)}`,
+        durationMs: Date.now() - startedAt,
+      });
+    });
+    child.on('close', (code, signal) => {
+      clearTimeout(killTimer);
+      const stderr = Buffer.concat(stderrChunks).toString('utf8');
+      const tail = timedOut
+        ? `${stderr}${stderr && !stderr.endsWith('\n') ? '\n' : ''}[killed: timeout after ${timeoutMs}ms]`
+        : stderr;
+      resolve({
+        exitCode: typeof code === 'number' ? code : (signal ? -1 : 0),
+        stdout: Buffer.concat(stdoutChunks).toString('utf8'),
+        stderr: tail,
+        durationMs: Date.now() - startedAt,
+      });
+    });
+    try {
+      child.stdin.end(stdin);
+    } catch {
+      // child may have already exited; close handler will resolve.
+    }
+  });
+});
+// StatusBar: best-effort current branch for the active tab's cwd. Returns null
+// for non-git dirs, detached HEAD, missing git, or timeouts so callers can
+// render `—` without branching on error shape. 1s ceiling keeps a wedged git
+// (network filesystem, hung index lock) from blocking the renderer.
+ipcMain.handle('app:git-branch', async (_e, payload) => {
+  const cwd = payload && typeof payload.cwd === 'string' ? payload.cwd : null;
+  if (!cwd) return null;
+  return await new Promise((resolve) => {
+    execFile('git', ['branch', '--show-current'], { cwd, timeout: 1000, windowsHide: true }, (err, stdout) => {
+      if (err) { resolve(null); return; }
+      const out = String(stdout).trim();
+      resolve(out.length ? out : null);
+    });
+  });
+});
 registerPtyHandlers();
 configMgr.registerConfigHandlers();
 transcripts.registerTranscriptHandlers();
@@ -193,6 +296,21 @@ billing.registerBillingHandlers();
 logs.registerLogHandlers();
 voiceHotkey.registerHotkeyHandlers();
 voiceWizard.registerWizardHandlers();
+scheduler.registerScheduleHandlers();
+watchers.registerWatcherHandlers();
+// OTEL telemetry export (opt-in via ~/.config/session-manager/otel.json).
+ipcMain.handle('otel:get-config', async () => otelSettings.load());
+ipcMain.handle('otel:set-config', async (_e, cfg) => {
+  if (!otelSettings.isValid(cfg)) {
+    return { ok: false, error: 'invalid config' };
+  }
+  const saved = await otelSettings.save(cfg);
+  const result = await otel.applyConfig(saved);
+  return { ok: !!result?.ok, error: result?.error ?? null, config: saved, status: otel.status() };
+});
+ipcMain.handle('otel:status', () => otel.status());
+ipcMain.handle('otel:config-path', () => otelSettings.storePath());
 // --- App lifecycle ---
@@ -311,6 +429,24 @@ app.whenReady().then(async () => {
   voiceHotkey.init(mainWindow).catch((e) => {
     logs.writeLine({ scope: 'voice-hotkey', level: 'error', message: 'init failed', meta: { error: e?.message } });
   });
+  scheduler.attachWindow(mainWindow);
+  watchers.attachWindow(mainWindow);
+  scheduler.init().catch((e) => {
+    logs.writeLine({ scope: 'scheduler', level: 'error', message: 'init failed', meta: { error: e?.message } });
+  });
+  // OTEL: load persisted config and start the exporter only if `enabled`.
+  // Failures are non-fatal — the app must keep working without telemetry.
+  otelSettings.load()
+    .then((cfg) => otel.applyConfig(cfg))
+    .then((res) => {
+      if (res && !res.ok && res.error) {
+        logs.writeLine({ scope: 'otel', level: 'warn', message: 'init failed', meta: { error: res.error } });
+      }
+    })
+    .catch((e) => {
+      logs.writeLine({ scope: 'otel', level: 'error', message: 'init failed', meta: { error: e?.message } });
+    });
 });
 app.on('will-quit', () => {
@@ -324,6 +460,7 @@ app.on('window-all-closed', () => {
   ptyManager.killAll();
   configMgr.closeAllWatchers();
   transcripts.closeAll();
+  watchers.manager.killAll();
   if (process.platform !== 'darwin') app.quit();
 });
@@ -335,4 +472,8 @@ app.on('before-quit', () => {
   ptyManager.killAll();
   configMgr.closeAllWatchers();
   transcripts.closeAll();
+  watchers.manager.killAll();
+  // Best-effort flush of any pending OTEL spans. shutdown() has its own 2s
+  // ceiling so a wedged exporter can't hold quit.
+  otel.shutdown().catch(() => {});
 });

package/src/main/otel.cjs ADDED Viewed

@@ -0,0 +1,248 @@
+/**
+ * otel — mirrors transcripts.cjs classified events as OpenTelemetry spans.
+ *
+ * Spans are 0-duration "events": one span per classified transcript line,
+ * named `transcript.<kind>`, with structural attributes only. Tool inputs,
+ * plan text, and agent prompts are excluded unless `includeContent` is on
+ * (matches upstream OTEL_LOG_USER_PROMPTS opt-in).
+ *
+ * The OTEL SDK is required lazily — if any of the @opentelemetry/* packages
+ * fail to load, the module is left in an inert state and `recordTranscriptEvent`
+ * becomes a no-op. The app must keep working without telemetry.
+ *
+ * Threading: the BatchSpanProcessor batches/sends spans on its own timer; we
+ * never block the transcript flush.
+ */
+const otelSettings = require('./otelSettings.cjs');
+let provider = null;
+let tracer = null;
+let enabled = false;
+let includeContent = false;
+let lastError = null;
+let initialized = false;
+/**
+ * Lazy-require all @opentelemetry/* packages. Returns null if any are missing.
+ * We catch the per-require so a partial install doesn't half-init.
+ */
+function loadDeps() {
+  try {
+    const api = require('@opentelemetry/api');
+    const { NodeTracerProvider } = require('@opentelemetry/sdk-trace-node');
+    const { BatchSpanProcessor } = require('@opentelemetry/sdk-trace-base');
+    const { OTLPTraceExporter } = require('@opentelemetry/exporter-trace-otlp-http');
+    const { Resource } = require('@opentelemetry/resources');
+    const { SemanticResourceAttributes } = require('@opentelemetry/semantic-conventions');
+    return { api, NodeTracerProvider, BatchSpanProcessor, OTLPTraceExporter, Resource, SemanticResourceAttributes };
+  } catch (err) {
+    return { error: err };
+  }
+}
+/**
+ * Tear down any existing provider. Best-effort — flushes pending spans on a
+ * 2s ceiling so a wedged exporter doesn't block app shutdown / config reload.
+ */
+async function shutdown() {
+  if (!provider) {
+    enabled = false;
+    tracer = null;
+    return;
+  }
+  const p = provider;
+  provider = null;
+  tracer = null;
+  enabled = false;
+  try {
+    await Promise.race([
+      p.shutdown(),
+      new Promise((resolve) => setTimeout(resolve, 2000)),
+    ]);
+  } catch (err) {
+    console.warn('[otel] shutdown failed:', err?.message);
+  }
+}
+/**
+ * Configure the tracer provider. Tears down any prior provider first so a
+ * settings change reliably re-points at the new endpoint.
+ *
+ * Returns { ok, error?: string } — the renderer surfaces `error` in the UI.
+ */
+async function init({ endpoint, headers, serviceName, includeContent: ic } = {}) {
+  await shutdown();
+  initialized = true;
+  const deps = loadDeps();
+  if (deps.error) {
+    lastError = `OTEL packages unavailable: ${deps.error.message}`;
+    return { ok: false, error: lastError };
+  }
+  const { NodeTracerProvider, BatchSpanProcessor, OTLPTraceExporter, Resource, SemanticResourceAttributes } = deps;
+  try {
+    const exporter = new OTLPTraceExporter({
+      url: String(endpoint || 'http://localhost:4318/v1/traces'),
+      headers: typeof headers === 'object' && headers ? headers : {},
+    });
+    const tp = new NodeTracerProvider({
+      resource: new Resource({
+        [SemanticResourceAttributes.SERVICE_NAME]: String(serviceName || 'session-manager'),
+      }),
+    });
+    tp.addSpanProcessor(new BatchSpanProcessor(exporter));
+    // Note: we deliberately do NOT call tp.register() — that installs a global
+    // tracer provider, which would intercept any other OTEL user in the
+    // process. We only want to emit our own spans, so we use the provider
+    // directly via getTracer().
+    provider = tp;
+    tracer = tp.getTracer('session-manager-transcripts');
+    includeContent = !!ic;
+    enabled = true;
+    lastError = null;
+    return { ok: true };
+  } catch (err) {
+    lastError = err?.message || String(err);
+    enabled = false;
+    return { ok: false, error: lastError };
+  }
+}
+/**
+ * Apply current persisted config: shut down if disabled, init if enabled.
+ * Called on app boot and after every settings save.
+ */
+async function applyConfig(cfg) {
+  if (!cfg || !cfg.enabled) {
+    await shutdown();
+    return { ok: true };
+  }
+  return await init({
+    endpoint: cfg.endpoint,
+    headers: otelSettings.parseHeaders(cfg.headers),
+    serviceName: cfg.serviceName,
+    includeContent: cfg.includeContent,
+  });
+}
+/**
+ * Build the kind-specific attribute subset. Keep PII fields gated behind
+ * `includeContent`. Truncate any free-form string at 4096 chars to bound the
+ * span payload — most exporters reject spans larger than ~64KiB.
+ */
+function attrsFor(kind, data) {
+  const cap = (s) => (typeof s === 'string' ? s.slice(0, 4096) : s);
+  switch (kind) {
+    case 'tool_use': {
+      const a = {
+        'tool.name': data?.name,
+        'tool.id': data?.id,
+      };
+      if (includeContent && data?.input != null) {
+        try { a['tool.input'] = cap(JSON.stringify(data.input)); } catch { /* */ }
+      }
+      return a;
+    }
+    case 'todo_write': {
+      const todos = Array.isArray(data) ? data : [];
+      let completed = 0, inProgress = 0;
+      for (const t of todos) {
+        if (t?.status === 'completed') completed++;
+        else if (t?.status === 'in_progress') inProgress++;
+      }
+      return {
+        'todo.count': todos.length,
+        'todo.completed': completed,
+        'todo.in_progress': inProgress,
+      };
+    }
+    case 'plan': {
+      const text = typeof data?.plan === 'string' ? data.plan : (typeof data === 'string' ? data : '');
+      const a = { 'plan.chars': text.length };
+      if (includeContent && text) a['plan.text'] = cap(text);
+      return a;
+    }
+    case 'usage': {
+      return {
+        'usage.input_tokens': Number(data?.input_tokens || 0),
+        'usage.output_tokens': Number(data?.output_tokens || 0),
+        'usage.cache_creation_input_tokens': Number(data?.cache_creation_input_tokens || 0),
+        'usage.cache_read_input_tokens': Number(data?.cache_read_input_tokens || 0),
+      };
+    }
+    case 'agent_spawn': {
+      const a = {
+        'agent.subtype': data?.subagent_type,
+        'agent.description': data?.description, // task description is structural metadata
+      };
+      if (includeContent && typeof data?.prompt === 'string') {
+        a['agent.prompt'] = cap(data.prompt);
+      }
+      return a;
+    }
+    default:
+      return {};
+  }
+}
+/**
+ * Drop attributes whose value is undefined/null so the exporter doesn't
+ * complain about unsupported attribute types.
+ */
+function pruneAttrs(obj) {
+  const out = {};
+  for (const [k, v] of Object.entries(obj)) {
+    if (v === undefined || v === null) continue;
+    out[k] = v;
+  }
+  return out;
+}
+/**
+ * Emit a 0-duration span for one classified transcript event.
+ * Synchronous + non-blocking: the BatchSpanProcessor handles network I/O
+ * on its own schedule.
+ */
+function recordTranscriptEvent({ tabId, tabCwd, kind, data, ts }) {
+  if (!enabled || !tracer) return;
+  try {
+    const startTime = typeof ts === 'number' ? ts : Date.now();
+    const attrs = pruneAttrs({
+      'tab.id': tabId,
+      'tab.cwd': tabCwd,
+      kind,
+      ...attrsFor(kind, data),
+    });
+    const span = tracer.startSpan(`transcript.${kind}`, {
+      startTime,
+      attributes: attrs,
+    });
+    span.end(startTime);
+  } catch (err) {
+    // A failure here must never break transcript ingestion. Log once-ish.
+    if (!recordTranscriptEvent._warned) {
+      recordTranscriptEvent._warned = true;
+      console.warn('[otel] recordTranscriptEvent failed:', err?.message);
+    }
+  }
+}
+function status() {
+  return {
+    enabled,
+    initialized,
+    error: lastError,
+    includeContent,
+  };
+}
+module.exports = {
+  init,
+  applyConfig,
+  shutdown,
+  recordTranscriptEvent,
+  status,
+};

package/src/main/otelSettings.cjs ADDED Viewed

@@ -0,0 +1,119 @@
+/**
+ * otelSettings — persists OTEL telemetry export configuration.
+ *
+ * Storage: ~/.config/session-manager/otel.json
+ * Shape: {
+ *   enabled: boolean,
+ *   endpoint: string,        // OTLP/HTTP traces endpoint
+ *   headers: string,         // newline-separated "Key: Value" pairs
+ *   serviceName: string,
+ *   includeContent: boolean, // mirrors upstream OTEL_LOG_USER_PROMPTS — opt-in PII
+ *   schemaVersion: 1
+ * }
+ *
+ * Atomic write pattern (tmp + rename) mirrors voiceSettings.cjs.
+ */
+const fsp = require('node:fs/promises');
+const path = require('node:path');
+const os = require('node:os');
+const SCHEMA_VERSION = 1;
+const DEFAULTS = Object.freeze({
+  enabled: false,
+  endpoint: 'http://localhost:4318/v1/traces',
+  headers: '',
+  serviceName: 'session-manager',
+  includeContent: false,
+  schemaVersion: SCHEMA_VERSION,
+});
+function storePath() {
+  return path.join(os.homedir(), '.config', 'session-manager', 'otel.json');
+}
+function isValid(cfg) {
+  if (!cfg || typeof cfg !== 'object') return false;
+  if (typeof cfg.enabled !== 'boolean') return false;
+  if (typeof cfg.endpoint !== 'string') return false;
+  if (typeof cfg.headers !== 'string') return false;
+  if (typeof cfg.serviceName !== 'string' || !cfg.serviceName.trim()) return false;
+  if (typeof cfg.includeContent !== 'boolean') return false;
+  return true;
+}
+function normalize(cfg) {
+  return {
+    enabled: !!cfg.enabled,
+    endpoint: typeof cfg.endpoint === 'string' && cfg.endpoint.trim() ? cfg.endpoint.trim() : DEFAULTS.endpoint,
+    headers: typeof cfg.headers === 'string' ? cfg.headers : '',
+    serviceName: typeof cfg.serviceName === 'string' && cfg.serviceName.trim() ? cfg.serviceName.trim() : DEFAULTS.serviceName,
+    includeContent: !!cfg.includeContent,
+    schemaVersion: SCHEMA_VERSION,
+  };
+}
+async function load() {
+  try {
+    const raw = await fsp.readFile(storePath(), 'utf8');
+    const data = JSON.parse(raw);
+    if (data && typeof data === 'object') {
+      return normalize({ ...DEFAULTS, ...data });
+    }
+  } catch (e) {
+    if (e.code !== 'ENOENT') {
+      console.warn('[otelSettings] load failed:', e.message);
+    }
+  }
+  return { ...DEFAULTS };
+}
+let writeQueue = Promise.resolve();
+async function save(cfg) {
+  if (!isValid(cfg)) throw new Error('Invalid OTEL config');
+  const next = normalize(cfg);
+  const run = async () => {
+    const p = storePath();
+    await fsp.mkdir(path.dirname(p), { recursive: true }).catch(() => {});
+    const body = JSON.stringify(next, null, 2) + '\n';
+    const tmp = `${p}.tmp-${process.pid}-${Date.now()}`;
+    await fsp.writeFile(tmp, body, 'utf8', { mode: 0o600 });
+    try { await fsp.chmod(tmp, 0o600); } catch { /* */ }
+    await fsp.rename(tmp, p);
+    return next;
+  };
+  const tail = writeQueue.then(run, run);
+  writeQueue = tail.catch(() => {});
+  return tail;
+}
+/**
+ * Parse "Key: Value\nKey2: Value2" → { Key: 'Value', Key2: 'Value2' }.
+ * Empty / whitespace-only lines and lines without ':' are silently dropped.
+ * Complexity: O(n) where n is the string length.
+ */
+function parseHeaders(text) {
+  const out = {};
+  if (typeof text !== 'string' || !text.trim()) return out;
+  for (const line of text.split(/\r?\n/)) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    const idx = trimmed.indexOf(':');
+    if (idx <= 0) continue;
+    const k = trimmed.slice(0, idx).trim();
+    const v = trimmed.slice(idx + 1).trim();
+    if (k) out[k] = v;
+  }
+  return out;
+}
+module.exports = {
+  load,
+  save,
+  storePath,
+  parseHeaders,
+  isValid,
+  DEFAULTS,
+  SCHEMA_VERSION,
+};