claude-inspect 0.1.0

package/dist/app/server/formats/registry.js

@@ -0,0 +1,87 @@
+import { compareVersions } from '../util/semver.js';
+import { isObj, str } from './util.js';
+export class FormatRegistry {
+    decoders = new Map();
+    hits = new Map();
+    drift = new Map();
+    register(d) {
+        const list = this.decoders.get(d.source) ?? [];
+        if (list.some((x) => x.id === d.id))
+            throw new Error(`Decoder ${d.id} doppelt registriert`);
+        list.push(d);
+        this.decoders.set(d.source, list);
+        return this;
+    }
+    /** Wählt den am besten passenden Decoder und dekodiert den Record. */
+    decode(source, raw, file, line = 0, opts = {}) {
+        const record = isObj(raw) ? raw : { __nonObject: raw };
+        const version = str(record.version) ?? str(record.cliVersion);
+        const ctx = {
+            source,
+            file,
+            line,
+            reportUnknown: (recordType, o, known) => {
+                if (!o)
+                    return undefined;
+                let extra;
+                for (const k of Object.keys(o)) {
+                    if (known.includes(k))
+                        continue;
+                    (extra ??= {})[k] = o[k];
+                    if (!opts.silent)
+                        this.noteDrift(source, recordType, k, version);
+                }
+                return extra;
+            },
+        };
+        let best;
+        let bestScore = 0;
+        for (const d of this.decoders.get(source) ?? []) {
+            const s = d.match(record, ctx);
+            if (s > bestScore) {
+                best = d;
+                bestScore = s;
+            }
+        }
+        if (!best)
+            throw new Error(`No decoder (not even a fallback) for source ${source}`);
+        if (opts.silent)
+            return { out: best.decode(record, ctx), decoder: best.id };
+        this.hits.set(best.id, (this.hits.get(best.id) ?? 0) + 1);
+        if (bestScore <= 1)
+            this.noteDrift(source, str(record.type) ?? '-', '(unknown record type)', version);
+        const known = best.knownFields?.(record);
+        if (known) {
+            const recordType = str(record.type) ?? '-';
+            for (const k of Object.keys(record))
+                if (!known.includes(k))
+                    this.noteDrift(source, recordType, k, version);
+        }
+        return { out: best.decode(record, ctx), decoder: best.id };
+    }
+    noteDrift(source, recordType, field, version) {
+        const key = `${source}\u0000${recordType}\u0000${field}`;
+        let d = this.drift.get(key);
+        if (!d) {
+            d = { source, recordType, field, count: 0 };
+            this.drift.set(key, d);
+        }
+        d.count++;
+        if (version) {
+            if (!d.firstVersion || compareVersions(version, d.firstVersion) < 0)
+                d.firstVersion = version;
+            if (!d.lastVersion || compareVersions(version, d.lastVersion) > 0)
+                d.lastVersion = version;
+        }
+    }
+    report() {
+        const decoders = [];
+        for (const list of this.decoders.values()) {
+            for (const d of list) {
+                decoders.push({ id: d.id, source: d.source, description: d.description, versions: d.versions, hits: this.hits.get(d.id) ?? 0 });
+            }
+        }
+        const drift = [...this.drift.values()].sort((a, b) => b.count - a.count).map((d) => ({ ...d }));
+        return { decoders, drift };
+    }
+}

package/dist/app/server/formats/subagent/meta.js

@@ -0,0 +1,28 @@
+import { sanitize } from '../../util/sanitize.js';
+import { extraFields, num, str } from '../util.js';
+const FIELDS = ['agentType', 'description', 'toolUseId', 'spawnDepth', 'requestShape', 'requestNonInteractive'];
+export const subagentMetaDecoder = {
+    id: 'subagent-meta@1',
+    source: 'subagent-meta',
+    description: 'subagent metadata: type, description, calling tool use, depth',
+    match: (raw) => ('agentType' in raw || 'toolUseId' in raw ? 10 : 0),
+    decode(raw) {
+        const extra = extraFields(raw, FIELDS);
+        return {
+            agentType: str(raw.agentType),
+            description: str(raw.description),
+            toolUseId: str(raw.toolUseId),
+            spawnDepth: num(raw.spawnDepth),
+            background: raw.requestShape === 'background',
+            extra: extra ? sanitize(extra) : undefined,
+        };
+    },
+    knownFields: () => FIELDS,
+};
+export const subagentMetaFallback = {
+    id: 'subagent-meta.fallback',
+    source: 'subagent-meta',
+    description: 'unknown subagent metadata',
+    match: () => 1,
+    decode: (raw) => ({ extra: sanitize(raw) }),
+};

package/dist/app/server/formats/task/task.js

@@ -0,0 +1,33 @@
+import { sanitize } from '../../util/sanitize.js';
+import { arr, extraFields, str } from '../util.js';
+const FIELDS = ['id', 'subject', 'description', 'status', 'activeForm', 'owner', 'blocks', 'blockedBy'];
+const ids = (v) => arr(v).map(String);
+/** tasks/<sessionId>/<n>.json (TaskCreate/TaskUpdate). */
+export const taskDecoder = {
+    id: 'task@1',
+    source: 'task',
+    description: 'task of a session task list (status, dependencies)',
+    match: (raw) => ('subject' in raw || 'status' in raw) && 'id' in raw ? 10 : 0,
+    decode(raw) {
+        const extra = extraFields(raw, FIELDS);
+        return {
+            id: String(raw.id),
+            subject: str(raw.subject),
+            description: str(raw.description),
+            status: str(raw.status),
+            activeForm: str(raw.activeForm),
+            owner: str(raw.owner),
+            blocks: ids(raw.blocks),
+            blockedBy: ids(raw.blockedBy),
+            extra: extra ? sanitize(extra) : undefined,
+        };
+    },
+    knownFields: () => FIELDS,
+};
+export const taskFallback = {
+    id: 'task.fallback',
+    source: 'task',
+    description: 'unknown task format',
+    match: () => 1,
+    decode: (raw) => ({ id: String(raw.id ?? '?'), blocks: [], blockedBy: [], extra: sanitize(raw) }),
+};

package/dist/app/server/formats/transcript/common.js

@@ -0,0 +1,33 @@
+import { bool, str } from '../util.js';
+/** Felder, die (fast) jeder Nachrichten-Record trägt. */
+export const ENVELOPE_FIELDS = [
+    'type',
+    'uuid',
+    'parentUuid',
+    'logicalParentUuid',
+    'timestamp',
+    'isSidechain',
+    'isMeta',
+    'userType',
+    'cwd',
+    'sessionId',
+    'session_id',
+    'sessionKind',
+    'version',
+    'gitBranch',
+    'entrypoint',
+    'slug',
+    'agentId',
+];
+export function envelope(raw) {
+    return {
+        recordType: str(raw.type) ?? '-',
+        version: str(raw.version),
+        uuid: str(raw.uuid),
+        parentUuid: raw.parentUuid === null ? null : str(raw.parentUuid),
+        timestamp: str(raw.timestamp),
+        agentId: str(raw.agentId),
+        isSidechain: bool(raw.isSidechain),
+        isMeta: bool(raw.isMeta),
+    };
+}

package/dist/app/server/formats/transcript/message.js

@@ -0,0 +1,206 @@
+import { clip, sanitize } from '../../util/sanitize.js';
+import { inRange } from '../../util/semver.js';
+import { arr, bool, extraFields, isObj, obj, str } from '../util.js';
+import { ENVELOPE_FIELDS, envelope } from './common.js';
+/**
+ * user- und assistant-Records im Messages-API-Format:
+ *   { type: "user"|"assistant", message: { role, content: string | Block[] , … }, … }
+ * Belegt für 2.1.72 – 2.1.283. `message.content` ist bei Nutzer-Prompts teils
+ * ein String, teils ein Block-Array; `toolUseResult` ist teils Objekt, teils String.
+ */
+const USER_FIELDS = [
+    ...ENVELOPE_FIELDS,
+    'message',
+    'promptId',
+    'sourceToolAssistantUUID',
+    'sourceToolUseID',
+    'toolUseResult',
+    'permissionMode',
+    'promptSource',
+    'origin',
+    'toolDenialKind',
+    'isCompactSummary',
+    'isVisibleInTranscriptOnly',
+    'interruptedMessageId',
+    'turnOrigin',
+    'turnCompanion',
+];
+const ASSISTANT_FIELDS = [
+    ...ENVELOPE_FIELDS,
+    'message',
+    'requestId',
+    'effort',
+    'perTurnEffort',
+    'apiBlockIndex',
+    'attributionAgent',
+    'attributionSkill',
+    'attributionMcpServer',
+    'attributionMcpTool',
+    'attributionPlugin',
+    'advisorModel',
+    'isApiErrorMessage',
+    'error',
+    'apiErrorStatus',
+];
+const ASSISTANT_MESSAGE_FIELDS = [
+    'model',
+    'id',
+    'type',
+    'role',
+    'content',
+    'stop_reason',
+    'stop_sequence',
+    'stop_details',
+    'usage',
+    'diagnostics',
+    'context_management',
+    'container',
+    'input_transformations',
+];
+/** Vollständige Dateiinhalte in toolUseResult (Edit/Write) – für die Anzeige unnötig. */
+const DROP_IN_RESULT = new Set(['originalFile']);
+function resultParts(content) {
+    if (typeof content === 'string')
+        return [{ type: 'text', ...clip(content) }];
+    return arr(content).map((b) => {
+        if (!isObj(b))
+            return { type: 'other', value: b };
+        switch (b.type) {
+            case 'text':
+                return { type: 'text', ...clip(str(b.text) ?? '') };
+            case 'image':
+                return { type: 'image', mediaType: str(obj(b.source)?.media_type) };
+            case 'tool_reference':
+                return { type: 'tool_reference', toolName: str(b.tool_name) ?? '?' };
+            default:
+                return { type: 'other', value: sanitize(b) };
+        }
+    });
+}
+function decodeUser(raw, ctx) {
+    const env = envelope(raw);
+    const msg = obj(raw.message) ?? {};
+    const content = msg.content;
+    const out = [];
+    const userFields = {
+        permissionMode: str(raw.permissionMode),
+        promptSource: str(raw.promptSource),
+        origin: raw.origin,
+        isCompactSummary: bool(raw.isCompactSummary),
+    };
+    if (typeof content === 'string') {
+        out.push({ ...env, kind: 'user-text', text: clip(content).text, ...userFields });
+    }
+    else {
+        for (const b of arr(content)) {
+            if (!isObj(b))
+                continue;
+            switch (b.type) {
+                case 'text':
+                    out.push({ ...env, kind: 'user-text', text: clip(str(b.text) ?? '').text, ...userFields });
+                    break;
+                case 'tool_result': {
+                    const tur = raw.toolUseResult;
+                    out.push({
+                        ...env,
+                        kind: 'tool-result',
+                        toolUseId: str(b.tool_use_id) ?? '',
+                        parts: resultParts(b.content),
+                        isError: b.is_error === true,
+                        structured: tur === undefined ? undefined : sanitize(tur, { dropKeys: DROP_IN_RESULT }),
+                        denied: str(raw.toolDenialKind),
+                    });
+                    break;
+                }
+                case 'image':
+                    out.push({ ...env, kind: 'image', mediaType: str(obj(b.source)?.media_type) });
+                    break;
+                default:
+                    out.push({ ...env, kind: 'unknown', raw: sanitize(b) });
+                    ctx.reportUnknown('user.message.content', { [String(b.type)]: true }, []);
+            }
+        }
+    }
+    if (out.length === 0)
+        out.push({ ...env, kind: 'user-text', text: '', ...userFields });
+    const extra = extraFields(raw, USER_FIELDS);
+    if (extra)
+        out[0].extra = sanitize(extra);
+    return out;
+}
+function decodeAssistant(raw, ctx) {
+    const env = envelope(raw);
+    const msg = obj(raw.message) ?? {};
+    const msgExtra = ctx.reportUnknown('assistant.message', msg, ASSISTANT_MESSAGE_FIELDS);
+    const fields = {
+        model: str(msg.model),
+        messageId: str(msg.id),
+        requestId: str(raw.requestId),
+        usage: obj(msg.usage),
+        stopReason: msg.stop_reason === null ? null : str(msg.stop_reason),
+        effort: str(raw.perTurnEffort) ?? str(raw.effort),
+        attribution: {
+            skill: str(raw.attributionSkill),
+            agent: str(raw.attributionAgent),
+            mcpServer: str(raw.attributionMcpServer),
+            mcpTool: str(raw.attributionMcpTool),
+            plugin: str(raw.attributionPlugin),
+        },
+        isApiError: bool(raw.isApiErrorMessage),
+    };
+    const out = [];
+    for (const b of arr(msg.content)) {
+        if (!isObj(b))
+            continue;
+        switch (b.type) {
+            case 'text':
+                out.push({ ...env, ...fields, kind: 'assistant-text', text: clip(str(b.text) ?? '').text });
+                break;
+            case 'thinking':
+                out.push({ ...env, ...fields, kind: 'thinking', text: clip(str(b.thinking) ?? '').text });
+                break;
+            case 'redacted_thinking':
+                out.push({ ...env, ...fields, kind: 'thinking', text: '', redacted: true });
+                break;
+            case 'tool_use':
+            case 'server_tool_use':
+                out.push({
+                    ...env,
+                    ...fields,
+                    kind: 'tool-use',
+                    toolUseId: str(b.id) ?? '',
+                    name: str(b.name) ?? '?',
+                    input: sanitize(obj(b.input) ?? {}) ?? {},
+                });
+                break;
+            default:
+                out.push({ ...env, kind: 'unknown', raw: sanitize(b) });
+                ctx.reportUnknown('assistant.message.content', { [String(b.type)]: true }, []);
+        }
+    }
+    if (out.length === 0) {
+        // z. B. API-Fehlermeldung ohne Inhalt
+        out.push({ ...env, ...fields, kind: 'assistant-text', text: str(raw.error) ?? '' });
+    }
+    const extra = { ...extraFields(raw, ASSISTANT_FIELDS), ...(msgExtra ? { message: msgExtra } : {}) };
+    if (Object.keys(extra).length)
+        out[0].extra = sanitize(extra);
+    return out;
+}
+export const messageDecoder = {
+    id: 'transcript.message@2',
+    source: 'transcript',
+    description: 'user/assistant records with Messages API content (text, thinking, tool calls and results)',
+    versions: '>=2.0.0',
+    match(raw) {
+        if ((raw.type !== 'user' && raw.type !== 'assistant') || !isObj(raw.message))
+            return 0;
+        return 10 + (inRange(str(raw.version), '>=2.0.0') ? 5 : 0);
+    },
+    decode(raw, ctx) {
+        return raw.type === 'assistant' ? decodeAssistant(raw, ctx) : decodeUser(raw, ctx);
+    },
+    knownFields(raw) {
+        return raw.type === 'assistant' ? ASSISTANT_FIELDS : USER_FIELDS;
+    },
+};

package/dist/app/server/formats/transcript/other.js

@@ -0,0 +1,130 @@
+import { sanitize } from '../../util/sanitize.js';
+import { extraFields, isObj, obj, str, without } from '../util.js';
+import { ENVELOPE_FIELDS, envelope } from './common.js';
+// ---------------------------------------------------------------------------
+// system-Records: stop_hook_summary, turn_duration, api_error, compact_boundary, …
+const SYSTEM_FIELDS = [
+    ...ENVELOPE_FIELDS,
+    'subtype',
+    'level',
+    'content',
+    // subtype-spezifisch
+    'hookCount',
+    'hookInfos',
+    'hookErrors',
+    'hookAdditionalContext',
+    'preventedContinuation',
+    'stopReason',
+    'hasOutput',
+    'toolUseID',
+    'durationMs',
+    'messageCount',
+    'error',
+    'retryInMs',
+    'retryAttempt',
+    'maxRetries',
+    'source',
+    'pendingBackgroundAgentCount',
+    'compactMetadata',
+    'commandRun',
+    'usageReport',
+    'url',
+    'contextUsage',
+];
+export const systemDecoder = {
+    id: 'transcript.system@2',
+    source: 'transcript',
+    description: 'system records (hooks, turn duration, API errors, compaction, Remote Control …)',
+    versions: '>=2.0.0',
+    match: (raw) => (raw.type === 'system' && typeof raw.subtype === 'string' ? 10 : 0),
+    decode(raw) {
+        const data = sanitize(without(raw, [...ENVELOPE_FIELDS, 'subtype', 'level', 'content']));
+        return [
+            {
+                ...envelope(raw),
+                kind: 'system',
+                subtype: str(raw.subtype) ?? '?',
+                level: str(raw.level),
+                text: str(raw.content),
+                data,
+            },
+        ];
+    },
+    knownFields: () => SYSTEM_FIELDS,
+};
+// ---------------------------------------------------------------------------
+// attachment-Records: Kontext, den Claude Code dem Modell mitgibt
+const ATTACHMENT_FIELDS = [...ENVELOPE_FIELDS, 'attachment', 'rendered', 'renderedInHumanTurn'];
+export const attachmentDecoder = {
+    id: 'transcript.attachment@2',
+    source: 'transcript',
+    description: 'attachment records (files, reminders, skill/tool listings, hook context …)',
+    versions: '>=2.1.0',
+    match: (raw) => (raw.type === 'attachment' && isObj(raw.attachment) ? 10 : 0),
+    decode(raw) {
+        const att = obj(raw.attachment) ?? {};
+        const entry = {
+            ...envelope(raw),
+            kind: 'attachment',
+            attachmentType: str(att.type) ?? '?',
+            data: sanitize(without(att, ['type'])),
+        };
+        const extra = extraFields(raw, ATTACHMENT_FIELDS);
+        if (raw.rendered !== undefined)
+            entry.data.__rendered = sanitize(raw.rendered);
+        if (extra)
+            entry.extra = sanitize(extra);
+        return [entry];
+    },
+    knownFields: () => ATTACHMENT_FIELDS,
+};
+// ---------------------------------------------------------------------------
+// Zustands-Records ohne Nachrichteninhalt: Titel, Modus, Kosten, Queue …
+export const META_TYPES = [
+    'custom-title',
+    'ai-title',
+    'agent-name',
+    'agent-setting',
+    'mode',
+    'permission-mode',
+    'last-prompt',
+    'cost-state',
+    'worktree-state',
+    'relocated',
+    'continued-in',
+    'bridge-session',
+    'queue-operation',
+    'file-history-snapshot',
+    'file-history-delta',
+    'frame-link',
+    'atis-latch',
+    'artifact-comment-monitor',
+    'artifact-autoreact-ledger',
+];
+export const metaDecoder = {
+    id: 'transcript.meta@2',
+    source: 'transcript',
+    description: `state records (${META_TYPES.length} types: titles, mode, cost, queue, worktree …)`,
+    versions: '>=2.1.0',
+    match: (raw) => (typeof raw.type === 'string' && META_TYPES.includes(raw.type) ? 10 : 0),
+    decode(raw) {
+        return [
+            {
+                ...envelope(raw),
+                kind: 'meta',
+                metaType: str(raw.type),
+                data: sanitize(without(raw, ['type', 'sessionId', 'timestamp'])),
+            },
+        ];
+    },
+};
+// ---------------------------------------------------------------------------
+export const transcriptFallback = {
+    id: 'transcript.fallback',
+    source: 'transcript',
+    description: 'unknown records – shown raw and reported as schema drift',
+    match: () => 1,
+    decode(raw) {
+        return [{ ...envelope(raw), kind: 'unknown', raw: sanitize(raw) }];
+    },
+};

package/dist/app/server/formats/types.js

@@ -0,0 +1,10 @@
+/**
+ * Format-Erkennung: Jede Datenquelle (SourceKind) hat eine Reihe von Decodern.
+ * Für jeden Record fragt die Registry alle Decoder der Quelle per match() nach
+ * einem Score und nimmt den höchsten. Jede Quelle hat einen Fallback-Decoder,
+ * damit nie ein Record verloren geht.
+ *
+ * Neues Format hinzufügen: neue Datei mit einem Decoder anlegen und in
+ * formats/index.ts registrieren. Details: docs/FORMATS.md
+ */
+export {};

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

@@ -0,0 +1,22 @@
+export const isObj = (v) => !!v && typeof v === 'object' && !Array.isArray(v);
+export const str = (v) => (typeof v === 'string' ? v : undefined);
+export const num = (v) => (typeof v === 'number' && Number.isFinite(v) ? v : undefined);
+export const bool = (v) => (typeof v === 'boolean' ? v : undefined);
+export const obj = (v) => (isObj(v) ? v : undefined);
+export const arr = (v) => (Array.isArray(v) ? v : []);
+/** Alle Felder von `raw`, die nicht in `known` stehen – oder undefined, wenn keine. */
+export function extraFields(raw, known) {
+    let out;
+    for (const k of Object.keys(raw)) {
+        if (!known.includes(k))
+            (out ??= {})[k] = raw[k];
+    }
+    return out;
+}
+export function without(raw, keys) {
+    const out = {};
+    for (const [k, v] of Object.entries(raw))
+        if (!keys.includes(k))
+            out[k] = v;
+    return out;
+}