@mingozhou/dsh-replay 0.3.3 → 0.4.2

package/lib/index.js

@@ -1,102 +1,1094 @@
 // src/index.ts
 import { readFile } from "node:fs/promises";
+
+// src/core/decode.ts
+var CHUNK_ROW_TYPES = /* @__PURE__ */ new Set(["text-chunks", "reasoning-chunks", "tool-call-chunks"]);
+function isChunkRow(record) {
+  return CHUNK_ROW_TYPES.has(record.type);
+}
+function expandChunkRow(row) {
+  const { seq0, time0, data } = row;
+  const { turn, step, index, dt } = data;
+  const events = [];
+  const count = (row.type === "tool-call-chunks" ? data.args?.length : data.texts?.length) ?? 0;
+  let time = time0;
+  for (let k = 0; k < count; k++) {
+    if (k > 0) time += dt[k - 1] ?? 0;
+    let chunk;
+    if (row.type === "text-chunks") {
+      chunk = { type: "text-delta", index, text: data.texts[k] };
+    } else if (row.type === "reasoning-chunks") {
+      chunk = { type: "reasoning-delta", index, text: data.texts[k] };
+    } else {
+      chunk = {
+        type: "tool-call-delta",
+        index,
+        id: data.id,
+        ...k === 0 && data.name !== void 0 ? { name: data.name } : {},
+        args: data.args[k]
+      };
+    }
+    events.push({
+      type: "assistant/chunk",
+      seq: seq0 + k,
+      time,
+      data: { turn, step, chunk }
+    });
+  }
+  return events;
+}
+function decodeStorageRecord(record) {
+  if (isChunkRow(record)) return expandChunkRow(record);
+  return [record];
+}
+function fromInspection(header, records) {
+  const events = records.flatMap(decodeStorageRecord).sort((a, b) => a.seq - b.seq);
+  return { header, events, malformed: [] };
+}
+
+// src/core/timeline.ts
+function contentText(message) {
+  if (!message?.content) return "";
+  return message.content.filter((b) => typeof b.text === "string" && b.type !== "reasoning").map((b) => b.text).join("");
+}
+function contentReasoning(message) {
+  if (!message?.content) return "";
+  return message.content.filter((b) => b.type === "reasoning" && typeof b.text === "string").map((b) => b.text).join("");
+}
+function oneLine(text, max) {
+  return truncate(text.replaceAll(/\s+/gu, " ").trim(), max);
+}
+function summarizeToolArguments(name2, raw) {
+  let args;
+  try {
+    const parsed = JSON.parse(raw);
+    if (typeof parsed === "object" && parsed !== null) args = parsed;
+  } catch {
+    args = void 0;
+  }
+  if (args === void 0) return oneLine(raw, 64);
+  const keys = ["command", "cmd", "script", "path", "file_path", "filePath", "url", "query", "pattern", "description"];
+  for (const key of keys) {
+    const value = args[key];
+    if (typeof value === "string" && value.trim() !== "") return oneLine(value, 64);
+  }
+  return name2;
+}
+function truncate(text, max = 96) {
+  const oneLine2 = text.replaceAll(/\s+/gu, " ").trim();
+  return oneLine2.length > max ? `${oneLine2.slice(0, max - 1)}\u2026` : oneLine2;
+}
+function tryPretty(raw) {
+  try {
+    return JSON.stringify(JSON.parse(raw), null, 2);
+  } catch {
+    return void 0;
+  }
+}
+function get(obj, key) {
+  return typeof obj === "object" && obj !== null ? obj[key] : void 0;
+}
+var HIDDEN_TYPES = /* @__PURE__ */ new Set(["assistant/chunk", "step/start", "step/end", "turn/start"]);
+function metaLabel(event) {
+  const d = event.data;
+  switch (event.type) {
+    case "turn/end": {
+      const reason = get(get(d, "reason"), "kind");
+      return reason === "completed" ? void 0 : `turn ended: ${String(reason)}`;
+    }
+    case "compaction/summary":
+      return "context compacted (summary)";
+    case "compaction/prune":
+      return "context pruned";
+    case "approval/asked":
+      return `approval requested: ${String(get(d, "toolName") ?? "")}`;
+    case "approval/decided": {
+      const outcome = get(d, "outcome") ?? get(d, "decision");
+      return `approval decided: ${typeof outcome === "string" ? outcome : JSON.stringify(outcome)}`;
+    }
+    case "sandbox/mode":
+      return `sandbox mode \u2192 ${JSON.stringify(d)}`;
+    case "permission/preset":
+      return `permission preset \u2192 ${JSON.stringify(d)}`;
+    case "plan/mode":
+      return `plan mode change`;
+    case "subagent/descriptor":
+      return `subagent spawned (${String(get(d, "mode") ?? "")})`;
+    case "session/end-seed":
+      return "seed boundary (fork/resume point)";
+    case "llm/retry":
+    case "llm/retry-started":
+      return "model request retried";
+    case "command/run":
+      return `command: ${truncate(JSON.stringify(d), 60)}`;
+    case "goal/change":
+      return "goal changed";
+    case "session/title":
+      return void 0;
+    default:
+      return void 0;
+  }
+}
+function shadowedSeqs(events) {
+  const surfaceOrder = [];
+  const shadowed = /* @__PURE__ */ new Set();
+  for (const event of events) {
+    const op = event.surfaceOp;
+    if (op === void 0) continue;
+    if (op === "append") {
+      surfaceOrder.push(event.seq);
+    } else if (typeof op === "object" && op.op === "replace") {
+      const removed = surfaceOrder.splice(op.start, op.end - op.start + 1, event.seq);
+      for (const seq of removed) shadowed.add(seq);
+    }
+  }
+  return shadowed;
+}
+function buildTimeline(session) {
+  const { events } = session;
+  const turns = /* @__PURE__ */ new Map();
+  const items = [];
+  const usageSamples = [];
+  const toolCallsBySeq = /* @__PURE__ */ new Map();
+  const toolCalls = [];
+  const usageByStep = /* @__PURE__ */ new Map();
+  const usageModelByStep = /* @__PURE__ */ new Map();
+  const modelTotals = {};
+  const models = /* @__PURE__ */ new Set();
+  const shadowed = shadowedSeqs(events);
+  let seedBoundarySeq;
+  let activeTurn;
+  let activeModel;
+  let sessionTitle;
+  const ensureTurn = (turn, event) => {
+    let model = turns.get(turn);
+    if (model === void 0) {
+      model = { turn, startSeq: event.seq, startTime: event.time, steps: [], items: [] };
+      turns.set(turn, model);
+    }
+    return model;
+  };
+  const ensureStep = (turnModel, step, event) => {
+    let model = turnModel.steps.find((s) => s.step === step);
+    if (model === void 0) {
+      model = { turn: turnModel.turn, step, startSeq: event.seq, startTime: event.time, items: [] };
+      turnModel.steps.push(model);
+    }
+    return model;
+  };
+  const push = (item) => {
+    if (shadowed.has(item.seq)) item.shadowed = true;
+    items.push(item);
+    if (item.turn !== void 0) {
+      const turnModel = ensureTurn(item.turn, item.event);
+      turnModel.items.push(item);
+      if (item.step !== void 0) ensureStep(turnModel, item.step, item.event).items.push(item);
+    }
+  };
+  for (const event of events) {
+    const d = event.data;
+    const turn = get(d, "turn");
+    const step = get(d, "step");
+    switch (event.type) {
+      case "turn/start":
+        activeTurn = turn;
+        ensureTurn(activeTurn, event);
+        break;
+      case "turn/end": {
+        const model = ensureTurn(turn, event);
+        model.endSeq = event.seq;
+        model.endTime = event.time;
+        model.endReason = String(get(get(d, "reason"), "kind") ?? "completed");
+        activeTurn = void 0;
+        break;
+      }
+      case "step/start":
+        ensureStep(ensureTurn(turn, event), step, event);
+        break;
+      case "step/end": {
+        const stepModel = ensureStep(ensureTurn(turn, event), step, event);
+        stepModel.endSeq = event.seq;
+        stepModel.endTime = event.time;
+        break;
+      }
+      case "user/message": {
+        const message = d;
+        const text = contentText(message);
+        push({
+          kind: "user",
+          seq: event.seq,
+          time: event.time,
+          type: event.type,
+          turn: activeTurn,
+          label: truncate(text) || "(user message)",
+          text,
+          event
+        });
+        break;
+      }
+      case "assistant/message": {
+        const message = get(d, "message");
+        const usage = get(d, "usage");
+        const text = contentText(message);
+        const reasoningText = contentReasoning(message);
+        const source = message?.source;
+        if (typeof source?.["model"] === "string") {
+          activeModel = source["model"];
+          models.add(activeModel);
+        }
+        if (usage) {
+          const key = `${String(turn)}/${String(step)}`;
+          usageByStep.set(key, usage);
+          if (activeModel !== void 0) usageModelByStep.set(key, activeModel);
+        }
+        push({
+          kind: "assistant",
+          seq: event.seq,
+          time: event.time,
+          turn,
+          step,
+          type: event.type,
+          label: truncate(text) || "(assistant message)",
+          text,
+          reasoningText,
+          usage,
+          event
+        });
+        break;
+      }
+      case "assistant/chunk": {
+        const chunk = get(d, "chunk");
+        if (get(chunk, "type") === "usage") {
+          const usage = get(chunk, "usage");
+          const key = `${String(turn)}/${String(step)}`;
+          usageByStep.set(key, usage);
+          if (activeModel !== void 0 && !usageModelByStep.has(key)) {
+            usageModelByStep.set(key, activeModel);
+          }
+        }
+        break;
+      }
+      case "tool/call": {
+        const raw = String(get(d, "arguments") ?? "");
+        const name2 = String(get(d, "name") ?? "");
+        const info = {
+          callId: String(get(d, "callId") ?? ""),
+          name: name2,
+          argumentsRaw: raw,
+          argumentsPretty: tryPretty(raw),
+          summary: summarizeToolArguments(name2, raw),
+          callSeq: event.seq,
+          callTime: event.time
+        };
+        toolCallsBySeq.set(info.callId, info);
+        toolCalls.push(info);
+        push({
+          kind: "tool",
+          seq: event.seq,
+          time: event.time,
+          turn,
+          step,
+          type: event.type,
+          label: info.summary === name2 ? name2 : `${name2} \xB7 ${info.summary}`,
+          toolCall: info,
+          event
+        });
+        break;
+      }
+      case "tool/result": {
+        const message = get(d, "message");
+        const source = message?.source;
+        const callId = String(source?.["callId"] ?? "");
+        const info = toolCallsBySeq.get(callId);
+        const block = message?.content?.[0];
+        const resultText = contentText(message) || (typeof get(block, "text") === "string" ? get(block, "text") : contentText({ content: get(block, "content") }));
+        const error = get(d, "error");
+        if (info) {
+          info.resultSeq = event.seq;
+          info.resultTime = event.time;
+          info.durationMs = event.time - info.callTime;
+          info.resultText = resultText;
+          info.error = error;
+        }
+        break;
+      }
+      case "session/end-seed":
+        seedBoundarySeq = event.seq;
+        push({
+          kind: "meta",
+          seq: event.seq,
+          time: event.time,
+          type: event.type,
+          label: "seed boundary (fork/resume point)",
+          event
+        });
+        break;
+      case "system/message": {
+        const message = get(d, "message");
+        const text = contentText(message);
+        push({
+          kind: "meta",
+          seq: event.seq,
+          time: event.time,
+          turn: typeof turn === "number" ? turn : void 0,
+          step: typeof step === "number" ? step : void 0,
+          type: event.type,
+          label: "system prompt",
+          text,
+          event
+        });
+        break;
+      }
+      case "model/selection": {
+        const model = get(d, "model");
+        if (typeof model === "string" && model !== "") {
+          activeModel = model;
+          models.add(model);
+          push({
+            kind: "meta",
+            seq: event.seq,
+            time: event.time,
+            type: event.type,
+            label: `model selected: ${model}`,
+            event
+          });
+        }
+        break;
+      }
+      case "request/context": {
+        const model = get(d, "model");
+        if (typeof model === "string") {
+          activeModel = model;
+          models.add(model);
+        }
+        break;
+      }
+      case "session/title": {
+        const title = get(d, "title");
+        if (typeof title === "string" && title !== "") sessionTitle = title;
+        break;
+      }
+      default: {
+        if (HIDDEN_TYPES.has(event.type)) break;
+        const label = metaLabel(event);
+        if (label !== void 0) {
+          push({
+            kind: "meta",
+            seq: event.seq,
+            time: event.time,
+            turn: typeof turn === "number" ? turn : void 0,
+            step: typeof step === "number" ? step : void 0,
+            type: event.type,
+            label,
+            event
+          });
+        }
+      }
+    }
+  }
+  const totals = { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, reasoning: 0, billedInput: 0 };
+  const emptyTotals = () => ({
+    input: 0,
+    output: 0,
+    cacheRead: 0,
+    cacheWrite: 0,
+    reasoning: 0,
+    billedInput: 0
+  });
+  for (const [key, usage] of usageByStep) {
+    const [turnStr, stepStr] = key.split("/");
+    const billed = usage.inputTokens + (usage.cacheReadTokens ?? 0) + (usage.cacheWriteTokens ?? 0);
+    totals.input += usage.inputTokens;
+    totals.output += usage.outputTokens;
+    totals.cacheRead += usage.cacheReadTokens ?? 0;
+    totals.cacheWrite += usage.cacheWriteTokens ?? 0;
+    totals.reasoning += usage.reasoningTokens ?? 0;
+    const modelName = usageModelByStep.get(key) ?? activeModel ?? "unknown";
+    const modelTotal = modelTotals[modelName] ?? emptyTotals();
+    modelTotal.input += usage.inputTokens;
+    modelTotal.output += usage.outputTokens;
+    modelTotal.cacheRead += usage.cacheReadTokens ?? 0;
+    modelTotal.cacheWrite += usage.cacheWriteTokens ?? 0;
+    modelTotal.reasoning += usage.reasoningTokens ?? 0;
+    modelTotal.billedInput += billed;
+    modelTotals[modelName] = modelTotal;
+    const turnModel = turns.get(Number(turnStr));
+    const stepModel = turnModel?.steps.find((s) => s.step === Number(stepStr));
+    if (stepModel) stepModel.usage = usage;
+    const anchor = stepModel?.items.find((i) => i.kind === "assistant");
+    usageSamples.push({
+      seq: anchor?.seq ?? stepModel?.startSeq ?? 0,
+      turn: Number(turnStr),
+      step: Number(stepStr),
+      usage
+    });
+  }
+  usageSamples.sort((a, b) => a.seq - b.seq);
+  totals.billedInput = totals.input + totals.cacheRead + totals.cacheWrite;
+  const orderedTurns = [...turns.values()].sort((a, b) => a.turn - b.turn);
+  for (const t of orderedTurns) t.steps.sort((a, b) => a.step - b.step);
+  const startTime = events[0]?.time ?? session.header.createdAt;
+  const endTime = events.at(-1)?.time ?? startTime;
+  return {
+    turns: orderedTurns,
+    items,
+    totals,
+    modelTotals,
+    usageSamples,
+    toolCalls,
+    durationMs: endTime - startTime,
+    startTime,
+    endTime,
+    eventCount: events.length,
+    seedBoundarySeq,
+    models: [...models],
+    title: sessionTitle
+  };
+}
+
+// src/core/redact.ts
+var RULES = [
+  { kind: "openai-key", re: /\bsk-[A-Za-z0-9_-]{16,}\b/g, replacement: "[REDACTED:openai-key]" },
+  {
+    kind: "github-token",
+    re: /\b(?:gh[pousr]_[A-Za-z0-9]{20,}|github_pat_[A-Za-z0-9_]{20,})\b/g,
+    replacement: "[REDACTED:github-token]"
+  },
+  { kind: "aws-key", re: /\b(?:AKIA|ASIA)[0-9A-Z]{16}\b/g, replacement: "[REDACTED:aws-key]" },
+  { kind: "google-key", re: /\bAIza[0-9A-Za-z_-]{20,}\b/g, replacement: "[REDACTED:google-key]" },
+  { kind: "slack-token", re: /\bxox[baprs]-[A-Za-z0-9-]{10,}\b/g, replacement: "[REDACTED:slack-token]" },
+  {
+    kind: "private-key",
+    re: /-----BEGIN [A-Z ]*PRIVATE KEY-----[\s\S]*?-----END [A-Z ]*PRIVATE KEY-----/g,
+    replacement: "[REDACTED:private-key]"
+  },
+  {
+    kind: "jwt",
+    re: /\beyJ[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}\b/g,
+    replacement: "[REDACTED:jwt]"
+  },
+  {
+    kind: "env-assignment",
+    re: /(\b[A-Z][A-Z0-9_]*(?:KEY|TOKEN|SECRET|PASSWORD|PASSWD|PRIVATE|CREDENTIAL)[A-Z0-9_]*\s*=\s*)(["']?)([^\s"'\\]{4,})\2/g,
+    replacement: (_m, prefix, quote) => `${prefix}${quote}[REDACTED]${quote}`
+  },
+  {
+    kind: "key-value",
+    re: /(["']?(?:api[_-]?key|secret|token|password|passwd|authorization|jwt[_-]?secret)["']?\s*[:=]\s*["']?)([^"'\s,}]{4,})/gi,
+    replacement: (_m, prefix) => `${prefix}[REDACTED]`
+  },
+  { kind: "bearer", re: /(\bBearer\s+)[A-Za-z0-9._~+/-]{8,}/gi, replacement: "$1[REDACTED]" },
+  {
+    kind: "basic-auth-url",
+    re: /(https?:\/\/[^/\s:@]+:)([^@\s/]+)(@)/g,
+    replacement: "$1[REDACTED]$3"
+  },
+  { kind: "windows-user", re: /([A-Za-z]:\\Users\\)([^\\\s"']+)/g, replacement: "$1[user]" },
+  { kind: "unix-home", re: /(\/(?:home|Users)\/)([^/\s"']+)/g, replacement: "$1[user]" },
+  { kind: "email", re: /\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}\b/g, replacement: "[email]" },
+  { kind: "session-id", re: /\bsession-[0-9a-f]{8}(?:-[0-9a-f]{4}){3}-[0-9a-f]{12}\b/gi, replacement: "session-[id]" }
+];
+var CREDENTIAL_KINDS = /* @__PURE__ */ new Set([
+  "openai-key",
+  "github-token",
+  "aws-key",
+  "google-key",
+  "slack-token",
+  "private-key",
+  "jwt",
+  "env-assignment",
+  "key-value",
+  "bearer",
+  "basic-auth-url"
+]);
+function redactText(input) {
+  let text = input;
+  let count = 0;
+  const kinds = /* @__PURE__ */ new Set();
+  for (const rule of RULES) {
+    rule.re.lastIndex = 0;
+    const matches = text.match(rule.re);
+    if (matches === null) continue;
+    count += matches.length;
+    kinds.add(rule.kind);
+    rule.re.lastIndex = 0;
+    text = text.replace(rule.re, rule.replacement);
+  }
+  return { text, count, kinds: [...kinds] };
+}
+function containsSecret(input) {
+  for (const rule of RULES) {
+    if (!CREDENTIAL_KINDS.has(rule.kind)) continue;
+    rule.re.lastIndex = 0;
+    const hit = rule.re.test(input);
+    rule.re.lastIndex = 0;
+    if (hit) return true;
+  }
+  return false;
+}
+
+// src/core/audit.ts
+function get2(obj, key) {
+  return typeof obj === "object" && obj !== null ? obj[key] : void 0;
+}
+function str(value) {
+  if (typeof value === "string") return value;
+  try {
+    return JSON.stringify(value) ?? "";
+  } catch {
+    return "";
+  }
+}
+function clipped(value, max = 500) {
+  return redactText(value).text.slice(0, max);
+}
+function toolName(event) {
+  return str(get2(event.data, "name"));
+}
+function argsOf(event) {
+  return str(get2(event.data, "arguments"));
+}
+function parseArgs(raw) {
+  try {
+    const value = JSON.parse(raw);
+    return typeof value === "object" && value !== null ? value : void 0;
+  } catch {
+    return void 0;
+  }
+}
+var PATH_KEYS = [
+  "path",
+  "file_path",
+  "filePath",
+  "target",
+  "destination",
+  "dest",
+  "filename",
+  "file",
+  "name"
+];
+function pathOf(raw) {
+  const args = parseArgs(raw);
+  if (args === void 0) return void 0;
+  for (const key of PATH_KEYS) {
+    const value = args[key];
+    if (typeof value === "string" && value !== "" && /[\\/.]/u.test(value)) return value;
+  }
+  return void 0;
+}
+var SHELL_TOOLS = /^(bash|shell|exec|run_command|terminal|subprocess|pwsh|powershell|cmd|run_code|code_execution)/iu;
+var WRITE_TOOLS = /^(write|write_file|edit|edit_file|create_file|str_replace|multi_edit|apply_patch|notebook_edit|fs_write|mv|move|rename|copy|rm|remove|delete|del|remove_item|rmdir|rd)/iu;
+var DESTRUCTIVE_TOOLS = /^(rm|remove|delete|del|remove_item|rmdir|rd|mv|move|rename)/iu;
+var READ_TOOLS = /^(read|read_file|view|open|cat|type|get-content|grep|search|glob|list|find|head|tail|less|more|strings|xxd)/iu;
+var NETWORK_TOOLS = /^(fetch|web_fetch|http|curl|download|web_search|browser|invoke-webrequest|iwr|invoke-restmethod|start-bitstransfer)/iu;
+var DANGEROUS_SHELL = [
+  // --- destructive deletes -------------------------------------------------
+  { re: /\brm\s+(-[a-z]*[rf][a-z]*\s+)+/iu, why: "recursive/forced delete", key: "rm-rf", severity: "critical" },
+  { re: /\bremove-item\b[^\n]*(?:-recurse|-force)/iu, why: "recursive/forced delete", key: "rm-rf", severity: "critical" },
+  { re: /\b(?:del|erase)\b[^\n]*\/[sq]/iu, why: "forced delete", key: "rm-rf", severity: "critical" },
+  { re: /\b(?:rd|rmdir)\b[^\n]*\/s/iu, why: "recursive directory delete", key: "rm-rf", severity: "critical" },
+  // --- privilege / system --------------------------------------------------
+  { re: /\bsudo\b/iu, why: "privilege escalation", key: "sudo", severity: "critical" },
+  { re: /\b(?:takeown|icacls)\b[^\n]*(?:grant|\/grant|\/f|\/reset)/iu, why: "ownership/permission change", key: "chmod", severity: "serious" },
+  { re: /\bchmod\s+([0-7]{3,4}|\+x)/u, why: "permission change", key: "chmod", severity: "serious" },
+  { re: /\bset-executionpolicy\b/iu, why: "script execution policy change", key: "exec-policy", severity: "serious" },
+  { re: /\b(?:bcdedit|vssadmin\s+delete|wevtutil\s+cl)\b/iu, why: "boot/shadow/log tampering", key: "system-tamper", severity: "critical" },
+  { re: /\b(?:reg\s+delete|schtasks\b[^\n]*\/create|sc\s+create|net\s+user|net\s+localgroup)\b/iu, why: "persistence or account change", key: "persistence", severity: "serious" },
+  // --- disk / remote code --------------------------------------------------
+  { re: /\b(?:dd|mkfs|fdisk|diskpart|format)\b/iu, why: "raw disk operation", key: "disk", severity: "critical" },
+  { re: /\b(?:iwr|invoke-webrequest|curl|wget|start-bitstransfer)\b[^\n|;]*(?:\||;)\s*(?:iex|invoke-expression)\b/iu, why: "pipe remote script to shell", key: "curl-pipe", severity: "critical" },
+  { re: /\b(?:downloadstring|downloadfile)\b/iu, why: "download and execute", key: "curl-pipe", severity: "critical" },
+  { re: /\b(?:powershell|pwsh)\b[^\n]*-e(?:nc|ncodedcommand)?\s+[A-Za-z0-9+/=]{40,}/iu, why: "encoded PowerShell command", key: "encoded-shell", severity: "critical" },
+  // --- credentials / exfiltration -----------------------------------------
+  { re: /\b(?:export|\$env:|\bset\b|\becho\b)[^\n]*(?:api[_-]?key|token|secret|password|passwd)/iu, why: "credential material in command", key: "creds", severity: "serious" },
+  { re: /\b(?:get-content|type|cat)\b[^\n]*(?:\.env\b|id_rsa|\.ssh[\\/]|credentials)/iu, why: "credential file read", key: "creds", severity: "serious" },
+  { re: /\b(?:curl|wget|iwr|invoke-webrequest|invoke-restmethod)\b[^\n]*(?:-d\b|--data|--upload-file|-f\b|\.env\b|secret|token|password)/iu, why: "possible credential exfiltration", key: "exfil", severity: "critical" },
+  { re: /\b(?:ssh|scp|rsync)\b[^\n]*(?:@|\bremote\b)/iu, why: "remote host access", key: "remote", severity: "warning" },
+  { re: /\b(?:invoke-command|enter-pssession|winrs)\b/iu, why: "remote execution", key: "remote", severity: "serious" },
+  // --- supply chain / repo ------------------------------------------------
+  { re: /\bgit\s+push\s+[^\n]*--force/iu, why: "force push", key: "force-push", severity: "serious" },
+  { re: /\b(?:npm|pnpm|yarn)\s+publish\b/iu, why: "package publish", key: "publish", severity: "warning" },
+  { re: /\bgh\s+release\s+create\b/iu, why: "release publish", key: "publish", severity: "warning" }
+];
+var SENSITIVE_PATH = /(?:^|[\\/])(?:\.env(?:\.[\w-]+)?(?:[\\/]|$)|\.ssh(?:[\\/]|$)|id_rsa|id_ed25519|\.aws(?:[\\/]|$)|\.kube(?:[\\/]|$)|\.docker(?:[\\/]config\.json|$)|credentials|\.npmrc|\.netrc|secrets?\.|\.pem|\.pfx|\.p12|ntuser\.dat|\.git[\\/]config|\.config[\\/]gh[\\/]hosts\.yml)/iu;
+var NETWORK_RISK = /(?:--data|-d\s|--upload-file|-f\s|body\s*[:=]|\.env\b|secret|token|password|passwd|private[_-]?key|authorization|api[_-]?key)/iu;
+function messageText(message) {
+  const content = get2(message, "content");
+  if (!Array.isArray(content)) return "";
+  return content.map((block) => typeof get2(block, "text") === "string" ? get2(block, "text") : "").join("");
+}
+function findDanger(event) {
+  if (event.type !== "tool/call") return void 0;
+  const name2 = toolName(event);
+  if (!SHELL_TOOLS.test(name2)) return void 0;
+  const args = argsOf(event);
+  return DANGEROUS_SHELL.find((pattern) => pattern.re.test(args));
+}
+var DEFAULT_RULES = [
+  {
+    id: "shell-exec",
+    category: "shell",
+    severity: (event) => findDanger(event)?.severity ?? "warning",
+    match: (event) => {
+      if (event.type !== "tool/call") return void 0;
+      const name2 = toolName(event);
+      if (!SHELL_TOOLS.test(name2)) return void 0;
+      const args = argsOf(event);
+      const hit = DANGEROUS_SHELL.find((pattern) => pattern.re.test(args));
+      if (hit === void 0) return void 0;
+      return {
+        title: `shell: ${hit.why}`,
+        detail: clipped(args),
+        messageKey: "f.shell.dangerous",
+        params: { whyKey: hit.key, why: hit.why, name: name2 }
+      };
+    }
+  },
+  {
+    id: "file-write",
+    category: "file",
+    severity: (event) => {
+      const args = argsOf(event);
+      const path = pathOf(args) ?? args;
+      return SENSITIVE_PATH.test(path) || containsSecret(args) ? "critical" : "warning";
+    },
+    match: (event) => {
+      if (event.type !== "tool/call") return void 0;
+      const name2 = toolName(event);
+      if (!WRITE_TOOLS.test(name2)) return void 0;
+      const args = argsOf(event);
+      const path = pathOf(args) ?? args;
+      const sensitive = SENSITIVE_PATH.test(path);
+      const secret = containsSecret(args);
+      if (!sensitive && !secret && !DESTRUCTIVE_TOOLS.test(name2)) return void 0;
+      const reason = sensitive ? "file write touches a sensitive path" : secret ? "credential material written to a file" : `destructive file operation via ${name2}`;
+      return {
+        title: reason,
+        detail: clipped(args),
+        messageKey: sensitive ? "f.file.sensitive" : secret ? "f.file.secret" : "f.file.destructive",
+        params: { name: name2, ...path !== args ? { path } : {} }
+      };
+    }
+  },
+  {
+    id: "sensitive-read",
+    category: "file",
+    severity: "serious",
+    match: (event) => {
+      if (event.type !== "tool/call") return void 0;
+      const name2 = toolName(event);
+      if (WRITE_TOOLS.test(name2) || SHELL_TOOLS.test(name2) || NETWORK_TOOLS.test(name2)) return void 0;
+      if (!READ_TOOLS.test(name2)) return void 0;
+      const args = argsOf(event);
+      const path = pathOf(args) ?? args;
+      if (!SENSITIVE_PATH.test(path)) return void 0;
+      return {
+        title: `access to sensitive path via ${name2}`,
+        detail: clipped(args),
+        messageKey: "f.read.sensitive",
+        params: { name: name2, ...path !== args ? { path } : {} }
+      };
+    }
+  },
+  {
+    id: "network",
+    category: "network",
+    severity: (event) => {
+      const args = argsOf(event);
+      return containsSecret(args) || SENSITIVE_PATH.test(args) ? "critical" : "warning";
+    },
+    match: (event) => {
+      if (event.type !== "tool/call") return void 0;
+      const name2 = toolName(event);
+      if (!NETWORK_TOOLS.test(name2)) return void 0;
+      const args = argsOf(event);
+      if (!NETWORK_RISK.test(args)) return void 0;
+      return {
+        title: `network request may carry sensitive data via ${name2}`,
+        detail: clipped(args),
+        messageKey: "f.network",
+        params: { name: name2 }
+      };
+    }
+  },
+  {
+    id: "secret-output",
+    category: "secret",
+    severity: "critical",
+    match: (event) => {
+      if (event.type !== "tool/result") return void 0;
+      const message = get2(event.data, "message");
+      const text = messageText(message) || str(message) || str(get2(event.data, "error"));
+      if (text === "" || !containsSecret(text)) return void 0;
+      return {
+        title: "tool output contains credential material",
+        detail: clipped(text, 300),
+        messageKey: "f.output.secret"
+      };
+    }
+  },
+  {
+    id: "approval-denied",
+    category: "approval",
+    severity: "warning",
+    match: (event) => {
+      if (event.type !== "approval/decided") return void 0;
+      const outcome = str(get2(event.data, "outcome") ?? get2(event.data, "decision"));
+      if (!/deny|denied|reject|refus/iu.test(outcome)) return void 0;
+      return { title: "user denied an approval", detail: clipped(outcome), messageKey: "f.approval.denied" };
+    }
+  },
+  {
+    id: "sandbox-change",
+    category: "config",
+    severity: (event) => {
+      const mode = str(get2(event.data, "mode"));
+      return /danger|full/iu.test(mode) ? "critical" : "serious";
+    },
+    match: (event) => event.type === "sandbox/mode" ? {
+      title: `sandbox mode changed to ${str(get2(event.data, "mode")) || "unknown"}`,
+      detail: clipped(JSON.stringify(event.data)),
+      messageKey: "f.sandbox.change",
+      params: { mode: str(get2(event.data, "mode")) }
+    } : void 0
+  },
+  {
+    id: "permission-change",
+    category: "config",
+    severity: (event) => {
+      const preset = str(get2(event.data, "preset"));
+      return /danger|full/iu.test(preset) ? "critical" : "serious";
+    },
+    match: (event) => event.type === "permission/preset" ? {
+      title: `permission preset changed to ${str(get2(event.data, "preset")) || "unknown"}`,
+      detail: clipped(JSON.stringify(event.data)),
+      messageKey: "f.permission.change",
+      params: { preset: str(get2(event.data, "preset")) }
+    } : void 0
+  },
+  {
+    id: "tool-error",
+    category: "error",
+    severity: "warning",
+    match: (event) => {
+      if (event.type !== "tool/result") return void 0;
+      const error = get2(event.data, "error");
+      if (error === void 0) return void 0;
+      return {
+        title: `tool failed: ${str(get2(error, "name"))}`,
+        detail: clipped(str(get2(error, "code"))),
+        messageKey: "f.tool.error",
+        params: { name: str(get2(error, "name")), code: str(get2(error, "code")) }
+      };
+    }
+  },
+  {
+    id: "turn-error",
+    category: "error",
+    severity: "warning",
+    match: (event) => {
+      if (event.type !== "turn/end") return void 0;
+      const kind = str(get2(get2(event.data, "reason"), "kind"));
+      if (kind === "" || kind === "completed" || kind === "aborted") return void 0;
+      return { title: `turn ended abnormally: ${kind}`, messageKey: "f.turn.error", params: { kind } };
+    }
+  }
+];
+var SEVERITY_ORDER = ["critical", "serious", "warning", "info"];
+var CONFIG_RULES = /* @__PURE__ */ new Set(["sandbox-change", "permission-change"]);
+function auditSession(session, rules = DEFAULT_RULES) {
+  const lastConfig = /* @__PURE__ */ new Map();
+  const changedConfig = /* @__PURE__ */ new Set();
+  let suppressed = 0;
+  for (const event of session.events) {
+    if (event.type !== "permission/preset" && event.type !== "sandbox/mode" && event.type !== "approval/policy") {
+      continue;
+    }
+    const value = JSON.stringify(event.data);
+    if (!lastConfig.has(event.type)) {
+      lastConfig.set(event.type, value);
+      suppressed++;
+      continue;
+    }
+    if (lastConfig.get(event.type) === value) {
+      suppressed++;
+      continue;
+    }
+    lastConfig.set(event.type, value);
+    changedConfig.add(event.seq);
+  }
+  const findings = [];
+  for (const event of session.events) {
+    for (const rule of rules) {
+      if (CONFIG_RULES.has(rule.id) && !changedConfig.has(event.seq)) continue;
+      const hit = rule.match(event);
+      if (hit === void 0) continue;
+      const severity = typeof rule.severity === "function" ? rule.severity(event) : rule.severity;
+      findings.push({
+        ruleId: rule.id,
+        severity,
+        category: hit.category ?? rule.category,
+        seq: event.seq,
+        time: event.time,
+        ...hit
+      });
+    }
+  }
+  findings.sort(
+    (a, b) => SEVERITY_ORDER.indexOf(a.severity) - SEVERITY_ORDER.indexOf(b.severity) || a.seq - b.seq
+  );
+  const counts = { critical: 0, serious: 0, warning: 0, info: 0 };
+  for (const finding of findings) counts[finding.severity]++;
+  return { findings, counts, scanned: session.events.length, rules: rules.length, suppressed };
+}
+
+// src/index.ts
 var name = "dsh-replay";
 var inject = ["webServer", "sessionQuery"];
-function json(res, status, body) {
+function json(res, status, body, head = false) {
   res.writeHead(status, {
     "content-type": "application/json; charset=utf-8",
-    "cache-control": "no-store"
+    "cache-control": "no-store",
+    "x-content-type-options": "nosniff",
+    "referrer-policy": "no-referrer"
   });
-  res.end(JSON.stringify(body));
+  res.end(head ? void 0 : JSON.stringify(body));
 }
-function get(obj, key) {
+function get3(obj, key) {
   return typeof obj === "object" && obj !== null ? obj[key] : void 0;
 }
 function headerOf(record) {
-  for (const candidate of [get(record, "header"), get(record, "meta"), record]) {
-    if (typeof get(candidate, "id") === "string" && typeof get(candidate, "createdAt") === "number") {
+  for (const candidate of [get3(record, "header"), get3(record, "meta"), record]) {
+    if (typeof get3(candidate, "id") === "string" && typeof get3(candidate, "createdAt") === "number") {
       return candidate;
     }
   }
   return void 0;
 }
-function titleOf(record, depth = 3) {
+function titleOf(record, depth = 4) {
+  if (typeof record === "string") return record === "" ? void 0 : record;
   if (typeof record !== "object" || record === null || depth < 0) return void 0;
   const direct = record["title"];
   if (typeof direct === "string" && direct.length > 0) return direct;
-  for (const value of Object.values(record)) {
-    if (typeof value === "object" && value !== null) {
-      const found = titleOf(value, depth - 1);
-      if (found !== void 0) return found;
-    }
+  for (const key of ["value", "session", "meta"]) {
+    const found = titleOf(record[key], depth - 1);
+    if (found !== void 0) return found;
   }
   return void 0;
 }
+function eventsOf(record) {
+  const events = get3(record, "events") ?? get3(get3(record, "session"), "events");
+  return Array.isArray(events) ? events : [];
+}
+function isLoopback(address) {
+  if (address === void 0) return false;
+  return address === "127.0.0.1" || address === "::1" || address === "::ffff:127.0.0.1" || address.startsWith("127.");
+}
+function hostIsLoopback(host) {
+  if (host === void 0 || host === "") return true;
+  const name2 = host.startsWith("[") ? host.slice(1, host.indexOf("]")) : host.split(":")[0];
+  return name2 === "localhost" || name2 === "127.0.0.1" || name2 === "::1" || name2.startsWith("127.");
+}
+function allowed(req, allowRemote) {
+  if (!allowRemote && !isLoopback(req.socket.remoteAddress)) return false;
+  if (!allowRemote && !hostIsLoopback(req.headers.host)) return false;
+  const origin = req.headers.origin;
+  if (origin !== void 0) {
+    if (origin === "null" || origin.startsWith("file://")) return true;
+    try {
+      const originUrl = new URL(origin);
+      if (req.headers.host !== void 0 && originUrl.host !== req.headers.host) return false;
+    } catch {
+      return false;
+    }
+  }
+  if (req.headers["sec-fetch-site"] === "cross-site") return false;
+  return true;
+}
+async function mapLimit(items, limit, task) {
+  const results = new Array(items.length);
+  let index = 0;
+  const workers = Array.from({ length: Math.min(limit, items.length) }, async () => {
+    while (index < items.length) {
+      const current = index++;
+      results[current] = await task(items[current]);
+    }
+  });
+  await Promise.all(workers);
+  return results;
+}
 function apply(ctx, config = {}) {
   const prefix = config.routePrefix ?? "/replay/api";
+  const allowRemote = config.allowRemote === true;
+  const summaryLimit = Math.min(Math.max(config.summaryLimit ?? 30, 1), 100);
   const webServer = ctx.webServer;
   const sessionQuery = ctx.sessionQuery;
+  const viewerCache = /* @__PURE__ */ new Map();
+  const summaryCache = /* @__PURE__ */ new Map();
+  const SUMMARY_TTL_MS = 3e4;
+  const loadEntries = async (options = {}) => {
+    const withTitles = options.withTitles !== false;
+    const records = await sessionQuery.listSessions();
+    const entries = [];
+    for (const record of records) {
+      const header = headerOf(record);
+      if (header === void 0) continue;
+      const id = String(header["id"]);
+      const title = titleOf(record);
+      const live = get3(record, "live");
+      entries.push({ header, ...title !== void 0 ? { title } : {}, ...typeof live === "boolean" ? { live } : {} });
+    }
+    const titles = /* @__PURE__ */ new Map();
+    for (const entry of entries) {
+      if (entry.title !== void 0) titles.set(String(entry.header["id"]), entry.title);
+    }
+    if (withTitles && sessionQuery.readTitleSnapshots !== void 0) {
+      try {
+        const snapshots = await sessionQuery.readTitleSnapshots(
+          entries.map((entry) => String(entry.header["id"]))
+        );
+        for (const snapshot of snapshots) {
+          const value = get3(snapshot, "value") ?? snapshot;
+          const header = get3(value, "session") ?? get3(value, "header");
+          const id = get3(header, "id");
+          const title = titleOf(value);
+          if (typeof id === "string" && title !== void 0) titles.set(id, title);
+        }
+      } catch {
+      }
+    }
+    const readTitle = sessionQuery.readTitle;
+    if (withTitles && readTitle !== void 0) {
+      await Promise.all(
+        entries.filter((entry) => !titles.has(String(entry.header["id"]))).map(async (entry) => {
+          try {
+            const id = String(entry.header["id"]);
+            const result = await readTitle.call(sessionQuery, id);
+            const title = titleOf(result);
+            if (title !== void 0) titles.set(id, title);
+          } catch {
+          }
+        })
+      );
+    }
+    for (const entry of entries) {
+      const id = String(entry.header["id"]);
+      const title = titles.get(id);
+      if (title !== void 0) entry.title = title;
+    }
+    return { entries, titles };
+  };
+  const summarize = async (entry) => {
+    const id = String(entry.header["id"]);
+    try {
+      const snapshot = await sessionQuery.readSession(id);
+      const header = headerOf(snapshot) ?? headerOf(get3(snapshot, "session")) ?? entry.header;
+      const records = eventsOf(snapshot);
+      const lastSeq = records.length > 0 ? Number(get3(records.at(-1), "seq") ?? -1) : -1;
+      const key = `${id}:${lastSeq}`;
+      const cached = summaryCache.get(id);
+      if (cached !== void 0 && cached.key === key && Date.now() - cached.at < SUMMARY_TTL_MS) {
+        return cached.value;
+      }
+      const parsed = fromInspection(
+        header,
+        records
+      );
+      const model = buildTimeline(parsed);
+      const report = auditSession(parsed);
+      const value = {
+        header,
+        ...entry.title !== void 0 ? { title: entry.title } : model.title !== void 0 ? { title: model.title } : {},
+        ...entry.live !== void 0 ? { live: entry.live } : {},
+        summary: {
+          events: model.eventCount,
+          turns: model.turns.length,
+          steps: model.turns.reduce((sum, turn) => sum + turn.steps.length, 0),
+          toolCalls: model.toolCalls.length,
+          toolErrors: model.toolCalls.filter((call) => call.error !== void 0).length,
+          durationMs: model.durationMs,
+          models: model.models,
+          tokens: model.totals,
+          modelTotals: model.modelTotals,
+          findings: report.findings.length,
+          critical: report.counts.critical,
+          serious: report.counts.serious,
+          warning: report.counts.warning,
+          info: report.counts.info
+        }
+      };
+      summaryCache.set(id, { key, at: Date.now(), value });
+      while (summaryCache.size > 100) {
+        const oldest = summaryCache.keys().next().value;
+        if (oldest === void 0) break;
+        summaryCache.delete(oldest);
+      }
+      return value;
+    } catch (error) {
+      return {
+        header: entry.header,
+        ...entry.title !== void 0 ? { title: entry.title } : {},
+        ...entry.live !== void 0 ? { live: entry.live } : {},
+        error: String(error)
+      };
+    }
+  };
   const handler = async (req, res) => {
+    if (!allowed(req, allowRemote)) {
+      json(res, 403, { error: "forbidden" });
+      return;
+    }
     const url = new URL(req.url ?? "/", "http://localhost");
     const rest = url.pathname.slice(prefix.length).replace(/^\//u, "");
+    const head = req.method === "HEAD";
     try {
       if (req.method !== "GET" && req.method !== "HEAD") {
-        json(res, 405, { error: "method not allowed" });
+        json(res, 405, { error: "method not allowed" }, head);
         return;
       }
       if (rest === "sessions") {
-        const records = await sessionQuery.listSessions();
-        const headers = records.map(headerOf).filter((h) => h !== void 0);
-        const titles = /* @__PURE__ */ new Map();
-        if (sessionQuery.readTitleSnapshots !== void 0) {
-          try {
-            const snapshots = await sessionQuery.readTitleSnapshots(headers.map((h) => String(h["id"])));
-            snapshots.forEach((snapshot, i) => {
-              const title = titleOf(snapshot);
-              const id = headers[i]?.["id"];
-              if (title !== void 0 && typeof id === "string") titles.set(id, title);
-            });
-          } catch {
-          }
-        }
-        const readTitle = sessionQuery.readTitle;
-        if (readTitle !== void 0) {
-          await Promise.all(
-            headers.filter((h) => !titles.has(String(h["id"]))).map(async (h) => {
-              try {
-                const title = titleOf(await readTitle.call(sessionQuery, String(h["id"])));
-                if (title !== void 0) titles.set(String(h["id"]), title);
-              } catch {
-              }
-            })
-          );
-        }
-        json(res, 200, {
-          sessions: headers.map((h) => ({ header: h, title: titles.get(String(h["id"])) }))
-        });
+        const { entries } = await loadEntries();
+        json(res, 200, { sessions: entries }, head);
+        return;
+      }
+      if (rest === "summary") {
+        const limitParam = Number(url.searchParams.get("limit"));
+        const limit = Number.isFinite(limitParam) && limitParam > 0 ? Math.min(Math.floor(limitParam), summaryLimit) : summaryLimit;
+        const { entries } = await loadEntries({ withTitles: false });
+        const selected = entries.slice(0, limit);
+        const summaries = await mapLimit(selected, 4, summarize);
+        json(res, 200, { sessions: summaries, total: entries.length }, head);
         return;
       }
       if (rest === "viewer.js") {
-        const source = await readFile(new URL("./viewer.js", import.meta.url), "utf8");
-        res.writeHead(200, { "content-type": "text/javascript; charset=utf-8" });
-        res.end(source);
+        let source = viewerCache.get("viewer");
+        if (source === void 0) {
+          source = await readFile(new URL("./viewer.js", import.meta.url), "utf8");
+          viewerCache.set("viewer", source);
+        }
+        res.writeHead(200, {
+          "content-type": "text/javascript; charset=utf-8",
+          "cache-control": "no-cache",
+          "x-content-type-options": "nosniff"
+        });
+        res.end(head ? void 0 : source);
         return;
       }
       if (rest.startsWith("session/")) {
         const id = decodeURIComponent(rest.slice("session/".length));
         const snapshot = await sessionQuery.readSession(id);
-        const header = headerOf(snapshot) ?? headerOf(get(snapshot, "session"));
-        const events = get(snapshot, "events") ?? get(get(snapshot, "session"), "events") ?? [];
+        const header = headerOf(snapshot) ?? headerOf(get3(snapshot, "session"));
         if (header === void 0) {
-          json(res, 404, { error: "session not found" });
+          json(res, 404, { error: "session not found" }, head);
           return;
         }
-        json(res, 200, { header, events });
+        json(res, 200, { header, events: eventsOf(snapshot) }, head);
         return;
       }
-      json(res, 404, { error: "unknown replay endpoint" });
+      json(res, 404, { error: "unknown replay endpoint" }, head);
     } catch (error) {
-      json(res, 500, { error: String(error) });
+      console.error("[dsh-replay] request failed", error);
+      json(res, 500, { error: "internal error" }, head);
     }
   };
   ctx.effect(