@tonyclaw/agent-inspector 3.0.45 → 3.0.46

package/.output/workers/logFinalizer.worker.js

@@ -8,9 +8,9 @@ var __export = (target, all) => {
 import { isMainThread, parentPort } from "node:worker_threads";
 
 // src/proxy/logFinalizer.ts
-import { Buffer as Buffer3 } from "node:buffer";
-import { existsSync as existsSync5, readFileSync as readFileSync2, rmSync as rmSync2, statSync as statSync2 } from "node:fs";
-import { join as join5 } from "node:path";
+import { Buffer as Buffer4 } from "node:buffer";
+import { existsSync as existsSync5, readFileSync as readFileSync2, rmSync as rmSync2, statSync } from "node:fs";
+import { join as join6 } from "node:path";
 import { fileURLToPath as fileURLToPath2, pathToFileURL } from "node:url";
 
 // src/proxy/chunkStorage.ts
@@ -19,29 +19,38 @@ import {
   readFileSync,
   unlinkSync,
   existsSync as existsSync3,
-  renameSync,
+  renameSync as renameSync2,
   copyFileSync
 } from "node:fs";
-import { join as join3, isAbsolute as isAbsolute2 } from "node:path";
+import { join as join4, isAbsolute as isAbsolute2 } from "node:path";
 
 // src/proxy/logger.ts
-import { Buffer as Buffer2 } from "node:buffer";
-import { appendFileSync } from "node:fs";
-import { appendFile, readdir, rename, stat, unlink } from "node:fs/promises";
+import { Buffer as Buffer3 } from "node:buffer";
+import { closeSync as closeSync2, constants as constants3, fsyncSync, openSync as openSync2, writeSync } from "node:fs";
+import { appendFile, readdir as readdir2, rename, stat as stat2, unlink as unlink2 } from "node:fs/promises";
 import path from "node:path";
 
 // src/proxy/dataDir.ts
-import { cpSync, existsSync as existsSync2, rmSync } from "node:fs";
+import { cpSync, existsSync, readdirSync as readdirSync2, renameSync, rmSync } from "node:fs";
 import { isAbsolute, join as join2 } from "node:path";
 
 // src/proxy/privateDataPath.ts
 import { spawnSync } from "node:child_process";
-import { chmodSync, existsSync, lstatSync, mkdirSync, readdirSync, statSync } from "node:fs";
-import { dirname, join } from "node:path";
+import {
+  closeSync,
+  constants,
+  fchmodSync,
+  fstatSync,
+  lstatSync,
+  mkdirSync,
+  openSync,
+  readdirSync,
+  realpathSync
+} from "node:fs";
+import { join, parse, resolve, sep } from "node:path";
 var PRIVATE_DIRECTORY_MODE = 448;
 var PRIVATE_FILE_MODE = 384;
-var securedPaths = /* @__PURE__ */ new Set();
-var securedFileIdentities = /* @__PURE__ */ new Map();
+var securedPathFingerprints = /* @__PURE__ */ new Map();
 var cachedWindowsSid = null;
 function windowsSystemPath(executable) {
   const systemRoot = process.env["SystemRoot"] ?? "C:\\Windows";
@@ -71,9 +80,7 @@ function resolveWindowsUserSid(run) {
 function windowsBroadGroupRemovalArgs() {
   return ["/remove:g", "*S-1-1-0", "*S-1-5-11", "*S-1-5-32-545"];
 }
-function applyWindowsUserOnlyAcl(path2, kind, run = runWindowsCommand) {
-  const sid = resolveWindowsUserSid(run);
-  if (sid === null) return false;
+function applyWindowsAclWithSid(path2, kind, sid, run) {
   const access = kind === "directory" ? `(OI)(CI)F` : "F";
   const result = run("icacls.exe", [
     path2,
@@ -85,93 +92,226 @@ function applyWindowsUserOnlyAcl(path2, kind, run = runWindowsCommand) {
   ]);
   return result.status === 0;
 }
-function applyWindowsUserOnlyTreeAcl(root, run = runWindowsCommand) {
+function applyWindowsUserOnlyAcl(path2, kind, run = runWindowsCommand) {
   const sid = resolveWindowsUserSid(run);
-  if (sid === null) return false;
-  const result = run("icacls.exe", [
-    root,
-    "/inheritance:r",
-    "/grant:r",
-    `*${sid}:(OI)(CI)F`,
-    `*${sid}:F`,
-    ...windowsBroadGroupRemovalArgs(),
-    "/T",
-    "/C",
-    "/Q"
-  ]);
-  return result.status === 0;
+  return sid !== null && applyWindowsAclWithSid(path2, kind, sid, run);
 }
-function applyPrivatePermissionsSync(path2, kind) {
+function comparablePath(path2) {
+  let normalized = path2;
   if (process.platform === "win32") {
-    return applyWindowsUserOnlyAcl(path2, kind);
+    if (normalized.startsWith("\\\\?\\UNC\\")) {
+      normalized = `\\\\${normalized.slice(8)}`;
+    } else if (normalized.startsWith("\\\\?\\")) {
+      normalized = normalized.slice(4);
+    }
   }
+  const absolute = resolve(normalized);
+  return process.platform === "win32" ? absolute.toLowerCase() : absolute;
+}
+function pathIdentity(stats) {
+  return `${String(stats.dev)}:${String(stats.ino)}:${String(stats.birthtimeMs)}`;
+}
+function readPathEntry(path2) {
+  let stats;
   try {
-    chmodSync(path2, kind === "directory" ? PRIVATE_DIRECTORY_MODE : PRIVATE_FILE_MODE);
-    return true;
+    const observed = lstatSync(path2);
+    if (observed === void 0) return { status: "missing" };
+    stats = observed;
   } catch {
-    return false;
+    return { status: "missing" };
   }
-}
-function secureOnce(path2, kind) {
-  const cacheKey = `${kind}:${path2}`;
-  if (securedPaths.has(cacheKey)) return true;
-  if (!applyPrivatePermissionsSync(path2, kind)) return false;
-  securedPaths.add(cacheKey);
-  return true;
-}
-function ensurePrivateDirectorySync(path2) {
+  if (stats.isSymbolicLink()) return { status: "unsafe" };
+  const kind = stats.isDirectory() ? "directory" : stats.isFile() ? "file" : null;
+  if (kind === null) return { status: "unsafe" };
+  let canonical;
   try {
-    mkdirSync(path2, { recursive: true, mode: PRIVATE_DIRECTORY_MODE });
+    canonical = realpathSync.native(path2);
   } catch {
-    return false;
+    return { status: "unsafe" };
   }
-  return secureOnce(path2, "directory");
+  if (comparablePath(canonical) !== comparablePath(path2)) return { status: "unsafe" };
+  return {
+    status: "ok",
+    entry: {
+      path: path2,
+      kind,
+      identity: pathIdentity(stats),
+      mode: stats.mode & 511
+    }
+  };
+}
+function snapshotPathChain(path2) {
+  const absolutePath = resolve(path2);
+  const root = parse(absolutePath).root;
+  const suffix = absolutePath.slice(root.length);
+  const parts = suffix === "" ? [] : suffix.split(sep).filter((part) => part !== "");
+  const entries = [];
+  let current = root;
+  const rootRead = readPathEntry(root);
+  if (rootRead.status !== "ok" || rootRead.entry.kind !== "directory") return null;
+  entries.push(rootRead.entry);
+  for (let index = 0; index < parts.length; index += 1) {
+    const part = parts[index];
+    if (part === void 0) return null;
+    current = join(current, part);
+    const read = readPathEntry(current);
+    if (read.status === "unsafe") return null;
+    if (read.status === "missing") {
+      return {
+        absolutePath,
+        complete: false,
+        entries,
+        missingParts: parts.slice(index)
+      };
+    }
+    if (index < parts.length - 1 && read.entry.kind !== "directory") return null;
+    entries.push(read.entry);
+  }
+  return { absolutePath, complete: true, entries, missingParts: [] };
 }
-function securePrivateFileSync(path2, forceAcl = false) {
-  let identity;
+function chainFingerprint(snapshot) {
+  return snapshot.entries.map((entry) => `${entry.path}:${entry.identity}`).join("|");
+}
+function snapshotsRetainPrefix(before, after) {
+  if (after.entries.length < before.entries.length) return false;
+  return before.entries.every((entry, index) => {
+    const next = after.entries[index];
+    return next !== void 0 && next.path === entry.path && next.identity === entry.identity;
+  });
+}
+function completeSnapshotForKind(path2, kind) {
+  const snapshot = snapshotPathChain(path2);
+  if (snapshot === null || !snapshot.complete) return null;
+  const leaf = snapshot.entries.at(-1);
+  return leaf !== void 0 && leaf.kind === kind ? snapshot : null;
+}
+function applyPosixPermissions(path2, kind, expectedIdentity) {
+  let descriptor = null;
   try {
-    const stats = statSync(path2);
-    identity = `${String(stats.dev)}:${String(stats.ino)}:${String(stats.birthtimeMs)}`;
+    const directoryFlag = kind === "directory" ? constants.O_DIRECTORY : 0;
+    descriptor = openSync(path2, constants.O_RDONLY | constants.O_NOFOLLOW | directoryFlag);
+    const before = fstatSync(descriptor);
+    if (pathIdentity(before) !== expectedIdentity) return false;
+    fchmodSync(descriptor, kind === "directory" ? PRIVATE_DIRECTORY_MODE : PRIVATE_FILE_MODE);
+    const after = fstatSync(descriptor);
+    return pathIdentity(after) === expectedIdentity && (after.mode & 511) === (kind === "directory" ? PRIVATE_DIRECTORY_MODE : PRIVATE_FILE_MODE);
   } catch {
     return false;
+  } finally {
+    if (descriptor !== null) {
+      try {
+        closeSync(descriptor);
+      } catch {
+      }
+    }
   }
-  if (securedFileIdentities.get(path2) === identity) return true;
-  if (process.platform === "win32" && !forceAcl && securedPaths.has(`directory:${dirname(path2)}`)) {
-    securedFileIdentities.set(path2, identity);
-    return true;
+}
+function permissionsArePrivate(entry) {
+  if (process.platform === "win32") return true;
+  return entry.mode === (entry.kind === "directory" ? PRIVATE_DIRECTORY_MODE : PRIVATE_FILE_MODE);
+}
+function secureExistingPath(path2, kind, forcePermissions = false) {
+  const before = completeSnapshotForKind(path2, kind);
+  if (before === null) return false;
+  const leaf = before.entries.at(-1);
+  if (leaf === void 0) return false;
+  const cacheKey = `${kind}:${before.absolutePath}`;
+  const beforeFingerprint = chainFingerprint(before);
+  if (!forcePermissions && securedPathFingerprints.get(cacheKey) === beforeFingerprint && permissionsArePrivate(leaf)) {
+    const cachedCheck = completeSnapshotForKind(path2, kind);
+    return cachedCheck !== null && chainFingerprint(cachedCheck) === beforeFingerprint;
   }
-  if (!applyPrivatePermissionsSync(path2, "file")) return false;
-  securedFileIdentities.set(path2, identity);
+  const applied = process.platform === "win32" ? applyWindowsUserOnlyAcl(path2, kind) : applyPosixPermissions(path2, kind, leaf.identity);
+  if (!applied) return false;
+  const after = completeSnapshotForKind(path2, kind);
+  if (after === null || !snapshotsRetainPrefix(before, after)) return false;
+  const afterLeaf = after.entries.at(-1);
+  if (afterLeaf === void 0 || afterLeaf.identity !== leaf.identity) return false;
+  if (!permissionsArePrivate(afterLeaf)) return false;
+  securedPathFingerprints.set(cacheKey, chainFingerprint(after));
   return true;
 }
-function securePrivateTreeSync(root) {
-  if (!existsSync(root)) return false;
-  let stats;
-  try {
-    stats = lstatSync(root);
-  } catch {
-    return false;
+function ensurePrivateDirectorySync(path2) {
+  const before = snapshotPathChain(path2);
+  if (before === null) return false;
+  let current = before.entries.at(-1)?.path;
+  if (current === void 0) return false;
+  for (const part of before.missingParts) {
+    const next = join(current, part);
+    try {
+      mkdirSync(next, { mode: PRIVATE_DIRECTORY_MODE });
+    } catch {
+      const raced = readPathEntry(next);
+      if (raced.status !== "ok" || raced.entry.kind !== "directory") return false;
+    }
+    if (!secureExistingPath(next, "directory", true)) return false;
+    current = next;
   }
-  if (stats.isSymbolicLink()) return true;
-  if (!stats.isDirectory()) return securePrivateFileSync(root, true);
-  if (process.platform === "win32") {
-    if (!applyWindowsUserOnlyTreeAcl(root)) return false;
-    securedPaths.add(`directory:${root}`);
+  const complete = completeSnapshotForKind(path2, "directory");
+  if (complete === null || !snapshotsRetainPrefix(before, complete)) return false;
+  return secureExistingPath(path2, "directory");
+}
+function securePrivateFileSync(path2, forceAcl = false) {
+  return secureExistingPath(path2, "file", forceAcl);
+}
+function collectSafeTree(root) {
+  const collected = [];
+  const visit = (path2) => {
+    const snapshot = snapshotPathChain(path2);
+    if (snapshot === null || !snapshot.complete) return false;
+    const leaf = snapshot.entries.at(-1);
+    if (leaf === void 0) return false;
+    const fingerprint = chainFingerprint(snapshot);
+    collected.push({ path: snapshot.absolutePath, kind: leaf.kind, fingerprint });
+    if (leaf.kind === "file") return true;
+    let entries;
+    try {
+      entries = readdirSync(path2);
+    } catch {
+      return false;
+    }
+    const afterRead = completeSnapshotForKind(path2, "directory");
+    if (afterRead === null || chainFingerprint(afterRead) !== fingerprint) return false;
+    for (const entry of entries) {
+      if (!visit(join(path2, entry))) return false;
+    }
     return true;
+  };
+  return visit(root) ? collected : null;
+}
+function treeFingerprintsMatch(expected, observed) {
+  if (observed === null || observed.length !== expected.length) return false;
+  return expected.every((entry, index) => {
+    const next = observed[index];
+    return next !== void 0 && next.path === entry.path && next.kind === entry.kind && next.fingerprint === entry.fingerprint;
+  });
+}
+function isPathTreeFreeOfIndirectionSync(root) {
+  return collectSafeTree(root) !== null;
+}
+function applyWindowsUserOnlyTreeAcl(root, run = runWindowsCommand) {
+  const entries = collectSafeTree(root);
+  if (entries === null) return false;
+  const sid = resolveWindowsUserSid(run);
+  if (sid === null) return false;
+  for (const entry of entries) {
+    const before = completeSnapshotForKind(entry.path, entry.kind);
+    if (before === null || chainFingerprint(before) !== entry.fingerprint) return false;
+    if (!applyWindowsAclWithSid(entry.path, entry.kind, sid, run)) return false;
+    const after = completeSnapshotForKind(entry.path, entry.kind);
+    if (after === null || chainFingerprint(after) !== entry.fingerprint) return false;
+    securedPathFingerprints.set(`${entry.kind}:${entry.path}`, entry.fingerprint);
   }
-  if (!ensurePrivateDirectorySync(root)) return false;
-  let entries;
-  try {
-    entries = readdirSync(root);
-  } catch {
-    return false;
-  }
-  let secured = true;
+  return treeFingerprintsMatch(entries, collectSafeTree(root));
+}
+function securePrivateTreeSync(root) {
+  const entries = collectSafeTree(root);
+  if (entries === null) return false;
+  if (process.platform === "win32") return applyWindowsUserOnlyTreeAcl(root);
   for (const entry of entries) {
-    const childPath = join(root, entry);
-    if (!securePrivateTreeSync(childPath)) secured = false;
+    if (!secureExistingPath(entry.path, entry.kind, true)) return false;
   }
-  return secured;
+  return treeFingerprintsMatch(entries, collectSafeTree(root));
 }
 
 // src/proxy/dataDir.ts
@@ -179,7 +319,7 @@ var CURRENT_DATA_DIR_NAME = ".agent-inspector";
 var LEGACY_DATA_DIR_NAMES = [".llm-inspector", ".llm-agent"];
 function getDataDir() {
   migrateLegacyDataDirs();
-  return resolveDataDir(existsSync2);
+  return resolveDataDir(existsSync);
 }
 function hasDataDirState(pathExists, dir) {
   return pathExists(join2(dir, "providers.json")) || pathExists(join2(dir, "config.json")) || pathExists(join2(dir, "logs")) || pathExists(join2(dir, "chunks"));
@@ -206,293 +346,52 @@ function migrateLegacyDataDirs() {
   if (hasExplicitDataDir()) return;
   const base = defaultBaseDir();
   const currentDir = join2(base, CURRENT_DATA_DIR_NAME);
-  if (hasDataDirState(existsSync2, currentDir)) return;
+  if (hasDataDirState(existsSync, currentDir)) return;
   for (const legacyName of LEGACY_DATA_DIR_NAMES) {
     const legacyDir = join2(base, legacyName);
-    if (!existsSync2(legacyDir)) continue;
+    if (!existsSync(legacyDir)) continue;
+    const stagingDir = join2(
+      base,
+      `${CURRENT_DATA_DIR_NAME}.migration-${String(process.pid)}-${String(Date.now())}`
+    );
     try {
-      if (!ensurePrivateDirectorySync(currentDir)) return;
-      cpSync(legacyDir, currentDir, { recursive: true, force: true });
-      if (!securePrivateTreeSync(currentDir)) return;
+      if (!isPathTreeFreeOfIndirectionSync(legacyDir)) return;
+      if (existsSync(currentDir)) {
+        if (readdirSync2(currentDir).length > 0) return;
+        rmSync(currentDir, { recursive: true, force: false });
+      }
+      if (!ensurePrivateDirectorySync(stagingDir)) return;
+      for (const entry of readdirSync2(legacyDir)) {
+        cpSync(join2(legacyDir, entry), join2(stagingDir, entry), {
+          recursive: true,
+          force: false,
+          errorOnExist: true
+        });
+      }
+      if (!isPathTreeFreeOfIndirectionSync(legacyDir)) {
+        rmSync(stagingDir, { recursive: true, force: true });
+        return;
+      }
+      if (!securePrivateTreeSync(stagingDir)) {
+        rmSync(stagingDir, { recursive: true, force: true });
+        return;
+      }
+      renameSync(stagingDir, currentDir);
       rmSync(legacyDir, { recursive: true, force: true });
+      return;
     } catch {
+      if (existsSync(stagingDir)) rmSync(stagingDir, { recursive: true, force: true });
+      return;
     }
   }
 }
 
-// src/proxy/logger.ts
-var DAY_MS = 24 * 60 * 60 * 1e3;
-var DEFAULT_RETENTION_DAYS = 7;
-var DEFAULT_APP_LOG_MAX_BYTES = 10 * 1024 * 1024;
-var DEFAULT_APP_LOG_MAX_FILES = 5;
-function writeStderrFallback(message, error51) {
-  process.stderr.write(`${message} ${String(error51)}
-`);
-}
-function resolveLogDir() {
-  const logDirEnv = process.env["LOG_DIR"];
-  if (logDirEnv !== void 0 && logDirEnv !== "") {
-    return path.isAbsolute(logDirEnv) ? logDirEnv : path.join(getDataDir(), logDirEnv);
-  }
-  return path.join(getDataDir(), "logs");
-}
-function getLogFilePath() {
-  const date5 = /* @__PURE__ */ new Date();
-  const yyyy = date5.getUTCFullYear();
-  const mm = String(date5.getUTCMonth() + 1).padStart(2, "0");
-  const dd = String(date5.getUTCDate()).padStart(2, "0");
-  return path.join(resolveLogDir(), `${yyyy}-${mm}-${dd}.jsonl`);
-}
-function getInspectorLogPath() {
-  const logFileEnv = process.env["AGENT_INSPECTOR_LOG_FILE"];
-  if (logFileEnv !== void 0 && logFileEnv !== "") {
-    return logFileEnv;
-  }
-  return path.join(getDataDir(), "logs", "inspector.log");
-}
-function readBoundedInteger(name, fallback, minimum, maximum) {
-  const raw = process.env[name];
-  if (raw === void 0 || raw === "") return fallback;
-  const parsed = Number(raw);
-  if (!Number.isInteger(parsed) || parsed < minimum || parsed > maximum) return fallback;
-  return parsed;
-}
-function getApplicationLogPolicy() {
-  const retentionDays = readBoundedInteger("LOG_RETENTION_DAYS", DEFAULT_RETENTION_DAYS, 1, 3650);
-  return {
-    maxBytes: readBoundedInteger(
-      "AGENT_INSPECTOR_APP_LOG_MAX_BYTES",
-      DEFAULT_APP_LOG_MAX_BYTES,
-      1,
-      1024 * 1024 * 1024
-    ),
-    maxFiles: readBoundedInteger(
-      "AGENT_INSPECTOR_APP_LOG_MAX_FILES",
-      DEFAULT_APP_LOG_MAX_FILES,
-      1,
-      100
-    ),
-    retentionMs: retentionDays * DAY_MS
-  };
-}
-function getRotatedGeneration(entry, baseName) {
-  const prefix = `${baseName}.`;
-  if (!entry.startsWith(prefix)) return null;
-  const suffix = entry.slice(prefix.length);
-  if (!/^\d+$/.test(suffix)) return null;
-  const generation = Number(suffix);
-  if (!Number.isSafeInteger(generation) || generation < 1) return null;
-  return generation;
-}
-async function listApplicationLogFiles(logPath) {
-  const directory = path.dirname(logPath);
-  const baseName = path.basename(logPath);
-  const entries = await readdir(directory);
-  const files = [];
-  for (const entry of entries) {
-    const generation = entry === baseName ? 0 : getRotatedGeneration(entry, baseName);
-    if (generation === null) continue;
-    const filePath = path.join(directory, entry);
-    try {
-      const fileStat = await stat(filePath);
-      if (!fileStat.isFile()) continue;
-      files.push({ generation, modifiedAt: fileStat.mtimeMs, path: filePath });
-    } catch {
-    }
-  }
-  return files;
-}
-async function removeApplicationLog(filePath) {
-  try {
-    await stat(filePath);
-  } catch {
-    return true;
-  }
-  try {
-    await unlink(filePath);
-    return true;
-  } catch {
-    return false;
-  }
-}
-async function maintainApplicationLogs(logPath, policy) {
-  const directory = path.dirname(logPath);
-  if (!ensurePrivateDirectorySync(directory)) return false;
-  let files;
-  try {
-    files = await listApplicationLogFiles(logPath);
-  } catch {
-    return false;
-  }
-  for (const file2 of files) {
-    if (!securePrivateFileSync(file2.path)) return false;
-  }
-  const cutoff = Date.now() - policy.retentionMs;
-  const retained = files.filter((file2) => file2.modifiedAt >= cutoff);
-  let maintained = true;
-  for (const file2 of files) {
-    if (file2.modifiedAt < cutoff && !await removeApplicationLog(file2.path)) maintained = false;
-  }
-  const rotated = retained.filter((file2) => file2.generation > 0).sort((left, right) => right.modifiedAt - left.modifiedAt);
-  const retainedRotatedCount = Math.max(0, policy.maxFiles - 1);
-  for (const file2 of rotated.slice(retainedRotatedCount)) {
-    if (!await removeApplicationLog(file2.path)) maintained = false;
-  }
-  return maintained;
-}
-async function moveApplicationLog(source, destination) {
-  try {
-    await stat(source);
-  } catch {
-    return true;
-  }
-  try {
-    await rename(source, destination);
-    if (!securePrivateFileSync(destination)) {
-      writeStderrFallback("[logger] Failed to secure rotated application log:", destination);
-      return false;
-    }
-    return true;
-  } catch (error51) {
-    writeStderrFallback("[logger] Failed to rotate application log:", error51);
-    return false;
-  }
-}
-async function rotateApplicationLog(logPath, maxFiles) {
-  if (maxFiles === 1) {
-    return await removeApplicationLog(logPath);
-  }
-  if (!await removeApplicationLog(`${logPath}.${String(maxFiles - 1)}`)) return false;
-  for (let generation = maxFiles - 2; generation >= 1; generation -= 1) {
-    if (!await moveApplicationLog(
-      `${logPath}.${String(generation)}`,
-      `${logPath}.${String(generation + 1)}`
-    )) {
-      return false;
-    }
-  }
-  return await moveApplicationLog(logPath, `${logPath}.1`);
-}
-async function rotateApplicationLogIfNeeded(logPath, incomingBytes, policy) {
-  try {
-    const fileStat = await stat(logPath);
-    if (fileStat.size > 0 && fileStat.size + incomingBytes > policy.maxBytes) {
-      return await rotateApplicationLog(logPath, policy.maxFiles);
-    }
-    return true;
-  } catch {
-    return true;
-  }
-}
-async function initLogger() {
-  const dir = resolveLogDir();
-  const policy = getApplicationLogPolicy();
-  const cutoff = Date.now() - policy.retentionMs;
-  try {
-    if (!ensurePrivateDirectorySync(dir)) {
-      writeStderrFallback("[logger] Failed to secure log directory:", dir);
-    } else if (!securePrivateTreeSync(dir)) {
-      writeStderrFallback("[logger] Failed to secure existing log files:", dir);
-    } else {
-      const entries = await readdir(dir);
-      for (const entry of entries) {
-        if (!entry.endsWith(".jsonl")) continue;
-        const fullPath = path.join(dir, entry);
-        try {
-          const s = await stat(fullPath);
-          if (s.mtimeMs < cutoff) {
-            await unlink(fullPath);
-          }
-        } catch {
-        }
-      }
-    }
-  } catch (err) {
-    writeStderrFallback("[logger] Failed to initialize log directory:", err);
-  }
-  const applicationLogPath = getInspectorLogPath();
-  if (!await maintainApplicationLogs(applicationLogPath, policy)) {
-    writeStderrFallback(
-      "[logger] Failed to initialize application log lifecycle:",
-      applicationLogPath
-    );
-  }
-}
-var loggerInitialization = null;
-var applicationLogWriteQueue = Promise.resolve();
-function ensureLoggerInitialized() {
-  if (loggerInitialization === null) loggerInitialization = initLogger();
-  return loggerInitialization;
-}
-async function appendApplicationLogLine(logPath, line, policy) {
-  const logDirPath = path.dirname(logPath);
-  if (!ensurePrivateDirectorySync(logDirPath)) {
-    return { ok: false, reason: "application log directory is not private" };
-  }
-  try {
-    if (!await rotateApplicationLogIfNeeded(logPath, Buffer2.byteLength(line, "utf-8"), policy)) {
-      return { ok: false, reason: "application log rotation failed" };
-    }
-    await appendFile(logPath, line, { encoding: "utf-8", mode: PRIVATE_FILE_MODE });
-    if (!securePrivateFileSync(logPath)) {
-      return { ok: false, reason: "application log permissions could not be secured" };
-    }
-    return { ok: true };
-  } catch (error51) {
-    return { ok: false, reason: error51 };
-  }
-}
-async function writeAppLog(message) {
-  const logPath = getInspectorLogPath();
-  const line = `[${(/* @__PURE__ */ new Date()).toISOString()}] ${message}
-`;
-  const initialization = ensureLoggerInitialized();
-  const write = async () => {
-    await initialization;
-    const result = await appendApplicationLogLine(logPath, line, getApplicationLogPolicy());
-    if (!result.ok) writeStderrFallback(`[logger] Failed to write to ${logPath}:`, result.reason);
-  };
-  applicationLogWriteQueue = applicationLogWriteQueue.then(write, write);
-  await applicationLogWriteQueue;
-}
-var logger = {
-  debug(message, ...args) {
-    const msg = args.length > 0 ? `${message} ${args.map(String).join(" ")}` : message;
-    void writeAppLog(`[DEBUG] ${msg}`);
-  },
-  info(message, ...args) {
-    const msg = args.length > 0 ? `${message} ${args.map(String).join(" ")}` : message;
-    void writeAppLog(`[INFO] ${msg}`);
-  },
-  warn(message, ...args) {
-    const msg = args.length > 0 ? `${message} ${args.map(String).join(" ")}` : message;
-    void writeAppLog(`[WARN] ${msg}`);
-  },
-  error(message, ...args) {
-    const msg = args.length > 0 ? `${message} ${args.map(String).join(" ")}` : message;
-    void writeAppLog(`[ERROR] ${msg}`);
-  }
-};
-var writeBuffer = [];
-var writeQueue = Promise.resolve();
-var logWriteLock = Promise.resolve();
-function drainBuffer() {
-  const toWrite = writeBuffer.join("");
-  writeBuffer = [];
-  return toWrite;
-}
-process.on("exit", () => {
-  if (writeBuffer.length > 0) {
-    const toWrite = drainBuffer();
-    try {
-      const filePath = getLogFilePath();
-      if (!ensurePrivateDirectorySync(path.dirname(filePath))) return;
-      appendFileSync(filePath, toWrite, { encoding: "utf-8", mode: PRIVATE_FILE_MODE });
-      void securePrivateFileSync(filePath);
-    } catch {
-    }
-  }
-});
+// src/proxy/jsonlRecovery.ts
+import { createHash, randomUUID } from "node:crypto";
+import { Buffer as Buffer2 } from "node:buffer";
+import { constants as constants2, existsSync as existsSync2, lstatSync as lstatSync2 } from "node:fs";
+import { link, lstat, open, readFile, readdir, stat, unlink } from "node:fs/promises";
+import { basename, join as join3, resolve as resolve2 } from "node:path";
 
 // node_modules/.bun/zod@4.4.3/node_modules/zod/v4/classic/external.js
 var external_exports = {};
@@ -677,7 +576,7 @@ __export(external_exports, {
   object: () => object,
   optional: () => optional,
   overwrite: () => _overwrite,
-  parse: () => parse2,
+  parse: () => parse3,
   parseAsync: () => parseAsync2,
   partialRecord: () => partialRecord,
   pipe: () => pipe,
@@ -997,7 +896,7 @@ __export(core_exports2, {
   isValidJWT: () => isValidJWT,
   locales: () => locales_exports,
   meta: () => meta,
-  parse: () => parse,
+  parse: () => parse2,
   parseAsync: () => parseAsync,
   prettifyError: () => prettifyError,
   process: () => process2,
@@ -1942,7 +1841,7 @@ var _parse = (_Err) => (schema, value, _ctx, _params) => {
   }
   return result.value;
 };
-var parse = /* @__PURE__ */ _parse($ZodRealError);
+var parse2 = /* @__PURE__ */ _parse($ZodRealError);
 var _parseAsync = (_Err) => async (schema, value, _ctx, params) => {
   const ctx = _ctx ? { ..._ctx, async: true } : { async: true };
   let result = schema._zod.run({ value, issues: [] }, ctx);
@@ -4734,10 +4633,10 @@ var $ZodFunction = /* @__PURE__ */ $constructor("$ZodFunction", (inst, def) => {
       throw new Error("implement() must be called with a function");
     }
     return function(...args) {
-      const parsedArgs = inst._def.input ? parse(inst._def.input, args) : args;
+      const parsedArgs = inst._def.input ? parse2(inst._def.input, args) : args;
       const result = Reflect.apply(func, this, parsedArgs);
       if (inst._def.output) {
-        return parse(inst._def.output, result);
+        return parse2(inst._def.output, result);
       }
       return result;
     };
@@ -13171,7 +13070,7 @@ var ZodRealError = /* @__PURE__ */ $constructor("ZodError", initializer2, {
 });
 
 // node_modules/.bun/zod@4.4.3/node_modules/zod/v4/classic/parse.js
-var parse2 = /* @__PURE__ */ _parse(ZodRealError);
+var parse3 = /* @__PURE__ */ _parse(ZodRealError);
 var parseAsync2 = /* @__PURE__ */ _parseAsync(ZodRealError);
 var safeParse2 = /* @__PURE__ */ _safeParse(ZodRealError);
 var safeParseAsync2 = /* @__PURE__ */ _safeParseAsync(ZodRealError);
@@ -13234,7 +13133,7 @@ var ZodType = /* @__PURE__ */ $constructor("ZodType", (inst, def) => {
   inst.def = def;
   inst.type = def.type;
   Object.defineProperty(inst, "_def", { value: def });
-  inst.parse = (data, params) => parse2(inst, data, params, { callee: inst.parse });
+  inst.parse = (data, params) => parse3(inst, data, params, { callee: inst.parse });
   inst.safeParse = (data, params) => safeParse2(inst, data, params);
   inst.parseAsync = async (data, params) => parseAsync2(inst, data, params, { callee: inst.parseAsync });
   inst.safeParseAsync = async (data, params) => safeParseAsync2(inst, data, params);
@@ -15027,6 +14926,15 @@ function trustAsJsonValue(value) {
 }
 
 // src/contracts/log.ts
+var LogIdSchema = external_exports.number().int().nonnegative().max(Number.MAX_SAFE_INTEGER);
+var CaptureIncompleteReasonSchema = external_exports.enum([
+  "capacity-exceeded",
+  "pipeline-closed",
+  "write-failed",
+  "finalize-failed",
+  "upstream-stream-error",
+  "shutdown"
+]);
 var StreamingChunkSchema = external_exports.object({
   index: external_exports.number(),
   timestamp: external_exports.number(),
@@ -15039,7 +14947,7 @@ var StreamingChunksArraySchema = external_exports.object({
 });
 var LogBodyPartSchema = external_exports.enum(["request", "response"]);
 var LogBodyChunkSchema = external_exports.object({
-  logId: external_exports.number().int().positive(),
+  logId: LogIdSchema,
   part: LogBodyPartSchema,
   text: external_exports.string(),
   offset: external_exports.number().int().nonnegative(),
@@ -15051,7 +14959,7 @@ var LogBodyChunkSchema = external_exports.object({
   contentMode: external_exports.enum(["empty", "partial", "full"])
 });
 var CapturedLogSchema = external_exports.object({
-  id: external_exports.number(),
+  id: LogIdSchema,
   timestamp: external_exports.string(),
   method: external_exports.string(),
   path: external_exports.string(),
@@ -15076,7 +14984,7 @@ var CapturedLogSchema = external_exports.object({
   headers: external_exports.record(external_exports.string(), external_exports.string()).optional(),
   apiFormat: external_exports.enum(["anthropic", "openai", "unknown"]).default("unknown"),
   isTest: external_exports.boolean().optional().default(false),
-  replayOfLogId: external_exports.number().nullable().optional(),
+  replayOfLogId: LogIdSchema.nullable().optional(),
   providerName: external_exports.string().nullable().optional(),
   clientPort: external_exports.number().nullable().optional(),
   clientPid: external_exports.number().nullable().optional(),
@@ -15087,6 +14995,10 @@ var CapturedLogSchema = external_exports.object({
   rawRequestBodyBytes: external_exports.number().int().nonnegative().nullable().optional(),
   responseTextBytes: external_exports.number().int().nonnegative().nullable().optional(),
   bodyContentMode: external_exports.enum(["full", "compact", "truncated"]).optional(),
+  captureIncomplete: external_exports.boolean().optional(),
+  droppedChunks: external_exports.number().int().nonnegative().optional(),
+  droppedBytes: external_exports.number().int().nonnegative().optional(),
+  captureIncompleteReason: CaptureIncompleteReasonSchema.nullable().optional(),
   warnings: external_exports.array(external_exports.string()).optional(),
   /** Error message from streaming response (e.g., SSE error event) */
   error: external_exports.string().nullable().optional()
@@ -15459,32 +15371,681 @@ var OpenAIResponsesSSEventSchema = external_exports.object({
 }).passthrough();
 function parseOpenAIResponse(rawBody) {
   try {
-    const json2 = JSON.parse(rawBody);
-    const result = OpenAIResponseSchema.safeParse(json2);
-    if (result.success) return result.data;
-    return null;
+    const json2 = JSON.parse(rawBody);
+    const result = OpenAIResponseSchema.safeParse(json2);
+    if (result.success) return result.data;
+    return null;
+  } catch {
+    return null;
+  }
+}
+function parseOpenAIResponsesResponse(rawBody) {
+  try {
+    const json2 = JSON.parse(rawBody);
+    const result = OpenAIResponsesResponseSchema.safeParse(json2);
+    if (result.success) return result.data;
+    return null;
+  } catch {
+    return null;
+  }
+}
+
+// src/proxy/schemas.ts
+var RequestModelSchema = external_exports.object({
+  model: external_exports.string()
+});
+var LooseRequestSchema = external_exports.object({
+  model: external_exports.string().optional(),
+  metadata: external_exports.object({ user_id: external_exports.string().optional() }).passthrough().optional()
+});
+
+// src/proxy/jsonlRecovery.ts
+var READ_CHUNK_BYTES = 64 * 1024;
+var QUARANTINE_DIRECTORY = "quarantine";
+var activeContext = null;
+function emptyHealth() {
+  return {
+    level: "ok",
+    diagnostic: null,
+    repairedFiles: 0,
+    delimiterRepairs: 0,
+    quarantinedTails: 0
+  };
+}
+function contextFor(logDir) {
+  const root = resolve2(logDir);
+  if (activeContext === null || activeContext.root !== root) {
+    activeContext = {
+      root,
+      health: emptyHealth(),
+      startup: null,
+      startupComplete: false,
+      safeFiles: /* @__PURE__ */ new Map()
+    };
+  }
+  return activeContext;
+}
+function copyHealth(health) {
+  return { ...health };
+}
+function hashBytes(value) {
+  return createHash("sha256").update(value).digest("hex");
+}
+function signatureFromStats(stats) {
+  return {
+    size: stats.size,
+    modifiedAt: stats.mtimeMs,
+    changedAt: stats.ctimeMs,
+    device: stats.dev,
+    inode: stats.ino
+  };
+}
+function signaturesMatch(left, right) {
+  return left.size === right.size && left.modifiedAt === right.modifiedAt && left.changedAt === right.changedAt && left.device === right.device && left.inode === right.inode;
+}
+function validateRecord(bytes) {
+  const withoutCarriageReturn = bytes.length > 0 && bytes[bytes.length - 1] === 13 ? bytes.subarray(0, -1) : bytes;
+  const text = withoutCarriageReturn.toString("utf-8");
+  if (text.trim() === "") return { valid: true };
+  let parsed;
+  try {
+    parsed = JSON.parse(text);
+  } catch {
+    return { valid: false, reason: "invalid-json" };
+  }
+  return CapturedLogSchema.safeParse(parsed).success ? { valid: true } : { valid: false, reason: "invalid-log-schema" };
+}
+async function scanFile(handle, size) {
+  const readBuffer = Buffer2.alloc(READ_CHUNK_BYTES);
+  let position = 0;
+  let pending = Buffer2.alloc(0);
+  let pendingOffset = 0;
+  let line = 1;
+  while (position < size) {
+    const length = Math.min(READ_CHUNK_BYTES, size - position);
+    let bytesRead;
+    try {
+      const result = await handle.read(readBuffer, 0, length, position);
+      bytesRead = result.bytesRead;
+    } catch (error51) {
+      return { status: "failed", reason: `read failed: ${String(error51)}` };
+    }
+    if (bytesRead === 0) {
+      return { status: "failed", reason: "captured-log file changed while being scanned" };
+    }
+    const chunk = readBuffer.subarray(0, bytesRead);
+    const combined = pending.length === 0 ? Buffer2.from(chunk) : Buffer2.concat([pending, chunk]);
+    let consumed = 0;
+    let newline = combined.indexOf(10, consumed);
+    while (newline !== -1) {
+      const record2 = combined.subarray(consumed, newline);
+      const validation = validateRecord(record2);
+      if (!validation.valid) {
+        return {
+          status: "interior-corruption",
+          line,
+          byteOffset: pendingOffset + consumed,
+          recordHash: hashBytes(record2),
+          reason: validation.reason
+        };
+      }
+      consumed = newline + 1;
+      line += 1;
+      newline = combined.indexOf(10, consumed);
+    }
+    pending = Buffer2.from(combined.subarray(consumed));
+    pendingOffset += consumed;
+    position += bytesRead;
+  }
+  return { status: "complete", pending, pendingOffset, nextLine: line };
+}
+async function syncDirectory(directory) {
+  let handle = null;
+  try {
+    handle = await open(directory, "r");
+    await handle.sync();
+  } catch {
+  } finally {
+    await handle?.close().catch(() => void 0);
+  }
+}
+async function removeTemporaryFile(filePath) {
+  await unlink(filePath).catch(() => void 0);
+}
+function readOwnProperty(value, name) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) return void 0;
+  return Object.getOwnPropertyDescriptor(value, name)?.value;
+}
+async function inspectExistingQuarantine(filePath, expected) {
+  if (!existsSync2(filePath)) return "missing";
+  try {
+    const parsed = JSON.parse(await readFile(filePath, "utf-8"));
+    return readOwnProperty(parsed, "schemaVersion") === expected.schemaVersion && readOwnProperty(parsed, "reason") === expected.reason && readOwnProperty(parsed, "sourceFile") === expected.sourceFile && readOwnProperty(parsed, "sourcePathHash") === expected.sourcePathHash && readOwnProperty(parsed, "tailOffset") === expected.tailOffset && readOwnProperty(parsed, "tailBytes") === expected.tailBytes && readOwnProperty(parsed, "tailSha256") === expected.tailSha256 && readOwnProperty(parsed, "tailBase64") === expected.tailBase64 ? "matching" : "conflicting";
+  } catch {
+    return "conflicting";
+  }
+}
+async function quarantineTail(context, sourceFile, tail, tailOffset) {
+  const quarantineDirectory = join3(context.root, QUARANTINE_DIRECTORY);
+  if (!ensurePrivateDirectorySync(quarantineDirectory)) return null;
+  const tailSha256 = hashBytes(tail);
+  const sourceFileName = basename(sourceFile);
+  const destination = join3(quarantineDirectory, `${sourceFileName}.tail-${tailSha256}.json`);
+  const temporary = join3(
+    quarantineDirectory,
+    `.${sourceFileName}.${String(process.pid)}.${randomUUID()}.tmp`
+  );
+  const record2 = {
+    schemaVersion: 1,
+    reason: "invalid-final-jsonl-record",
+    sourceFile: sourceFileName,
+    sourcePathHash: hashBytes(Buffer2.from(resolve2(sourceFile), "utf-8")),
+    recoveredAt: (/* @__PURE__ */ new Date()).toISOString(),
+    tailOffset,
+    tailBytes: tail.length,
+    tailSha256,
+    tailBase64: tail.toString("base64")
+  };
+  const existing = await inspectExistingQuarantine(destination, record2);
+  if (existing === "matching") {
+    return securePrivateFileSync(destination) ? destination : null;
+  }
+  if (existing === "conflicting") return null;
+  let handle = null;
+  try {
+    handle = await open(temporary, "wx", PRIVATE_FILE_MODE);
+    await handle.writeFile(`${JSON.stringify(record2)}
+`, "utf-8");
+    await handle.sync();
+    await handle.close();
+    handle = null;
+    if (!securePrivateFileSync(temporary)) {
+      await removeTemporaryFile(temporary);
+      return null;
+    }
+    await link(temporary, destination);
+    await unlink(temporary);
+    if (!securePrivateFileSync(destination)) return null;
+    await syncDirectory(quarantineDirectory);
+    return destination;
+  } catch {
+    await handle?.close().catch(() => void 0);
+    await removeTemporaryFile(temporary);
+    const racedExisting = await inspectExistingQuarantine(destination, record2);
+    return racedExisting === "matching" && securePrivateFileSync(destination) ? destination : null;
+  }
+}
+async function recoverFile(context, filePath) {
+  if (!existsSync2(filePath)) {
+    context.safeFiles.delete(filePath);
+    return {
+      status: "clean",
+      signature: { size: 0, modifiedAt: 0, changedAt: 0, device: 0, inode: 0 }
+    };
+  }
+  let fileStats;
+  try {
+    fileStats = await lstat(filePath);
+  } catch (error51) {
+    return { status: "failed", reason: `stat failed: ${String(error51)}` };
+  }
+  if (fileStats.isSymbolicLink() || !fileStats.isFile()) {
+    return { status: "failed", reason: "captured-log path is not a regular private file" };
+  }
+  const initialSignature = signatureFromStats(fileStats);
+  const safeSignature = context.safeFiles.get(filePath);
+  if (safeSignature !== void 0 && signaturesMatch(safeSignature, initialSignature)) {
+    return { status: "clean", signature: initialSignature };
+  }
+  let handle = null;
+  try {
+    handle = await open(filePath, constants2.O_RDWR | constants2.O_NOFOLLOW);
+    const openedStats = await handle.stat();
+    if (!openedStats.isFile()) {
+      return { status: "failed", reason: "captured-log handle is not a regular file" };
+    }
+    const openedSignature = signatureFromStats(openedStats);
+    if (!signaturesMatch(initialSignature, openedSignature)) {
+      return {
+        status: "failed",
+        reason: "captured-log path changed between metadata validation and open"
+      };
+    }
+    const scan = await scanFile(handle, openedStats.size);
+    const scannedSignature = signatureFromStats(await handle.stat());
+    if (!signaturesMatch(openedSignature, scannedSignature)) {
+      return {
+        status: "failed",
+        reason: "captured-log file changed while recovery was scanning it"
+      };
+    }
+    switch (scan.status) {
+      case "failed":
+        return scan;
+      case "interior-corruption":
+        return scan;
+      case "complete": {
+        if (scan.pending.length === 0) {
+          return { status: "clean", signature: signatureFromStats(await handle.stat()) };
+        }
+        const validation = validateRecord(scan.pending);
+        if (validation.valid) {
+          const write = await handle.write(Buffer2.from("\n", "utf-8"), 0, 1, openedStats.size);
+          if (write.bytesWritten !== 1) {
+            return { status: "failed", reason: "captured-log delimiter append was incomplete" };
+          }
+          await handle.sync();
+          return {
+            status: "delimiter-appended",
+            signature: signatureFromStats(await handle.stat())
+          };
+        }
+        const quarantinePath = await quarantineTail(
+          context,
+          filePath,
+          scan.pending,
+          scan.pendingOffset
+        );
+        if (quarantinePath === null) {
+          return { status: "failed", reason: "invalid tail could not be privately quarantined" };
+        }
+        const beforeTruncate = signatureFromStats(await handle.stat());
+        if (!signaturesMatch(openedSignature, beforeTruncate)) {
+          return {
+            status: "failed",
+            reason: "captured-log file changed before invalid-tail truncation"
+          };
+        }
+        await handle.truncate(scan.pendingOffset);
+        await handle.sync();
+        return {
+          status: "tail-quarantined",
+          signature: signatureFromStats(await handle.stat())
+        };
+      }
+    }
+    return { status: "failed", reason: "unsupported captured-log scan state" };
+  } catch (error51) {
+    return { status: "failed", reason: String(error51) };
+  } finally {
+    await handle?.close().catch(() => void 0);
+  }
+}
+function applyFileResult(context, filePath, result) {
+  const file2 = basename(filePath);
+  switch (result.status) {
+    case "clean":
+      context.safeFiles.set(filePath, result.signature);
+      return;
+    case "delimiter-appended":
+      context.safeFiles.set(filePath, result.signature);
+      context.health.delimiterRepairs += 1;
+      context.health.repairedFiles += 1;
+      return;
+    case "tail-quarantined":
+      context.safeFiles.set(filePath, result.signature);
+      context.health.quarantinedTails += 1;
+      context.health.repairedFiles += 1;
+      if (context.health.level !== "unavailable") {
+        context.health.level = "degraded";
+        context.health.diagnostic = `Recovered and quarantined an invalid JSONL tail in ${file2}`;
+      }
+      return;
+    case "interior-corruption":
+      context.safeFiles.delete(filePath);
+      context.health.level = "unavailable";
+      context.health.diagnostic = `JSONL corruption in ${file2} at line ${String(result.line)} (offset ${String(result.byteOffset)}, ${result.reason}, sha256 ${result.recordHash})`;
+      return;
+    case "failed":
+      context.safeFiles.delete(filePath);
+      context.health.level = "unavailable";
+      context.health.diagnostic = `JSONL recovery failed for ${file2}: ${result.reason}`;
+  }
+}
+async function runStartupRecovery(context) {
+  if (!ensurePrivateDirectorySync(context.root)) {
+    context.health.level = "unavailable";
+    context.health.diagnostic = "Captured-log directory could not be made private";
+    return copyHealth(context.health);
+  }
+  let entries;
+  try {
+    entries = await readdir(context.root);
+  } catch (error51) {
+    context.health.level = "unavailable";
+    context.health.diagnostic = `Captured-log directory could not be listed: ${String(error51)}`;
+    return copyHealth(context.health);
+  }
+  const files = entries.filter((entry) => entry.endsWith(".jsonl")).sort();
+  for (const file2 of files) {
+    const filePath = join3(context.root, file2);
+    const result = await recoverFile(context, filePath);
+    applyFileResult(context, filePath, result);
+    if (context.health.level === "unavailable") break;
+  }
+  return copyHealth(context.health);
+}
+async function recoverCapturedLogStorage(logDir) {
+  const context = contextFor(logDir);
+  if (context.startup === null) {
+    context.startup = runStartupRecovery(context).then((health) => {
+      context.startupComplete = true;
+      return health;
+    });
+  }
+  return await context.startup;
+}
+function canAppendCapturedLogFileOnExit(logDir, filePath) {
+  const context = contextFor(logDir);
+  if (!context.startupComplete || context.health.level === "unavailable") return false;
+  const trusted = context.safeFiles.get(filePath);
+  if (trusted === void 0) return false;
+  try {
+    const observed = lstatSync2(filePath);
+    if (observed === void 0 || observed.isSymbolicLink() || !observed.isFile()) return false;
+    return signaturesMatch(trusted, signatureFromStats(observed));
+  } catch {
+    return false;
+  }
+}
+
+// src/proxy/logger.ts
+var DAY_MS = 24 * 60 * 60 * 1e3;
+var DEFAULT_RETENTION_DAYS = 7;
+var DEFAULT_APP_LOG_MAX_BYTES = 10 * 1024 * 1024;
+var DEFAULT_APP_LOG_MAX_FILES = 5;
+function writeStderrFallback(message, error51) {
+  process.stderr.write(`${message} ${String(error51)}
+`);
+}
+function resolveLogDir() {
+  const logDirEnv = process.env["LOG_DIR"];
+  if (logDirEnv !== void 0 && logDirEnv !== "") {
+    return path.isAbsolute(logDirEnv) ? logDirEnv : path.join(getDataDir(), logDirEnv);
+  }
+  return path.join(getDataDir(), "logs");
+}
+function getLogFilePath() {
+  const date5 = /* @__PURE__ */ new Date();
+  const yyyy = date5.getUTCFullYear();
+  const mm = String(date5.getUTCMonth() + 1).padStart(2, "0");
+  const dd = String(date5.getUTCDate()).padStart(2, "0");
+  return path.join(resolveLogDir(), `${yyyy}-${mm}-${dd}.jsonl`);
+}
+function getInspectorLogPath() {
+  const logFileEnv = process.env["AGENT_INSPECTOR_LOG_FILE"];
+  if (logFileEnv !== void 0 && logFileEnv !== "") {
+    return logFileEnv;
+  }
+  return path.join(getDataDir(), "logs", "inspector.log");
+}
+function readBoundedInteger(name, fallback, minimum, maximum) {
+  const raw = process.env[name];
+  if (raw === void 0 || raw === "") return fallback;
+  const parsed = Number(raw);
+  if (!Number.isInteger(parsed) || parsed < minimum || parsed > maximum) return fallback;
+  return parsed;
+}
+function getApplicationLogPolicy() {
+  const retentionDays = readBoundedInteger("LOG_RETENTION_DAYS", DEFAULT_RETENTION_DAYS, 1, 3650);
+  return {
+    maxBytes: readBoundedInteger(
+      "AGENT_INSPECTOR_APP_LOG_MAX_BYTES",
+      DEFAULT_APP_LOG_MAX_BYTES,
+      1,
+      1024 * 1024 * 1024
+    ),
+    maxFiles: readBoundedInteger(
+      "AGENT_INSPECTOR_APP_LOG_MAX_FILES",
+      DEFAULT_APP_LOG_MAX_FILES,
+      1,
+      100
+    ),
+    retentionMs: retentionDays * DAY_MS
+  };
+}
+function getRotatedGeneration(entry, baseName) {
+  const prefix = `${baseName}.`;
+  if (!entry.startsWith(prefix)) return null;
+  const suffix = entry.slice(prefix.length);
+  if (!/^\d+$/.test(suffix)) return null;
+  const generation = Number(suffix);
+  if (!Number.isSafeInteger(generation) || generation < 1) return null;
+  return generation;
+}
+async function listApplicationLogFiles(logPath) {
+  const directory = path.dirname(logPath);
+  const baseName = path.basename(logPath);
+  const entries = await readdir2(directory);
+  const files = [];
+  for (const entry of entries) {
+    const generation = entry === baseName ? 0 : getRotatedGeneration(entry, baseName);
+    if (generation === null) continue;
+    const filePath = path.join(directory, entry);
+    try {
+      const fileStat = await stat2(filePath);
+      if (!fileStat.isFile()) continue;
+      files.push({ generation, modifiedAt: fileStat.mtimeMs, path: filePath });
+    } catch {
+    }
+  }
+  return files;
+}
+async function removeApplicationLog(filePath) {
+  try {
+    await stat2(filePath);
   } catch {
-    return null;
+    return true;
+  }
+  try {
+    await unlink2(filePath);
+    return true;
+  } catch {
+    return false;
   }
 }
-function parseOpenAIResponsesResponse(rawBody) {
+async function maintainApplicationLogs(logPath, policy) {
+  const directory = path.dirname(logPath);
+  if (!ensurePrivateDirectorySync(directory)) return false;
+  let files;
   try {
-    const json2 = JSON.parse(rawBody);
-    const result = OpenAIResponsesResponseSchema.safeParse(json2);
-    if (result.success) return result.data;
-    return null;
+    files = await listApplicationLogFiles(logPath);
   } catch {
-    return null;
+    return false;
+  }
+  for (const file2 of files) {
+    if (!securePrivateFileSync(file2.path)) return false;
+  }
+  const cutoff = Date.now() - policy.retentionMs;
+  const retained = files.filter((file2) => file2.modifiedAt >= cutoff);
+  let maintained = true;
+  for (const file2 of files) {
+    if (file2.modifiedAt < cutoff && !await removeApplicationLog(file2.path)) maintained = false;
+  }
+  const rotated = retained.filter((file2) => file2.generation > 0).sort((left, right) => right.modifiedAt - left.modifiedAt);
+  const retainedRotatedCount = Math.max(0, policy.maxFiles - 1);
+  for (const file2 of rotated.slice(retainedRotatedCount)) {
+    if (!await removeApplicationLog(file2.path)) maintained = false;
   }
+  return maintained;
 }
-
-// src/proxy/schemas.ts
-var RequestModelSchema = external_exports.object({
-  model: external_exports.string()
-});
-var LooseRequestSchema = external_exports.object({
-  model: external_exports.string().optional(),
-  metadata: external_exports.object({ user_id: external_exports.string().optional() }).passthrough().optional()
+async function moveApplicationLog(source, destination) {
+  try {
+    await stat2(source);
+  } catch {
+    return true;
+  }
+  try {
+    await rename(source, destination);
+    if (!securePrivateFileSync(destination)) {
+      writeStderrFallback("[logger] Failed to secure rotated application log:", destination);
+      return false;
+    }
+    return true;
+  } catch (error51) {
+    writeStderrFallback("[logger] Failed to rotate application log:", error51);
+    return false;
+  }
+}
+async function rotateApplicationLog(logPath, maxFiles) {
+  if (maxFiles === 1) {
+    return await removeApplicationLog(logPath);
+  }
+  if (!await removeApplicationLog(`${logPath}.${String(maxFiles - 1)}`)) return false;
+  for (let generation = maxFiles - 2; generation >= 1; generation -= 1) {
+    if (!await moveApplicationLog(
+      `${logPath}.${String(generation)}`,
+      `${logPath}.${String(generation + 1)}`
+    )) {
+      return false;
+    }
+  }
+  return await moveApplicationLog(logPath, `${logPath}.1`);
+}
+async function rotateApplicationLogIfNeeded(logPath, incomingBytes, policy) {
+  try {
+    const fileStat = await stat2(logPath);
+    if (fileStat.size > 0 && fileStat.size + incomingBytes > policy.maxBytes) {
+      return await rotateApplicationLog(logPath, policy.maxFiles);
+    }
+    return true;
+  } catch {
+    return true;
+  }
+}
+async function initLogger() {
+  const dir = resolveLogDir();
+  const policy = getApplicationLogPolicy();
+  const cutoff = Date.now() - policy.retentionMs;
+  try {
+    if (!ensurePrivateDirectorySync(dir)) {
+      writeStderrFallback("[logger] Failed to secure log directory:", dir);
+    } else if (!securePrivateTreeSync(dir)) {
+      writeStderrFallback("[logger] Failed to secure existing log files:", dir);
+    } else {
+      const recovery = await recoverCapturedLogStorage(dir);
+      if (recovery.level === "unavailable") {
+        writeStderrFallback(
+          "[logger] Captured-log recovery blocked readiness:",
+          recovery.diagnostic ?? "unknown recovery failure"
+        );
+      } else {
+        const entries = await readdir2(dir);
+        for (const entry of entries) {
+          if (!entry.endsWith(".jsonl")) continue;
+          const fullPath = path.join(dir, entry);
+          try {
+            const s = await stat2(fullPath);
+            if (s.mtimeMs < cutoff) {
+              await unlink2(fullPath);
+            }
+          } catch {
+          }
+        }
+      }
+    }
+  } catch (err) {
+    writeStderrFallback("[logger] Failed to initialize log directory:", err);
+  }
+  const applicationLogPath = getInspectorLogPath();
+  if (!await maintainApplicationLogs(applicationLogPath, policy)) {
+    writeStderrFallback(
+      "[logger] Failed to initialize application log lifecycle:",
+      applicationLogPath
+    );
+  }
+}
+var loggerInitialization = null;
+var applicationLogWriteQueue = Promise.resolve();
+function ensureLoggerInitialized() {
+  if (loggerInitialization === null) loggerInitialization = initLogger();
+  return loggerInitialization;
+}
+async function appendApplicationLogLine(logPath, line, policy) {
+  const logDirPath = path.dirname(logPath);
+  if (!ensurePrivateDirectorySync(logDirPath)) {
+    return { ok: false, reason: "application log directory is not private" };
+  }
+  try {
+    if (!await rotateApplicationLogIfNeeded(logPath, Buffer3.byteLength(line, "utf-8"), policy)) {
+      return { ok: false, reason: "application log rotation failed" };
+    }
+    await appendFile(logPath, line, { encoding: "utf-8", mode: PRIVATE_FILE_MODE });
+    if (!securePrivateFileSync(logPath)) {
+      return { ok: false, reason: "application log permissions could not be secured" };
+    }
+    return { ok: true };
+  } catch (error51) {
+    return { ok: false, reason: error51 };
+  }
+}
+async function writeAppLog(message) {
+  const logPath = getInspectorLogPath();
+  const line = `[${(/* @__PURE__ */ new Date()).toISOString()}] ${message}
+`;
+  const initialization = ensureLoggerInitialized();
+  const write = async () => {
+    await initialization;
+    const result = await appendApplicationLogLine(logPath, line, getApplicationLogPolicy());
+    if (!result.ok) writeStderrFallback(`[logger] Failed to write to ${logPath}:`, result.reason);
+  };
+  applicationLogWriteQueue = applicationLogWriteQueue.then(write, write);
+  await applicationLogWriteQueue;
+}
+var logger = {
+  debug(message, ...args) {
+    const msg = args.length > 0 ? `${message} ${args.map(String).join(" ")}` : message;
+    void writeAppLog(`[DEBUG] ${msg}`);
+  },
+  info(message, ...args) {
+    const msg = args.length > 0 ? `${message} ${args.map(String).join(" ")}` : message;
+    void writeAppLog(`[INFO] ${msg}`);
+  },
+  warn(message, ...args) {
+    const msg = args.length > 0 ? `${message} ${args.map(String).join(" ")}` : message;
+    void writeAppLog(`[WARN] ${msg}`);
+  },
+  error(message, ...args) {
+    const msg = args.length > 0 ? `${message} ${args.map(String).join(" ")}` : message;
+    void writeAppLog(`[ERROR] ${msg}`);
+  }
+};
+var writeBuffer = [];
+var writeQueue = Promise.resolve();
+var logWriteLock = Promise.resolve();
+function drainBuffer() {
+  const toWrite = writeBuffer.join("");
+  writeBuffer = [];
+  return toWrite;
+}
+process.on("exit", () => {
+  if (writeBuffer.length > 0) {
+    const toWrite = drainBuffer();
+    try {
+      const filePath = getLogFilePath();
+      if (!ensurePrivateDirectorySync(path.dirname(filePath))) return;
+      if (!canAppendCapturedLogFileOnExit(resolveLogDir(), filePath)) return;
+      const descriptor = openSync2(
+        filePath,
+        constants3.O_WRONLY | constants3.O_APPEND | constants3.O_NOFOLLOW,
+        PRIVATE_FILE_MODE
+      );
+      try {
+        const payload = Buffer3.from(toWrite, "utf-8");
+        let written = 0;
+        while (written < payload.length) {
+          const writeCount = writeSync(descriptor, payload, written, payload.length - written);
+          if (writeCount === 0) return;
+          written += writeCount;
+        }
+        fsyncSync(descriptor);
+      } finally {
+        closeSync2(descriptor);
+      }
+      void securePrivateFileSync(filePath);
+    } catch {
+    }
+  }
 });
 
 // src/proxy/chunkStorage.ts
@@ -15501,15 +16062,15 @@ var StreamingChunksDataSchema = external_exports.object({
 function getChunksDir() {
   const chunksDirEnv = process.env["CHUNKS_DIR"];
   if (chunksDirEnv !== void 0 && chunksDirEnv !== "") {
-    return isAbsolute2(chunksDirEnv) ? chunksDirEnv : join3(getDataDir(), chunksDirEnv);
+    return isAbsolute2(chunksDirEnv) ? chunksDirEnv : join4(getDataDir(), chunksDirEnv);
   }
-  return join3(getDataDir(), "chunks");
+  return join4(getDataDir(), "chunks");
 }
 function getChunkFilePath(logId) {
-  return join3(getChunksDir(), `${logId}.json`);
+  return join4(getChunksDir(), `${logId}.json`);
 }
 function getTempFilePath(logId) {
-  return join3(getChunksDir(), `.${logId}.tmp`);
+  return join4(getChunksDir(), `.${logId}.tmp`);
 }
 function writeChunks(logId, chunks, truncated) {
   const dir = getChunksDir();
@@ -15535,7 +16096,7 @@ function writeChunks(logId, chunks, truncated) {
     return targetPath;
   }
   try {
-    renameSync(tempPath, targetPath);
+    renameSync2(tempPath, targetPath);
   } catch (err) {
     logger.warn("[chunkStorage] Rename failed, falling back to copy+delete:", String(err));
     try {
@@ -15551,14 +16112,14 @@ function writeChunks(logId, chunks, truncated) {
   return targetPath;
 }
 
-// src/proxy/constants.ts
-var PROXY_IDENTITY = process.env["PROXY_IDENTITY"] ?? "inspector9527@Tony";
-var PATH_V1_CHAT_COMPLETIONS = "/v1/chat/completions";
-var PATH_CHAT_COMPLETIONS = "/chat/completions";
-var PATH_V1_RESPONSES = "/v1/responses";
-var PATH_RESPONSES = "/responses";
-var PATH_V1_MESSAGES = "/v1/messages";
-var MAX_REQUEST_BODY_BYTES = 50 * 1024 * 1024;
+// src/lib/apiFormat.ts
+var API_FORMAT_PATH_ENTRIES = [
+  ["/v1/messages", "anthropic"],
+  ["/v1/chat/completions", "openai"],
+  ["/chat/completions", "openai"],
+  ["/v1/responses", "openai"],
+  ["/responses", "openai"]
+];
 
 // src/proxy/formats/registry.ts
 var FormatRegistryImpl = class {
@@ -15598,11 +16159,9 @@ var formatRegistry = new FormatRegistryImpl();
 function formatForPath(path2) {
   return formatRegistry.getByPath(path2) ?? null;
 }
-formatRegistry.registerPath(PATH_V1_MESSAGES, "anthropic");
-formatRegistry.registerPath(PATH_V1_CHAT_COMPLETIONS, "openai");
-formatRegistry.registerPath(PATH_CHAT_COMPLETIONS, "openai");
-formatRegistry.registerPath(PATH_V1_RESPONSES, "openai");
-formatRegistry.registerPath(PATH_RESPONSES, "openai");
+for (const [path2, format] of API_FORMAT_PATH_ENTRIES) {
+  formatRegistry.registerPath(path2, format);
+}
 
 // src/proxy/formats/anthropic/stream.ts
 function parseInputJson(json2) {
@@ -16558,12 +17117,12 @@ registry2.register(alibabaProvider);
 // src/proxy/sessionProcess.ts
 import { existsSync as existsSync4 } from "node:fs";
 import { fileURLToPath } from "node:url";
-import { join as join4 } from "node:path";
+import { join as join5 } from "node:path";
 var IDLE_TIMEOUT_MS = Number(process.env["SESSION_PROCESS_IDLE_MS"]) || 5 * 60 * 1e3;
 function resolveSessionWorkerPath() {
   const workerDir = process.env["AGENT_INSPECTOR_WORKER_DIR"];
   if (workerDir !== void 0 && workerDir.trim().length > 0) {
-    const builtWorkerPath = join4(workerDir, "sessionWorkerEntry.js");
+    const builtWorkerPath = join5(workerDir, "sessionWorkerEntry.js");
     if (existsSync4(builtWorkerPath)) return builtWorkerPath;
   }
   return fileURLToPath(new URL("./sessionWorkerEntry.ts", import.meta.url));
@@ -16573,6 +17132,7 @@ function isSessionProcessAvailable() {
 }
 
 // src/proxy/logIndex.ts
+var INDEX_READ_CHUNK_BYTES = 64 * 1024;
 var idGenerationChain = Promise.resolve();
 
 // src/lib/publicBasePathContext.ts
@@ -16693,14 +17253,14 @@ function cleanupPathForRawStream(rawStream) {
 }
 function rawStreamByteLength(rawStream) {
   if (typeof rawStream === "string") {
-    return Buffer3.byteLength(rawStream, "utf8");
+    return Buffer4.byteLength(rawStream, "utf8");
   }
   switch (rawStream.type) {
     case "memory":
-      return Buffer3.byteLength(rawStream.rawStream, "utf8");
+      return Buffer4.byteLength(rawStream.rawStream, "utf8");
     case "file":
       try {
-        return statSync2(rawStream.path).size;
+        return statSync(rawStream.path).size;
       } catch {
         return null;
       }
@@ -16859,8 +17419,13 @@ function buildFinalizeLogResult(job) {
   switch (job.type) {
     case "non-streaming":
       return finalizeNonStreaming(job, log);
-    case "streaming":
-      return finalizeStreaming(job, log);
+    case "streaming": {
+      const result = finalizeStreaming(job, log);
+      if (job.terminalError !== void 0 && job.terminalError !== null) {
+        result.log.error = job.terminalError;
+      }
+      return result;
+    }
     case "stream-abort":
       return finalizeStreamAbort(job, log);
     default: {
@@ -16888,7 +17453,7 @@ var WORKER_COUNT = Math.max(1, Number(process.env["FINALIZER_WORKER_COUNT"]) ||
 function resolveLogFinalizerWorkerUrl() {
   const workerDir = process.env["AGENT_INSPECTOR_WORKER_DIR"];
   if (workerDir !== void 0 && workerDir.trim().length > 0) {
-    const builtWorkerPath = join5(workerDir, "logFinalizer.worker.js");
+    const builtWorkerPath = join6(workerDir, "logFinalizer.worker.js");
     if (existsSync5(builtWorkerPath)) return pathToFileURL(builtWorkerPath);
   }
   return new URL("./logFinalizer.worker.ts", import.meta.url);