claude-inspect 0.1.0 → 0.2.1

package/README.md

@@ -2,7 +2,7 @@
 
 [![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](LICENSE)
 [![npm](https://img.shields.io/npm/v/claude-inspect)](https://www.npmjs.com/package/claude-inspect)
-![Node.js ≥ 20](https://img.shields.io/badge/node-%E2%89%A5%2020-green)
+![Node.js ≥ 22](https://img.shields.io/badge/node-%E2%89%A5%2022-green)
 ![TypeScript](https://img.shields.io/badge/TypeScript-Svelte%205-3178c6)
 ![Dark mode](https://img.shields.io/badge/dark%20mode-%E2%9C%93-2b2a27)
 ![No hooks](https://img.shields.io/badge/Claude%20Code-no%20hooks%20needed-d97757)
@@ -69,7 +69,7 @@ becomes hard to tell *who is doing what*. claude-inspect answers:
 
 ## Quick start
 
-Requirements: Node.js ≥ 20, macOS or Linux, Claude Code writing to `~/.claude`.
+Requirements: Node.js ≥ 22, macOS, Linux or Windows, Claude Code writing to `~/.claude`. On Windows, live process status is read via PowerShell; the autostart service and the live `demo` are macOS/Linux only (`demo --out <dir>` works everywhere).
 
 ```bash
 npx claude-inspect --open        # try it once

package/dist/app/server/cli/demo.js

@@ -292,6 +292,10 @@ export async function runDemo(opts) {
         console.log(`Demo data written to ${ROOT} (no processes started)`);
         return;
     }
+    if (process.platform === 'win32') {
+        console.error('The live demo starts Unix processes (sh, sleep, pgrep) and needs macOS or Linux. Use `demo --out <dir>` to only generate the data.');
+        process.exit(1);
+    }
     // orchestrator = shell that forks the implementer (process tree: implementer → orchestrator)
     const children = [
         spawn('sh', ['-c', 'sleep 7200 & wait'], { stdio: 'ignore', detached: true }),

package/dist/app/server/cli/service.js

@@ -114,13 +114,15 @@ function macStatus() {
 // ---------------------------------------------------------------------------
 // Linux (systemd --user)
 const unitPath = join(homedir(), '.config', 'systemd', 'user', 'claude-inspect.service');
+/** systemd-Quoting für ExecStart (Pfade mit Leerzeichen, Anführungszeichen, Backslashes, %). */
+const q = (s) => `"${s.replace(/\\/g, '\\\\').replace(/"/g, '\\"').replace(/%/g, '%%')}"`;
 function linuxInstall() {
     mkdirSync(dirname(unitPath), { recursive: true });
     writeFileSync(unitPath, `[Unit]
 Description=claude-inspect – live dashboard for Claude Code agents
 
 [Service]
-ExecStart=${nodePath()} ${ENTRY} --port ${port} --no-auth
+ExecStart=${q(nodePath())} ${q(ENTRY)} --port ${port} --no-auth
 WorkingDirectory=${ROOT}
 Restart=on-failure
 RestartSec=10

package/dist/app/server/history/search.js

@@ -2,6 +2,7 @@ import { readFile } from 'node:fs/promises';
 import { toolSummary } from '../../shared/tools.js';
 import { paths } from '../config.js';
 import { registry } from '../formats/index.js';
+import { pathTail } from '../sources/projects.js';
 function snippet(text, needle, radius = 90) {
     const i = text.toLowerCase().indexOf(needle);
     if (i < 0)
@@ -117,7 +118,7 @@ export async function search(query, files, knownSessions, limit = 200, budgetMs
                         continue;
                     hits.push({
                         sessionId: p.sessionId ?? '',
-                        project: p.project?.split('/').pop() ?? '?',
+                        project: p.project ? pathTail(p.project) : '?',
                         title: 'transcript no longer exists',
                         line: i,
                         kind: 'history-prompt',

package/dist/app/server/inspector.js

@@ -1,7 +1,7 @@
 import { EventEmitter } from 'node:events';
 import { watch } from 'node:fs';
 import { stat } from 'node:fs/promises';
-import { join } from 'node:path';
+import { basename, join } from 'node:path';
 import { CLAUDE_DIR, relToClaude } from './config.js';
 import { registry } from './formats/index.js';
 import { HistoryIndex } from './history/aggregator.js';
@@ -15,6 +15,17 @@ import { ProjectIndex } from './sources/projects.js';
 import { SpawnIndex } from './sources/spawns.js';
 import { agentCallIds, listSubagents } from './sources/subagents.js';
 import { TranscriptStore } from './sources/transcripts.js';
+/**
+ * IDE-Erweiterungen und SDK-Hosts (VS Code, JetBrains ACP …) halten claude-Prozesse am Leben,
+ * auch wenn das Chat-Panel längst zu ist. Ohne Transcript gab es darin nie ein Gespräch.
+ * Terminal-Sessions (entrypoint "cli") bleiben außen vor: Dort sitzt jemand vor dem Prompt.
+ */
+const IDE_GRACE_MS = 2 * 60_000;
+function idleIdeProcess(p) {
+    if (p.status === 'busy' || !p.entrypoint || p.entrypoint === 'cli' || p.kind === 'bg')
+        return false;
+    return Date.now() - (p.startedAt ?? 0) > IDE_GRACE_MS;
+}
 /** Subagenten, deren Datei so lange unverändert ist, gelten ohne Abschluss als "stale". */
 const SUBAGENT_STALE_MS = 10 * 60_000;
 /** Subagenten erscheinen auf dem Dashboard, wenn sie so kürzlich aktiv waren. */
@@ -166,10 +177,14 @@ export class Inspector extends EventEmitter {
             if (p.alive) {
                 try {
                     dp.session = await this.sessionLive(p.sessionId, p);
+                    if (dp.session?.ended && p.status !== 'busy')
+                        dp.inactive = dp.session.ended;
                 }
                 catch {
                     /* Transcript nicht lesbar */
                 }
+                if (!dp.session && !this.index.get(p.sessionId) && idleIdeProcess(p))
+                    dp.inactive = { reason: 'no-conversation', at: p.updatedAt ? new Date(p.updatedAt).toISOString() : undefined };
             }
             processes.push(dp);
         }
@@ -214,6 +229,7 @@ export class Inspector extends EventEmitter {
             costUSD: a.costUSD,
             lastPrompt: a.lastPrompt,
             spawned: await this.spawnedSessions(sessionId),
+            ended: a.ended,
         };
     }
     async spawnParent(sessionId) {
@@ -260,7 +276,7 @@ export class Inspector extends EventEmitter {
      * Status und aktuelle Aktivität zu bestimmen (für Dashboard und Detailansicht).
      */
     async resolveSubagents(sessionPath, files, load) {
-        const sessionId = sessionPath.replace(/^.*\//, '').replace(/\.jsonl$/, '');
+        const sessionId = basename(sessionPath, '.jsonl');
         const out = [];
         for (const sf of files) {
             const info = {

package/dist/app/server/model/analyze.js

@@ -9,6 +9,29 @@ function short(s, max = 140) {
         .trim();
     return one.length > max ? one.slice(0, max - 1) + '…' : one;
 }
+/**
+ * Wurde die Session nach der letzten echten Eingabe verlassen? Eine neue Eingabe danach hebt das auf.
+ * - `/exit`: bei Hintergrund-Sessions trennt das nur das Terminal, der Prozess läuft weiter
+ * - Remote Control meldet, dass die Session auf einem anderen Gerät beendet oder archiviert wurde
+ */
+function endedAfterLastPrompt(entries) {
+    for (let i = entries.length - 1; i >= 0; i--) {
+        const e = entries[i];
+        if (e.kind === 'user-text') {
+            if (/^<command-name>\/(exit|quit)<\/command-name>/.test(e.text))
+                return { reason: 'exit', at: e.timestamp };
+            if (!e.isMeta && e.text && !e.text.startsWith('<'))
+                return undefined;
+        }
+        else if (e.kind === 'system' && /ended or archived/i.test(e.text ?? '')) {
+            return { reason: 'archived', at: e.timestamp };
+        }
+        else if (e.kind === 'assistant-text' || e.kind === 'tool-use') {
+            return undefined; // danach wurde noch gearbeitet
+        }
+    }
+    return undefined;
+}
 export function analyze(entries) {
     const a = { outputTokens: 0, toolCalls: 0, pendingTools: [], current: null, finished: false, errored: false };
     const open = new Map();
@@ -68,6 +91,7 @@ export function analyze(entries) {
         summary: toolSummary(t.name, t.input),
         since: t.timestamp,
     }));
+    a.ended = endedAfterLastPrompt(entries);
     // Aktuelle Aktivität aus dem letzten bedeutsamen Eintrag
     let last;
     for (let i = entries.length - 1; i >= 0; i--) {

package/dist/app/server/run.js

@@ -11,6 +11,14 @@ function findWebRoot() {
     const candidates = [join(here, '..', '..', 'dist', 'web'), join(here, '..', '..', 'web')];
     return candidates.find((d) => existsSync(join(d, 'index.html'))) ?? candidates[0];
 }
+function openBrowser(url) {
+    const [bin, args] = process.platform === 'darwin'
+        ? ['open', [url]]
+        : process.platform === 'win32'
+            ? ['rundll32', ['url.dll,FileProtocolHandler', url]] // kein cmd/start: "&" in der URL wäre dort ein Befehlstrenner
+            : ['xdg-open', [url]];
+    execFile(bin, args, () => undefined).on('error', () => undefined);
+}
 export async function runServer(opts) {
     const inspector = new Inspector();
     const t0 = Date.now();
@@ -24,10 +32,8 @@ export async function runServer(opts) {
     const url = noAuth ? `http://localhost:${opts.port}/` : `http://localhost:${opts.port}/?t=${token}`;
     console.log(`claude-inspect is reading ${CLAUDE_DIR} (started in ${Date.now() - t0} ms)`);
     console.log(opts.dev ? `API (dev, no token): ${url}  –  UI: npm run dev:web` : `Dashboard: ${url}`);
-    if (opts.open && process.platform === 'darwin')
-        execFile('open', [url]);
-    else if (opts.open && process.platform === 'linux')
-        execFile('xdg-open', [url]);
+    if (opts.open)
+        openBrowser(url);
     const shutdown = () => {
         inspector.stop();
         process.exit(0);

package/dist/app/server/sources/processes.js

@@ -4,13 +4,14 @@ import { join } from 'node:path';
 import { paths } from '../config.js';
 import { registry } from '../formats/index.js';
 import { readJson } from '../util/jsonl.js';
+const norm = (s) => s.replace(/\s+/g, ' ').trim();
 /**
  * Startzeiten laufender Prozesse per `ps` (rein lesend).
  * TZ=UTC, weil Claude Code `procStart` in UTC schreibt.
  */
 function procStarts(pids) {
     return new Promise((resolve) => {
-        if (pids.length === 0 || process.platform === 'win32')
+        if (pids.length === 0)
             return resolve(new Map());
         execFile('ps', ['-o', 'pid=,lstart=', '-p', pids.join(',')], { env: { ...process.env, TZ: 'UTC', LC_ALL: 'C' }, timeout: 5000 }, (_err, stdout) => {
             // ps endet mit Code 1, wenn einzelne PIDs fehlen – die Ausgabe ist trotzdem gültig.
@@ -25,10 +26,8 @@ function procStarts(pids) {
     });
 }
 /** Eltern-PID und Programmname aller Prozesse (`ps -A`), für die Zuordnung per Prozessbaum. */
-function processTable() {
+function unixTable() {
     return new Promise((resolve) => {
-        if (process.platform === 'win32')
-            return resolve(new Map());
         execFile('ps', ['-A', '-o', 'pid=,ppid=,comm='], { timeout: 5000, maxBuffer: 8 * 1024 * 1024 }, (_err, stdout) => {
             const out = new Map();
             for (const line of String(stdout ?? '').split('\n')) {
@@ -40,13 +39,66 @@ function processTable() {
         });
     });
 }
+/** Windows: Prozesstabelle inkl. Startzeit per CIM (rein lesend). */
+const WIN_PS = "Get-CimInstance Win32_Process | ForEach-Object { '{0} {1} {2} {3}' -f $_.ProcessId, $_.ParentProcessId, " +
+    "$(if ($_.CreationDate) { $_.CreationDate.ToUniversalTime().ToString('o') } else { '-' }), $_.Name }";
+function windowsTable() {
+    return new Promise((resolve) => {
+        execFile('powershell.exe', ['-NoProfile', '-NonInteractive', '-Command', WIN_PS], { timeout: 10_000, maxBuffer: 8 * 1024 * 1024, windowsHide: true }, (_err, stdout) => {
+            const out = new Map();
+            for (const line of String(stdout ?? '').split(/\r?\n/)) {
+                const m = /^(\d+) (\d+) (\S+) (.*)$/.exec(line.trim());
+                if (m)
+                    out.set(Number(m[1]), { ppid: Number(m[2]), start: m[3] === '-' ? undefined : m[3], comm: m[4].toLowerCase().replace(/\.exe$/, '') });
+            }
+            resolve(out);
+        });
+    });
+}
+// PowerShell zu starten kostet spürbar CPU – die Tabelle wird unter Windows kurz zwischengespeichert.
+let winCache;
+function cachedWindowsTable() {
+    if (!winCache || Date.now() - winCache.at > 5000)
+        winCache = { at: Date.now(), table: windowsTable() };
+    return winCache.table;
+}
+/** Startzeit als Epoch-ms. `ps lstart` ("Mon Sep 28 19:15:43 2026") hat keine Zone und ist UTC. */
+function parseStart(s) {
+    if (s === undefined || s === '')
+        return undefined;
+    if (typeof s === 'number' || /^\d+$/.test(s))
+        return Number(s);
+    const zoned = /(?:Z|[+-]\d{2}:?\d{2}|UTC|GMT)$/.test(s.trim());
+    const t = Date.parse(zoned ? s : `${s} UTC`);
+    return Number.isNaN(t) ? undefined : t;
+}
+/**
+ * Läuft der Prozess noch, und ist es derselbe (PIDs werden wiederverwendet)?
+ * Exakter Textvergleich, wo das Format bekannt ist; sonst Vergleich als Zeitpunkt.
+ * Ist `procStart` unbekannt oder unlesbar, reicht die Existenz der PID.
+ */
+export function sameProcess(actual, expected) {
+    if (actual === undefined)
+        return false;
+    if (!expected || norm(actual) === norm(expected))
+        return true;
+    const a = parseStart(actual);
+    const e = parseStart(expected);
+    if (a !== undefined && e !== undefined)
+        return Math.abs(a - e) <= 2000;
+    // Unbekanntes Format: unter Windows (kein ps-Format) zählt die PID, sonst lieber "nicht aktiv".
+    return process.platform === 'win32';
+}
 /**
  * Programme, die zwischen aufrufendem Agenten und gestartetem claude liegen dürfen
  * (Bash-Tool → Shell → evtl. Wrapper → claude). Alles andere – etwa der Daemon,
  * der Hintergrund-Jobs forkt – ist keine Aufrufbeziehung.
  */
-const LAUNCH_INTERMEDIATES = new Set(['sh', 'zsh', 'bash', 'dash', 'fish', '-zsh', '-bash', 'env', 'caffeinate', 'timeout', 'gtimeout', 'nohup', 'time', 'script', 'xargs', 'stdbuf', 'nice', 'sudo']);
-const norm = (s) => s.replace(/\s+/g, ' ').trim();
+const LAUNCH_INTERMEDIATES = new Set([
+    'sh', 'zsh', 'bash', 'dash', 'fish', '-zsh', '-bash', 'env', 'caffeinate', 'timeout', 'gtimeout', 'nohup', 'time', 'script', 'xargs', 'stdbuf', 'nice', 'sudo',
+    // Windows (Namen ohne .exe)
+    'cmd', 'powershell', 'pwsh',
+]);
 export async function readProcesses() {
     let names = [];
     try {
@@ -72,12 +124,19 @@ export async function readProcesses() {
             /* halb geschrieben oder gelöscht */
         }
     }
-    const [running, table] = await Promise.all([procStarts(decoded.map((p) => p.pid).filter((p) => p > 0)), processTable()]);
-    for (const p of decoded) {
-        const actual = running.get(p.pid);
-        const expected = procStart.get(p.pid);
-        p.alive = actual !== undefined && (!expected || norm(actual) === norm(expected));
+    if (decoded.length === 0)
+        return decoded;
+    let running;
+    let table;
+    if (process.platform === 'win32') {
+        table = await cachedWindowsTable();
+        running = new Map([...table].map(([pid, r]) => [pid, r.start ?? '']));
+    }
+    else {
+        [running, table] = await Promise.all([procStarts(decoded.map((p) => p.pid).filter((p) => p > 0)), unixTable()]);
     }
+    for (const p of decoded)
+        p.alive = sameProcess(running.get(p.pid), procStart.get(p.pid));
     // Prozessbaum hochlaufen (claude → zsh → claude …) bis zum nächsten bekannten Claude-Prozess.
     const alivePids = new Set(decoded.filter((p) => p.alive).map((p) => p.pid));
     for (const p of decoded) {

package/dist/app/server/sources/projects.js

@@ -1,14 +1,19 @@
 import { readdir, readFile, stat } from 'node:fs/promises';
 import { join } from 'node:path';
-import { paths } from '../config.js';
+import { paths, relToClaude } from '../config.js';
 import { registry } from '../formats/index.js';
 import { isObj, num, str } from '../formats/util.js';
 import { readHeadTail } from '../util/jsonl.js';
 import { compareVersions } from '../util/semver.js';
+/** Letztes Segment eines Pfads – egal ob mit "/" (macOS/Linux) oder "\\" (Windows). */
+export function pathTail(p) {
+    return p.replace(/[\\/]+$/, '').split(/[\\/]/).pop() || p;
+}
 export function projectName(cwd, projectDir) {
     if (cwd)
-        return cwd.replace(/\/+$/, '').split('/').pop() || cwd;
-    return projectDir.replace(/^-Users-[^-]+-/, '');
+        return pathTail(cwd);
+    // kodiertes Home-Verzeichnis: -Users-<name>- (macOS), -home-<name>- (Linux), C--Users-<name>- (Windows)
+    return projectDir.replace(/^(?:[A-Za-z]-)?-(?:Users|home)-[^-]+-/, '');
 }
 /**
  * Index über alle Session-Transcripts unter ~/.claude/projects.
@@ -54,7 +59,7 @@ export class ProjectIndex {
     }
     /** Aktualisiert einen einzelnen Eintrag nach einem Watch-Event. */
     async touch(path) {
-        const m = /\/projects\/([^/]+)\/([^/]+)\.jsonl$/.exec(path);
+        const m = /^projects\/([^/]+)\/([^/]+)\.jsonl$/.exec(relToClaude(path));
         if (!m)
             return;
         try {

package/dist/app/server/sources/spawns.js

@@ -120,7 +120,7 @@ export function scoreSpawn(child, call) {
             evidence.push('time (rough)');
         }
     }
-    if (child.cwd && call.cwd && child.cwd.replace(/\/$/, '') === call.cwd.replace(/\/$/, '')) {
+    if (child.cwd && call.cwd && child.cwd.replace(/[\\/]+$/, '') === call.cwd.replace(/[\\/]+$/, '')) {
         score += 5;
         evidence.push('directory');
     }