claude-inspect 0.1.0

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

@@ -0,0 +1,30 @@
+import { readdir } from 'node:fs/promises';
+import { join } from 'node:path';
+import { paths } from '../config.js';
+import { registry } from '../formats/index.js';
+import { readJson } from '../util/jsonl.js';
+export async function readTasks(sessionId) {
+    if (!/^[\w-]+$/.test(sessionId))
+        return [];
+    const dir = join(paths.tasks, sessionId);
+    let names;
+    try {
+        names = await readdir(dir);
+    }
+    catch {
+        return [];
+    }
+    const out = [];
+    for (const n of names) {
+        if (!n.endsWith('.json'))
+            continue;
+        const file = join(dir, n);
+        try {
+            out.push(registry.decode('task', await readJson(file), file).out);
+        }
+        catch {
+            /* halb geschrieben */
+        }
+    }
+    return out.sort((a, b) => Number(a.id) - Number(b.id) || a.id.localeCompare(b.id));
+}

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

@@ -0,0 +1,121 @@
+import { LIMITS } from '../config.js';
+import { registry } from '../formats/index.js';
+import { JsonlTail, readLineAt } from '../util/jsonl.js';
+/** Ein geladenes Transcript (Hauptsession oder Subagent), inkrementell nachgeführt. */
+export class Transcript {
+    path;
+    sessionId;
+    agentId;
+    entries = [];
+    /** Byte-Offset je Zeilennummer – für die Rohansicht. */
+    lineOffsets = new Map();
+    tail;
+    lastAccess = Date.now();
+    constructor(path, sessionId, agentId) {
+        this.path = path;
+        this.sessionId = sessionId;
+        this.agentId = agentId;
+        this.tail = new JsonlTail(path);
+    }
+    get bytes() {
+        return this.tail.offset;
+    }
+    /** Liest neue Zeilen. Gibt die Anzahl neuer Einträge zurück (-1 = komplett neu geladen). */
+    async refresh() {
+        const { lines, reset } = await this.tail.readNew();
+        if (reset) {
+            this.entries = [];
+            this.lineOffsets.clear();
+        }
+        const before = this.entries.length;
+        for (const l of lines) {
+            this.lineOffsets.set(l.line, l.offset);
+            let decoded;
+            let decoder;
+            if (l.error !== undefined) {
+                decoded = [{ kind: 'unknown', recordType: '(corrupt line)', raw: l.error }];
+                decoder = 'jsonl.parse-error';
+            }
+            else {
+                ({ out: decoded, decoder } = registry.decode('transcript', l.value, this.path, l.line));
+            }
+            for (const d of decoded) {
+                this.entries.push({ ...d, seq: this.entries.length, line: l.line, decoder });
+            }
+        }
+        return reset ? -1 : this.entries.length - before;
+    }
+    async rawLine(line) {
+        const off = this.lineOffsets.get(line);
+        if (off === undefined)
+            return undefined;
+        return readLineAt(this.path, off, LIMITS.maxRawLine);
+    }
+}
+/**
+ * Hält geladene Transcripts im Speicher (LRU mit Byte-Budget).
+ * Nichts wird auf Platte gespeichert.
+ */
+export class TranscriptStore {
+    loaded = new Map();
+    loading = new Map();
+    isLoaded(path) {
+        return this.loaded.has(path);
+    }
+    peek(path) {
+        return this.loaded.get(path);
+    }
+    async get(path, sessionId, agentId) {
+        const t = this.loaded.get(path);
+        if (t) {
+            t.lastAccess = Date.now();
+            return t;
+        }
+        let p = this.loading.get(path);
+        if (!p) {
+            p = (async () => {
+                const nt = new Transcript(path, sessionId, agentId);
+                await nt.refresh();
+                this.loaded.set(path, nt);
+                this.evict();
+                return nt;
+            })().finally(() => this.loading.delete(path));
+            this.loading.set(path, p);
+        }
+        return p;
+    }
+    /** Nach einer Dateiänderung: nur nachladen, wenn das Transcript bereits im Speicher ist. */
+    async refreshIfLoaded(path) {
+        const t = this.loaded.get(path);
+        if (!t)
+            return undefined;
+        try {
+            const added = await t.refresh();
+            return added === 0 ? undefined : { transcript: t, added };
+        }
+        catch {
+            // Datei gelöscht (Claude Code räumt auf) → aus dem Speicher nehmen
+            this.loaded.delete(path);
+            return undefined;
+        }
+    }
+    all() {
+        return [...this.loaded.values()];
+    }
+    evict() {
+        let total = 0;
+        for (const t of this.loaded.values())
+            total += t.bytes;
+        if (total <= LIMITS.transcriptCacheBytes)
+            return;
+        const byAge = [...this.loaded.values()].sort((a, b) => a.lastAccess - b.lastAccess);
+        for (const t of byAge) {
+            if (total <= LIMITS.transcriptCacheBytes * 0.8)
+                break;
+            if (Date.now() - t.lastAccess < 60_000)
+                continue; // gerade benutzt
+            this.loaded.delete(t.path);
+            total -= t.bytes;
+        }
+    }
+}

package/dist/app/server/util/jsonl.js

@@ -0,0 +1,124 @@
+import { open, stat } from 'node:fs/promises';
+function parseLine(text, line, offset) {
+    try {
+        return { line, offset, value: JSON.parse(text) };
+    }
+    catch (e) {
+        return { line, offset, error: e.message };
+    }
+}
+/**
+ * Liest eine wachsende JSONL-Datei inkrementell: Jeder Aufruf von readNew()
+ * liefert nur die seitdem vollständig geschriebenen Zeilen.
+ */
+export class JsonlTail {
+    path;
+    offset = 0;
+    lineNo = 0;
+    leftover = Buffer.alloc(0);
+    constructor(path) {
+        this.path = path;
+    }
+    /**
+     * @param prefilter Optional: nur Zeilen parsen, deren Rohtext passt (spart bei
+     *                  großen Dateien den Großteil der JSON.parse-Arbeit).
+     */
+    async readNew(prefilter) {
+        const st = await stat(this.path);
+        let reset = false;
+        if (st.size < this.offset) {
+            // Datei wurde gekürzt oder ersetzt → von vorn.
+            this.offset = 0;
+            this.lineNo = 0;
+            this.leftover = Buffer.alloc(0);
+            reset = true;
+        }
+        if (st.size === this.offset)
+            return { lines: [], reset };
+        const fh = await open(this.path, 'r');
+        try {
+            const len = st.size - this.offset;
+            const buf = Buffer.alloc(len);
+            const { bytesRead } = await fh.read(buf, 0, len, this.offset);
+            const chunk = Buffer.concat([this.leftover, buf.subarray(0, bytesRead)]);
+            const chunkStart = this.offset - this.leftover.length;
+            this.offset += bytesRead;
+            const lines = [];
+            let start = 0;
+            for (let i = chunk.indexOf(10); i !== -1; i = chunk.indexOf(10, start)) {
+                const text = chunk.toString('utf8', start, i);
+                if (text.trim() && (!prefilter || prefilter(text)))
+                    lines.push(parseLine(text, this.lineNo, chunkStart + start));
+                this.lineNo++;
+                start = i + 1;
+            }
+            this.leftover = Buffer.from(chunk.subarray(start));
+            return { lines, reset };
+        }
+        finally {
+            await fh.close();
+        }
+    }
+}
+/** Liest nur Anfang und Ende einer Datei – für schnelle Zusammenfassungen. */
+export async function readHeadTail(path, headBytes, tailBytes) {
+    const st = await stat(path);
+    const fh = await open(path, 'r');
+    try {
+        const parse = (buf, dropFirst, dropLast) => {
+            const parts = buf.toString('utf8').split('\n');
+            if (dropFirst)
+                parts.shift();
+            if (dropLast)
+                parts.pop();
+            const out = [];
+            for (const p of parts) {
+                if (!p.trim())
+                    continue;
+                try {
+                    out.push(JSON.parse(p));
+                }
+                catch {
+                    /* angeschnittene Zeile */
+                }
+            }
+            return out;
+        };
+        if (st.size <= headBytes + tailBytes) {
+            const buf = Buffer.alloc(st.size);
+            await fh.read(buf, 0, st.size, 0);
+            const all = parse(buf, false, false);
+            return { head: all, tail: all, size: st.size };
+        }
+        const hb = Buffer.alloc(headBytes);
+        await fh.read(hb, 0, headBytes, 0);
+        const tb = Buffer.alloc(tailBytes);
+        await fh.read(tb, 0, tailBytes, st.size - tailBytes);
+        return { head: parse(hb, false, true), tail: parse(tb, true, false), size: st.size };
+    }
+    finally {
+        await fh.close();
+    }
+}
+/** Liest eine einzelne Zeile ab einem bekannten Byte-Offset. */
+export async function readLineAt(path, offset, maxBytes) {
+    const fh = await open(path, 'r');
+    try {
+        const buf = Buffer.alloc(maxBytes);
+        const { bytesRead } = await fh.read(buf, 0, maxBytes, offset);
+        const end = buf.subarray(0, bytesRead).indexOf(10);
+        return buf.toString('utf8', 0, end === -1 ? bytesRead : end);
+    }
+    finally {
+        await fh.close();
+    }
+}
+export async function readJson(path) {
+    const fh = await open(path, 'r');
+    try {
+        return JSON.parse(await fh.readFile('utf8'));
+    }
+    finally {
+        await fh.close();
+    }
+}

package/dist/app/server/util/sanitize.js

@@ -0,0 +1,42 @@
+import { LIMITS } from '../config.js';
+const SECRET_KEY = /(token|secret|password|passwd|api[_-]?key|authorization|cookie|credential)/i;
+function isSecretKey(key) {
+    // Token-*Zähler* (input_tokens, totalTokens …) sind Zahlen und bleiben sichtbar.
+    return SECRET_KEY.test(key);
+}
+/**
+ * Tiefe Kopie, die
+ * - String-Werte unter geheimnisverdächtigen Schlüsseln maskiert,
+ * - Base64-Bilddaten durch einen Platzhalter ersetzt,
+ * - zu lange Strings kürzt.
+ */
+export function sanitize(value, opts = {}, key = '') {
+    const max = opts.maxString ?? LIMITS.maxString;
+    if (typeof value === 'string') {
+        if (key && isSecretKey(key))
+            return value ? '••••••' : value;
+        if ((key === 'base64' || key === 'data') && value.length > 256 && /^[A-Za-z0-9+/=\s]+$/.test(value.slice(0, 256))) {
+            return `[base64, ${value.length} characters omitted]`;
+        }
+        if (value.length > max)
+            return value.slice(0, max) + `\n… [${value.length - max} characters truncated]`;
+        return value;
+    }
+    if (Array.isArray(value))
+        return value.map((v) => sanitize(v, opts));
+    if (value && typeof value === 'object') {
+        const out = {};
+        for (const [k, v] of Object.entries(value)) {
+            if (opts.dropKeys?.has(k)) {
+                out[k] = typeof v === 'string' ? `[${v.length} characters omitted]` : v === null ? null : '[omitted]';
+                continue;
+            }
+            out[k] = sanitize(v, opts, k);
+        }
+        return out;
+    }
+    return value;
+}
+export function clip(s, max = LIMITS.maxString) {
+    return s.length > max ? { text: s.slice(0, max), truncated: s.length - max } : { text: s };
+}

package/dist/app/server/util/semver.js

@@ -0,0 +1,33 @@
+/** Minimaler Versionsvergleich für "2.1.283"-artige Strings. */
+export function compareVersions(a, b) {
+    const pa = a.split(/[.-]/).map((x) => parseInt(x, 10));
+    const pb = b.split(/[.-]/).map((x) => parseInt(x, 10));
+    for (let i = 0; i < Math.max(pa.length, pb.length); i++) {
+        const x = Number.isNaN(pa[i]) ? 0 : (pa[i] ?? 0);
+        const y = Number.isNaN(pb[i]) ? 0 : (pb[i] ?? 0);
+        if (x !== y)
+            return x < y ? -1 : 1;
+    }
+    return 0;
+}
+/**
+ * Prüft Bereiche wie ">=2.1.0", "<2.2.0", ">=2.1.0 <2.2.0" oder "*".
+ * Ein fehlendes `version` passt auf jeden Bereich (ältere Records hatten nicht immer eins).
+ */
+export function inRange(version, range) {
+    if (!range || range === '*' || !version)
+        return true;
+    return range.split(/\s+/).every((part) => {
+        const m = /^(>=|<=|>|<|=)?(.+)$/.exec(part);
+        if (!m)
+            return true;
+        const c = compareVersions(version, m[2]);
+        switch (m[1]) {
+            case '>=': return c >= 0;
+            case '<=': return c <= 0;
+            case '>': return c > 0;
+            case '<': return c < 0;
+            default: return c === 0;
+        }
+    });
+}

package/dist/app/shared/pricing.js

@@ -0,0 +1,57 @@
+const PRICES = [
+    // Reihenfolge: spezifischere Präfixe zuerst
+    ['claude-fable-5-1', { input: 10, output: 50, cacheRead: 0.25 }],
+    ['claude-mythos-5-1', { input: 10, output: 50, cacheRead: 0.25 }],
+    ['claude-fable-5', { input: 10, output: 50 }],
+    ['claude-mythos-5', { input: 10, output: 50 }],
+    ['claude-opus-5-5', { input: 4, output: 20, cacheRead: 0.2 }],
+    ['claude-opus-5', { input: 5, output: 25 }],
+    ['claude-opus-4-8', { input: 5, output: 25 }],
+    ['claude-opus-4-7', { input: 5, output: 25 }],
+    ['claude-opus-4-6', { input: 5, output: 25 }],
+    ['claude-opus-4-5', { input: 5, output: 25 }],
+    ['claude-sonnet-5', { input: 2, output: 10 }],
+    ['claude-sonnet-4', { input: 3, output: 15 }],
+    ['claude-haiku-4-5', { input: 1, output: 5 }],
+];
+export function priceFor(model) {
+    if (!model)
+        return undefined;
+    return PRICES.find(([p]) => model === p || model.startsWith(p + '-') || model.startsWith(p + '['))?.[1];
+}
+export const emptyTotals = () => ({ input: 0, output: 0, cacheRead: 0, cacheWrite5m: 0, cacheWrite1h: 0, requests: 0 });
+export function addUsage(t, u) {
+    t.input += u.input_tokens ?? 0;
+    t.output += u.output_tokens ?? 0;
+    t.cacheRead += u.cache_read_input_tokens ?? 0;
+    const cc = u.cache_creation;
+    if (cc && (cc.ephemeral_1h_input_tokens !== undefined || cc.ephemeral_5m_input_tokens !== undefined)) {
+        t.cacheWrite5m += cc.ephemeral_5m_input_tokens ?? 0;
+        t.cacheWrite1h += cc.ephemeral_1h_input_tokens ?? 0;
+    }
+    else {
+        t.cacheWrite5m += u.cache_creation_input_tokens ?? 0;
+    }
+    t.requests++;
+}
+export function mergeTotals(a, b) {
+    a.input += b.input;
+    a.output += b.output;
+    a.cacheRead += b.cacheRead;
+    a.cacheWrite5m += b.cacheWrite5m;
+    a.cacheWrite1h += b.cacheWrite1h;
+    a.requests += b.requests;
+}
+/** Geschätzte Kosten in USD, oder undefined bei unbekanntem Modell. */
+export function estimateCost(model, t) {
+    const p = priceFor(model);
+    if (!p)
+        return undefined;
+    const M = 1_000_000;
+    return ((t.input * p.input +
+        t.output * p.output +
+        t.cacheRead * (p.cacheRead ?? p.input * 0.1) +
+        t.cacheWrite5m * p.input * 1.25 +
+        t.cacheWrite1h * p.input * 2) /
+        M);
+}

package/dist/app/shared/tools.js

@@ -0,0 +1,62 @@
+// Kurzbeschreibung eines Tool-Aufrufs für Listen und Statuszeilen.
+function str(v) {
+    return typeof v === 'string' && v.length > 0 ? v : undefined;
+}
+export function basename(p) {
+    const i = p.replace(/\/+$/, '').lastIndexOf('/');
+    return i >= 0 ? p.slice(i + 1) : p;
+}
+function firstLine(s, max = 120) {
+    const line = s.split('\n', 1)[0] ?? '';
+    return line.length > max ? line.slice(0, max - 1) + '…' : line;
+}
+/** "mcp__claude-in-chrome__navigate" → { server: "claude-in-chrome", tool: "navigate" } */
+export function splitMcpName(name) {
+    const m = /^mcp_{1,2}(.+?)__(.+)$/.exec(name);
+    return m ? { server: m[1], tool: m[2] } : { tool: name };
+}
+export function toolSummary(name, input) {
+    const i = input ?? {};
+    switch (name) {
+        case 'Bash':
+            return str(i.description) ?? firstLine(str(i.command) ?? '');
+        case 'Read':
+        case 'Write':
+        case 'Edit':
+        case 'MultiEdit':
+        case 'NotebookEdit':
+            return basename(str(i.file_path) ?? str(i.notebook_path) ?? '');
+        case 'Grep':
+        case 'Glob':
+            return (str(i.pattern) ?? '') + (str(i.path) ? ` in ${basename(str(i.path))}` : '');
+        case 'Agent':
+        case 'Task':
+            return [str(i.subagent_type), str(i.description)].filter(Boolean).join(': ');
+        case 'WebFetch':
+            return str(i.url) ?? '';
+        case 'WebSearch':
+            return str(i.query) ?? '';
+        case 'Skill':
+            return str(i.skill) ?? '';
+        case 'SendMessage':
+            return `→ ${str(i.to) ?? '?'}`;
+        case 'ToolSearch':
+            return str(i.query) ?? '';
+        case 'ScheduleWakeup':
+            return str(i.reason) ?? '';
+        case 'TaskCreate':
+        case 'TaskUpdate':
+            return str(i.subject) ?? str(i.taskId) ?? '';
+        case 'AskUserQuestion': {
+            const q = Array.isArray(i.questions) ? i.questions[0] : undefined;
+            return firstLine(str(q?.question) ?? '');
+        }
+    }
+    for (const k of ['description', 'command', 'url', 'query', 'path', 'file_path', 'prompt', 'action', 'name']) {
+        const v = str(i[k]);
+        if (v)
+            return firstLine(v);
+    }
+    const keys = Object.keys(i);
+    return keys.length ? keys.slice(0, 3).join(', ') : '';
+}

package/dist/app/shared/types.js

@@ -0,0 +1,3 @@
+// Normiertes Domain-Model. Wird von Server und Frontend gemeinsam genutzt.
+// Die Decoder in src/server/formats übersetzen die Rohformate von Claude Code in diese Typen.
+export {};