@tonyclaw/llm-inspector 1.6.0

package/src/proxy/providers.ts

@@ -0,0 +1,234 @@
+import { z } from "zod";
+import Conf from "conf";
+import { randomUUID } from "crypto";
+
+export const ProviderConfigSchema = z.object({
+  id: z.string(),
+  name: z.string(),
+  apiKey: z.string(),
+  model: z.string().optional(),
+  /** API format: "anthropic" or "openai" */
+  format: z.enum(["anthropic", "openai"]).optional(),
+  /** Base URL for the provider (deprecated - use anthropicBaseUrl/openaiBaseUrl instead) */
+  baseUrl: z.string().optional(),
+  /** Anthropic API base URL */
+  anthropicBaseUrl: z.string().optional(),
+  /** OpenAI API base URL */
+  openaiBaseUrl: z.string().optional(),
+  /** Auth header to use: "bearer" (default) or "x-api-key" */
+  authHeader: z.enum(["bearer", "x-api-key"]).optional().default("bearer"),
+  createdAt: z.string(),
+  updatedAt: z.string(),
+});
+
+export type ProviderConfig = z.infer<typeof ProviderConfigSchema>;
+
+const ProvidersStoreSchema = z.object({
+  providers: z.array(ProviderConfigSchema),
+});
+
+type ProvidersStore = z.infer<typeof ProvidersStoreSchema>;
+
+// Using conf for storage - works in any Node.js environment without Electron
+// Note: conf stores data in plain JSON. For production, consider additional encryption.
+export const store = new Conf<ProvidersStore>({
+  projectName: "llm-inspector",
+  defaults: {
+    providers: [],
+  },
+});
+
+/**
+ * Migrates existing provider configs to preserve both Anthropic and OpenAI URLs.
+ * Old configs had anthropicBaseUrl/openaiBaseUrl, we now keep both.
+ */
+function migrateProviders(): void {
+  const providers = store.get("providers", []);
+  let migrated = false;
+
+  const updated = providers.map((p) => {
+    // Helper to safely get old URL properties using Object.getOwnPropertyDescriptor
+    function getOldUrl(obj: unknown, key: string): string {
+      if (obj !== null && typeof obj === "object") {
+        const desc = Object.getOwnPropertyDescriptor(obj, key);
+        if (desc !== undefined && typeof desc.value === "string") {
+          return desc.value;
+        }
+      }
+      return "";
+    }
+
+    const oldAnthropicBaseUrl = getOldUrl(p, "anthropicBaseUrl");
+    const oldOpenaiBaseUrl = getOldUrl(p, "openaiBaseUrl");
+
+    // If already migrated (has format field and both URLs), skip
+    if (p.format !== undefined && oldAnthropicBaseUrl === "" && oldOpenaiBaseUrl === "") {
+      return p;
+    }
+
+    // Preserve both URLs
+    const newAnthropicUrl =
+      oldAnthropicBaseUrl !== "" ? oldAnthropicBaseUrl : (p.anthropicBaseUrl ?? "");
+    const newOpenaiUrl = oldOpenaiBaseUrl !== "" ? oldOpenaiBaseUrl : (p.openaiBaseUrl ?? "");
+
+    // Determine primary format based on which URL is set
+    let format: "anthropic" | "openai" | undefined;
+    let baseUrl: string | undefined;
+
+    if (newAnthropicUrl !== "" && newOpenaiUrl !== "") {
+      // Both URLs set - prefer anthropic as default, use baseUrl for backward compat
+      format = p.format ?? "anthropic";
+      baseUrl = p.baseUrl !== undefined && p.baseUrl !== "" ? p.baseUrl : newAnthropicUrl;
+    } else if (newOpenaiUrl !== "") {
+      format = "openai";
+      baseUrl = newOpenaiUrl;
+    } else if (newAnthropicUrl !== "") {
+      format = "anthropic";
+      baseUrl = newAnthropicUrl;
+    }
+
+    migrated = true;
+
+    return {
+      ...p,
+      format,
+      baseUrl,
+      anthropicBaseUrl: newAnthropicUrl,
+      openaiBaseUrl: newOpenaiUrl,
+    };
+  });
+
+  if (migrated) {
+    store.set("providers", updated);
+  }
+}
+
+// Run migration on module load
+migrateProviders();
+
+export function getProviders(): ProviderConfig[] {
+  return store.get("providers", []);
+}
+
+export function getProvider(id: string): ProviderConfig | undefined {
+  const providers = getProviders();
+  return providers.find((p) => p.id === id);
+}
+
+/**
+ * Normalizes an API key by stripping "Bearer " prefix if present.
+ */
+function normalizeApiKey(apiKey: string): string {
+  return apiKey.replace(/^Bearer\s+/i, "").trim();
+}
+
+export function addProvider(
+  name: string,
+  apiKey: string,
+  format: "anthropic" | "openai",
+  baseUrl?: string,
+  model?: string,
+  authHeader?: "bearer" | "x-api-key",
+): ProviderConfig {
+  const providers = getProviders();
+  const now = new Date().toISOString();
+  const newProvider: ProviderConfig = {
+    id: randomUUID(),
+    name,
+    apiKey: normalizeApiKey(apiKey),
+    format,
+    baseUrl,
+    model,
+    authHeader: authHeader ?? "bearer",
+    createdAt: now,
+    updatedAt: now,
+  };
+  providers.push(newProvider);
+  store.set("providers", providers);
+  return newProvider;
+}
+
+export function updateProvider(
+  id: string,
+  updates: Partial<Omit<ProviderConfig, "id" | "createdAt">>,
+): ProviderConfig | null {
+  const providers = getProviders();
+  const existing = providers.find((p) => p.id === id);
+  if (!existing) return null;
+
+  const updated: ProviderConfig = {
+    id: existing.id,
+    name: updates.name ?? existing.name,
+    apiKey: updates.apiKey !== undefined ? normalizeApiKey(updates.apiKey) : existing.apiKey,
+    model: updates.model !== undefined ? updates.model : existing.model,
+    format: updates.format ?? existing.format,
+    baseUrl: updates.baseUrl !== undefined ? updates.baseUrl : existing.baseUrl,
+    authHeader: updates.authHeader ?? existing.authHeader,
+    createdAt: existing.createdAt,
+    updatedAt: new Date().toISOString(),
+  };
+  const index = providers.findIndex((p) => p.id === id);
+  providers[index] = updated;
+  store.set("providers", providers);
+  return updated;
+}
+
+export function deleteProvider(id: string): boolean {
+  const providers = getProviders();
+  const filtered = providers.filter((p) => p.id !== id);
+  if (filtered.length === providers.length) return false;
+
+  store.set("providers", filtered);
+  return true;
+}
+
+/**
+ * Converts display model name to API usage name based on provider-specific rules.
+ * Default behavior: returns model as-is.
+ * MiniMax: replaces spaces with hyphens.
+ */
+export function getModelUsageName(model: string, providerName?: string): string {
+  if (
+    providerName !== undefined &&
+    providerName !== "" &&
+    providerName.toLowerCase().includes("minimax")
+  ) {
+    return model.replace(/ /g, "-");
+  }
+  return model;
+}
+
+/**
+ * Normalize a model name for comparison: lowercase, replace whitespace with hyphens.
+ */
+function normalizeModelName(name: string): string {
+  return name.toLowerCase().replace(/\s+/g, "-");
+}
+
+/**
+ * Finds a provider by model name using two strategies:
+ * 1. Case-insensitive prefix match against "{provider.name}-" (e.g., "deepseek-" matches "deepseek-*")
+ * 2. Case-insensitive match against provider.model field (with whitespace/hyphen normalization)
+ */
+export function findProviderByModel(model: string): ProviderConfig | null {
+  const providers = getProviders();
+  const modelLower = model.toLowerCase();
+  const modelNormalized = normalizeModelName(model);
+
+  for (const provider of providers) {
+    // Strategy 1: provider name prefix match
+    const providerPrefix = (provider.name + "-").toLowerCase();
+    if (modelLower.startsWith(providerPrefix)) {
+      return provider;
+    }
+    // Strategy 2: match against provider.model field with normalization
+    if (
+      provider.model !== undefined &&
+      provider.model !== "" &&
+      modelNormalized === normalizeModelName(provider.model)
+    ) {
+      return provider;
+    }
+  }
+  return null;
+}

package/src/proxy/schemas.ts

@@ -0,0 +1,160 @@
+import { z } from "zod";
+
+// Import JsonValueSchema from shared location to avoid circular dependency
+import { JsonValueSchema, type JsonValue } from "./formats/jsonSchema";
+
+export { JsonValueSchema };
+export type { JsonValue };
+
+export type RequestFormat = "anthropic" | "openai" | "unknown";
+
+function safeGetProperty(obj: unknown, key: string): unknown {
+  if (obj === null || typeof obj !== "object" || Array.isArray(obj)) return undefined;
+  const desc = Object.getOwnPropertyDescriptor(obj, key);
+  return desc?.value;
+}
+
+/**
+ * A single SSE event from a streaming response.
+ */
+export const StreamingChunkSchema = z.object({
+  index: z.number(),
+  timestamp: z.number(),
+  type: z.string(),
+  data: JsonValueSchema,
+});
+
+export type StreamingChunk = z.infer<typeof StreamingChunkSchema>;
+
+const StreamingChunksArraySchema = z.object({
+  chunks: z.array(StreamingChunkSchema),
+  truncated: z.boolean().optional().default(false),
+});
+
+export const CapturedLogSchema = z.object({
+  id: z.number(),
+  timestamp: z.string(),
+  method: z.string(),
+  path: z.string(),
+  model: z.string().nullable(),
+  sessionId: z.string().nullable(),
+  rawRequestBody: z.string().nullable(),
+  responseStatus: z.number().nullable(),
+  responseText: z.string().nullable(),
+  inputTokens: z.number().nullable(),
+  outputTokens: z.number().nullable(),
+  cacheCreationInputTokens: z.number().nullable(),
+  cacheReadInputTokens: z.number().nullable(),
+  elapsedMs: z.number().nullable(),
+  streaming: z.boolean(),
+  userAgent: z.string().nullable(),
+  origin: z.string().nullable(),
+  rawHeaders: z.record(z.string(), z.string()).optional(),
+  /** Headers sent to the upstream LLM */
+  headers: z.record(z.string(), z.string()).optional(),
+  apiFormat: z.enum(["anthropic", "openai", "unknown"]).default("unknown"),
+  isTest: z.boolean().optional().default(false),
+  providerName: z.string().nullable().optional(),
+  clientPort: z.number().nullable().optional(),
+  clientPid: z.number().nullable().optional(),
+  clientCwd: z.string().nullable().optional(),
+  clientProjectFolder: z.string().nullable().optional(),
+  streamingChunks: StreamingChunksArraySchema.optional(),
+  streamingChunksPath: z.string().nullable().optional(),
+});
+
+export type CapturedLog = z.infer<typeof CapturedLogSchema>;
+
+export type TokenUsage = {
+  inputTokens: number | null;
+  outputTokens: number | null;
+  cacheCreationInputTokens: number | null;
+  cacheReadInputTokens: number | null;
+};
+
+// ============================================================
+// Import types and schemas from formats
+// ============================================================
+
+// Import types and schemas from formats for internal use
+import { InspectorRequestSchema, type InspectorRequest } from "./formats/anthropic/schemas";
+
+// Re-export types and schemas from formats for backward compatibility
+export {
+  InspectorRequestSchema,
+  InspectorResponseSchema,
+  SseEventSchema,
+} from "./formats/anthropic/schemas";
+export type {
+  InspectorRequest,
+  InspectorResponse,
+  ResponseContentBlockType,
+} from "./formats/anthropic/schemas";
+
+export {
+  OpenAIRequestSchema,
+  OpenAIResponseSchema,
+  OpenAISSERawChunkSchema,
+  type OpenAIResponse,
+  parseOpenAIResponse,
+} from "./formats/openai/schemas";
+
+// ============================================================
+// Utility functions
+// ============================================================
+
+function detectFormat(rawBody: string | null): RequestFormat {
+  if (rawBody === null) return "unknown";
+  try {
+    const json: unknown = JSON.parse(rawBody);
+    if (typeof json === "object" && json !== null && !Array.isArray(json)) {
+      const keys = Object.keys(json);
+      if (keys.includes("model") && keys.includes("messages")) {
+        if (keys.includes("system") || keys.includes("tools")) {
+          return "anthropic";
+        }
+        const msgVal = safeGetProperty(json, "messages");
+        if (Array.isArray(msgVal)) {
+          return "openai";
+        }
+      }
+    }
+    return "unknown";
+  } catch {
+    return "unknown";
+  }
+}
+
+// Schema for model name in request body (used for routing)
+const RequestModelSchema = z.object({
+  model: z.string(),
+});
+
+export function extractModelFromBody(body: string): string | null {
+  try {
+    const json: unknown = JSON.parse(body);
+    const parsed = RequestModelSchema.safeParse(json);
+    if (parsed.success) {
+      return parsed.data.model;
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Parse a raw request body into an InspectorRequest.
+ * @deprecated Use FormatHandler.parseRequest() instead
+ */
+export function parseRequest(rawBody: string | null): InspectorRequest | null {
+  if (rawBody === null) return null;
+  try {
+    const json: unknown = JSON.parse(rawBody);
+    const result = InspectorRequestSchema.safeParse(json);
+    if (result.success) return result.data;
+    return null;
+  } catch {
+    return null;
+  }
+}

package/src/proxy/socketTracker.ts

@@ -0,0 +1,158 @@
+import { exec } from "node:child_process";
+import { promisify } from "node:util";
+
+const execAsync = promisify(exec);
+
+type ClientInfo = {
+  port: number | null;
+  pid: number | null;
+  cwd: string | null;
+  projectFolder: string | null;
+};
+
+type CacheEntry = ClientInfo & {
+  expiresAt: number;
+};
+
+// Cache entries: port -> { pid, cwd, projectFolder, expiresAt }
+const cache = new Map<number, CacheEntry>();
+
+// Cache TTL in milliseconds (5 minutes)
+const CACHE_TTL_MS = 5 * 60 * 1000;
+
+function getFromCache(port: number): ClientInfo | null {
+  const entry = cache.get(port);
+  if (entry && Date.now() < entry.expiresAt) {
+    return { port: entry.port, pid: entry.pid, cwd: entry.cwd, projectFolder: entry.projectFolder };
+  }
+  // Expired or not found
+  if (entry) cache.delete(port);
+  return null;
+}
+
+function setCache(port: number, info: ClientInfo): void {
+  cache.set(port, { ...info, expiresAt: Date.now() + CACHE_TTL_MS });
+}
+
+/**
+ * Get the remote port from a Request's underlying socket.
+ * Works with Bun, Node.js, and Nitro's event.node.req.
+ */
+function extractRemotePort(request: Request): number | null {
+  // Try Bun's socket property by accessing the underlying socket
+  // Bun's Request has a socket property with remotePort that standard Request doesn't have
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/consistent-type-assertions, @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-member-access
+  const socket = (request as any).socket;
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/consistent-type-assertions, @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-member-access
+  const remotePort = (socket as any)?.remotePort;
+  // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+  if (remotePort !== undefined && remotePort !== null) return remotePort;
+
+  // Try to get from headers (some proxies add x-forwarded-port)
+  // This is a fallback - not all requests will have this
+
+  return null;
+}
+
+/**
+ * Look up PID from a local port using netstat.
+ * Returns PID as number, or null if not found.
+ */
+async function lookupPidByPort(port: number): Promise<number | null> {
+  try {
+    // netstat -aon finds all connections with port, -n avoids DNS resolution
+    // Filter by ESTABLISHED connections on the specific port
+    const { stdout } = await execAsync(`netstat -aon | findstr :${port} | findstr ESTABLISHED`, {
+      windowsHide: true,
+    });
+
+    const lines = stdout.trim().split("\n").filter(Boolean);
+    for (const line of lines) {
+      // Format: TCP    127.0.0.1:12345    127.0.0.1:54321    ESTABLISHED    12345
+      // The last space-separated token is the PID
+      const parts = line.trim().split(/\s+/);
+      const lastPart = parts[parts.length - 1];
+      if (lastPart !== undefined) {
+        const pid = parseInt(lastPart, 10);
+        if (!isNaN(pid) && pid > 0) return pid;
+      }
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Get the working directory and command line for a process by PID.
+ * Returns { cwd, projectFolder } or { cwd: null, projectFolder: null }.
+ */
+async function lookupProcessInfo(
+  pid: number,
+): Promise<{ cwd: string | null; projectFolder: string | null }> {
+  try {
+    // Use wmic to get the full command line
+    const { stdout } = await execAsync(
+      `wmic process where processid=${pid} get commandline /value`,
+      { windowsHide: true },
+    );
+
+    const lines = stdout.trim().split("\n").filter(Boolean);
+    for (const line of lines) {
+      if (line.includes("=")) {
+        const commandLine = (line.split("=")[1] ?? "").trim();
+        if (commandLine) {
+          // Extract CWD from command line
+          // The command typically looks like: "C:\path\to\ai-tool\resources\app\bin\cli\win32-x64\tool.exe" ...
+          // or "C:\Users\user\AppData\Local\Programs\Claude\Claude.exe" --some-flag
+          // We need to find the working directory - it's usually the directory containing the exe
+          // but we also need to check if a --parent-dir flag was passed
+
+          // Parse the command line to find the executable path
+          const exeMatch = commandLine.match(/^"([^"]+)"/) || commandLine.match(/^([^\s]+)/);
+          if (exeMatch && exeMatch[1] !== undefined) {
+            const exePath = exeMatch[1];
+            const exeDir = exePath.substring(0, exePath.lastIndexOf("\\"));
+            return {
+              cwd: exeDir,
+              projectFolder: exeDir.split("\\").pop() ?? null,
+            };
+          }
+        }
+      }
+    }
+    return { cwd: null, projectFolder: null };
+  } catch {
+    return { cwd: null, projectFolder: null };
+  }
+}
+
+/**
+ * Get client info (PID, CWD, project folder) from a request's source port.
+ * Uses caching to avoid repeated netstat/wmic calls.
+ */
+export async function getClientInfo(request: Request): Promise<ClientInfo> {
+  const port = extractRemotePort(request);
+  if (port === null) {
+    return { port: null, pid: null, cwd: null, projectFolder: null };
+  }
+
+  // Check cache first
+  const cached = getFromCache(port);
+  if (cached) return cached;
+
+  // Lookup PID from port
+  const pid = await lookupPidByPort(port);
+  if (pid === null) {
+    const info = { port, pid: null, cwd: null, projectFolder: null };
+    setCache(port, info);
+    return info;
+  }
+
+  // Lookup process info from PID
+  const { cwd, projectFolder } = await lookupProcessInfo(pid);
+
+  const info = { port, pid, cwd, projectFolder };
+  setCache(port, info);
+  return info;
+}