@tonyclaw/agent-inspector 3.0.26 → 3.0.27

package/.output/server/_ssr/{router-CZe_R31M.mjs → router-Dgx6-ot3.mjs}

@@ -1,17 +1,19 @@
 import { c as createRouter, a as createRootRoute, b as createFileRoute, l as lazyRouteComponent, O as Outlet, H as HeadContent, S as Scripts } from "../_libs/tanstack__react-router.mjs";
 import { r as reactExports, j as jsxRuntimeExports } from "../_libs/react.mjs";
 import { S as SWRConfig } from "../_libs/swr.mjs";
-import { existsSync, readFileSync, mkdirSync, writeFileSync, renameSync, copyFileSync, unlinkSync, createReadStream, readdirSync, statSync, rmSync, cpSync, createWriteStream } from "node:fs";
+import { existsSync, readFileSync, mkdirSync, writeFileSync, renameSync, copyFileSync, unlinkSync, createReadStream, readdirSync, statSync, rmSync, cpSync, chmodSync, createWriteStream } from "node:fs";
 import fs, { mkdir, appendFile, writeFile, readdir, open, readFile, stat, unlink, rm, rename } from "node:fs/promises";
 import { createInterface } from "node:readline";
 import { Buffer } from "node:buffer";
 import path, { basename, join, dirname, isAbsolute, resolve, relative } from "node:path";
-import { randomUUID, createHash } from "node:crypto";
+import { randomUUID, timingSafeEqual, createHash, createDecipheriv, randomBytes, createCipheriv } from "node:crypto";
 import { spawn, execFile } from "node:child_process";
 import { fileURLToPath } from "node:url";
 import { C as Conf } from "../_libs/conf.mjs";
 import { randomUUID as randomUUID$1 } from "crypto";
 import { promisify } from "node:util";
+import { lookup } from "node:dns/promises";
+import { isIP } from "node:net";
 import { Worker } from "node:worker_threads";
 import { M as McpServer, W as WebStandardStreamableHTTPServerTransport, R as ResourceTemplate } from "../_libs/modelcontextprotocol__server.mjs";
 import { J as JSZip } from "../_libs/jszip.mjs";
@@ -370,7 +372,7 @@ function RootDocument({ children }) {
     ] })
   ] });
 }
-const $$splitComponentImporter$1 = () => import("./index-CzxhDjlq.mjs");
+const $$splitComponentImporter$1 = () => import("./index-DuSWrjbH.mjs");
 const Route$L = createFileRoute("/")({
   ssr: false,
   component: lazyRouteComponent($$splitComponentImporter$1, "component")
@@ -414,7 +416,7 @@ function decodeSessionIdFromPath(encoded) {
 function getSessionPath(sessionId) {
   return `/session/${encodeSessionIdForPath(sessionId)}`;
 }
-const $$splitComponentImporter = () => import("../_sessionId-BQ6YQOO1.mjs");
+const $$splitComponentImporter = () => import("../_sessionId-eA_h2_s6.mjs");
 const Route$K = createFileRoute("/session/$sessionId")({
   ssr: false,
   component: lazyRouteComponent($$splitComponentImporter, "component"),
@@ -1192,6 +1194,18 @@ function readChunks(path2) {
     return null;
   }
 }
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function readProperty$5(value, name2) {
+  if (!isRecord(value)) return void 0;
+  const descriptor = Object.getOwnPropertyDescriptor(value, name2);
+  return descriptor === void 0 ? void 0 : descriptor.value;
+}
+function textByteLength(value) {
+  if (value === null) return null;
+  return new TextEncoder().encode(value).byteLength;
+}
 const SQLITE_INDEX_FILE = "inspector.sqlite";
 const SQLITE_PACKAGE_NAME$1 = "better-sqlite3";
 const BUN_SQLITE_MODULE_NAME$1 = "bun:sqlite";
@@ -1328,7 +1342,7 @@ function objectFromUnknown$1(value) {
   if (typeof value === "object" || typeof value === "function") return value;
   return null;
 }
-function readProperty$5(value, name2) {
+function readProperty$4(value, name2) {
   let current = objectFromUnknown$1(value);
   while (current !== null) {
     const desc = Object.getOwnPropertyDescriptor(current, name2);
@@ -1342,7 +1356,7 @@ function readProperty$5(value, name2) {
   return void 0;
 }
 function readFunction$1(value, name2) {
-  const property = readProperty$5(value, name2);
+  const property = readProperty$4(value, name2);
   return typeof property === "function" ? property : null;
 }
 function callMethod$1(target, methodName, args) {
@@ -1384,7 +1398,7 @@ function execSql$1(db, sql) {
   return result !== void 0;
 }
 function sqliteConstructorFromModule$1(moduleValue, exportName) {
-  const exportedValue = readProperty$5(moduleValue, exportName);
+  const exportedValue = readProperty$4(moduleValue, exportName);
   if (typeof exportedValue === "function") {
     return (path2) => Reflect.construct(exportedValue, [path2]);
   }
@@ -1527,11 +1541,11 @@ function entryParams(entry) {
   ];
 }
 function readNumber$1(row, name2) {
-  const value = readProperty$5(row, name2);
+  const value = readProperty$4(row, name2);
   return typeof value === "number" && Number.isFinite(value) ? value : null;
 }
 function readString$2(row, name2) {
-  const value = readProperty$5(row, name2);
+  const value = readProperty$4(row, name2);
   return typeof value === "string" ? value : null;
 }
 function readBoolean(row, name2) {
@@ -1716,9 +1730,6 @@ function getIndexPath() {
 }
 let cachedIndex = null;
 let sqliteBackfillScheduledMaxId = 0;
-function textByteLength$2(value) {
-  return value === null ? null : Buffer.byteLength(value, "utf8");
-}
 function createLogIndexEntryMetadata(log) {
   return {
     sessionId: log.sessionId,
@@ -1751,8 +1762,8 @@ function createLogIndexEntryMetadata(log) {
       clientCwd: log.clientCwd ?? null,
       clientProjectFolder: log.clientProjectFolder ?? null,
       streamingChunksPath: log.streamingChunksPath ?? null,
-      rawRequestBodyBytes: log.rawRequestBodyBytes ?? textByteLength$2(log.rawRequestBody),
-      responseTextBytes: log.responseTextBytes ?? textByteLength$2(log.responseText),
+      rawRequestBodyBytes: log.rawRequestBodyBytes ?? textByteLength(log.rawRequestBody),
+      responseTextBytes: log.responseTextBytes ?? textByteLength(log.responseText),
       warnings: log.warnings,
       error: log.error ?? null
     }
@@ -1932,7 +1943,7 @@ function readStringArrayField(entry, field) {
 function readTextByteLength(entry, bytesField, textField) {
   const explicitBytes = readNumberOrNullField(entry, bytesField);
   if (explicitBytes !== null && explicitBytes >= 0) return explicitBytes;
-  return textByteLength$2(readStringOrNullField(entry, textField));
+  return textByteLength(readStringOrNullField(entry, textField));
 }
 function readLogIndexSummary(entry, id) {
   return {
@@ -2284,9 +2295,18 @@ const HEADER_CONTENT_ENCODING = "content-encoding";
 const HEADER_CONTENT_LENGTH = "content-length";
 const HEADER_HOST = "host";
 const AUTH_HEADER_X_API_KEY = "x-api-key";
+const SENSITIVE_HEADERS = /* @__PURE__ */ new Set([
+  HEADER_AUTHORIZATION,
+  HEADER_X_API_KEY,
+  "cookie",
+  "set-cookie",
+  "proxy-authorization"
+]);
 const CONTENT_TYPE_EVENT_STREAM = "text/event-stream";
 const STATUS_FORBIDDEN = 403;
 const STATUS_BAD_GATEWAY = 502;
+const STATUS_PAYLOAD_TOO_LARGE = 413;
+const MAX_REQUEST_BODY_BYTES = 50 * 1024 * 1024;
 const PRESERVE_HEADERS = /* @__PURE__ */ new Set([HEADER_CONTENT_TYPE]);
 class FormatRegistryImpl {
   handlers = /* @__PURE__ */ new Map();
@@ -2383,7 +2403,7 @@ function objectFromUnknown(value) {
   if (typeof value === "object" || typeof value === "function") return value;
   return null;
 }
-function readProperty$4(value, name2) {
+function readProperty$3(value, name2) {
   let current = objectFromUnknown(value);
   while (current !== null) {
     const desc = Object.getOwnPropertyDescriptor(current, name2);
@@ -2397,7 +2417,7 @@ function readProperty$4(value, name2) {
   return void 0;
 }
 function readFunction(value, name2) {
-  const property = readProperty$4(value, name2);
+  const property = readProperty$3(value, name2);
   return typeof property === "function" ? property : null;
 }
 function callMethod(target, methodName, args) {
@@ -2435,7 +2455,7 @@ function closeDatabase(db) {
   callMethod(db, "close", []);
 }
 function sqliteConstructorFromModule(moduleValue, exportName) {
-  const exportedValue = readProperty$4(moduleValue, exportName);
+  const exportedValue = readProperty$3(moduleValue, exportName);
   if (typeof exportedValue === "function") {
     return (path2) => Reflect.construct(exportedValue, [path2]);
   }
@@ -2526,11 +2546,11 @@ async function archiveSessionLog(log) {
   }
 }
 function readString$1(row, name2) {
-  const value = readProperty$4(row, name2);
+  const value = readProperty$3(row, name2);
   return typeof value === "string" ? value : null;
 }
 function readNumber(row, name2) {
-  const value = readProperty$4(row, name2);
+  const value = readProperty$3(row, name2);
   return typeof value === "number" && Number.isFinite(value) ? value : null;
 }
 function logFromJson(value) {
@@ -3110,10 +3130,6 @@ function removeFromCache(id) {
   memoryCache.delete(id);
   removeLogsFromCursorPageIndexes(/* @__PURE__ */ new Set([id]));
 }
-function textByteLength$1(value) {
-  if (value === null) return null;
-  return Buffer.byteLength(value, "utf8");
-}
 function compactLogForList(log) {
   return {
     ...log,
@@ -3122,8 +3138,8 @@ function compactLogForList(log) {
     rawHeaders: void 0,
     headers: void 0,
     streamingChunks: void 0,
-    rawRequestBodyBytes: log.rawRequestBodyBytes ?? textByteLength$1(log.rawRequestBody),
-    responseTextBytes: log.responseTextBytes ?? textByteLength$1(log.responseText),
+    rawRequestBodyBytes: log.rawRequestBodyBytes ?? textByteLength(log.rawRequestBody),
+    responseTextBytes: log.responseTextBytes ?? textByteLength(log.responseText),
     bodyContentMode: "compact"
   };
 }
@@ -4275,7 +4291,7 @@ const AnthropicFormatHandler = {
       if (result.success) {
         return {
           model: result.data.model,
-          sessionId: result.data.metadata?.user_id ?? headers?.get("x-session-affinity") ?? null
+          sessionId: result.data.metadata?.user_id ?? headers?.get("x-agent-inspector-session-id") ?? headers?.get("x-session-affinity") ?? null
         };
       }
       return null;
@@ -4390,24 +4406,24 @@ const anthropicProvider = {
 };
 registry.register(anthropicProvider);
 const MAX_CHUNKS = 1e3;
-function readProperty$3(value, key) {
+function readProperty$2(value, key) {
   if (value === null || typeof value !== "object" || Array.isArray(value)) return void 0;
   return Object.getOwnPropertyDescriptor(value, key)?.value;
 }
 function readStringProperty$2(value, key) {
-  const property = readProperty$3(value, key);
+  const property = readProperty$2(value, key);
   return typeof property === "string" ? property : null;
 }
 function readNumberProperty(value, key) {
-  const property = readProperty$3(value, key);
+  const property = readProperty$2(value, key);
   return typeof property === "number" && Number.isFinite(property) ? property : null;
 }
 function readObjectProperty(value, key) {
-  const property = readProperty$3(value, key);
+  const property = readProperty$2(value, key);
   return property !== null && typeof property === "object" && !Array.isArray(property) ? property : null;
 }
 function readArrayProperty$1(value, key) {
-  const property = readProperty$3(value, key);
+  const property = readProperty$2(value, key);
   return Array.isArray(property) ? property : [];
 }
 function parseSseEvents(raw) {
@@ -4599,7 +4615,7 @@ function extractChatCompletionsStream(events, log, fallbackModel, collectChunks)
 }
 function parseResponsesResponse(value) {
   const fromResponseProperty = OpenAIResponsesResponseSchema.safeParse(
-    readProperty$3(value, "response")
+    readProperty$2(value, "response")
   );
   if (fromResponseProperty.success) return fromResponseProperty.data;
   const direct = OpenAIResponsesResponseSchema.safeParse(value);
@@ -5416,6 +5432,146 @@ function withBuiltinProviderModelMetadata(provider, updatedAt) {
     modelMetadata: result.modelMetadata
   };
 }
+const SECRET_REFERENCE_PREFIX = "secret:provider:";
+const SECRET_FILE_VERSION = 1;
+const KEY_BYTES = 32;
+const IV_BYTES = 12;
+const AUTH_TAG_BYTES = 16;
+const SecretFileSchema = object({
+  version: literal(SECRET_FILE_VERSION),
+  secrets: record(string(), string())
+});
+function emptySecretFile() {
+  return { version: SECRET_FILE_VERSION, secrets: {} };
+}
+function readSecretFile(path2) {
+  if (!existsSync(path2)) return emptySecretFile();
+  try {
+    const parsed = JSON.parse(readFileSync(path2, "utf8"));
+    const result = SecretFileSchema.safeParse(parsed);
+    if (result.success) return result.data;
+    logger.warn(`[provider-secrets] Ignoring invalid secret file ${path2}`);
+  } catch (error) {
+    logger.warn(`[provider-secrets] Could not read ${path2}: ${String(error)}`);
+  }
+  return emptySecretFile();
+}
+function writePrivateFile(path2, content) {
+  const temporaryPath = `${path2}.${String(process.pid)}.tmp`;
+  try {
+    writeFileSync(temporaryPath, content, { encoding: "utf8", mode: 384 });
+    chmodSync(temporaryPath, 384);
+    renameSync(temporaryPath, path2);
+    chmodSync(path2, 384);
+    return true;
+  } catch (error) {
+    rmSync(temporaryPath, { force: true });
+    logger.error(`[provider-secrets] Could not write ${path2}: ${String(error)}`);
+    return false;
+  }
+}
+function readKey(path2) {
+  try {
+    if (!existsSync(path2)) return null;
+    const key = Buffer.from(readFileSync(path2, "utf8").trim(), "base64");
+    if (key.byteLength === KEY_BYTES) return key;
+    logger.error(`[provider-secrets] Invalid encryption key at ${path2}`);
+    return null;
+  } catch (error) {
+    logger.error(`[provider-secrets] Could not read encryption key: ${String(error)}`);
+    return null;
+  }
+}
+function readOrCreateKey(keyPath, secretsPath) {
+  const existingKey = readKey(keyPath);
+  if (existingKey !== null) return existingKey;
+  if (existsSync(keyPath)) return null;
+  if (existsSync(secretsPath)) {
+    logger.error(
+      `[provider-secrets] Refusing to replace missing key while encrypted secrets exist at ${secretsPath}`
+    );
+    return null;
+  }
+  const key = randomBytes(KEY_BYTES);
+  if (!writePrivateFile(keyPath, key.toString("base64"))) return null;
+  return key;
+}
+function encrypt(secret, key) {
+  try {
+    const iv = randomBytes(IV_BYTES);
+    const cipher = createCipheriv("aes-256-gcm", key, iv);
+    const ciphertext = Buffer.concat([cipher.update(secret, "utf8"), cipher.final()]);
+    const tag = cipher.getAuthTag();
+    return Buffer.concat([iv, tag, ciphertext]).toString("base64");
+  } catch (error) {
+    logger.error(`[provider-secrets] Encryption failed: ${String(error)}`);
+    return null;
+  }
+}
+function decrypt(payload, key) {
+  try {
+    const packed = Buffer.from(payload, "base64");
+    if (packed.byteLength <= IV_BYTES + AUTH_TAG_BYTES) return null;
+    const iv = packed.subarray(0, IV_BYTES);
+    const tag = packed.subarray(IV_BYTES, IV_BYTES + AUTH_TAG_BYTES);
+    const ciphertext = packed.subarray(IV_BYTES + AUTH_TAG_BYTES);
+    const decipher = createDecipheriv("aes-256-gcm", key, iv);
+    decipher.setAuthTag(tag);
+    return Buffer.concat([decipher.update(ciphertext), decipher.final()]).toString("utf8");
+  } catch {
+    return null;
+  }
+}
+function providerIdFromReference(reference) {
+  if (!reference.startsWith(SECRET_REFERENCE_PREFIX)) return null;
+  const providerId = reference.slice(SECRET_REFERENCE_PREFIX.length);
+  return providerId === "" ? null : providerId;
+}
+function createProviderSecretStore(directory) {
+  mkdirSync(directory, { recursive: true });
+  const keyPath = join(directory, "provider-secrets.key");
+  const secretsPath = join(directory, "provider-secrets.json");
+  function writeSecrets(data) {
+    return writePrivateFile(secretsPath, JSON.stringify(data, null, 2));
+  }
+  return {
+    isReference: (value) => providerIdFromReference(value) !== null,
+    write: (providerId, secret) => {
+      const key = readOrCreateKey(keyPath, secretsPath);
+      if (key === null) return null;
+      const encrypted = encrypt(secret, key);
+      if (encrypted === null) return null;
+      const data = readSecretFile(secretsPath);
+      const next = {
+        ...data,
+        secrets: { ...data.secrets, [providerId]: encrypted }
+      };
+      if (!writeSecrets(next)) return null;
+      return `${SECRET_REFERENCE_PREFIX}${providerId}`;
+    },
+    read: (reference) => {
+      const providerId = providerIdFromReference(reference);
+      if (providerId === null) return null;
+      const key = readKey(keyPath);
+      if (key === null) return null;
+      const encrypted = readSecretFile(secretsPath).secrets[providerId];
+      if (encrypted === void 0) return null;
+      return decrypt(encrypted, key);
+    },
+    delete: (providerId) => {
+      const data = readSecretFile(secretsPath);
+      if (data.secrets[providerId] === void 0) return;
+      const nextSecrets = { ...data.secrets };
+      delete nextSecrets[providerId];
+      void writeSecrets({ ...data, secrets: nextSecrets });
+    }
+  };
+}
+function secretValuesEqual(left, right) {
+  const leftBuffer = Buffer.from(left);
+  const rightBuffer = Buffer.from(right);
+  return leftBuffer.byteLength === rightBuffer.byteLength && timingSafeEqual(leftBuffer, rightBuffer);
+}
 object({
   providers: array(ProviderConfigSchema)
 });
@@ -5562,6 +5718,60 @@ const store = new Conf({
   },
   ...configPath !== void 0 ? { path: configPath } : {}
 });
+const providerSecretStore = createProviderSecretStore(dirname(store.path));
+function providerWithResolvedSecret(provider) {
+  if (!providerSecretStore.isReference(provider.apiKey)) return provider;
+  const apiKey = providerSecretStore.read(provider.apiKey);
+  if (apiKey !== null) return { ...provider, apiKey };
+  logger.error(`[providers] Secret is missing or unreadable for provider "${provider.name}"`);
+  return null;
+}
+function persistProviders(providers, removedProviderIds = /* @__PURE__ */ new Set()) {
+  const existingReferences = /* @__PURE__ */ new Map();
+  const unresolvedRecords = /* @__PURE__ */ new Map();
+  for (const candidate of store.get("providers", [])) {
+    const parsed = ProviderConfigSchema.safeParse(candidate);
+    if (parsed.success && providerSecretStore.isReference(parsed.data.apiKey)) {
+      existingReferences.set(parsed.data.id, parsed.data.apiKey);
+      if (providerSecretStore.read(parsed.data.apiKey) === null) {
+        unresolvedRecords.set(parsed.data.id, parsed.data);
+      }
+    }
+  }
+  const persisted = providers.map((provider) => {
+    const existingReference = existingReferences.get(provider.id);
+    if (existingReference !== void 0) {
+      const existingSecret = providerSecretStore.read(existingReference);
+      if (existingSecret !== null && secretValuesEqual(existingSecret, provider.apiKey)) {
+        return { ...provider, apiKey: existingReference };
+      }
+    }
+    const reference = providerSecretStore.write(provider.id, provider.apiKey);
+    if (reference !== null) return { ...provider, apiKey: reference };
+    logger.error(
+      `[providers] SecretStore unavailable; provider "${provider.name}" remains in the legacy storage format`
+    );
+    return provider;
+  });
+  const persistedIds = new Set(persisted.map((provider) => provider.id));
+  for (const [id, provider] of unresolvedRecords) {
+    if (!persistedIds.has(id) && !removedProviderIds.has(id)) persisted.push(provider);
+  }
+  store.set("providers", persisted);
+}
+function migratePlaintextProviderSecrets() {
+  const raw = store.get("providers", []);
+  let changed = false;
+  const migrated = raw.map((candidate) => {
+    const parsed = ProviderConfigSchema.safeParse(candidate);
+    if (!parsed.success || providerSecretStore.isReference(parsed.data.apiKey)) return candidate;
+    const reference = providerSecretStore.write(parsed.data.id, parsed.data.apiKey);
+    if (reference === null) return candidate;
+    changed = true;
+    return { ...parsed.data, apiKey: reference };
+  });
+  if (changed) store.set("providers", migrated);
+}
 migrateFromDataDirConfig(store, dataDir);
 migrateFromLegacyConfLocation(store);
 function migrateProvider(p) {
@@ -5663,13 +5873,15 @@ if (providersJson !== void 0) {
   } catch {
   }
 }
+migratePlaintextProviderSecrets();
 function getProviders() {
   const raw = store.get("providers", []);
   const valid = [];
   for (const candidate of raw) {
     const entry = ProviderConfigSchema.safeParse(candidate);
     if (entry.success) {
-      valid.push(entry.data);
+      const resolved = providerWithResolvedSecret(entry.data);
+      if (resolved !== null) valid.push(resolved);
       continue;
     }
     let candidateName = "<unknown>";
@@ -5690,7 +5902,7 @@ function getProvider(id) {
 function redactProvider(provider) {
   return {
     ...provider,
-    apiKey: maskApiKey(provider.apiKey)
+    apiKey: "configured"
   };
 }
 function redactProviders(providers) {
@@ -5707,7 +5919,7 @@ function addProvider(name2, apiKey, format, baseUrl, models, authHeader, apiDocs
   const resolvedOpenaiResponsesUrl = openaiResponsesBaseUrl ?? "";
   const now = (/* @__PURE__ */ new Date()).toISOString();
   const existing = providers.find(
-    (p) => p.apiKey === normalizedKey && (p.anthropicBaseUrl ?? "") === (resolvedAnthropicUrl ?? "") && (p.openaiBaseUrl ?? "") === (resolvedOpenaiUrl ?? "") && (p.openaiResponsesBaseUrl ?? "") === (resolvedOpenaiResponsesUrl ?? "")
+    (p) => secretValuesEqual(p.apiKey, normalizedKey) && (p.anthropicBaseUrl ?? "") === (resolvedAnthropicUrl ?? "") && (p.openaiBaseUrl ?? "") === (resolvedOpenaiUrl ?? "") && (p.openaiResponsesBaseUrl ?? "") === (resolvedOpenaiResponsesUrl ?? "")
   );
   if (existing) {
     const existingIndex = providers.findIndex((p) => p.id === existing.id);
@@ -5724,7 +5936,7 @@ function addProvider(name2, apiKey, format, baseUrl, models, authHeader, apiDocs
     if (existingIndex >= 0) {
       providers[existingIndex] = enriched;
     }
-    store.set("providers", providers);
+    persistProviders(providers);
     return enriched;
   }
   const newProvider = withBuiltinProviderModelMetadata(
@@ -5749,7 +5961,7 @@ function addProvider(name2, apiKey, format, baseUrl, models, authHeader, apiDocs
     now
   );
   providers.push(newProvider);
-  store.set("providers", providers);
+  persistProviders(providers);
   return newProvider;
 }
 function updateProvider(id, updates) {
@@ -5781,14 +5993,15 @@ function updateProvider(id, updates) {
   );
   const index = providers.findIndex((p) => p.id === id);
   providers[index] = updated;
-  store.set("providers", providers);
+  persistProviders(providers);
   return updated;
 }
 function deleteProvider(id) {
   const providers = getProviders();
   const filtered = providers.filter((p) => p.id !== id);
   if (filtered.length === providers.length) return false;
-  store.set("providers", filtered);
+  persistProviders(filtered, /* @__PURE__ */ new Set([id]));
+  providerSecretStore.delete(id);
   return true;
 }
 function exportProviders() {
@@ -5855,7 +6068,7 @@ function importProviders(json) {
       imported++;
     }
     if (newProviders.length > 0) {
-      store.set("providers", [...existingProviders, ...newProviders]);
+      persistProviders([...existingProviders, ...newProviders]);
     }
   } catch (err) {
     return {
@@ -6486,6 +6699,145 @@ function toPersistedConfig(value) {
     timeDisplayFormat: value.timeDisplayFormat
   };
 }
+const LOOPBACK_HOSTNAMES = /* @__PURE__ */ new Set([
+  "localhost",
+  "ip6-localhost",
+  "ip6-loopback",
+  "[::1]",
+  "[::ffff:127.0.0.1]"
+]);
+function isLoopbackHost(hostname) {
+  const lower2 = hostname.toLowerCase().replace(/^\[|]$/g, "");
+  if (LOOPBACK_HOSTNAMES.has(lower2)) return true;
+  if (lower2 === "::1") return true;
+  if (lower2.startsWith("::ffff:127.")) return true;
+  if (lower2.startsWith("::ffff:7f00:")) return true;
+  return /^127\./.test(lower2);
+}
+function mappedIpv4Address(hostname) {
+  const lower2 = hostname.toLowerCase();
+  if (!lower2.startsWith("::ffff:")) return null;
+  const suffix = lower2.slice("::ffff:".length);
+  if (/^\d{1,3}(?:\.\d{1,3}){3}$/.test(suffix)) return suffix;
+  const match = /^([0-9a-f]{1,4}):([0-9a-f]{1,4})$/.exec(suffix);
+  if (match === null) return null;
+  const highText = match[1];
+  const lowText = match[2];
+  if (highText === void 0 || lowText === void 0) return null;
+  const high = Number.parseInt(highText, 16);
+  const low = Number.parseInt(lowText, 16);
+  return `${String(high >> 8)}.${String(high & 255)}.${String(low >> 8)}.${String(low & 255)}`;
+}
+function isInternalHost(hostname) {
+  if (LOOPBACK_HOSTNAMES.has(hostname.toLowerCase())) return true;
+  const mappedIpv4 = mappedIpv4Address(hostname);
+  if (mappedIpv4 !== null) return isInternalHost(mappedIpv4);
+  const ipv4Match = /^(\d{1,3})\.(\d{1,3})\.(\d{1,3})\.(\d{1,3})$/.exec(hostname);
+  if (ipv4Match !== null) {
+    const [, a, b] = ipv4Match;
+    if (a === void 0 || b === void 0) return false;
+    const first = Number.parseInt(a, 10);
+    const second = Number.parseInt(b, 10);
+    if (first === 127) return true;
+    if (first === 10) return true;
+    if (first === 172 && second >= 16 && second <= 31) return true;
+    if (first === 192 && second === 168) return true;
+    if (first === 169 && second === 254) return true;
+    if (first === 0) return true;
+    if (first === 100 && second >= 64 && second <= 127) return true;
+    if (first >= 224) return true;
+    if (first === 198 && (second === 18 || second === 19)) return true;
+    return false;
+  }
+  const lower2 = hostname.toLowerCase();
+  if (lower2 === "::") return true;
+  if (lower2 === "::1") return true;
+  if (/^fe[89ab]/.test(lower2)) return true;
+  if (lower2.startsWith("fc") || lower2.startsWith("fd")) return true;
+  if (lower2.startsWith("ff")) return true;
+  return false;
+}
+function evaluateUpstreamUrl(rawUrl, options = {}) {
+  if (options.bypass === true) return { allow: true };
+  let parsed;
+  try {
+    parsed = new URL(rawUrl);
+  } catch {
+    return { allow: false, reason: "Not a valid URL" };
+  }
+  if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+    return { allow: false, reason: `Unsupported scheme "${parsed.protocol}"` };
+  }
+  if (options.allowLoopback === true && parsed.hostname === "localhost") {
+    return { allow: true };
+  }
+  const hostname = parsed.hostname.replace(/^\[|]$/g, "");
+  if (isInternalHost(hostname)) {
+    if (options.allowLoopback === true) {
+      if (isLoopbackHost(hostname)) return { allow: true };
+    }
+    return {
+      allow: false,
+      reason: `Refusing to proxy to internal address "${hostname}"`
+    };
+  }
+  return { allow: true };
+}
+async function defaultResolver(hostname) {
+  return lookup(hostname, { all: true, verbatim: true });
+}
+function isLoopbackAddress(hostname) {
+  const lower2 = hostname.toLowerCase();
+  return lower2 === "::1" || lower2.startsWith("::ffff:127.") || lower2.startsWith("::ffff:7f00:") || /^127\./.test(lower2);
+}
+async function evaluateResolvedUpstreamUrl(rawUrl, options = {}) {
+  const initial = evaluateUpstreamUrl(rawUrl, options);
+  if (!initial.allow || options.bypass === true) return initial;
+  const parsed = new URL(rawUrl);
+  const hostname = parsed.hostname.replace(/^\[|]$/g, "");
+  if (isIP(hostname) !== 0 || hostname.toLowerCase() === "localhost") return initial;
+  let addresses;
+  try {
+    addresses = await (options.resolver ?? defaultResolver)(hostname);
+  } catch (error) {
+    return {
+      allow: false,
+      reason: `Could not safely resolve upstream host "${hostname}": ${String(error)}`
+    };
+  }
+  if (addresses.length === 0) {
+    return { allow: false, reason: `Upstream host "${hostname}" resolved to no addresses` };
+  }
+  for (const resolved of addresses) {
+    if (!isInternalHost(resolved.address)) continue;
+    if (options.allowLoopback === true && isLoopbackAddress(resolved.address)) continue;
+    return {
+      allow: false,
+      reason: `Refusing upstream host "${hostname}" because it resolves to internal address "${resolved.address}"`
+    };
+  }
+  return { allow: true };
+}
+function isRedirectStatus(status) {
+  return status >= 300 && status < 400;
+}
+async function safeFetch(rawUrl, init = {}, options = {}) {
+  const decision = await evaluateResolvedUpstreamUrl(rawUrl, options);
+  if (!decision.allow) {
+    return { ok: false, kind: "network-policy", reason: decision.reason };
+  }
+  const response = await fetch(rawUrl, { ...init, redirect: "manual" });
+  if (!isRedirectStatus(response.status)) return { ok: true, response };
+  if (response.body !== null) {
+    await response.body.cancel().catch(() => void 0);
+  }
+  const location = response.headers.get("location");
+  return {
+    ok: false,
+    kind: "redirect",
+    reason: location === null ? `Upstream returned blocked redirect HTTP ${String(response.status)}` : `Upstream redirect to "${location}" is blocked; configure the final API URL directly`
+  };
+}
 const BILLING_HEADER_PREFIX = "x-anthropic-billing-header:";
 function isClaudeCodeBillingHeaderBlock(text) {
   const trimmed = text.trimStart();
@@ -6631,30 +6983,23 @@ function parseJson$1(raw) {
     return { ok: false };
   }
 }
-function isRecord$2(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function readProperty$2(value, key) {
-  if (!isRecord$2(value)) return void 0;
-  return Object.getOwnPropertyDescriptor(value, key)?.value;
-}
 function hasOwnProperty(value, key) {
   return Object.getOwnPropertyDescriptor(value, key) !== void 0;
 }
 function readString(value, key) {
-  const property = readProperty$2(value, key);
+  const property = readProperty$5(value, key);
   return typeof property === "string" ? property : null;
 }
 function readArray(value, key) {
-  const property = readProperty$2(value, key);
+  const property = readProperty$5(value, key);
   return Array.isArray(property) ? property : [];
 }
 function readStringArray(value, key) {
   return readArray(value, key).filter((item) => typeof item === "string");
 }
 function readObject(value, key) {
-  const property = readProperty$2(value, key);
-  return isRecord$2(property) ? property : null;
+  const property = readProperty$5(value, key);
+  return isRecord(property) ? property : null;
 }
 function normalizeExpectedType(typeName) {
   switch (typeName) {
@@ -6671,7 +7016,7 @@ function normalizeExpectedType(typeName) {
   }
 }
 function schemaTypes(schema) {
-  const typeValue = readProperty$2(schema, "type");
+  const typeValue = readProperty$5(schema, "type");
   const rawTypes = Array.isArray(typeValue) ? typeValue : [typeValue];
   const types = [];
   for (const rawType of rawTypes) {
@@ -6699,7 +7044,7 @@ function actualType(value) {
     case "function":
     case "object":
     case "symbol":
-      return isRecord$2(value) ? "object" : "unknown";
+      return isRecord(value) ? "object" : "unknown";
   }
   return "unknown";
 }
@@ -6716,7 +7061,7 @@ function matchesExpectedType(value, expected) {
     case "number":
       return typeof value === "number" && Number.isFinite(value);
     case "object":
-      return isRecord$2(value);
+      return isRecord(value);
     case "string":
       return typeof value === "string";
   }
@@ -6761,7 +7106,7 @@ function schemaAllowsObjectValidation(schema, expectedTypes) {
   return expectedTypes.includes("object");
 }
 function schemaAllowsArrayValidation(schema, expectedTypes) {
-  if (expectedTypes.length === 0) return readProperty$2(schema, "items") !== void 0;
+  if (expectedTypes.length === 0) return readProperty$5(schema, "items") !== void 0;
   return expectedTypes.includes("array");
 }
 function addTypeWarning(warnings, toolName, path2, expectedTypes, value) {
@@ -6794,7 +7139,7 @@ function validateObjectSchema(schema, value, toolName, path2, warnings) {
   }
 }
 function validateArraySchema(schema, value, toolName, path2, warnings) {
-  const itemsSchema = readProperty$2(schema, "items");
+  const itemsSchema = readProperty$5(schema, "items");
   if (itemsSchema === void 0) return;
   let index = 0;
   for (const item of value) {
@@ -6803,7 +7148,7 @@ function validateArraySchema(schema, value, toolName, path2, warnings) {
   }
 }
 function validateEnum(schema, value, toolName, path2, warnings) {
-  const enumValue = readProperty$2(schema, "enum");
+  const enumValue = readProperty$5(schema, "enum");
   if (Array.isArray(enumValue) && enumValue.length > 0 && !enumMatches(value, enumValue)) {
     warnings.push(
       `Tool call "${toolName}" ${pathLabel(path2)} expected one of ${formatJsonValue(
@@ -6821,7 +7166,7 @@ function validateEnum(schema, value, toolName, path2, warnings) {
   }
 }
 function validateValueAgainstSchema(schema, value, toolName, path2, warnings) {
-  if (!isRecord$2(schema)) return;
+  if (!isRecord(schema)) return;
   const expectedTypes = schemaTypes(schema);
   if (expectedTypes.length > 0 && !matchesAnyExpectedType(value, expectedTypes)) {
     addTypeWarning(warnings, toolName, path2, expectedTypes, value);
@@ -6829,7 +7174,7 @@ function validateValueAgainstSchema(schema, value, toolName, path2, warnings) {
   }
   validateEnum(schema, value, toolName, path2, warnings);
   if (schemaAllowsObjectValidation(schema, expectedTypes)) {
-    if (isRecord$2(value)) {
+    if (isRecord(value)) {
       validateObjectSchema(schema, value, toolName, path2, warnings);
     } else if (expectedTypes.length === 0) {
       warnings.push(
@@ -6850,7 +7195,7 @@ function validateValueAgainstSchema(schema, value, toolName, path2, warnings) {
 function extractAnthropicToolSchemas(request) {
   const tools = /* @__PURE__ */ new Map();
   for (const tool of readArray(request, "tools")) {
-    if (!isRecord$2(tool)) continue;
+    if (!isRecord(tool)) continue;
     const name2 = readString(tool, "name");
     if (name2 === null || name2 === "") continue;
     tools.set(name2, {
@@ -6920,7 +7265,7 @@ function extractOpenAIToolCalls(response) {
     for (const call of readArray(message, "tool_calls")) {
       const functionCall = readObject(call, "function");
       const name2 = functionCall === null ? null : readString(functionCall, "name");
-      const parsedArguments = functionCall === null ? { value: {}, issue: "function block is missing" } : parseOpenAIArguments(readProperty$2(functionCall, "arguments"));
+      const parsedArguments = functionCall === null ? { value: {}, issue: "function block is missing" } : parseOpenAIArguments(readProperty$5(functionCall, "arguments"));
       calls.push({
         name: name2,
         arguments: parsedArguments.value,
@@ -6931,7 +7276,7 @@ function extractOpenAIToolCalls(response) {
     }
     const legacyFunctionCall = readObject(message, "function_call");
     if (legacyFunctionCall !== null) {
-      const parsedArguments = parseOpenAIArguments(readProperty$2(legacyFunctionCall, "arguments"));
+      const parsedArguments = parseOpenAIArguments(readProperty$5(legacyFunctionCall, "arguments"));
       calls.push({
         name: readString(legacyFunctionCall, "name"),
         arguments: parsedArguments.value,
@@ -6947,7 +7292,7 @@ function extractOpenAIToolCalls(response) {
       outputIndex++;
       continue;
     }
-    const parsedArguments = parseOpenAIArguments(readProperty$2(item, "arguments"));
+    const parsedArguments = parseOpenAIArguments(readProperty$5(item, "arguments"));
     calls.push({
       name: readString(item, "name"),
       arguments: parsedArguments.value,
@@ -6968,7 +7313,7 @@ function extractAnthropicToolCalls(response) {
     }
     calls.push({
       name: readString(block, "name"),
-      arguments: readProperty$2(block, "input") ?? {},
+      arguments: readProperty$5(block, "input") ?? {},
       argumentIssue: null,
       location: `content[${contentIndex}]`
     });
@@ -7751,12 +8096,14 @@ function injectProviderAuth(headers, provider) {
   }
   headers.set(HEADER_AUTHORIZATION, `Bearer ${apiKey}`);
 }
+const ALLOW_LOOPBACK$2 = process.env["AGENT_INSPECTOR_ALLOW_LOOPBACK"] === "1";
 function buildProxyHeaders(originalHeaders, captureRawHeaders) {
   const rawHeaders = captureRawHeaders ? {} : void 0;
   const headers = new Headers();
   if (rawHeaders !== void 0) {
     originalHeaders.forEach((value, key) => {
-      rawHeaders[key.toLowerCase()] = value;
+      const lowerKey = key.toLowerCase();
+      rawHeaders[lowerKey] = SENSITIVE_HEADERS.has(lowerKey) ? maskApiKey(value) : value;
     });
   }
   headers.set(HEADER_USER_AGENT, PROXY_IDENTITY);
@@ -7784,6 +8131,37 @@ function parseRequestPath(req, url) {
 function errorMessage(err) {
   return err instanceof Error ? err.message : String(err);
 }
+async function readBodyWithLimit(req, limitBytes) {
+  if (req.body === null || req.method === "GET" || req.method === "HEAD") {
+    return { ok: true, body: null };
+  }
+  const contentLengthHeader = req.headers.get(HEADER_CONTENT_LENGTH);
+  if (contentLengthHeader !== null) {
+    const declared = Number.parseInt(contentLengthHeader, 10);
+    if (Number.isFinite(declared) && declared > limitBytes) {
+      return { ok: false, reason: "too-large" };
+    }
+  }
+  const reader = req.body.getReader();
+  const decoder = new TextDecoder();
+  const chunks = [];
+  let totalBytes = 0;
+  try {
+    for (; ; ) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      totalBytes += value.byteLength;
+      if (totalBytes > limitBytes) {
+        return { ok: false, reason: "too-large" };
+      }
+      chunks.push(decoder.decode(value, { stream: true }));
+    }
+    chunks.push(decoder.decode());
+    return { ok: true, body: chunks.join("") };
+  } finally {
+    reader.releaseLock();
+  }
+}
 function scheduleLogFinalization(job) {
   void enqueueFinalizeLogJob(job).catch((err) => {
     logger.error(
@@ -7891,10 +8269,12 @@ function handleStreamingResponse(upstreamRes, req, startTime, upstreamUrl, log,
 async function handleProxy(req) {
   const url = new URL(req.url);
   const parsed = parseRequestPath(req, url);
-  let requestBody = null;
-  if (req.body && req.method !== "GET" && req.method !== "HEAD") {
-    requestBody = await req.text();
+  const bodyRead = await readBodyWithLimit(req, MAX_REQUEST_BODY_BYTES);
+  if (!bodyRead.ok) {
+    logger.warn(`[handler] Rejected oversized request body: ${req.method} ${parsed.apiPath}`);
+    return new Response("Request body too large", { status: STATUS_PAYLOAD_TOO_LARGE });
   }
+  const requestBody = bodyRead.body;
   const config = getConfig();
   let bodyToForward = requestBody;
   if (config.stripClaudeCodeBillingHeader && requestBody !== null && parsed.isMessages) {
@@ -7941,7 +8321,8 @@ async function handleProxy(req) {
   const upstreamHeadersObj = captureFullDetails ? {} : void 0;
   if (upstreamHeadersObj !== void 0) {
     upstreamHeaders.forEach((value, key) => {
-      upstreamHeadersObj[key.toLowerCase()] = value;
+      const lowerKey = key.toLowerCase();
+      upstreamHeadersObj[lowerKey] = SENSITIVE_HEADERS.has(lowerKey) ? maskApiKey(value) : value;
     });
   }
   const log = await createLog(
@@ -7959,12 +8340,30 @@ async function handleProxy(req) {
   );
   let upstreamRes;
   try {
-    upstreamRes = await fetch(upstreamUrl, {
-      method: req.method,
-      headers: upstreamHeaders,
-      body: bodyToForward,
-      signal: req.signal
-    });
+    const fetchResult = await safeFetch(
+      upstreamUrl,
+      {
+        method: req.method,
+        headers: upstreamHeaders,
+        body: bodyToForward,
+        signal: req.signal
+      },
+      { allowLoopback: ALLOW_LOOPBACK$2 }
+    );
+    if (!fetchResult.ok) {
+      const status = fetchResult.kind === "network-policy" ? STATUS_FORBIDDEN : STATUS_BAD_GATEWAY;
+      logger.warn(`[handler] Safe fetch blocked ${upstreamUrl}: ${fetchResult.reason}`);
+      log.elapsedMs = Date.now() - startTime;
+      log.responseStatus = status;
+      log.responseText = fetchResult.reason;
+      appendLogEntry({ ...buildFileLogEntry(log, upstreamUrl), error: fetchResult.reason });
+      finalizeLogUpdate(log);
+      return new Response(
+        fetchResult.kind === "network-policy" ? "Forbidden: upstream URL is not permitted" : "Proxy error: upstream redirects are not permitted",
+        { status }
+      );
+    }
+    upstreamRes = fetchResult.response;
   } catch (err) {
     log.elapsedMs = Date.now() - startTime;
     if (err instanceof Error && err.name === "AbortError") {
@@ -9506,6 +9905,7 @@ const Route$H = createFileRoute("/api/runs")({
     }
   }
 });
+const ALLOW_LOOPBACK$1 = process.env["AGENT_INSPECTOR_ALLOW_LOOPBACK"] === "1";
 const ProviderInputSchema = object({
   name: string().min(1, "Name is required"),
   apiKey: string().min(1, "API key is required"),
@@ -9524,17 +9924,25 @@ const ProviderInputSchema = object({
 const Route$G = createFileRoute("/api/providers")({
   server: {
     handlers: {
-      GET: ({ request }) => {
-        const url = new URL(request.url);
-        const includeSecrets = url.searchParams.get("includeSecrets") === "1";
-        const providers = getProviders();
-        return Response.json(includeSecrets ? providers : redactProviders(providers));
+      GET: () => {
+        return Response.json(redactProviders(getProviders()));
       },
       POST: async ({ request }) => {
         const parsed = ProviderInputSchema.safeParse(await request.json());
         if (!parsed.success) {
           return Response.json({ error: parsed.error.message }, { status: 400 });
         }
+        for (const candidate of [
+          parsed.data.anthropicBaseUrl,
+          parsed.data.openaiBaseUrl,
+          parsed.data.openaiResponsesBaseUrl
+        ]) {
+          if (candidate === void 0 || candidate === "") continue;
+          const decision = evaluateUpstreamUrl(candidate, { allowLoopback: ALLOW_LOOPBACK$1 });
+          if (!decision.allow) {
+            return Response.json({ error: decision.reason }, { status: 400 });
+          }
+        }
         const newProvider = addProvider(
           parsed.data.name,
           parsed.data.apiKey,
@@ -9551,7 +9959,7 @@ const Route$G = createFileRoute("/api/providers")({
           parsed.data.modelMetadata,
           parsed.data.openaiResponsesBaseUrl
         );
-        return Response.json(newProvider, { status: 201 });
+        return Response.json(redactProvider(newProvider), { status: 201 });
       }
     }
   }
@@ -9571,9 +9979,6 @@ const PiAgentResponseSchema = object({
   protocol: _enum(["openaiResponses", "openaiChat", "anthropic"]),
   logCount: number().int().nonnegative()
 });
-function isRecord$1(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
 function normalizeAnthropicStopReason(value) {
   switch (value) {
     case "end_turn":
@@ -9612,20 +10017,20 @@ function extractStopReason(log) {
     if (typeof json === "string") {
       json = JSON.parse(json);
     }
-    if (!isRecord$1(json)) return null;
+    if (!isRecord(json)) return null;
     if (typeof json.stop_reason === "string") {
       return normalizeAnthropicStopReason(json.stop_reason);
     }
     if (Array.isArray(json.choices)) {
       for (const choice of json.choices) {
-        if (!isRecord$1(choice) || typeof choice.finish_reason !== "string") continue;
+        if (!isRecord(choice) || typeof choice.finish_reason !== "string") continue;
         const reason = normalizeOpenAIFinishReason(choice.finish_reason);
         if (reason !== null) return reason;
       }
     }
     if (Array.isArray(json.output)) {
       for (const item of json.output) {
-        if (isRecord$1(item) && item.type === "function_call") {
+        if (isRecord(item) && item.type === "function_call") {
           return "tool_use";
         }
       }
@@ -9633,7 +10038,7 @@ function extractStopReason(log) {
         return "stop";
       }
     }
-    if (json.status === "incomplete" && isRecord$1(json.incomplete_details)) {
+    if (json.status === "incomplete" && isRecord(json.incomplete_details)) {
       const reason = json.incomplete_details.reason;
       if (typeof reason === "string" && isResponsesLengthLimitReason(reason)) {
         return "length";
@@ -9980,7 +10385,7 @@ const Route$E = createFileRoute("/api/models")({
   }
 });
 const name = "@tonyclaw/agent-inspector";
-const version = "3.0.26";
+const version = "3.0.27";
 const packageJson = {
   name,
   version
@@ -10062,8 +10467,7 @@ function isMcpWriteEnabled() {
   const readonlyFlag = parseFlag(process.env["AGENT_INSPECTOR_MCP_READONLY"]);
   if (readonlyFlag === true) return false;
   const writesFlag = parseFlag(process.env["AGENT_INSPECTOR_MCP_WRITES"]);
-  if (writesFlag === false) return false;
-  return true;
+  return writesFlag === true;
 }
 function getMcpModeInfo() {
   const writesEnabled = isMcpWriteEnabled();
@@ -10074,7 +10478,7 @@ function getMcpModeInfo() {
       AGENT_INSPECTOR_MCP_READONLY: process.env["AGENT_INSPECTOR_MCP_READONLY"] ?? null,
       AGENT_INSPECTOR_MCP_WRITES: process.env["AGENT_INSPECTOR_MCP_WRITES"] ?? null
     },
-    note: writesEnabled ? "MCP write/action tools are enabled. Set AGENT_INSPECTOR_MCP_READONLY=1 to expose the same catalog while blocking mutations." : "MCP is in readonly mode. Read tools/resources still work, while write/action tools return an isError result."
+    note: writesEnabled ? "MCP write/action tools are enabled explicitly by AGENT_INSPECTOR_MCP_WRITES=1." : "MCP is readonly by default. Read tools/resources still work; set AGENT_INSPECTOR_MCP_WRITES=1 to enable mutations."
   };
 }
 function groupEvidenceDir(groupId) {
@@ -10646,10 +11050,6 @@ function toolError(message) {
 function inspectorBaseUrl() {
   return `http://127.0.0.1:${String(getCurrentPort())}`;
 }
-function textByteLength(value) {
-  if (value === null) return null;
-  return Buffer.byteLength(value, "utf8");
-}
 function hasBodyText(value, byteLength) {
   if (value !== null && value.length > 0) return true;
   return byteLength !== void 0 && byteLength !== null && byteLength > 0;
@@ -10780,14 +11180,29 @@ function processSummary(clientPid, logs, total, limit) {
 }
 async function readCompactLogsPage(callApi2, params) {
   const path2 = `/api/logs?${params.toString()}`;
-  const res = await callApi2(path2);
-  if (!res.ok) return toolError(`GET ${path2} returned ${res.status}`);
-  const rawBody = await res.json();
-  const parsed = LogsListResponseSchema.safeParse(rawBody);
-  if (!parsed.success) return toolError("GET /api/logs returned an unparseable logs shape");
+  const parsed = await fetchApiJson(callApi2, path2, LogsListResponseSchema);
+  if (!parsed.ok) return parsed.error;
   const logs = parsed.data.logs ?? [];
   return { logs, total: parsed.data.total ?? logs.length };
 }
+async function fetchApiJson(callApi2, path2, schema, init) {
+  const res = await callApi2(path2, init);
+  if (!res.ok) {
+    return { ok: false, error: toolError(`${methodFor(init)} ${path2} returned ${res.status}`) };
+  }
+  const rawBody = await res.json();
+  const parsed = schema.safeParse(rawBody);
+  if (!parsed.success) {
+    return {
+      ok: false,
+      error: toolError(`${methodFor(init)} ${path2} returned an unparseable shape`)
+    };
+  }
+  return { ok: true, data: parsed.data };
+}
+function methodFor(init) {
+  return (init?.method ?? "GET").toUpperCase();
+}
 function isToolResult(value) {
   return typeof value === "object" && value !== null && Object.getOwnPropertyDescriptor(value, "content") !== void 0;
 }
@@ -10847,13 +11262,8 @@ async function searchLogsImpl(callApi2, args) {
   });
 }
 async function getLogImpl(callApi2, id) {
-  const res = await callApi2(`/api/logs/${id}`);
-  if (!res.ok) return toolError(`GET /api/logs/${id} returned ${res.status}`);
-  const rawBody = await res.json();
-  const parsed = CapturedLogSchema.safeParse(rawBody);
-  if (!parsed.success) {
-    return toolError(`GET /api/logs/${id} returned an unparseable CapturedLog`);
-  }
+  const parsed = await fetchApiJson(callApi2, `/api/logs/${id}`, CapturedLogSchema);
+  if (!parsed.ok) return parsed.error;
   return textJson(buildBoundedLogDetail(parsed.data));
 }
 async function getLogChunksImpl(callApi2, id) {
@@ -10875,11 +11285,8 @@ async function getSessionImpl(callApi2, args) {
     params.set("includeHistory", "1");
   }
   const path2 = `/api/sessions?${params.toString()}`;
-  const res = await callApi2(path2);
-  if (!res.ok) return toolError(`GET ${path2} returned ${res.status}`);
-  const rawBody = await res.json();
-  const parsed = SessionInfoSchema.safeParse(rawBody);
-  if (!parsed.success) return toolError("GET /api/sessions returned an unparseable session info");
+  const parsed = await fetchApiJson(callApi2, path2, SessionInfoSchema);
+  if (!parsed.ok) return parsed.error;
   return textJson(parsed.data);
 }
 function createRunImpl(args) {
@@ -11089,13 +11496,8 @@ async function getProcessTimelineImpl(callApi2, args) {
   });
 }
 async function getLogHeadersImpl(callApi2, id) {
-  const res = await callApi2(`/api/logs/${id}`);
-  if (!res.ok) return toolError(`GET /api/logs/${id} returned ${res.status}`);
-  const rawBody = await res.json();
-  const parsed = CapturedLogSchema.safeParse(rawBody);
-  if (!parsed.success) {
-    return toolError(`GET /api/logs/${id} returned an unparseable CapturedLog`);
-  }
+  const parsed = await fetchApiJson(callApi2, `/api/logs/${id}`, CapturedLogSchema);
+  if (!parsed.ok) return parsed.error;
   const log = parsed.data;
   return textJson({
     id: log.id,
@@ -11346,18 +11748,13 @@ async function listModelsImpl(callApi2) {
   if (!res.ok) return toolError(`GET /api/models returned ${res.status}`);
   return textJson(await res.json());
 }
-function includeSecretsQuery(includeSecrets) {
-  return includeSecrets === true ? "?includeSecrets=1" : "";
-}
-async function listProvidersImpl(callApi2, args = {}) {
-  const res = await callApi2(`/api/providers${includeSecretsQuery(args.includeSecrets)}`);
+async function listProvidersImpl(callApi2) {
+  const res = await callApi2("/api/providers");
   if (!res.ok) return toolError(`GET /api/providers returned ${res.status}`);
   return textJson(await res.json());
 }
-async function getProviderImpl(callApi2, id, args = {}) {
-  const res = await callApi2(
-    `/api/providers/${encodeURIComponent(id)}${includeSecretsQuery(args.includeSecrets)}`
-  );
+async function getProviderImpl(callApi2, id) {
+  const res = await callApi2(`/api/providers/${encodeURIComponent(id)}`);
   if (!res.ok) return toolError(`GET /api/providers/${id} returned ${res.status}`);
   return textJson(await res.json());
 }
@@ -11417,9 +11814,6 @@ async function testProviderImpl(callApi2, id) {
   if (!res.ok) return toolError(`POST /api/providers/${id}/test returned ${res.status}`);
   return textJson(await res.json());
 }
-function isRecord(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
 function stringField(record2, key) {
   const value = record2[key];
   return typeof value === "string" && value.length > 0 ? value : null;
@@ -12442,24 +12836,21 @@ function registerTools(server) {
     "inspector_list_providers",
     {
       title: "List configured LLM providers",
-      description: "Returns the configured ProviderConfig array with apiKey redacted by default. Set includeSecrets=true only when the user explicitly needs plaintext local provider keys; this exposes secrets from <dataDir>/providers.json.",
-      inputSchema: object({
-        includeSecrets: boolean().optional().describe("Return plaintext provider API keys. Exposes local secrets when true.")
-      })
+      description: "Returns the configured ProviderConfig array with write-only API keys represented as configured.",
+      inputSchema: object({})
     },
-    (args) => safeCall(() => listProvidersImpl(callApi, args))
+    () => safeCall(() => listProvidersImpl(callApi))
   );
   server.registerTool(
     "inspector_get_provider",
     {
       title: "Get a single provider by id",
-      description: "Returns one ProviderConfig with apiKey redacted by default. Set includeSecrets=true only when the user explicitly needs the plaintext local provider key.",
+      description: "Returns one ProviderConfig. API keys are write-only and represented as configured.",
       inputSchema: object({
-        id: string().describe("The provider id."),
-        includeSecrets: boolean().optional().describe("Return the plaintext provider API key. Exposes a local secret when true.")
+        id: string().describe("The provider id.")
       })
     },
-    ({ id, includeSecrets }) => safeCall(() => getProviderImpl(callApi, id, { includeSecrets }))
+    ({ id }) => safeCall(() => getProviderImpl(callApi, id))
   );
   server.registerTool(
     "inspector_replay_log",
@@ -14601,6 +14992,7 @@ const Route$u = createFileRoute("/api/providers/export")({
     }
   }
 });
+const ALLOW_LOOPBACK = process.env["AGENT_INSPECTOR_ALLOW_LOOPBACK"] === "1";
 const ProviderUpdateSchema = object({
   name: string().min(1, "Name is required").optional(),
   apiKey: string().min(1, "API key is required").optional(),
@@ -14620,26 +15012,36 @@ const ProviderUpdateSchema = object({
 const Route$t = createFileRoute("/api/providers/$providerId")({
   server: {
     handlers: {
-      GET: ({ params, request }) => {
-        const url = new URL(request.url);
-        const includeSecrets = url.searchParams.get("includeSecrets") === "1";
+      GET: ({ params }) => {
         const providers = getProviders();
         const provider = providers.find((p) => p.id === params.providerId);
         if (!provider) {
           return Response.json({ error: "Provider not found" }, { status: 404 });
         }
-        return Response.json(includeSecrets ? provider : redactProvider(provider));
+        return Response.json(redactProvider(provider));
       },
       PUT: async ({ params, request }) => {
         const parsed = ProviderUpdateSchema.safeParse(await request.json());
         if (!parsed.success) {
           return Response.json({ error: parsed.error.message }, { status: 400 });
         }
+        for (const candidate of [
+          parsed.data.baseUrl,
+          parsed.data.anthropicBaseUrl,
+          parsed.data.openaiBaseUrl,
+          parsed.data.openaiResponsesBaseUrl
+        ]) {
+          if (candidate === void 0 || candidate === "") continue;
+          const decision = evaluateUpstreamUrl(candidate, { allowLoopback: ALLOW_LOOPBACK });
+          if (!decision.allow) {
+            return Response.json({ error: decision.reason }, { status: 400 });
+          }
+        }
         const updated = updateProvider(params.providerId, parsed.data);
         if (!updated) {
           return Response.json({ error: "Provider not found" }, { status: 404 });
         }
-        return Response.json(updated);
+        return Response.json(redactProvider(updated));
       },
       DELETE: ({ params }) => {
         const deleted = deleteProvider(params.providerId);
@@ -14725,6 +15127,8 @@ const Route$s = createFileRoute("/api/logs/stream")({
     }
   }
 });
+const MAX_ZIP_COMPRESSED_BYTES = 200 * 1024 * 1024;
+const MAX_ZIP_DECOMPRESSED_BYTES = 500 * 1024 * 1024;
 const ManifestSchema = object({
   version: string().optional(),
   exportedAt: string().optional(),
@@ -14925,12 +15329,15 @@ function legacyDraftFromParts(input) {
     error: null
   });
 }
-async function readZipText(zip, path2) {
+async function readZipText(zip, path2, remaining) {
   const file = zip.file(path2);
-  return file === null ? null : await file.async("text");
+  if (file === null) return null;
+  const text = await file.async("text");
+  remaining.bytes -= Buffer.byteLength(text, "utf8");
+  return text;
 }
-async function readManifest(zip) {
-  const text = await readZipText(zip, "manifest.json");
+async function readManifest(zip, remaining) {
+  const text = await readZipText(zip, "manifest.json", remaining);
   const parsed = ManifestSchema.safeParse(parseJson(text));
   return parsed.success ? parsed.data : null;
 }
@@ -14976,10 +15383,19 @@ function validateManifestVersion(manifest) {
   }
   return { ok: true, warning: null };
 }
+function bombError(warnings = []) {
+  return {
+    ok: false,
+    message: `Archive decompresses to more than ${MAX_ZIP_DECOMPRESSED_BYTES} bytes.`,
+    warnings
+  };
+}
 async function parseZipLogImport(data) {
   const warnings = [];
   const zip = await JSZip.loadAsync(data);
-  const manifest = await readManifest(zip);
+  const remaining = { bytes: MAX_ZIP_DECOMPRESSED_BYTES };
+  const manifest = await readManifest(zip, remaining);
+  if (remaining.bytes < 0) return bombError();
   const versionCheck = validateManifestVersion(manifest);
   if (!versionCheck.ok) {
     return {
@@ -14995,15 +15411,21 @@ async function parseZipLogImport(data) {
   if (manifest?.redacted === true) {
     warnings.push("Imported redacted export. Secrets and some replay details may be unavailable.");
   }
-  const metadataText2 = await readZipText(zip, "logs.json");
+  const metadataText2 = await readZipText(zip, "logs.json", remaining);
+  if (remaining.bytes < 0) return bombError(warnings);
   const metadataLogs = metadataText2 === null ? null : parseJsonLogs(metadataText2);
   const logs = [];
   let skipped = 0;
   if (metadataLogs !== null) {
     for (const log of metadataLogs) {
-      const requestText = await readZipText(zip, `#${String(log.id)}.Request.json`);
-      const responseText = await readZipText(zip, `#${String(log.id)}.Response.json`);
-      const streamingText = await readZipText(zip, `#${String(log.id)}.SSE.Response.json`);
+      const requestText = await readZipText(zip, `#${String(log.id)}.Request.json`, remaining);
+      const responseText = await readZipText(zip, `#${String(log.id)}.Response.json`, remaining);
+      const streamingText = await readZipText(
+        zip,
+        `#${String(log.id)}.SSE.Response.json`,
+        remaining
+      );
+      if (remaining.bytes < 0) return bombError(warnings);
       logs.push(
         draftFromCapturedLog(
           log,
@@ -15016,9 +15438,14 @@ async function parseZipLogImport(data) {
     return { ok: true, logs, skipped, warnings };
   }
   for (const originalId of manifest?.logIds ?? []) {
-    const requestText = await readZipText(zip, `#${String(originalId)}.Request.json`);
-    const responseText = await readZipText(zip, `#${String(originalId)}.Response.json`);
-    const streamingText = await readZipText(zip, `#${String(originalId)}.SSE.Response.json`);
+    const requestText = await readZipText(zip, `#${String(originalId)}.Request.json`, remaining);
+    const responseText = await readZipText(zip, `#${String(originalId)}.Response.json`, remaining);
+    const streamingText = await readZipText(
+      zip,
+      `#${String(originalId)}.SSE.Response.json`,
+      remaining
+    );
+    if (remaining.bytes < 0) return bombError(warnings);
     if (requestText === null && responseText === null && streamingText === null) {
       skipped += 1;
       continue;
@@ -15073,8 +15500,22 @@ function parseTextLogImport(text) {
 async function parseImportedLogFile(input) {
   try {
     if (looksLikeZip(input.data, input.fileName)) {
+      if (input.data.byteLength > MAX_ZIP_COMPRESSED_BYTES) {
+        return {
+          ok: false,
+          message: `Archive exceeds maximum size of ${MAX_ZIP_COMPRESSED_BYTES} bytes.`,
+          warnings: []
+        };
+      }
       return await parseZipLogImport(input.data);
     }
+    if (input.data.byteLength > MAX_ZIP_COMPRESSED_BYTES) {
+      return {
+        ok: false,
+        message: `Import file exceeds maximum size of ${MAX_ZIP_COMPRESSED_BYTES} bytes.`,
+        warnings: []
+      };
+    }
     return parseTextLogImport(new TextDecoder("utf-8").decode(input.data));
   } catch (err) {
     return {
@@ -15352,19 +15793,25 @@ async function searchOpenClawGateway(query, project) {
       warning: "OpenClaw Gateway is not configured. Set OPENCLAW_GATEWAY_URL."
     };
   }
-  const response = await fetch(buildToolInvokeUrl(gatewayUrl), {
-    method: "POST",
-    headers: gatewayHeaders(),
-    body: JSON.stringify({
-      tool: "memory_search",
-      args: {
-        query: buildSearchQuery(query, project),
-        maxResults: 10,
-        corpus: "all"
-      },
-      sessionKey: getOpenClawSessionKey()
-    })
-  });
+  const fetchResult = await safeFetch(
+    buildToolInvokeUrl(gatewayUrl),
+    {
+      method: "POST",
+      headers: gatewayHeaders(),
+      body: JSON.stringify({
+        tool: "memory_search",
+        args: {
+          query: buildSearchQuery(query, project),
+          maxResults: 10,
+          corpus: "all"
+        },
+        sessionKey: getOpenClawSessionKey()
+      })
+    },
+    { bypass: true }
+  );
+  if (!fetchResult.ok) return { results: [], warning: fetchResult.reason };
+  const response = fetchResult.response;
   const raw = await response.json().catch(() => null);
   if (!response.ok) {
     return {
@@ -15619,11 +16066,17 @@ async function promoteToOpenClaw(candidate) {
       error: "OpenClaw memory backend is not configured. Set OPENCLAW_WORKSPACE_DIR for file-backed memory or OPENCLAW_MEMORY_URL for a legacy HTTP backend."
     };
   }
-  const response = await fetch(buildMemoryUrl(endpoint), {
-    method: "POST",
-    headers: authHeaders(),
-    body: JSON.stringify(buildOpenClawPayload(candidate))
-  });
+  const fetchResult = await safeFetch(
+    buildMemoryUrl(endpoint),
+    {
+      method: "POST",
+      headers: authHeaders(),
+      body: JSON.stringify(buildOpenClawPayload(candidate))
+    },
+    { bypass: true }
+  );
+  if (!fetchResult.ok) return { success: false, error: fetchResult.reason };
+  const response = fetchResult.response;
   if (!response.ok) {
     return { success: false, error: `OpenClaw memory write failed with ${response.status}` };
   }
@@ -15646,10 +16099,16 @@ async function searchOpenClaw(query, project) {
       warning: `OpenClaw search backend is not configured. Set OPENCLAW_GATEWAY_URL or OPENCLAW_MEMORY_URL.${workspaceHint}`
     };
   }
-  const response = await fetch(buildSearchUrl(endpoint, query, project), {
-    method: "GET",
-    headers: authHeaders()
-  });
+  const fetchResult = await safeFetch(
+    buildSearchUrl(endpoint, query, project),
+    {
+      method: "GET",
+      headers: authHeaders()
+    },
+    { bypass: true }
+  );
+  if (!fetchResult.ok) return { results: [], warning: fetchResult.reason };
+  const response = fetchResult.response;
   if (!response.ok) {
     return { results: [], warning: `OpenClaw search failed with ${response.status}` };
   }
@@ -16770,12 +17229,20 @@ async function testEndpoint(baseUrl, provider, path2, model, protocol) {
   const timeoutId = setTimeout(() => controller.abort(), getProviderTestTimeoutMs());
   try {
     requestUrl = buildUpstreamUrl(baseUrl, path2);
-    const response = await fetch(requestUrl, {
-      method: "POST",
-      headers: requestHeaders,
-      body,
-      signal: controller.signal
-    });
+    const fetchResult = await safeFetch(
+      requestUrl,
+      {
+        method: "POST",
+        headers: requestHeaders,
+        body,
+        signal: controller.signal
+      },
+      { allowLoopback: process.env["AGENT_INSPECTOR_ALLOW_LOOPBACK"] === "1" }
+    );
+    if (!fetchResult.ok) {
+      return createErrorResult(fetchResult.reason, Date.now() - startTime, false);
+    }
+    const response = fetchResult.response;
     const latencyMs = Date.now() - startTime;
     if (!response.ok) {
       const responseText2 = await readResponseText(response);
@@ -16894,12 +17361,20 @@ async function testStreamingEndpoint(baseUrl, provider, path2, model, protocol)
   const timeoutId = setTimeout(() => controller.abort(), getProviderTestTimeoutMs());
   try {
     requestUrl = buildUpstreamUrl(baseUrl, path2);
-    const response = await fetch(requestUrl, {
-      method: "POST",
-      headers: requestHeaders,
-      body,
-      signal: controller.signal
-    });
+    const fetchResult = await safeFetch(
+      requestUrl,
+      {
+        method: "POST",
+        headers: requestHeaders,
+        body,
+        signal: controller.signal
+      },
+      { allowLoopback: process.env["AGENT_INSPECTOR_ALLOW_LOOPBACK"] === "1" }
+    );
+    if (!fetchResult.ok) {
+      return createErrorResult(fetchResult.reason, Date.now() - startTime, true);
+    }
+    const response = fetchResult.response;
     const latencyMs = Date.now() - startTime;
     if (!response.ok) {
       const responseText = await readResponseText(response);
@@ -17281,7 +17756,16 @@ const Route$f = createFileRoute("/api/providers/$providerId/model-metadata")({
         }
         let response;
         try {
-          response = await fetch(sourceUrl, { headers: { Accept: "application/json" } });
+          const fetchResult = await safeFetch(sourceUrl, {
+            headers: { Accept: "application/json" }
+          });
+          if (!fetchResult.ok) {
+            return Response.json(
+              { error: `Model metadata URL blocked: ${fetchResult.reason}` },
+              { status: 400 }
+            );
+          }
+          response = fetchResult.response;
         } catch (err) {
           return Response.json(
             { error: `Failed to fetch model metadata: ${String(err)}` },
@@ -17393,11 +17877,22 @@ const Route$e = createFileRoute("/api/logs/$id/replay")({
         const startTime = Date.now();
         let upstreamRes;
         try {
-          upstreamRes = await fetch(upstreamUrl, {
-            method: "POST",
-            headers,
-            body: modifiedBody
-          });
+          const fetchResult = await safeFetch(
+            upstreamUrl,
+            {
+              method: "POST",
+              headers,
+              body: modifiedBody
+            },
+            { allowLoopback: process.env["AGENT_INSPECTOR_ALLOW_LOOPBACK"] === "1" }
+          );
+          if (!fetchResult.ok) {
+            return Response.json({
+              success: false,
+              error: fetchResult.reason
+            });
+          }
+          upstreamRes = fetchResult.response;
         } catch (err) {
           return Response.json({
             success: false,
@@ -18778,13 +19273,13 @@ const router = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProper
 export {
   PiAgentResponseSchema as $,
   AnthropicResponseSchema$1 as A,
-  GroupEvidenceExportResultSchema as B,
+  DeleteInspectorGroupsResponseSchema as B,
   CapturedLogSchema as C,
   DEFAULT_CAPTURE_MODE as D,
-  DeleteInspectorGroupResponseSchema as E,
-  providerHasContextMetadata as F,
+  GroupEvidenceExportResultSchema as E,
+  DeleteInspectorGroupResponseSchema as F,
   GroupEvidenceReadResponseSchema as G,
-  maskApiKey as H,
+  providerHasContextMetadata as H,
   InspectorGroupsListResponseSchema as I,
   findProviderModelMetadata as J,
   KnowledgeCandidateSchema as K,
@@ -18817,22 +19312,22 @@ export {
   persistThemeMode as f,
   readStoredUiScalePreference as g,
   persistUiScalePreference as h,
-  applyUiScalePreference as i,
-  normalizeUiScalePreference as j,
-  AnthropicRequestSchema as k,
-  parseOpenAIResponse as l,
-  parseOpenAIResponsesResponse as m,
+  isRecord as i,
+  applyUiScalePreference as j,
+  normalizeUiScalePreference as k,
+  AnthropicRequestSchema as l,
+  parseOpenAIResponse as m,
   normalizeThemeMode as n,
-  OpenAIResponsesRequestSchema as o,
+  parseOpenAIResponsesResponse as o,
   packageJson as p,
-  apiFormatForPath as q,
+  OpenAIResponsesRequestSchema as q,
   readStoredThemeMode as r,
   safeGetOwnProperty as s,
-  getSessionPath as t,
-  stripClaudeCodeBillingHeader as u,
-  isTurnBoundary as v,
-  extractStopReason as w,
-  AlertSummarySchema as x,
-  AlertListResponseSchema as y,
-  DeleteInspectorGroupsResponseSchema as z
+  apiFormatForPath as t,
+  getSessionPath as u,
+  stripClaudeCodeBillingHeader as v,
+  isTurnBoundary as w,
+  extractStopReason as x,
+  AlertSummarySchema as y,
+  AlertListResponseSchema as z
 };