@neiltron/session-visualizer 0.1.0

package/bin/session-visualizer.js

@@ -0,0 +1,1371 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import { readFileSync as readFileSync2, realpathSync } from "node:fs";
+import { dirname, join as join2, resolve as resolve3 } from "node:path";
+import process2 from "node:process";
+import { spawn } from "node:child_process";
+import { fileURLToPath } from "node:url";
+
+// src/lib/cli-options.ts
+var DEFAULT_PORT = 4174;
+function parseCliOptions(argv) {
+  const options = {
+    sourceRoot: void 0,
+    open: false,
+    port: DEFAULT_PORT,
+    help: false,
+    version: false
+  };
+  for (let index = 0; index < argv.length; index += 1) {
+    const argument = argv[index] ?? "";
+    if (argument === "--help" || argument === "-h") {
+      options.help = true;
+      continue;
+    }
+    if (argument === "--version" || argument === "-v") {
+      options.version = true;
+      continue;
+    }
+    if (argument === "--open") {
+      options.open = true;
+      continue;
+    }
+    if (argument === "--port") {
+      const nextValue = argv[index + 1];
+      if (!nextValue) {
+        return invalid(options, "Missing value for --port.");
+      }
+      const port = Number(nextValue);
+      if (!Number.isInteger(port) || port < 0 || port > 65535) {
+        return invalid(options, `Invalid port: ${nextValue}`);
+      }
+      options.port = port;
+      index += 1;
+      continue;
+    }
+    if (argument.startsWith("--port=")) {
+      const value = argument.slice("--port=".length);
+      const port = Number(value);
+      if (!Number.isInteger(port) || port < 0 || port > 65535) {
+        return invalid(options, `Invalid port: ${value}`);
+      }
+      options.port = port;
+      continue;
+    }
+    if (argument.startsWith("-")) {
+      return invalid(options, `Unknown option: ${argument}`);
+    }
+    if (options.sourceRoot !== void 0) {
+      return invalid(options, `Unexpected extra argument: ${argument}`);
+    }
+    options.sourceRoot = argument;
+  }
+  return { ok: true, options, error: null };
+}
+function renderHelp(commandName, packageName) {
+  return [
+    `${commandName} \u2014 local filmstrip inspector for Pi session JSONL files`,
+    "",
+    `Usage:`,
+    `  npx ${packageName} [source-root] [--open] [--port <number>]`,
+    `  ${commandName} [source-root] [--open] [--port <number>]`,
+    "",
+    `Arguments:`,
+    `  source-root        Optional directory containing Pi session JSONL files`,
+    "",
+    `Options:`,
+    `  --open             Open the default browser after the server is ready`,
+    `  --port <number>    Port to bind (default: ${DEFAULT_PORT}; use 0 for an ephemeral port)`,
+    `  -h, --help         Show this help`,
+    `  -v, --version      Show package version`,
+    "",
+    `Examples:`,
+    `  npx ${packageName} /path/to/logs`,
+    `  npx ${packageName} --open`,
+    `  ${commandName} /path/to/logs --port 4300`
+  ].join("\n");
+}
+function invalid(options, error) {
+  return { ok: false, options, error };
+}
+
+// src/lib/node-server.ts
+import { createServer } from "node:http";
+import { Readable } from "node:stream";
+
+// src/server/app-handler.ts
+import { existsSync, readFileSync } from "node:fs";
+import { extname, isAbsolute as isAbsolute2, join, relative as relative2, resolve as resolve2 } from "node:path";
+
+// src/lib/discovery.ts
+import { constants } from "node:fs";
+import { access, readFile, readdir } from "node:fs/promises";
+import { basename, isAbsolute, posix as posix2, relative, resolve, sep } from "node:path";
+
+// src/lib/normalize.ts
+import { posix } from "node:path";
+
+// src/lib/format.ts
+function parseTimestamp(value) {
+  if (typeof value === "number" && Number.isFinite(value)) {
+    return value;
+  }
+  if (typeof value === "string" && value.trim()) {
+    const parsed = Date.parse(value);
+    return Number.isNaN(parsed) ? null : parsed;
+  }
+  return null;
+}
+
+// src/lib/normalize.ts
+function buildSessionDetail({ relativePath, parsed }) {
+  const session = buildSessionSummary(relativePath, parsed.rawEntries);
+  const events = normalizeEvents(parsed.rawEntries);
+  const toolSpans = buildToolSpans(events);
+  applyToolPairMetadata(events, toolSpans);
+  const stats = buildStats(parsed.rawEntries, parsed.warnings.length);
+  return {
+    session,
+    stats,
+    warnings: parsed.warnings,
+    rawEntries: parsed.rawEntries,
+    events,
+    toolSpans
+  };
+}
+function buildSessionIndexRow(detail) {
+  return {
+    ...detail.session,
+    ...detail.stats
+  };
+}
+function buildSessionSummary(relativePath, rawEntries) {
+  const pathMetadata = deriveSessionPathMetadata(relativePath);
+  const timestamps = rawEntries.map((record) => getEntryTimeMs(record.entry)).filter((value) => value !== null).sort((left, right) => left - right);
+  const startedAt = rawEntries.find((record) => record.entry.type === "session")?.entry.timestamp;
+  const latestModelChange = [...rawEntries].reverse().find((record) => record.entry.type === "model_change")?.entry;
+  const latestMessageWithModel = [...rawEntries].reverse().find(
+    (record) => {
+      return isMessageEntry(record.entry) && (typeof record.entry.provider === "string" || typeof record.entry.model === "string");
+    }
+  )?.entry;
+  const startedAtIso = typeof startedAt === "string" ? startedAt : timestamps.length > 0 ? new Date(timestamps[0]).toISOString() : null;
+  return {
+    ...pathMetadata,
+    startedAt: startedAtIso,
+    durationMs: timestamps.length >= 2 ? timestamps[timestamps.length - 1] - timestamps[0] : null,
+    provider: latestModelChange && typeof latestModelChange.provider === "string" ? latestModelChange.provider : typeof latestMessageWithModel?.provider === "string" ? latestMessageWithModel.provider : null,
+    modelId: latestModelChange && typeof latestModelChange.modelId === "string" ? latestModelChange.modelId : typeof latestMessageWithModel?.model === "string" ? latestMessageWithModel.model : null
+  };
+}
+function deriveSessionPathMetadata(relativePath) {
+  const normalizedPath = posix.normalize(relativePath.replace(/\\/g, "/")).replace(/^\.\//, "");
+  const parts = normalizedPath.split("/").filter(Boolean);
+  const fileName = parts.at(-1) ?? normalizedPath;
+  const parentParts = parts.slice(0, -1);
+  if (parts.length >= 4 && parts[0] === "tasks" && parts[2] === "pi-sessions") {
+    const taskId = parts[1] ?? null;
+    const nestedParts = parentParts.slice(3);
+    return {
+      relativePath: normalizedPath,
+      fileName,
+      groupLabel: taskId ? nestedParts.length > 0 ? `${taskId} / ${nestedParts.join("/")}` : taskId : parentParts.join("/") || null,
+      layoutHint: "task",
+      taskId,
+      chatId: null
+    };
+  }
+  if (parts.length >= 4 && parts[0] === "chats" && parts[2] === "pi-sessions") {
+    const chatId = parts[1] ?? null;
+    const nestedParts = parentParts.slice(3);
+    return {
+      relativePath: normalizedPath,
+      fileName,
+      groupLabel: chatId ? nestedParts.length > 0 ? `${chatId} / ${nestedParts.join("/")}` : chatId : parentParts.join("/") || null,
+      layoutHint: "chat",
+      taskId: null,
+      chatId
+    };
+  }
+  return {
+    relativePath: normalizedPath,
+    fileName,
+    groupLabel: parentParts.length > 0 ? parentParts.join("/") : null,
+    layoutHint: "generic",
+    taskId: null,
+    chatId: null
+  };
+}
+function buildStats(rawEntries, warningCount = 0) {
+  let toolCount = 0;
+  let errorCount = 0;
+  let customCount = 0;
+  for (const record of rawEntries) {
+    const entry = record.entry;
+    if (entry.type === "custom") {
+      customCount += 1;
+      continue;
+    }
+    if (!isMessageEntry(entry)) {
+      continue;
+    }
+    const message = entry.message;
+    if (!message) {
+      continue;
+    }
+    if (message.role === "assistant") {
+      toolCount += (message.content ?? []).filter((item) => item.type === "toolCall").length;
+    }
+    if (message.role === "toolResult" && message.isError) {
+      errorCount += 1;
+    }
+  }
+  return {
+    eventCount: rawEntries.length,
+    toolCount,
+    errorCount,
+    customCount,
+    warningCount
+  };
+}
+function normalizeEvents(rawEntries) {
+  const events = [];
+  let sequence = 0;
+  rawEntries.forEach((record, rawEntryIndex) => {
+    const entry = record.entry;
+    const entryTimeMs = getEntryTimeMs(entry);
+    const entryTimestamp = typeof entry.timestamp === "string" ? entry.timestamp : entryTimeMs !== null ? new Date(entryTimeMs).toISOString() : null;
+    if (entry.type === "session") {
+      events.push(createEvent({
+        id: entry.id ?? `session-${rawEntryIndex}`,
+        sequence: sequence += 1,
+        rawEntryIndex,
+        rawEntryId: entry.id ?? null,
+        contentIndex: null,
+        lane: "metadata",
+        type: entry.type,
+        role: null,
+        label: "session start",
+        preview: typeof entry.cwd === "string" ? entry.cwd : null,
+        timestamp: entryTimestamp,
+        timeMs: entryTimeMs,
+        provider: null,
+        modelId: null,
+        toolName: null,
+        toolCallId: null,
+        pairedToolEventId: null,
+        pairedToolSpanId: null,
+        pairStatus: null,
+        isError: false,
+        hasImage: false,
+        attachmentCount: 0,
+        badge: "session"
+      }));
+      return;
+    }
+    if (entry.type === "model_change") {
+      events.push(createEvent({
+        id: entry.id ?? `model-${rawEntryIndex}`,
+        sequence: sequence += 1,
+        rawEntryIndex,
+        rawEntryId: entry.id ?? null,
+        contentIndex: null,
+        lane: "metadata",
+        type: entry.type,
+        role: null,
+        label: "model change",
+        preview: compactParts([
+          typeof entry.provider === "string" ? entry.provider : void 0,
+          typeof entry.modelId === "string" ? entry.modelId : void 0
+        ]).join(" / ") || null,
+        timestamp: entryTimestamp,
+        timeMs: entryTimeMs,
+        provider: typeof entry.provider === "string" ? entry.provider : null,
+        modelId: typeof entry.modelId === "string" ? entry.modelId : null,
+        toolName: null,
+        toolCallId: null,
+        pairedToolEventId: null,
+        pairedToolSpanId: null,
+        pairStatus: null,
+        isError: false,
+        hasImage: false,
+        attachmentCount: 0,
+        badge: typeof entry.modelId === "string" ? entry.modelId : null
+      }));
+      return;
+    }
+    if (entry.type === "thinking_level_change") {
+      events.push(createEvent({
+        id: entry.id ?? `thinking-level-${rawEntryIndex}`,
+        sequence: sequence += 1,
+        rawEntryIndex,
+        rawEntryId: entry.id ?? null,
+        contentIndex: null,
+        lane: "metadata",
+        type: entry.type,
+        role: null,
+        label: "thinking level",
+        preview: typeof entry.thinkingLevel === "string" ? entry.thinkingLevel : null,
+        timestamp: entryTimestamp,
+        timeMs: entryTimeMs,
+        provider: null,
+        modelId: null,
+        toolName: null,
+        toolCallId: null,
+        pairedToolEventId: null,
+        pairedToolSpanId: null,
+        pairStatus: null,
+        isError: false,
+        hasImage: false,
+        attachmentCount: 0,
+        badge: typeof entry.thinkingLevel === "string" ? entry.thinkingLevel : null
+      }));
+      return;
+    }
+    if (entry.type === "custom") {
+      events.push(createEvent({
+        id: entry.id ?? `custom-${rawEntryIndex}`,
+        sequence: sequence += 1,
+        rawEntryIndex,
+        rawEntryId: entry.id ?? null,
+        contentIndex: null,
+        lane: "custom",
+        type: entry.type,
+        role: null,
+        label: `custom: ${entry.customType ?? "event"}`,
+        preview: previewFromUnknown(entry.data),
+        timestamp: entryTimestamp,
+        timeMs: entryTimeMs,
+        provider: null,
+        modelId: null,
+        toolName: null,
+        toolCallId: null,
+        pairedToolEventId: null,
+        pairedToolSpanId: null,
+        pairStatus: null,
+        isError: false,
+        hasImage: false,
+        attachmentCount: 0,
+        badge: typeof entry.customType === "string" ? entry.customType : "custom"
+      }));
+      return;
+    }
+    if (!isMessageEntry(entry)) {
+      events.push(createEvent({
+        id: entry.id ?? `entry-${rawEntryIndex}`,
+        sequence: sequence += 1,
+        rawEntryIndex,
+        rawEntryId: entry.id ?? null,
+        contentIndex: null,
+        lane: "metadata",
+        type: entry.type,
+        role: null,
+        label: entry.type,
+        preview: null,
+        timestamp: entryTimestamp,
+        timeMs: entryTimeMs,
+        provider: null,
+        modelId: null,
+        toolName: null,
+        toolCallId: null,
+        pairedToolEventId: null,
+        pairedToolSpanId: null,
+        pairStatus: null,
+        isError: false,
+        hasImage: false,
+        attachmentCount: 0,
+        badge: null
+      }));
+      return;
+    }
+    const message = entry.message;
+    if (!message) {
+      return;
+    }
+    const role = typeof message.role === "string" ? message.role : null;
+    const messageProvider = typeof entry.provider === "string" ? entry.provider : null;
+    const messageModel = typeof entry.model === "string" ? entry.model : null;
+    if (role === "toolResult") {
+      const content = message.content ?? [];
+      const preview = getFirstText(content) ?? (content.some((item) => item.type === "image") ? "Image attachment" : null);
+      const hasImage = content.some((item) => item.type === "image");
+      const attachmentCount = content.filter((item) => item.type === "image").length;
+      events.push(createEvent({
+        id: entry.id ?? `tool-result-${rawEntryIndex}`,
+        sequence: sequence += 1,
+        rawEntryIndex,
+        rawEntryId: entry.id ?? null,
+        contentIndex: null,
+        lane: "tools",
+        type: "toolResult",
+        role,
+        label: `toolResult: ${message.toolName ?? "tool"}`,
+        preview,
+        timestamp: entryTimestamp,
+        timeMs: entryTimeMs,
+        provider: messageProvider,
+        modelId: messageModel,
+        toolName: typeof message.toolName === "string" ? message.toolName : null,
+        toolCallId: typeof message.toolCallId === "string" ? message.toolCallId : null,
+        pairedToolEventId: null,
+        pairedToolSpanId: null,
+        pairStatus: null,
+        isError: Boolean(message.isError),
+        hasImage,
+        attachmentCount,
+        badge: message.isError ? "error" : attachmentCount > 0 ? `${attachmentCount} image` : null
+      }));
+      return;
+    }
+    const contents = message.content ?? [];
+    contents.forEach((content, contentIndex) => {
+      const normalized = normalizeMessageContent({
+        entry,
+        content,
+        rawEntryIndex,
+        contentIndex,
+        role,
+        timestamp: entryTimestamp,
+        timeMs: entryTimeMs,
+        sequence: sequence += 1
+      });
+      if (normalized) {
+        events.push(normalized);
+      }
+    });
+  });
+  return events.sort((left, right) => {
+    const leftTime = left.timeMs ?? Number.MAX_SAFE_INTEGER;
+    const rightTime = right.timeMs ?? Number.MAX_SAFE_INTEGER;
+    if (leftTime !== rightTime) {
+      return leftTime - rightTime;
+    }
+    if (left.rawEntryIndex !== right.rawEntryIndex) {
+      return left.rawEntryIndex - right.rawEntryIndex;
+    }
+    return left.sequence - right.sequence;
+  });
+}
+function normalizeMessageContent(input) {
+  const { entry, content, rawEntryIndex, contentIndex, role, timestamp, timeMs, sequence } = input;
+  const provider = typeof entry.provider === "string" ? entry.provider : null;
+  const modelId = typeof entry.model === "string" ? entry.model : null;
+  if (role === "user") {
+    return createEvent({
+      id: `${entry.id ?? `message-${rawEntryIndex}`}:user:${contentIndex}`,
+      sequence,
+      rawEntryIndex,
+      rawEntryId: entry.id ?? null,
+      contentIndex,
+      lane: "user",
+      type: content.type,
+      role,
+      label: content.type === "text" ? "user prompt" : `user ${content.type}`,
+      preview: previewFromContent(content),
+      timestamp,
+      timeMs,
+      provider,
+      modelId,
+      toolName: null,
+      toolCallId: null,
+      pairedToolEventId: null,
+      pairedToolSpanId: null,
+      pairStatus: null,
+      isError: false,
+      hasImage: content.type === "image",
+      attachmentCount: content.type === "image" ? 1 : 0,
+      badge: content.type
+    });
+  }
+  if (role === "assistant") {
+    if (content.type === "toolCall") {
+      return createEvent({
+        id: `${entry.id ?? `message-${rawEntryIndex}`}:toolCall:${contentIndex}`,
+        sequence,
+        rawEntryIndex,
+        rawEntryId: entry.id ?? null,
+        contentIndex,
+        lane: "tools",
+        type: content.type,
+        role,
+        label: `toolCall: ${content.name ?? "tool"}`,
+        preview: previewFromContent(content),
+        timestamp,
+        timeMs,
+        provider,
+        modelId,
+        toolName: typeof content.name === "string" ? content.name : null,
+        toolCallId: typeof content.id === "string" ? content.id : null,
+        pairedToolEventId: null,
+        pairedToolSpanId: null,
+        pairStatus: null,
+        isError: false,
+        hasImage: false,
+        attachmentCount: 0,
+        badge: typeof content.name === "string" ? content.name : "tool"
+      });
+    }
+    return createEvent({
+      id: `${entry.id ?? `message-${rawEntryIndex}`}:assistant:${contentIndex}`,
+      sequence,
+      rawEntryIndex,
+      rawEntryId: entry.id ?? null,
+      contentIndex,
+      lane: "assistant",
+      type: content.type,
+      role,
+      label: content.type === "thinking" ? "assistant thinking" : content.type === "text" ? "assistant reply" : `assistant ${content.type}`,
+      preview: previewFromContent(content),
+      timestamp,
+      timeMs,
+      provider,
+      modelId,
+      toolName: null,
+      toolCallId: null,
+      pairedToolEventId: null,
+      pairedToolSpanId: null,
+      pairStatus: null,
+      isError: false,
+      hasImage: content.type === "image",
+      attachmentCount: content.type === "image" ? 1 : 0,
+      badge: content.type
+    });
+  }
+  return createEvent({
+    id: `${entry.id ?? `message-${rawEntryIndex}`}:${role ?? "message"}:${contentIndex}`,
+    sequence,
+    rawEntryIndex,
+    rawEntryId: entry.id ?? null,
+    contentIndex,
+    lane: "metadata",
+    type: content.type,
+    role,
+    label: role ? `${role} ${content.type}` : content.type,
+    preview: previewFromContent(content),
+    timestamp,
+    timeMs,
+    provider,
+    modelId,
+    toolName: null,
+    toolCallId: null,
+    pairedToolEventId: null,
+    pairedToolSpanId: null,
+    pairStatus: null,
+    isError: false,
+    hasImage: content.type === "image",
+    attachmentCount: content.type === "image" ? 1 : 0,
+    badge: content.type
+  });
+}
+function createEvent(event) {
+  return event;
+}
+function buildToolSpans(events) {
+  const toolCalls = /* @__PURE__ */ new Map();
+  const toolResults = /* @__PURE__ */ new Map();
+  events.forEach((event) => {
+    if (!event.toolCallId) {
+      return;
+    }
+    if (event.type === "toolCall") {
+      toolCalls.set(event.toolCallId, event);
+      return;
+    }
+    if (event.type === "toolResult") {
+      toolResults.set(event.toolCallId, event);
+    }
+  });
+  const spans = [];
+  for (const [toolCallId, callEvent] of toolCalls) {
+    const resultEvent = toolResults.get(toolCallId) ?? null;
+    spans.push({
+      id: `tool-span:${toolCallId}`,
+      toolCallId,
+      toolName: callEvent.toolName,
+      toolCallEventId: callEvent.id,
+      toolResultEventId: resultEvent?.id ?? null,
+      startedAt: callEvent.timestamp,
+      endedAt: resultEvent?.timestamp ?? null,
+      startTimeMs: callEvent.timeMs,
+      endTimeMs: resultEvent?.timeMs ?? null,
+      durationMs: callEvent.timeMs !== null && resultEvent && resultEvent.timeMs !== null && resultEvent.timeMs >= callEvent.timeMs ? resultEvent.timeMs - callEvent.timeMs : null,
+      isError: Boolean(resultEvent?.isError),
+      hasImage: Boolean(resultEvent?.hasImage),
+      pairStatus: resultEvent ? "paired" : "orphan_call",
+      label: `tool: ${callEvent.toolName ?? "tool"}`
+    });
+  }
+  return spans;
+}
+function applyToolPairMetadata(events, toolSpans) {
+  const eventsById = new Map(events.map((event) => [event.id, event]));
+  const toolCalls = new Set(toolSpans.map((span) => span.toolCallEventId));
+  const toolResults = new Set(toolSpans.flatMap((span) => span.toolResultEventId ? [span.toolResultEventId] : []));
+  toolSpans.forEach((span) => {
+    const callEvent = eventsById.get(span.toolCallEventId);
+    if (callEvent) {
+      callEvent.pairStatus = span.pairStatus;
+      callEvent.pairedToolEventId = span.toolResultEventId;
+      callEvent.pairedToolSpanId = span.id;
+    }
+    if (!span.toolResultEventId) {
+      return;
+    }
+    const resultEvent = eventsById.get(span.toolResultEventId);
+    if (resultEvent) {
+      resultEvent.pairStatus = "paired";
+      resultEvent.pairedToolEventId = span.toolCallEventId;
+      resultEvent.pairedToolSpanId = span.id;
+    }
+  });
+  events.forEach((event) => {
+    if (event.type === "toolCall" && !toolCalls.has(event.id)) {
+      event.pairStatus = "orphan_call";
+    }
+    if (event.type === "toolResult" && !toolResults.has(event.id)) {
+      event.pairStatus = "orphan_result";
+    }
+  });
+}
+function getEntryTimeMs(entry) {
+  const topLevel = parseTimestamp(entry.timestamp);
+  if (topLevel !== null) {
+    return topLevel;
+  }
+  if (isMessageEntry(entry)) {
+    return parseTimestamp(entry.message?.timestamp);
+  }
+  return null;
+}
+function getFirstText(content) {
+  for (const item of content) {
+    const preview = previewFromContent(item);
+    if (preview) {
+      return preview;
+    }
+  }
+  return null;
+}
+function previewFromContent(content) {
+  if (content.type === "text" && typeof content.text === "string") {
+    return compactText(content.text);
+  }
+  if (content.type === "thinking" && typeof content.thinking === "string") {
+    return compactText(content.thinking);
+  }
+  if (content.type === "toolCall") {
+    if (typeof content.partialJson === "string" && content.partialJson.trim()) {
+      return compactText(content.partialJson);
+    }
+    return previewFromUnknown(content.arguments);
+  }
+  if (content.type === "image") {
+    return typeof content.alt === "string" ? content.alt : typeof content.url === "string" ? content.url : "Image attachment";
+  }
+  return previewFromUnknown(content);
+}
+function previewFromUnknown(value) {
+  if (typeof value === "string") {
+    return compactText(value);
+  }
+  if (value && typeof value === "object") {
+    try {
+      return compactText(JSON.stringify(value));
+    } catch {
+      return null;
+    }
+  }
+  return null;
+}
+function compactText(value) {
+  return value.replace(/\s+/g, " ").trim();
+}
+function compactParts(values) {
+  return values.filter((value) => Boolean(value && value.trim()));
+}
+function isMessageEntry(entry) {
+  return entry.type === "message" && typeof entry === "object" && entry !== null;
+}
+
+// src/lib/parser.ts
+function parseJsonlContent(content) {
+  const lines = content.split(/\r?\n/);
+  const rawEntries = [];
+  const warnings = [];
+  let lastNonEmptyIndex = -1;
+  for (let index = 0; index < lines.length; index += 1) {
+    if (lines[index]?.trim()) {
+      lastNonEmptyIndex = index;
+    }
+  }
+  for (let index = 0; index < lines.length; index += 1) {
+    const source = lines[index] ?? "";
+    const trimmed = source.trim();
+    if (!trimmed) {
+      continue;
+    }
+    try {
+      rawEntries.push({
+        lineNumber: index + 1,
+        source,
+        entry: JSON.parse(trimmed)
+      });
+    } catch (error) {
+      const isLast = index === lastNonEmptyIndex;
+      warnings.push({
+        type: isLast ? "trailing_partial_line" : "malformed_line",
+        lineNumber: index + 1,
+        source,
+        message: error instanceof Error ? error.message : "Invalid JSON"
+      });
+    }
+  }
+  return { rawEntries, warnings };
+}
+
+// src/lib/discovery.ts
+var SKIP_DIRECTORY_NAMES = /* @__PURE__ */ new Set([".git", "node_modules", "dist", "build", ".next", ".turbo"]);
+var RECOGNIZED_ENTRY_TYPES = /* @__PURE__ */ new Set(["session", "message", "model_change", "thinking_level_change", "custom"]);
+function resolveSourceRoot(explicitRoot) {
+  if (explicitRoot === null) {
+    return null;
+  }
+  if (explicitRoot && explicitRoot.trim()) {
+    return resolve(explicitRoot);
+  }
+  return null;
+}
+function createSessionSource(rootPath, overrides = {}) {
+  return {
+    rootPath,
+    rootLabel: rootPath ? basename(rootPath) || rootPath : null,
+    status: rootPath ? "ready" : "unset",
+    error: null,
+    ...overrides
+  };
+}
+async function validateSourceRoot(inputPath) {
+  if (!inputPath.trim()) {
+    throw new Error("Enter a directory path to open.");
+  }
+  const rootPath = resolve(inputPath);
+  try {
+    await access(rootPath, constants.R_OK);
+    await readdir(rootPath, { withFileTypes: true });
+  } catch (error) {
+    throw new Error(formatDirectoryError(rootPath, error));
+  }
+  return rootPath;
+}
+async function scanSessionIndex(rootPath) {
+  const sessionFiles = await discoverSessionFiles(rootPath);
+  const rows = await Promise.all(
+    sessionFiles.map(async ({ relativePath, absolutePath }) => {
+      try {
+        const parsed = await readParsedSessionFile(absolutePath);
+        if (!isRecognizedSessionFile(parsed)) {
+          return null;
+        }
+        return buildSessionIndexRow(buildSessionDetail({ relativePath, parsed }));
+      } catch {
+        return null;
+      }
+    })
+  );
+  return rows.filter((row) => row !== null).sort((left, right) => {
+    const leftTime = left.startedAt ? Date.parse(left.startedAt) : 0;
+    const rightTime = right.startedAt ? Date.parse(right.startedAt) : 0;
+    if (leftTime !== rightTime) {
+      return rightTime - leftTime;
+    }
+    return left.relativePath.localeCompare(right.relativePath);
+  });
+}
+async function getSessionDetail(rootPath, relativePath) {
+  const sessionPath = resolveSessionPath(rootPath, relativePath);
+  if (!sessionPath) {
+    return null;
+  }
+  try {
+    await access(sessionPath, constants.R_OK);
+  } catch {
+    return null;
+  }
+  try {
+    const parsed = await readParsedSessionFile(sessionPath);
+    if (!isRecognizedSessionFile(parsed)) {
+      return null;
+    }
+    const normalizedRelativePath = toPortableRelativePath(rootPath, sessionPath);
+    return buildSessionDetail({ relativePath: normalizedRelativePath, parsed });
+  } catch {
+    return null;
+  }
+}
+async function discoverSessionFiles(rootPath) {
+  const discovered = [];
+  await walkDirectory(rootPath, rootPath, discovered, true);
+  return discovered.sort((left, right) => left.relativePath.localeCompare(right.relativePath));
+}
+function resolveSessionPath(rootPath, relativePath) {
+  const normalizedRoot = resolve(rootPath);
+  const normalizedInput = relativePath.replace(/\\/g, "/");
+  if (!normalizedInput.trim() || normalizedInput.includes("\0") || posix2.isAbsolute(normalizedInput)) {
+    return null;
+  }
+  const normalizedRelativePath = posix2.normalize(normalizedInput).replace(/^\.\//, "");
+  if (!normalizedRelativePath || normalizedRelativePath === "." || normalizedRelativePath.startsWith("../") || normalizedRelativePath === ".." || !normalizedRelativePath.endsWith(".jsonl")) {
+    return null;
+  }
+  const resolvedPath = resolve(normalizedRoot, ...normalizedRelativePath.split("/"));
+  return isPathWithinRoot(normalizedRoot, resolvedPath) ? resolvedPath : null;
+}
+async function walkDirectory(rootPath, currentPath, discovered, isRoot = false) {
+  let entries;
+  try {
+    entries = await readdir(currentPath, { withFileTypes: true });
+  } catch (error) {
+    if (isRoot) {
+      throw new Error(formatDirectoryError(currentPath, error));
+    }
+    return;
+  }
+  const sortedEntries = [...entries].sort((left, right) => left.name.localeCompare(right.name));
+  for (const entry of sortedEntries) {
+    if (entry.isSymbolicLink()) {
+      continue;
+    }
+    const absolutePath = resolve(currentPath, entry.name);
+    if (entry.isDirectory()) {
+      if (SKIP_DIRECTORY_NAMES.has(entry.name)) {
+        continue;
+      }
+      await walkDirectory(rootPath, absolutePath, discovered);
+      continue;
+    }
+    if (!entry.isFile() || !entry.name.endsWith(".jsonl")) {
+      continue;
+    }
+    discovered.push({
+      relativePath: toPortableRelativePath(rootPath, absolutePath),
+      absolutePath
+    });
+  }
+}
+function toPortableRelativePath(rootPath, absolutePath) {
+  return relative(rootPath, absolutePath).split(sep).join("/");
+}
+function isPathWithinRoot(rootPath, candidatePath) {
+  const relativeCandidate = relative(rootPath, candidatePath);
+  return relativeCandidate === "" || !relativeCandidate.startsWith("..") && !isAbsolute(relativeCandidate);
+}
+function isRecognizedSessionFile(parsed) {
+  return parsed.rawEntries.some((record) => RECOGNIZED_ENTRY_TYPES.has(record.entry.type));
+}
+function formatDirectoryError(rootPath, error) {
+  if (error && typeof error === "object" && "code" in error) {
+    const code = String(error.code);
+    if (code === "ENOENT") {
+      return `Directory does not exist: ${rootPath}`;
+    }
+    if (code === "ENOTDIR") {
+      return `Path is not a directory: ${rootPath}`;
+    }
+    if (code === "EACCES" || code === "EPERM") {
+      return `Directory is not readable: ${rootPath}`;
+    }
+  }
+  return `Could not read directory: ${rootPath}`;
+}
+async function readParsedSessionFile(path) {
+  const content = await readFile(path, "utf8");
+  return parseJsonlContent(content);
+}
+
+// src/server/allowed-hosts.ts
+function defaultAllowedHosts(host, port) {
+  const allowedHosts = [formatHostAndPort(host, port)];
+  if (host === "127.0.0.1") {
+    allowedHosts.push(formatHostAndPort("localhost", port));
+  }
+  return allowedHosts;
+}
+function formatHostAndPort(host, port) {
+  if (host.includes(":")) {
+    return `[${host}]:${port}`;
+  }
+  return `${host}:${port}`;
+}
+
+// src/server/app-handler.ts
+var CONTENT_TYPES = /* @__PURE__ */ new Map([
+  [".css", "text/css; charset=utf-8"],
+  [".gif", "image/gif"],
+  [".html", "text/html; charset=utf-8"],
+  [".ico", "image/x-icon"],
+  [".jpeg", "image/jpeg"],
+  [".jpg", "image/jpeg"],
+  [".js", "text/javascript; charset=utf-8"],
+  [".json", "application/json; charset=utf-8"],
+  [".mjs", "text/javascript; charset=utf-8"],
+  [".png", "image/png"],
+  [".svg", "image/svg+xml"],
+  [".txt", "text/plain; charset=utf-8"],
+  [".webp", "image/webp"]
+]);
+function createAppFetchHandler(options = {}) {
+  const configuredRoot = options.dataDir === void 0 ? process.env.DATA_DIR : options.dataDir;
+  const initialRoot = resolveSourceRoot(configuredRoot);
+  const distDir = resolve2(options.distDir ?? join(process.cwd(), "dist"));
+  const host = options.host ?? process.env.HOST ?? "127.0.0.1";
+  const port = options.port ?? Number(process.env.PORT ?? 4174);
+  const allowedHosts = new Set(options.allowedHosts ?? defaultAllowedHosts(host, port));
+  let source = createSessionSource(initialRoot, initialRoot ? { status: "scanning" } : void 0);
+  let sessions = [];
+  let scanPromise = null;
+  let scanGeneration = 0;
+  if (initialRoot) {
+    void startScan(initialRoot);
+  }
+  return async function handleRequest(request) {
+    const url = new URL(request.url);
+    const hostError = validateRequestHost(request, url, allowedHosts);
+    if (hostError) {
+      return json(403, hostError);
+    }
+    const originError = validateRequestOrigin(request, allowedHosts);
+    if (originError) {
+      return json(403, originError);
+    }
+    if (request.method === "GET" && url.pathname === "/health") {
+      return json(200, {
+        ok: true,
+        host,
+        port,
+        source
+      });
+    }
+    if (request.method === "GET" && url.pathname === "/api/source") {
+      return json(200, { ok: true, source });
+    }
+    if (request.method === "POST" && url.pathname === "/api/source/open") {
+      const body = await readJsonBody(request);
+      if (!body || typeof body.path !== "string") {
+        return json(400, { ok: false, error: "invalid_request", message: "Expected a JSON body with a string path.", source });
+      }
+      const result = await openSource(body.path);
+      return json(result.ok ? 200 : 400, result);
+    }
+    if (request.method === "POST" && url.pathname === "/api/source/rescan") {
+      const result = await rescanSource();
+      return json(result.ok ? 200 : 400, result);
+    }
+    if (request.method === "GET" && url.pathname === "/api/sessions") {
+      await waitForPendingScan();
+      return json(200, { ok: true, sessions });
+    }
+    if (request.method === "GET" && url.pathname === "/api/sessions/detail") {
+      if (!source.rootPath) {
+        return json(400, { ok: false, error: "source_not_selected" });
+      }
+      const relativePath = url.searchParams.get("path") ?? "";
+      if (!resolveSessionPath(source.rootPath, relativePath)) {
+        return json(400, { ok: false, error: "invalid_path" });
+      }
+      const detail = await getSessionDetail(source.rootPath, relativePath);
+      if (!detail) {
+        return json(404, { ok: false, error: "not_found" });
+      }
+      return json(200, { ok: true, detail });
+    }
+    if (request.method !== "GET") {
+      return json(405, { ok: false, error: "method_not_allowed" });
+    }
+    const staticResponse = serveStatic(url.pathname, distDir);
+    if (staticResponse) {
+      return staticResponse;
+    }
+    return json(404, { ok: false, error: "not_found" });
+  };
+  async function openSource(inputPath) {
+    const previousSource = source;
+    const previousSessions = sessions;
+    let nextRootPath;
+    try {
+      nextRootPath = await validateSourceRoot(inputPath);
+    } catch (error) {
+      const message = getErrorMessage(error);
+      source = previousSource.rootPath ? { ...previousSource, error: message } : createSessionSource(null, { status: "error", error: message });
+      sessions = previousSessions;
+      return {
+        ok: false,
+        error: "invalid_source_path",
+        message,
+        source
+      };
+    }
+    sessions = [];
+    await startScan(nextRootPath);
+    if (source.status === "error") {
+      return {
+        ok: false,
+        error: "scan_failed",
+        message: source.error ?? "Failed to scan source root.",
+        source
+      };
+    }
+    return { ok: true, source };
+  }
+  async function rescanSource() {
+    if (!source.rootPath) {
+      source = createSessionSource(null, { status: "error", error: "Choose a source root before rescanning." });
+      return {
+        ok: false,
+        error: "source_not_selected",
+        message: source.error,
+        source
+      };
+    }
+    await startScan(source.rootPath);
+    if (source.status === "error") {
+      return {
+        ok: false,
+        error: "scan_failed",
+        message: source.error ?? "Failed to scan source root.",
+        source
+      };
+    }
+    return { ok: true, source };
+  }
+  async function startScan(rootPath) {
+    const generation = ++scanGeneration;
+    source = createSessionSource(rootPath, { status: "scanning", error: null });
+    const pendingScan = scanSessionIndex(rootPath).then((nextSessions) => {
+      if (generation !== scanGeneration || source.rootPath !== rootPath) {
+        return;
+      }
+      sessions = nextSessions;
+      source = createSessionSource(rootPath, { status: "ready", error: null });
+    }).catch((error) => {
+      if (generation !== scanGeneration || source.rootPath !== rootPath) {
+        return;
+      }
+      sessions = [];
+      source = createSessionSource(rootPath, {
+        status: "error",
+        error: getErrorMessage(error)
+      });
+    }).finally(() => {
+      if (scanPromise === pendingScan) {
+        scanPromise = null;
+      }
+    });
+    scanPromise = pendingScan;
+    await pendingScan;
+  }
+  async function waitForPendingScan() {
+    if (scanPromise) {
+      await scanPromise;
+    }
+  }
+}
+function validateRequestHost(request, url, allowedHosts) {
+  const requestHost = request.headers.get("host") ?? url.host;
+  if (!requestHost || allowedHosts.has(requestHost)) {
+    return null;
+  }
+  return {
+    ok: false,
+    error: "invalid_host",
+    message: `Requests must use one of: ${[...allowedHosts].join(", ")}.`
+  };
+}
+function validateRequestOrigin(request, allowedHosts) {
+  const origin = request.headers.get("origin");
+  if (!origin) {
+    return null;
+  }
+  try {
+    const originUrl = new URL(origin);
+    if (allowedHosts.has(originUrl.host)) {
+      return null;
+    }
+  } catch {
+  }
+  return {
+    ok: false,
+    error: "invalid_origin",
+    message: "Cross-origin requests are not allowed."
+  };
+}
+function serveStatic(pathname, distDir) {
+  if (!existsSync(distDir)) {
+    return null;
+  }
+  const normalizedPath = pathname === "/" ? "/index.html" : pathname;
+  const safePath = resolve2(distDir, `.${normalizedPath}`);
+  if (isPathWithinDirectory(distDir, safePath) && existsSync(safePath)) {
+    return fileResponse(safePath);
+  }
+  const indexPath = join(distDir, "index.html");
+  if (existsSync(indexPath)) {
+    return fileResponse(indexPath, "text/html; charset=utf-8");
+  }
+  return null;
+}
+function fileResponse(path, contentType = CONTENT_TYPES.get(extname(path)) ?? "application/octet-stream") {
+  return new Response(readFileSync(path), {
+    headers: { "content-type": contentType }
+  });
+}
+async function readJsonBody(request) {
+  try {
+    return await request.json();
+  } catch {
+    return null;
+  }
+}
+function getErrorMessage(error) {
+  return error instanceof Error ? error.message : "Unexpected error";
+}
+function isPathWithinDirectory(rootPath, candidatePath) {
+  const relativeCandidate = relative2(rootPath, candidatePath);
+  return relativeCandidate === "" || !relativeCandidate.startsWith("..") && !isAbsolute2(relativeCandidate);
+}
+function json(status, body) {
+  return new Response(JSON.stringify(body), {
+    status,
+    headers: { "content-type": "application/json; charset=utf-8" }
+  });
+}
+
+// src/lib/node-server.ts
+async function startNodeServer(options = {}) {
+  const requestedHost = options.host ?? "127.0.0.1";
+  const requestedPort = options.port ?? 4174;
+  let handleRequest = createAppFetchHandler({
+    ...options,
+    host: requestedHost,
+    port: requestedPort
+  });
+  const server = createServer(async (request, response) => {
+    try {
+      const appRequest = toWebRequest(request, requestedHost, getListeningPort(server, requestedPort));
+      const appResponse = await handleRequest(appRequest);
+      await writeWebResponse(appResponse, response);
+    } catch (error) {
+      response.statusCode = 500;
+      response.setHeader("content-type", "application/json; charset=utf-8");
+      response.end(JSON.stringify({
+        ok: false,
+        error: "internal_server_error",
+        message: error instanceof Error ? error.message : "Unexpected error"
+      }));
+    }
+  });
+  await new Promise((resolvePromise, rejectPromise) => {
+    server.once("error", rejectPromise);
+    server.listen(requestedPort, requestedHost, () => {
+      server.off("error", rejectPromise);
+      resolvePromise();
+    });
+  });
+  const address = server.address();
+  if (!address || typeof address === "string") {
+    throw new Error("Could not determine the Node server address.");
+  }
+  handleRequest = createAppFetchHandler({
+    ...options,
+    host: requestedHost,
+    port: address.port,
+    allowedHosts: defaultAllowedHosts(requestedHost, address.port)
+  });
+  return {
+    host: requestedHost,
+    port: address.port,
+    url: `http://${formatHostAndPort(requestedHost, address.port)}`,
+    close: async () => {
+      await new Promise((resolvePromise, rejectPromise) => {
+        server.close((error) => {
+          if (error) {
+            rejectPromise(error);
+            return;
+          }
+          resolvePromise();
+        });
+      });
+    }
+  };
+}
+function toWebRequest(request, host, port) {
+  const url = new URL(request.url ?? "/", `http://${formatHostAndPort(host, port)}`);
+  const body = request.method === "GET" || request.method === "HEAD" ? void 0 : Readable.toWeb(request);
+  const init = {
+    method: request.method,
+    headers: request.headers,
+    body,
+    duplex: body ? "half" : void 0
+  };
+  return new Request(url, init);
+}
+async function writeWebResponse(response, nodeResponse) {
+  nodeResponse.statusCode = response.status;
+  response.headers.forEach((value, key) => {
+    nodeResponse.setHeader(key, value);
+  });
+  if (!response.body) {
+    nodeResponse.end();
+    return;
+  }
+  await new Promise((resolvePromise, rejectPromise) => {
+    const stream = Readable.fromWeb(response.body);
+    stream.on("error", rejectPromise);
+    nodeResponse.on("finish", resolvePromise);
+    nodeResponse.on("error", rejectPromise);
+    stream.pipe(nodeResponse);
+  });
+}
+function getListeningPort(server, fallbackPort) {
+  const address = server.address();
+  if (!address || typeof address === "string") {
+    return fallbackPort;
+  }
+  return address.port;
+}
+
+// src/cli.ts
+async function runCli(dependencies = {}) {
+  const stdout = dependencies.stdout ?? process2.stdout;
+  const stderr = dependencies.stderr ?? process2.stderr;
+  const startServer = dependencies.startServer ?? startNodeServer;
+  const openBrowser = dependencies.openBrowser ?? openDefaultBrowser;
+  const packageMetadata = dependencies.packageMetadata ?? readPackageMetadata();
+  const argv = dependencies.argv ?? process2.argv.slice(2);
+  const parsed = parseCliOptions(argv);
+  const help = renderHelp(packageMetadata.commandName, packageMetadata.name);
+  if (!parsed.ok) {
+    writeLine(stderr, parsed.error ?? "Invalid arguments.");
+    writeLine(stderr, "");
+    writeLine(stderr, help);
+    return 1;
+  }
+  if (parsed.options.help) {
+    writeLine(stdout, help);
+    return 0;
+  }
+  if (parsed.options.version) {
+    writeLine(stdout, packageMetadata.version);
+    return 0;
+  }
+  let startedServer;
+  try {
+    startedServer = await startServer({
+      dataDir: parsed.options.sourceRoot,
+      distDir: resolvePackageDistDir(),
+      port: parsed.options.port
+    });
+  } catch (error) {
+    writeLine(stderr, error instanceof Error ? error.message : "Could not start session-visualizer.");
+    return 1;
+  }
+  if (dependencies.attachSignalHandlers !== false) {
+    attachShutdownHandlers(startedServer);
+  }
+  writeLine(stdout, `session-visualizer available at ${startedServer.url}`);
+  if (!parsed.options.sourceRoot) {
+    writeLine(stdout, "No source root configured. Open the URL, click Edit, and enter a directory path containing Pi session logs.");
+  }
+  if (parsed.options.open) {
+    try {
+      await openBrowser(startedServer.url);
+      writeLine(stdout, "Opened the default browser.");
+    } catch (error) {
+      writeLine(stderr, `Warning: could not open the default browser: ${error instanceof Error ? error.message : "Unexpected error"}`);
+    }
+  }
+  return 0;
+}
+async function openDefaultBrowser(url) {
+  const child = process2.platform === "darwin" ? spawn("open", [url], { detached: true, stdio: "ignore" }) : process2.platform === "win32" ? spawn("cmd", ["/c", "start", "", url], { detached: true, stdio: "ignore" }) : spawn("xdg-open", [url], { detached: true, stdio: "ignore" });
+  await new Promise((resolvePromise, rejectPromise) => {
+    let settled = false;
+    let fallbackTimeout = null;
+    const cleanup = () => {
+      if (fallbackTimeout) {
+        clearTimeout(fallbackTimeout);
+      }
+      child.off("error", onError);
+      child.off("spawn", onSpawn);
+      child.off("close", onClose);
+    };
+    const settle = (callback) => {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      cleanup();
+      callback();
+    };
+    const onError = (error) => {
+      settle(() => rejectPromise(error));
+    };
+    const onSpawn = () => {
+      child.unref();
+      fallbackTimeout = setTimeout(() => {
+        settle(resolvePromise);
+      }, 1e3);
+    };
+    const onClose = (code) => {
+      if (code === 0) {
+        settle(resolvePromise);
+        return;
+      }
+      settle(() => rejectPromise(new Error(`Browser opener exited with code ${code ?? "unknown"}.`)));
+    };
+    child.once("error", onError);
+    child.once("spawn", onSpawn);
+    child.once("close", onClose);
+  });
+}
+function readPackageMetadata() {
+  const packageJsonPath = join2(packageRootDir(), "package.json");
+  const packageJson = JSON.parse(readFileSync2(packageJsonPath, "utf8"));
+  const commandName = typeof packageJson.bin === "string" ? "session-visualizer" : Object.keys(packageJson.bin ?? {})[0] ?? "session-visualizer";
+  return {
+    name: packageJson.name ?? "@neiltron/session-visualizer",
+    commandName,
+    version: packageJson.version ?? "0.0.0"
+  };
+}
+function resolvePackageDistDir() {
+  return join2(packageRootDir(), "dist");
+}
+function packageRootDir() {
+  return join2(dirname(fileURLToPath(import.meta.url)), "..");
+}
+function attachShutdownHandlers(startedServer) {
+  const shutdown = async () => {
+    try {
+      await startedServer.close();
+    } finally {
+      process2.exit(0);
+    }
+  };
+  process2.on("SIGINT", shutdown);
+  process2.on("SIGTERM", shutdown);
+}
+function writeLine(stream, line) {
+  stream.write(`${line}
+`);
+}
+var isMainModule = process2.argv[1] ? realpathSync(resolve3(process2.argv[1])) === realpathSync(fileURLToPath(import.meta.url)) : false;
+if (isMainModule) {
+  const exitCode = await runCli();
+  if (exitCode !== 0) {
+    process2.exit(exitCode);
+  }
+}
+export {
+  runCli
+};