@tonyclaw/agent-inspector 3.1.32 → 4.0.2

package/src/proxy/logImporter.ts

@@ -1,813 +0,0 @@
-import { basename } from "node:path";
-import { Buffer } from "node:buffer";
-import JSZip from "jszip";
-import { z } from "zod";
-import {
-  CapturedLogSchema,
-  LogIdSchema,
-  StreamingChunkSchema,
-  type ApiFormat,
-  type CapturedLog,
-  type StreamingChunk,
-} from "../contracts";
-import packageJson from "../../package.json";
-import { apiFormatForPath } from "./formats";
-import { analyzeToolSchemaWarnings } from "./toolSchemaWarnings";
-
-export type ImportedLogDraft = Omit<CapturedLog, "id">;
-
-export type LogImportLimits = {
-  maxCompressedBytes: number;
-  maxEntries: number;
-  maxEntryUncompressedBytes: number;
-  maxTotalUncompressedBytes: number;
-  maxExpansionRatio: number;
-};
-
-export const DEFAULT_LOG_IMPORT_LIMITS: Readonly<LogImportLimits> = {
-  maxCompressedBytes: 200 * 1024 * 1024,
-  maxEntries: 10_000,
-  maxEntryUncompressedBytes: 128 * 1024 * 1024,
-  maxTotalUncompressedBytes: 500 * 1024 * 1024,
-  maxExpansionRatio: 100,
-};
-
-const ZIP_END_OF_CENTRAL_DIRECTORY_SIGNATURE = 0x06054b50;
-const ZIP_CENTRAL_DIRECTORY_SIGNATURE = 0x02014b50;
-const ZIP_END_OF_CENTRAL_DIRECTORY_BYTES = 22;
-const ZIP_CENTRAL_DIRECTORY_HEADER_BYTES = 46;
-const ZIP_MAX_COMMENT_BYTES = 0xffff;
-const ZIP_16_BIT_SENTINEL = 0xffff;
-const ZIP_32_BIT_SENTINEL = 0xffffffff;
-
-export type ParsedLogImport =
-  | {
-      ok: true;
-      logs: ImportedLogDraft[];
-      skipped: number;
-      warnings: string[];
-    }
-  | {
-      ok: false;
-      message: string;
-      warnings: string[];
-    };
-
-const ManifestSchema = z
-  .object({
-    version: z.string().optional(),
-    exportedAt: z.string().optional(),
-    mode: z.string().optional(),
-    redacted: z.boolean().optional(),
-    logIds: z.array(LogIdSchema).optional(),
-  })
-  .passthrough();
-
-const LogsArraySchema = z.array(CapturedLogSchema);
-const LogsEnvelopeSchema = z.object({ logs: z.array(CapturedLogSchema) }).passthrough();
-const StreamingChunksImportSchema = z.object({
-  chunks: z.array(StreamingChunkSchema),
-  truncated: z.boolean().optional().default(false),
-});
-
-type ParsedManifest = z.infer<typeof ManifestSchema>;
-
-type ZipBudget = {
-  remainingBytes: number;
-  decompressedBytes: number;
-  compressedBytes: number;
-  limits: Readonly<LogImportLimits>;
-};
-
-type ZipTextResult = { ok: true; text: string | null } | { ok: false; message: string };
-
-type ZipDirectoryInspection = { ok: true } | { ok: false; message: string };
-
-const SEMVER_MAJOR_PATTERN = /^([0-9]+)\.[0-9]+\.[0-9]+(?:[-+].*)?$/;
-
-function readRecordProperty(value: unknown, name: string): unknown {
-  if (typeof value !== "object" || value === null || Array.isArray(value)) return undefined;
-  const desc = Object.getOwnPropertyDescriptor(value, name);
-  return desc === undefined ? undefined : desc.value;
-}
-
-function parseJson(text: string | null): unknown {
-  if (text === null) return null;
-  try {
-    const parsed: unknown = JSON.parse(text);
-    return parsed;
-  } catch {
-    return null;
-  }
-}
-
-function parseJsonLogs(text: string): CapturedLog[] | null {
-  const parsed = parseJson(text);
-  const direct = LogsArraySchema.safeParse(parsed);
-  if (direct.success) return direct.data;
-
-  const envelope = LogsEnvelopeSchema.safeParse(parsed);
-  if (envelope.success) return envelope.data.logs;
-
-  return null;
-}
-
-function parseJsonlLogs(text: string): { logs: CapturedLog[]; skipped: number } {
-  const logs: CapturedLog[] = [];
-  let skipped = 0;
-  for (const line of text.split(/\r?\n/)) {
-    if (line.trim() === "") continue;
-    const parsed = CapturedLogSchema.safeParse(parseJson(line));
-    if (parsed.success) {
-      logs.push(parsed.data);
-    } else {
-      skipped += 1;
-    }
-  }
-  return { logs, skipped };
-}
-
-function readStringProperty(value: unknown, name: string): string | null {
-  const property = readRecordProperty(value, name);
-  return typeof property === "string" ? property : null;
-}
-
-function hasProperty(value: unknown, name: string): boolean {
-  if (typeof value !== "object" || value === null || Array.isArray(value)) return false;
-  return Object.getOwnPropertyDescriptor(value, name) !== undefined;
-}
-
-function modelFromRequestText(requestText: string | null): string | null {
-  return readStringProperty(parseJson(requestText), "model");
-}
-
-function inferApiFormatFromBody(
-  path: string,
-  model: string | null,
-  requestText: string | null,
-): ApiFormat {
-  const pathFormat = apiFormatForPath(path);
-  if (pathFormat !== "unknown") return pathFormat;
-
-  const normalizedModel = model?.toLowerCase() ?? "";
-  if (normalizedModel.startsWith("claude-")) return "anthropic";
-  if (
-    normalizedModel.startsWith("gpt-") ||
-    normalizedModel.startsWith("o1-") ||
-    normalizedModel.startsWith("o3-") ||
-    normalizedModel.startsWith("o4-") ||
-    normalizedModel.startsWith("deepseek-") ||
-    normalizedModel.startsWith("glm-") ||
-    normalizedModel.startsWith("qwen")
-  ) {
-    return "openai";
-  }
-
-  const parsedRequest = parseJson(requestText);
-  if (hasProperty(parsedRequest, "system") || hasProperty(parsedRequest, "max_tokens")) {
-    return "anthropic";
-  }
-  return "openai";
-}
-
-function defaultPathForApiFormat(apiFormat: ApiFormat): string {
-  switch (apiFormat) {
-    case "anthropic":
-      return "/v1/messages";
-    case "openai":
-      return "/v1/chat/completions";
-    case "unknown":
-      return "/v1/chat/completions";
-  }
-}
-
-function normalizeTimestamp(value: string, fallback: string): string {
-  return Number.isNaN(new Date(value).getTime()) ? fallback : value;
-}
-
-function responseStatusFromText(responseText: string | null): number | null {
-  if (responseText === null) return null;
-  const parsed = parseJson(responseText);
-  return hasProperty(parsed, "error") ? 500 : 200;
-}
-
-function mergeWarnings(
-  existing: readonly string[] | undefined,
-  generated: readonly string[],
-): string[] | undefined {
-  const values: string[] = [];
-  for (const warning of existing ?? []) {
-    if (!values.includes(warning)) values.push(warning);
-  }
-  for (const warning of generated) {
-    if (!values.includes(warning)) values.push(warning);
-  }
-  return values.length === 0 ? undefined : values;
-}
-
-function withToolWarnings(log: ImportedLogDraft): ImportedLogDraft {
-  const warnings = analyzeToolSchemaWarnings({
-    rawRequestBody: log.rawRequestBody,
-    responseText: log.responseText,
-    apiFormat: log.apiFormat,
-  });
-  return {
-    ...log,
-    warnings: mergeWarnings(log.warnings, warnings),
-  };
-}
-
-function streamingChunksFromText(text: string | null):
-  | {
-      chunks: StreamingChunk[];
-      truncated: boolean;
-    }
-  | undefined {
-  const parsed = StreamingChunksImportSchema.safeParse(parseJson(text));
-  return parsed.success ? parsed.data : undefined;
-}
-
-function draftFromCapturedLog(
-  log: CapturedLog,
-  requestText: string | null,
-  responseText: string | null,
-  streamingChunks: { chunks: StreamingChunk[]; truncated: boolean } | undefined,
-): ImportedLogDraft {
-  const rawRequestBody = requestText ?? log.rawRequestBody;
-  const response = responseText ?? log.responseText;
-  const model = log.model ?? modelFromRequestText(rawRequestBody);
-  const apiFormat =
-    log.apiFormat === "unknown"
-      ? inferApiFormatFromBody(log.path, model, rawRequestBody)
-      : log.apiFormat;
-  const path = log.path.trim() === "" ? defaultPathForApiFormat(apiFormat) : log.path;
-
-  return withToolWarnings({
-    timestamp: normalizeTimestamp(log.timestamp, new Date().toISOString()),
-    method: log.method.trim() === "" ? "POST" : log.method,
-    path,
-    model,
-    sessionId: null,
-    rawRequestBody,
-    responseStatus: log.responseStatus ?? responseStatusFromText(response),
-    responseText: response,
-    inputTokens: log.inputTokens,
-    outputTokens: log.outputTokens,
-    cacheCreationInputTokens: log.cacheCreationInputTokens,
-    cacheReadInputTokens: log.cacheReadInputTokens,
-    elapsedMs: log.elapsedMs,
-    firstChunkMs: log.firstChunkMs ?? null,
-    totalStreamMs: log.totalStreamMs ?? null,
-    tokensPerSecond: log.tokensPerSecond ?? null,
-    streaming: log.streaming || streamingChunks !== undefined,
-    userAgent: log.userAgent,
-    origin: log.origin,
-    rawHeaders: log.rawHeaders,
-    headers: log.headers,
-    apiFormat,
-    isTest: false,
-    replayOfLogId: null,
-    providerName: log.providerName ?? null,
-    clientPort: log.clientPort ?? null,
-    clientPid: log.clientPid ?? null,
-    clientCwd: log.clientCwd ?? null,
-    clientProjectFolder: log.clientProjectFolder ?? null,
-    streamingChunks,
-    streamingChunksPath: null,
-    rawRequestBodyBytes: log.rawRequestBodyBytes,
-    responseTextBytes: log.responseTextBytes,
-    bodyContentMode: "full",
-    warnings: log.warnings,
-    error: log.error ?? null,
-  });
-}
-
-function legacyDraftFromParts(input: {
-  exportedAt: string;
-  requestText: string | null;
-  responseText: string | null;
-  streamingChunks: { chunks: StreamingChunk[]; truncated: boolean } | undefined;
-}): ImportedLogDraft {
-  const model = modelFromRequestText(input.requestText);
-  const apiFormat = inferApiFormatFromBody("", model, input.requestText);
-  return withToolWarnings({
-    timestamp: input.exportedAt,
-    method: "POST",
-    path: defaultPathForApiFormat(apiFormat),
-    model,
-    sessionId: null,
-    rawRequestBody: input.requestText,
-    responseStatus: responseStatusFromText(input.responseText),
-    responseText: input.responseText,
-    inputTokens: null,
-    outputTokens: null,
-    cacheCreationInputTokens: null,
-    cacheReadInputTokens: null,
-    elapsedMs: null,
-    firstChunkMs: null,
-    totalStreamMs: null,
-    tokensPerSecond: null,
-    streaming: input.streamingChunks !== undefined,
-    userAgent: "agent-inspector-import",
-    origin: null,
-    apiFormat,
-    isTest: false,
-    replayOfLogId: null,
-    providerName: null,
-    clientPort: null,
-    clientPid: null,
-    clientCwd: null,
-    clientProjectFolder: null,
-    streamingChunks: input.streamingChunks,
-    streamingChunksPath: null,
-    bodyContentMode: "full",
-    error: null,
-  });
-}
-
-function zipEntryLimitMessage(path: string, maxBytes: number): string {
-  return `Archive entry "${path}" exceeds maximum uncompressed size of ${String(maxBytes)} bytes.`;
-}
-
-function zipTotalLimitMessage(maxBytes: number): string {
-  return `Archive exceeds maximum total uncompressed size of ${String(maxBytes)} bytes.`;
-}
-
-function zipExpansionLimitMessage(maxRatio: number): string {
-  return `Archive exceeds maximum expansion ratio of ${String(maxRatio)}:1.`;
-}
-
-function exceedsExpansionRatio(
-  uncompressedBytes: number,
-  compressedBytes: number,
-  maxRatio: number,
-): boolean {
-  if (uncompressedBytes === 0) return false;
-  if (compressedBytes === 0) return true;
-  return uncompressedBytes > compressedBytes * maxRatio;
-}
-
-function findEndOfCentralDirectory(data: Uint8Array, view: DataView): number | null {
-  const firstCandidate = Math.max(
-    0,
-    data.byteLength - ZIP_END_OF_CENTRAL_DIRECTORY_BYTES - ZIP_MAX_COMMENT_BYTES,
-  );
-  for (
-    let offset = data.byteLength - ZIP_END_OF_CENTRAL_DIRECTORY_BYTES;
-    offset >= firstCandidate;
-    offset -= 1
-  ) {
-    if (view.getUint32(offset, true) !== ZIP_END_OF_CENTRAL_DIRECTORY_SIGNATURE) continue;
-    const commentBytes = view.getUint16(offset + 20, true);
-    if (offset + ZIP_END_OF_CENTRAL_DIRECTORY_BYTES + commentBytes === data.byteLength) {
-      return offset;
-    }
-  }
-  return null;
-}
-
-/**
- * JSZip does not expose declared entry sizes. Inspect the central directory so
- * hostile archives are rejected before an inflater or JSON parser runs.
- */
-function inspectZipDirectory(
-  data: Uint8Array,
-  limits: Readonly<LogImportLimits>,
-): ZipDirectoryInspection {
-  if (data.byteLength < ZIP_END_OF_CENTRAL_DIRECTORY_BYTES) {
-    return { ok: false, message: "Invalid ZIP archive: central directory was not found." };
-  }
-
-  const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
-  const endOffset = findEndOfCentralDirectory(data, view);
-  if (endOffset === null) {
-    return { ok: false, message: "Invalid ZIP archive: central directory was not found." };
-  }
-
-  const diskNumber = view.getUint16(endOffset + 4, true);
-  const centralDirectoryDisk = view.getUint16(endOffset + 6, true);
-  const entriesOnDisk = view.getUint16(endOffset + 8, true);
-  const entryCount = view.getUint16(endOffset + 10, true);
-  const directoryBytes = view.getUint32(endOffset + 12, true);
-  const directoryOffset = view.getUint32(endOffset + 16, true);
-
-  if (
-    diskNumber !== 0 ||
-    centralDirectoryDisk !== 0 ||
-    entriesOnDisk !== entryCount ||
-    entryCount === ZIP_16_BIT_SENTINEL ||
-    directoryBytes === ZIP_32_BIT_SENTINEL ||
-    directoryOffset === ZIP_32_BIT_SENTINEL
-  ) {
-    return { ok: false, message: "ZIP64 and split archives are not supported for log import." };
-  }
-  if (entryCount > limits.maxEntries) {
-    return {
-      ok: false,
-      message: `Archive contains more than ${String(limits.maxEntries)} entries.`,
-    };
-  }
-
-  const directoryEnd = directoryOffset + directoryBytes;
-  if (directoryEnd > endOffset || directoryEnd > data.byteLength) {
-    return { ok: false, message: "Invalid ZIP archive: central directory is out of bounds." };
-  }
-
-  let offset = directoryOffset;
-  let totalCompressedBytes = 0;
-  let totalUncompressedBytes = 0;
-  for (let index = 0; index < entryCount; index += 1) {
-    if (
-      offset + ZIP_CENTRAL_DIRECTORY_HEADER_BYTES > directoryEnd ||
-      view.getUint32(offset, true) !== ZIP_CENTRAL_DIRECTORY_SIGNATURE
-    ) {
-      return { ok: false, message: "Invalid ZIP archive: malformed central directory entry." };
-    }
-
-    const flags = view.getUint16(offset + 8, true);
-    const compressedBytes = view.getUint32(offset + 20, true);
-    const uncompressedBytes = view.getUint32(offset + 24, true);
-    const fileNameBytes = view.getUint16(offset + 28, true);
-    const extraBytes = view.getUint16(offset + 30, true);
-    const commentBytes = view.getUint16(offset + 32, true);
-    const localHeaderOffset = view.getUint32(offset + 42, true);
-    const entryEnd =
-      offset + ZIP_CENTRAL_DIRECTORY_HEADER_BYTES + fileNameBytes + extraBytes + commentBytes;
-
-    if (
-      compressedBytes === ZIP_32_BIT_SENTINEL ||
-      uncompressedBytes === ZIP_32_BIT_SENTINEL ||
-      localHeaderOffset === ZIP_32_BIT_SENTINEL
-    ) {
-      return { ok: false, message: "ZIP64 archives are not supported for log import." };
-    }
-    if ((flags & 0x1) !== 0) {
-      return { ok: false, message: "Encrypted ZIP entries are not supported for log import." };
-    }
-    if (entryEnd > directoryEnd || localHeaderOffset >= directoryOffset) {
-      return { ok: false, message: "Invalid ZIP archive: entry metadata is out of bounds." };
-    }
-    if (uncompressedBytes > limits.maxEntryUncompressedBytes) {
-      return {
-        ok: false,
-        message: zipEntryLimitMessage(
-          `entry ${String(index + 1)}`,
-          limits.maxEntryUncompressedBytes,
-        ),
-      };
-    }
-    if (exceedsExpansionRatio(uncompressedBytes, compressedBytes, limits.maxExpansionRatio)) {
-      return { ok: false, message: zipExpansionLimitMessage(limits.maxExpansionRatio) };
-    }
-
-    totalCompressedBytes += compressedBytes;
-    totalUncompressedBytes += uncompressedBytes;
-    if (totalUncompressedBytes > limits.maxTotalUncompressedBytes) {
-      return { ok: false, message: zipTotalLimitMessage(limits.maxTotalUncompressedBytes) };
-    }
-    if (
-      exceedsExpansionRatio(totalUncompressedBytes, totalCompressedBytes, limits.maxExpansionRatio)
-    ) {
-      return { ok: false, message: zipExpansionLimitMessage(limits.maxExpansionRatio) };
-    }
-
-    offset = entryEnd;
-  }
-
-  if (offset !== directoryEnd) {
-    return { ok: false, message: "Invalid ZIP archive: central directory size is inconsistent." };
-  }
-  return { ok: true };
-}
-
-function bufferFromZipChunk(chunk: unknown): Buffer | null {
-  if (Buffer.isBuffer(chunk)) return chunk;
-  if (chunk instanceof Uint8Array) return Buffer.from(chunk);
-  return null;
-}
-
-async function readZipText(zip: JSZip, path: string, budget: ZipBudget): Promise<ZipTextResult> {
-  const file = zip.file(path);
-  if (file === null) return { ok: true, text: null };
-
-  return await new Promise((resolve) => {
-    const chunks: Buffer[] = [];
-    const stream = file.nodeStream("nodebuffer");
-    let entryBytes = 0;
-    let settled = false;
-
-    const settle = (result: ZipTextResult): void => {
-      if (settled) return;
-      settled = true;
-      resolve(result);
-    };
-
-    stream.on("data", (chunk: unknown) => {
-      if (settled) return;
-      const buffer = bufferFromZipChunk(chunk);
-      if (buffer === null) {
-        stream.pause();
-        settle({ ok: false, message: `Archive entry "${path}" produced invalid data.` });
-        return;
-      }
-
-      entryBytes += buffer.byteLength;
-      if (entryBytes > budget.limits.maxEntryUncompressedBytes) {
-        stream.pause();
-        settle({
-          ok: false,
-          message: zipEntryLimitMessage(path, budget.limits.maxEntryUncompressedBytes),
-        });
-        return;
-      }
-      if (buffer.byteLength > budget.remainingBytes) {
-        stream.pause();
-        settle({
-          ok: false,
-          message: zipTotalLimitMessage(budget.limits.maxTotalUncompressedBytes),
-        });
-        return;
-      }
-      const decompressedBytes = budget.decompressedBytes + buffer.byteLength;
-      if (
-        exceedsExpansionRatio(
-          decompressedBytes,
-          budget.compressedBytes,
-          budget.limits.maxExpansionRatio,
-        )
-      ) {
-        stream.pause();
-        settle({
-          ok: false,
-          message: zipExpansionLimitMessage(budget.limits.maxExpansionRatio),
-        });
-        return;
-      }
-
-      budget.remainingBytes -= buffer.byteLength;
-      budget.decompressedBytes = decompressedBytes;
-      chunks.push(buffer);
-    });
-    stream.on("error", (error: unknown) => {
-      settle({
-        ok: false,
-        message: error instanceof Error ? error.message : `Failed to decompress "${path}".`,
-      });
-    });
-    stream.on("end", () => {
-      settle({ ok: true, text: Buffer.concat(chunks, entryBytes).toString("utf8") });
-    });
-  });
-}
-
-async function readManifest(
-  zip: JSZip,
-  budget: ZipBudget,
-): Promise<{ ok: true; manifest: ParsedManifest | null } | { ok: false; message: string }> {
-  const result = await readZipText(zip, "manifest.json", budget);
-  if (!result.ok) return result;
-  const parsed = ManifestSchema.safeParse(parseJson(result.text));
-  return { ok: true, manifest: parsed.success ? parsed.data : null };
-}
-
-function versionMajor(version: string): number | null {
-  const match = SEMVER_MAJOR_PATTERN.exec(version);
-  if (match === null) return null;
-  const major = match[1];
-  return major === undefined ? null : Number.parseInt(major, 10);
-}
-
-function validateManifestVersion(manifest: ParsedManifest | null):
-  | {
-      ok: true;
-      warning: string | null;
-    }
-  | {
-      ok: false;
-      message: string;
-    } {
-  const exportedVersion = manifest?.version;
-  if (exportedVersion === undefined) {
-    return {
-      ok: true,
-      warning:
-        "Imported legacy export without version metadata. Compatibility could not be verified.",
-    };
-  }
-
-  const exportedMajor = versionMajor(exportedVersion);
-  if (exportedMajor === null) {
-    return {
-      ok: false,
-      message: `Unsupported export version "${exportedVersion}".`,
-    };
-  }
-
-  const currentMajor = versionMajor(packageJson.version);
-  if (currentMajor === null) {
-    return {
-      ok: true,
-      warning: `Current Agent Inspector version "${packageJson.version}" could not be verified against export version "${exportedVersion}".`,
-    };
-  }
-
-  if (exportedMajor !== currentMajor) {
-    return {
-      ok: false,
-      message: `Export version mismatch: archive was created by Agent Inspector v${exportedVersion}, current version is v${packageJson.version}. Import with a matching major version.`,
-    };
-  }
-
-  if (exportedVersion !== packageJson.version) {
-    return {
-      ok: true,
-      warning: `Imported export from Agent Inspector v${exportedVersion}; current version is v${packageJson.version}.`,
-    };
-  }
-
-  return { ok: true, warning: null };
-}
-
-async function parseZipLogImport(
-  data: Uint8Array,
-  limits: Readonly<LogImportLimits>,
-): Promise<ParsedLogImport> {
-  const warnings: string[] = [];
-  const inspection = inspectZipDirectory(data, limits);
-  if (!inspection.ok) return { ...inspection, warnings };
-
-  const zip = await JSZip.loadAsync(data);
-  const budget: ZipBudget = {
-    remainingBytes: limits.maxTotalUncompressedBytes,
-    decompressedBytes: 0,
-    compressedBytes: data.byteLength,
-    limits,
-  };
-
-  const manifestResult = await readManifest(zip, budget);
-  if (!manifestResult.ok) return { ...manifestResult, warnings };
-  const manifest = manifestResult.manifest;
-  const versionCheck = validateManifestVersion(manifest);
-  if (!versionCheck.ok) {
-    return {
-      ok: false,
-      message: versionCheck.message,
-      warnings,
-    };
-  }
-  if (versionCheck.warning !== null) {
-    warnings.push(versionCheck.warning);
-  }
-
-  const exportedAt = normalizeTimestamp(manifest?.exportedAt ?? "", new Date().toISOString());
-  if (manifest?.redacted === true) {
-    warnings.push("Imported redacted export. Secrets and some replay details may be unavailable.");
-  }
-
-  const metadataResult = await readZipText(zip, "logs.json", budget);
-  if (!metadataResult.ok) return { ...metadataResult, warnings };
-  const metadataLogs = metadataResult.text === null ? null : parseJsonLogs(metadataResult.text);
-  const logs: ImportedLogDraft[] = [];
-  let skipped = 0;
-
-  if (metadataLogs !== null) {
-    for (const log of metadataLogs) {
-      const requestResult = await readZipText(zip, `#${String(log.id)}.Request.json`, budget);
-      if (!requestResult.ok) return { ...requestResult, warnings };
-      const responseResult = await readZipText(zip, `#${String(log.id)}.Response.json`, budget);
-      if (!responseResult.ok) return { ...responseResult, warnings };
-      const streamingResult = await readZipText(
-        zip,
-        `#${String(log.id)}.SSE.Response.json`,
-        budget,
-      );
-      if (!streamingResult.ok) return { ...streamingResult, warnings };
-      logs.push(
-        draftFromCapturedLog(
-          log,
-          requestResult.text,
-          responseResult.text,
-          streamingChunksFromText(streamingResult.text),
-        ),
-      );
-    }
-    return { ok: true, logs, skipped, warnings };
-  }
-
-  for (const originalId of manifest?.logIds ?? []) {
-    const requestResult = await readZipText(zip, `#${String(originalId)}.Request.json`, budget);
-    if (!requestResult.ok) return { ...requestResult, warnings };
-    const responseResult = await readZipText(zip, `#${String(originalId)}.Response.json`, budget);
-    if (!responseResult.ok) return { ...responseResult, warnings };
-    const streamingResult = await readZipText(
-      zip,
-      `#${String(originalId)}.SSE.Response.json`,
-      budget,
-    );
-    if (!streamingResult.ok) return { ...streamingResult, warnings };
-    if (
-      requestResult.text === null &&
-      responseResult.text === null &&
-      streamingResult.text === null
-    ) {
-      skipped += 1;
-      continue;
-    }
-    logs.push(
-      legacyDraftFromParts({
-        exportedAt,
-        requestText: requestResult.text,
-        responseText: responseResult.text,
-        streamingChunks: streamingChunksFromText(streamingResult.text),
-      }),
-    );
-  }
-
-  if (logs.length === 0) {
-    return {
-      ok: false,
-      message: "No importable logs were found in the archive.",
-      warnings,
-    };
-  }
-
-  return { ok: true, logs, skipped, warnings };
-}
-
-function looksLikeZip(data: Uint8Array, fileName: string): boolean {
-  if (fileName.toLowerCase().endsWith(".zip")) return true;
-  return data[0] === 0x50 && data[1] === 0x4b;
-}
-
-function parseTextLogImport(text: string): ParsedLogImport {
-  const jsonLogs = parseJsonLogs(text);
-  if (jsonLogs !== null) {
-    return {
-      ok: true,
-      logs: jsonLogs.map((log) => draftFromCapturedLog(log, null, null, undefined)),
-      skipped: 0,
-      warnings: [],
-    };
-  }
-
-  const jsonl = parseJsonlLogs(text);
-  if (jsonl.logs.length > 0) {
-    return {
-      ok: true,
-      logs: jsonl.logs.map((log) => draftFromCapturedLog(log, null, null, undefined)),
-      skipped: jsonl.skipped,
-      warnings: [],
-    };
-  }
-
-  return {
-    ok: false,
-    message:
-      "Unsupported import file. Use an Agent Inspector export ZIP, logs.json, or JSONL file.",
-    warnings: [],
-  };
-}
-
-export async function parseImportedLogFile(input: {
-  fileName: string;
-  data: Uint8Array;
-  limits?: Readonly<LogImportLimits>;
-}): Promise<ParsedLogImport> {
-  const limits = input.limits ?? DEFAULT_LOG_IMPORT_LIMITS;
-  try {
-    if (looksLikeZip(input.data, input.fileName)) {
-      if (input.data.byteLength > limits.maxCompressedBytes) {
-        return {
-          ok: false,
-          message: `Archive exceeds maximum compressed size of ${String(limits.maxCompressedBytes)} bytes.`,
-          warnings: [],
-        };
-      }
-      return await parseZipLogImport(input.data, limits);
-    }
-
-    if (input.data.byteLength > limits.maxCompressedBytes) {
-      return {
-        ok: false,
-        message: `Import file exceeds maximum size of ${String(limits.maxCompressedBytes)} bytes.`,
-        warnings: [],
-      };
-    }
-
-    return parseTextLogImport(new TextDecoder("utf-8").decode(input.data));
-  } catch (err) {
-    return {
-      ok: false,
-      message: err instanceof Error ? err.message : "Failed to parse import file.",
-      warnings: [],
-    };
-  }
-}
-
-export function sessionNameFromImportFileName(fileName: string): string {
-  const normalized = fileName.replaceAll("\\", "/");
-  const base = basename(normalized)
-    .replace(/\.(zip|json|jsonl)$/i, "")
-    .trim();
-  return base === "" ? `import-${new Date().toISOString().slice(0, 10)}` : base;
-}