@tonyclaw/agent-inspector 2.0.0

package/src/proxy/config.ts

@@ -0,0 +1,172 @@
+import {
+  writeFileSync,
+  mkdirSync,
+  readFileSync,
+  unlinkSync,
+  existsSync,
+  renameSync,
+  copyFileSync,
+} from "node:fs";
+import { join } from "node:path";
+import { logger } from "./logger";
+import { getDataDir } from "./dataDir";
+import {
+  DEFAULT_SLOW_RESPONSE_THRESHOLD_SECONDS,
+  RuntimeConfigSchema,
+  type RuntimeConfig,
+} from "../lib/runtimeConfig";
+
+// Re-export so server-side callers (api/config.ts, tests) keep the
+// existing import path `from "../../proxy/config"`.
+export { RuntimeConfigSchema };
+export type { RuntimeConfig };
+
+/**
+ * Runtime-mutable server config. Includes proxy behavior flags and UI tuning
+ * settings that should take effect without restarting the dev server. The API
+ * layer reads and writes the same object via `getConfig` / `setConfig`.
+ *
+ * Boot-time precedence (first match wins):
+ *   1. `data/config.json` on disk (persisted state)
+ *   2. `AGENT_INSPECTOR_STRIP_CLAUDE_CODE_BILLING_HEADER` env var
+ *   3. `false` (off by default, to keep the proxy transparent)
+ *
+ * The env var is read once at module init; changing it requires a restart.
+ * Once the user has saved a value via the API, the persisted file takes
+ * precedence over the env var for the lifetime of the process.
+ */
+
+// --- Persistence ---
+
+function getConfigFilePath(): string {
+  return join(getDataDir(), "config.json");
+}
+
+function getConfigTempPath(): string {
+  return join(getDataDir(), "config.json.tmp");
+}
+
+// --- Module state ---
+
+// Internal: writeable singleton. Read via getConfig(), mutate via setConfig().
+let currentConfig: RuntimeConfig = resolveInitialConfig();
+
+function resolveInitialConfig(): RuntimeConfig {
+  // 1. Persisted file
+  const filePath = getConfigFilePath();
+  if (existsSync(filePath)) {
+    try {
+      const content = readFileSync(filePath, "utf-8");
+      const parsed: unknown = JSON.parse(content);
+      const result = RuntimeConfigSchema.safeParse(parsed);
+      if (result.success) {
+        logger.info(`[config] Loaded persisted config from ${filePath}`);
+        return result.data;
+      }
+      logger.warn(
+        `[config] Persisted config at ${filePath} is invalid; falling back to env/default`,
+      );
+    } catch (err) {
+      logger.warn(
+        `[config] Failed to read persisted config at ${filePath}: ${String(err)}; falling back to env/default`,
+      );
+    }
+  }
+
+  // 2. Env var
+  if (process.env["AGENT_INSPECTOR_STRIP_CLAUDE_CODE_BILLING_HEADER"] === "1") {
+    return {
+      stripClaudeCodeBillingHeader: true,
+      hasSeenOnboarding: false,
+      slowResponseThresholdSeconds: DEFAULT_SLOW_RESPONSE_THRESHOLD_SECONDS,
+    };
+  }
+
+  // 3. Default off
+  return {
+    stripClaudeCodeBillingHeader: false,
+    hasSeenOnboarding: false,
+    slowResponseThresholdSeconds: DEFAULT_SLOW_RESPONSE_THRESHOLD_SECONDS,
+  };
+}
+
+/**
+ * Returns the current config. Synchronous; safe to call on the hot path.
+ */
+export function getConfig(): RuntimeConfig {
+  return currentConfig;
+}
+
+/**
+ * Applies a partial update to the in-memory config and persists to disk.
+ * Returns the updated full config. Persistence failures are logged but
+ * do not throw — the in-memory value is always updated so the caller
+ * sees a consistent response.
+ */
+export function setConfig(patch: Partial<RuntimeConfig>): RuntimeConfig {
+  const next: RuntimeConfig = {
+    ...currentConfig,
+    ...patch,
+  };
+  currentConfig = next;
+  persistConfig(next);
+  return next;
+}
+
+/**
+ * For tests: reset the in-memory config to a known value without
+ * touching disk. Use `setConfig` in production code.
+ */
+export function _resetConfigForTests(value: RuntimeConfig): void {
+  currentConfig = value;
+}
+
+/**
+ * For tests: re-run the boot-time resolution against the current env vars
+ * and the on-disk config file, and update the in-memory value. Use this to
+ * test env-var precedence without having to reload the module.
+ */
+export function _rebootForTests(): void {
+  currentConfig = resolveInitialConfig();
+}
+
+// --- Atomic write ---
+
+/**
+ * Atomic write: temp file + rename. Mirrors the pattern in chunkStorage.ts.
+ * Returns true on success, false on failure (logged but not thrown).
+ */
+function persistConfig(value: RuntimeConfig): boolean {
+  const dir = getDataDir();
+  const targetPath = getConfigFilePath();
+  const tempPath = getConfigTempPath();
+
+  try {
+    mkdirSync(dir, { recursive: true });
+  } catch (err) {
+    logger.error(`[config] Failed to create data directory ${dir}: ${String(err)}`);
+    return false;
+  }
+
+  try {
+    writeFileSync(tempPath, JSON.stringify(value), "utf-8");
+  } catch (err) {
+    logger.error(`[config] Failed to write config temp file: ${String(err)}`);
+    return false;
+  }
+
+  try {
+    renameSync(tempPath, targetPath);
+    return true;
+  } catch (err) {
+    logger.warn(`[config] Rename failed, falling back to copy+delete: ${String(err)}`);
+    try {
+      copyFileSync(tempPath, targetPath);
+      unlinkSync(tempPath);
+      return true;
+    } catch (copyErr) {
+      logger.error(`[config] Failed to copy config file: ${String(copyErr)}`);
+      return false;
+    }
+  }
+}

package/src/proxy/constants.ts

@@ -0,0 +1,47 @@
+// Proxy module constants
+
+export const DEFAULT_UPSTREAM = "https://api.anthropic.com";
+export const DEFAULT_OPENAI_UPSTREAM = "https://api.openai.com/v1";
+
+// Unified proxy identity - used as user-agent and x-proxy-identity header value
+export const PROXY_IDENTITY = process.env["PROXY_IDENTITY"] ?? "inspector9527@Tony";
+
+// API paths
+export const PATH_V1_CHAT_COMPLETIONS = "/v1/chat/completions";
+export const PATH_CHAT_COMPLETIONS = "/chat/completions";
+export const PATH_V1_MESSAGES = "/v1/messages";
+
+// Header names
+export const HEADER_CONTENT_TYPE = "content-type";
+export const HEADER_USER_AGENT = "user-agent";
+export const HEADER_X_PROXY_IDENTITY = "x-proxy-identity";
+export const HEADER_AUTHORIZATION = "authorization";
+export const HEADER_X_API_KEY = "x-api-key";
+export const HEADER_CONTENT_ENCODING = "content-encoding";
+export const HEADER_CONTENT_LENGTH = "content-length";
+export const HEADER_HOST = "host";
+
+// Auth header types
+export const AUTH_HEADER_X_API_KEY = "x-api-key";
+
+// Content types
+export const CONTENT_TYPE_EVENT_STREAM = "text/event-stream";
+
+// Response status
+export const STATUS_FORBIDDEN = 403;
+export const STATUS_BAD_GATEWAY = 502;
+
+// Standard/safe headers to preserve when forwarding to upstream.
+// NOTE: Authorization is intentionally excluded to prevent client auth tokens from leaking.
+export const PRESERVE_HEADERS = new Set([HEADER_CONTENT_TYPE]);
+
+// Opt-in rewrite: the *initial* value for the strip-Claude-Code-billing-header
+// flag. The runtime, mutable source of truth is `src/proxy/config.ts`, which
+// reads this constant at module-load time as its precedence-2 fallback (after
+// the persisted `data/config.json`, before the `false` default). After boot,
+// the handler reads `getConfig().stripClaudeCodeBillingHeader` on every
+// request, so a PATCH to `/api/config` (or the Settings → Proxy tab in the UI)
+// takes effect without a restart. The env var itself is read once at boot.
+//
+// What it does: when enabled, the proxy strips the
+// `x-anthropic-billing-header:` text block that Claude Code prepends to the

package/src/proxy/dataDir.ts

@@ -0,0 +1,86 @@
+import { existsSync } from "node:fs";
+import { isAbsolute, join } from "node:path";
+
+const CURRENT_DATA_DIR_NAME = ".agent-inspector";
+const LEGACY_DATA_DIR_NAME = ".llm-inspector";
+
+/**
+ * Compute the directory where agent-inspector stores its on-disk state
+ * (runtime config, providers config, log chunks, etc.). Centralised here
+ * so every store agrees on the same path.
+ *
+ * Resolution order (first match wins):
+ *   1. `AGENT_INSPECTOR_DATA_DIR` env var — absolute path used as-is,
+ *      relative path joined to the OS-specific base below.
+ *   2. `AGENT_INSPECTOR_CONFIG_DIR` env var — kept for backward compat
+ *      with the runtime config; treated as a directory *name* (relative
+ *      to the OS-specific base) when not absolute.
+ *   3. OS-specific base + `.agent-inspector`.
+ *   4. Backward compatibility: if `.agent-inspector` has no known state
+ *      files but `.llm-inspector` does, reuse `.llm-inspector`.
+ *
+ * Windows base is `%USERPROFILE%` (falling back to `%APPDATA%`, then `C:\`).
+ * macOS / Linux base is `$HOME` (falling back to `/tmp`).
+ *
+ * The env var is re-read on every call so tests and the CLI can swap the
+ * directory after this module has been imported.
+ */
+export function getDataDir(): string {
+  return resolveDataDir(existsSync);
+}
+
+type PathExists = (path: string) => boolean;
+type DataDirEnv = Readonly<Record<string, string | undefined>>;
+
+function hasDataDirState(pathExists: PathExists, dir: string): boolean {
+  return (
+    pathExists(join(dir, "providers.json")) ||
+    pathExists(join(dir, "config.json")) ||
+    pathExists(join(dir, "logs")) ||
+    pathExists(join(dir, "chunks"))
+  );
+}
+
+export function resolveDataDir(
+  pathExists: PathExists,
+  env: DataDirEnv = process.env,
+  platform: typeof process.platform = process.platform,
+): string {
+  const isWindows = platform === "win32";
+  const base = isWindows
+    ? (env["USERPROFILE"] ?? env["APPDATA"] ?? "C:\\")
+    : (env["HOME"] ?? "/tmp");
+
+  const dirEnv = env["AGENT_INSPECTOR_DATA_DIR"];
+  if (dirEnv !== undefined && dirEnv !== "") {
+    return isAbsolute(dirEnv) ? dirEnv : join(base, dirEnv);
+  }
+
+  // Backward-compat: the runtime config historically read
+  // `AGENT_INSPECTOR_CONFIG_DIR` as a directory *name* (relative to base).
+  // Honour it so existing CLI scripts keep working.
+  const legacyDirEnv = env["AGENT_INSPECTOR_CONFIG_DIR"];
+  if (legacyDirEnv !== undefined && legacyDirEnv !== "") {
+    return isAbsolute(legacyDirEnv) ? legacyDirEnv : join(base, legacyDirEnv);
+  }
+
+  const currentDir = join(base, CURRENT_DATA_DIR_NAME);
+  const legacyDir = join(base, LEGACY_DATA_DIR_NAME);
+  return !hasDataDirState(pathExists, currentDir) && hasDataDirState(pathExists, legacyDir)
+    ? legacyDir
+    : currentDir;
+}
+
+/**
+ * `true` when the user has explicitly asked for a non-default data
+ * directory. Used to skip the one-time legacy migration so we don't
+ * write to a path the user didn't choose.
+ */
+export function hasExplicitDataDir(): boolean {
+  return (
+    (process.env["AGENT_INSPECTOR_DATA_DIR"] !== undefined &&
+      process.env["AGENT_INSPECTOR_DATA_DIR"] !== "") ||
+    (process.env["AGENT_INSPECTOR_CONFIG_DIR"] !== undefined &&
+      process.env["AGENT_INSPECTOR_CONFIG_DIR"] !== "")
+  );
+}

package/src/proxy/formats/anthropic/anthropicProvider.ts

@@ -0,0 +1,75 @@
+import type { CapturedLog } from "../../schemas";
+import type { ProviderProtocol } from "../protocol";
+import { registry } from "../providers";
+import { extractAnthropicStream } from "./stream";
+
+const DEFAULT_UPSTREAM = "https://api.anthropic.com";
+
+// Default routes - MiniMax is hardcoded here
+const DEFAULT_ROUTES: Record<string, string> = {
+  MiniMax: "https://api.minimaxi.com/anthropic",
+};
+
+function getUpstreamForModel(model: string): string {
+  let bestPrefix = "";
+  let bestUrl = DEFAULT_UPSTREAM;
+
+  for (const [prefix, url] of Object.entries(DEFAULT_ROUTES)) {
+    if (model.startsWith(prefix) && prefix.length > bestPrefix.length) {
+      bestPrefix = prefix;
+      bestUrl = url;
+    }
+  }
+
+  return bestUrl;
+}
+
+/**
+ * Anthropic Provider Implementation
+ */
+export const anthropicProvider: ProviderProtocol = {
+  name: "anthropic",
+
+  matches(model: string): boolean {
+    const modelLower = model.toLowerCase();
+
+    // Don't match OpenAI models
+    if (modelLower.startsWith("openai-")) {
+      return false;
+    }
+
+    // Match Anthropic models
+    if (modelLower.includes("claude") || modelLower.includes("anthropic")) {
+      return true;
+    }
+
+    // Match known route prefixes (e.g., MiniMax)
+    for (const prefix of Object.keys(DEFAULT_ROUTES)) {
+      if (modelLower.startsWith(prefix.toLowerCase())) {
+        return true;
+      }
+    }
+
+    // Default to Anthropic for unknown models (legacy behavior)
+    return true;
+  },
+
+  getUpstreamBase(_isChatCompletions: boolean, providerConfig?: { baseUrl?: string }): string {
+    if (providerConfig?.baseUrl !== undefined) {
+      return providerConfig.baseUrl;
+    }
+    return DEFAULT_UPSTREAM;
+  },
+
+  extractStream(
+    raw: string,
+    log: CapturedLog,
+    fallbackModel?: string,
+    collectChunks?: boolean,
+  ): string {
+    return extractAnthropicStream(raw, log, fallbackModel, collectChunks);
+  },
+};
+
+// Register the provider
+registry.register(anthropicProvider);

package/src/proxy/formats/anthropic/handler.ts

@@ -0,0 +1,71 @@
+import type { FormatHandler, ParsedRequest } from "../handler";
+import type { CapturedLog, TokenUsage } from "../../schemas";
+import { AnthropicRequestSchema, AnthropicResponseSchema } from "./schemas";
+import { extractAnthropicStream } from "./stream";
+
+export const AnthropicFormatHandler: FormatHandler = {
+  format: "anthropic",
+
+  parseRequest(rawBody: string, headers?: Headers): ParsedRequest | null {
+    try {
+      const json: unknown = JSON.parse(rawBody);
+      const result = AnthropicRequestSchema.safeParse(json);
+      if (result.success) {
+        return {
+          model: result.data.model,
+          sessionId: result.data.metadata?.user_id ?? headers?.get("x-session-affinity") ?? null,
+        };
+      }
+      return null;
+    } catch {
+      return null;
+    }
+  },
+
+  extractTokens(responseBody: string): TokenUsage {
+    try {
+      const json: unknown = JSON.parse(responseBody);
+      const result = AnthropicResponseSchema.safeParse(json);
+      if (result.success) {
+        return {
+          inputTokens: result.data.usage.input_tokens ?? null,
+          outputTokens: result.data.usage.output_tokens ?? null,
+          cacheCreationInputTokens: result.data.usage.cache_creation_input_tokens ?? null,
+          cacheReadInputTokens: result.data.usage.cache_read_input_tokens ?? null,
+        };
+      }
+    } catch {
+      // Fall through
+    }
+    return {
+      inputTokens: null,
+      outputTokens: null,
+      cacheCreationInputTokens: null,
+      cacheReadInputTokens: null,
+    };
+  },
+
+  extractStream(
+    raw: string,
+    log: CapturedLog,
+    fallbackModel?: string,
+    collectChunks?: boolean,
+  ): string {
+    return extractAnthropicStream(raw, log, fallbackModel, collectChunks);
+  },
+
+  detectFormat(rawBody: string | null): boolean {
+    if (rawBody === null) return false;
+    try {
+      const json: unknown = JSON.parse(rawBody);
+      if (typeof json === "object" && json !== null && !Array.isArray(json)) {
+        const keys = Object.keys(json);
+        // Anthropic puts `system` as a top-level key alongside `model` and `messages`
+        return keys.includes("model") && keys.includes("messages") && keys.includes("system");
+      }
+      return false;
+    } catch {
+      return false;
+    }
+  },
+};

package/src/proxy/formats/anthropic/index.ts

@@ -0,0 +1,14 @@
+// Register format handler
+import "./register";
+
+export { AnthropicFormatHandler } from "./handler";
+export {
+  AnthropicRequestSchema,
+  AnthropicResponseSchema,
+  SseEventSchema,
+  type AnthropicRequest,
+  type AnthropicResponse,
+  type ResponseContentBlockType,
+} from "./schemas";
+export { extractAnthropicStream } from "./stream";
+export { anthropicProvider } from "./anthropicProvider";

package/src/proxy/formats/anthropic/register.ts

@@ -0,0 +1,4 @@
+import { formatRegistry } from "../registry";
+import { AnthropicFormatHandler } from "./handler";
+
+formatRegistry.register(AnthropicFormatHandler);