@tonyclaw/agent-inspector 4.0.1 → 4.0.3

package/src/proxy/providerImporters.ts

@@ -1,578 +0,0 @@
-import { existsSync, readFileSync } from "node:fs";
-import { homedir } from "node:os";
-import { join } from "node:path";
-import { getProviders } from "./providers";
-import { normalizeApiKey } from "./providers";
-import type { ProviderConfig } from "../lib/providerContract";
-import { isPlainRecord } from "../lib/objectUtils";
-
-export type ExternalProvider = {
-  name: string;
-  apiKey: string;
-  format: "anthropic" | "openai";
-  anthropicBaseUrl: string;
-  openaiBaseUrl: string;
-  openaiResponsesBaseUrl: string;
-  models: string[];
-  sourceTool: "claude-code" | "opencode" | "mimo-code";
-  alreadyExists: boolean;
-};
-
-const ZHIPU_OPENAI_BASE_URL = "https://open.bigmodel.cn/api/paas/v4";
-const ZHIPU_CODING_OPENAI_BASE_URL = "https://open.bigmodel.cn/api/coding/paas/v4";
-const ZHIPU_CODING_ANTHROPIC_BASE_URL = "https://open.bigmodel.cn/api/anthropic";
-const MINIMAX_OPENAI_BASE_URL = "https://api.minimaxi.com";
-
-function defaultOpenAIResponsesBaseUrl(providerId: string): string {
-  const normalized = providerId.toLowerCase();
-  return normalized === "minimax" || normalized.startsWith("minimax-")
-    ? MINIMAX_OPENAI_BASE_URL
-    : "";
-}
-
-function openAIResponsesBaseUrlMatchesExisting(
-  provider: ProviderConfig,
-  externalProvider: ExternalProvider,
-): boolean {
-  const existingUrl = provider.openaiResponsesBaseUrl ?? "";
-  if (existingUrl === externalProvider.openaiResponsesBaseUrl) return true;
-
-  const defaultUrl = defaultOpenAIResponsesBaseUrl(externalProvider.name);
-  if (defaultUrl === "") return false;
-
-  return (
-    (existingUrl === "" && externalProvider.openaiResponsesBaseUrl === defaultUrl) ||
-    (existingUrl === defaultUrl && externalProvider.openaiResponsesBaseUrl === "")
-  );
-}
-
-function readJsonSafe(filePath: string): Record<string, unknown> | null {
-  try {
-    if (!existsSync(filePath)) return null;
-    const raw = readFileSync(filePath, "utf-8");
-    const parsed: unknown = JSON.parse(raw);
-    return isPlainRecord(parsed) ? parsed : null;
-  } catch {
-    return null;
-  }
-}
-
-function getEnvValue(envObj: unknown, key: string): string | undefined {
-  if (!isPlainRecord(envObj)) return undefined;
-  const val = envObj[key];
-  return typeof val === "string" ? val.trim() : undefined;
-}
-
-// Map of well-known API hostnames to their proper brand names.
-// The key is the domain (second-level domain extracted from the hostname),
-// matched case-insensitively.
-const KNOWN_PROVIDER_NAMES: Record<string, string> = {
-  deepseek: "DeepSeek",
-  minimaxi: "MiniMax",
-  openai: "OpenAI",
-  anthropic: "Anthropic",
-  openrouter: "OpenRouter",
-  groq: "Groq",
-  together: "Together",
-  fireworks: "Fireworks",
-  bedrock: "Bedrock",
-  vertexai: "Vertex AI",
-  azure: "Azure",
-  moonshot: "Moonshot",
-  zhipu: "ZhipuAI",
-  zhipuai: "ZhipuAI",
-  bigmodel: "ZhipuAI",
-  zai: "Z.AI",
-  qwen: "Qwen",
-  baichuan: "Baichuan",
-  iflytek: "iFlytek",
-  doubao: "Doubao",
-  lingyiwanwu: "LingyiWanwu",
-  stepfun: "StepFun",
-};
-
-function deriveNameFromUrl(url: string): string {
-  try {
-    const hostname = new URL(url).hostname;
-    const parts = hostname.split(".");
-    const domain = parts.length >= 2 ? (parts[parts.length - 2] ?? hostname) : hostname;
-    const domainLower = domain.toLowerCase();
-    // Check known providers first
-    if (KNOWN_PROVIDER_NAMES[domainLower] !== undefined) {
-      return KNOWN_PROVIDER_NAMES[domainLower];
-    }
-    return domain.charAt(0).toUpperCase() + domain.slice(1);
-  } catch {
-    return "Imported Provider";
-  }
-}
-
-// ── Claude Code ──────────────────────────────────────────
-
-function detectClaudeCodeProviders(): ExternalProvider[] {
-  const home = homedir();
-  const results: ExternalProvider[] = [];
-
-  // Read global + local settings, local takes precedence
-  const globalConfig = readJsonSafe(join(home, ".claude", "settings.json"));
-  const localConfig = readJsonSafe(join(home, ".claude", "settings.local.json"));
-
-  const mergedEnv: Record<string, unknown> = {};
-  if (isPlainRecord(globalConfig)) {
-    const env = globalConfig["env"];
-    if (isPlainRecord(env)) {
-      Object.assign(mergedEnv, env);
-    }
-  }
-  if (isPlainRecord(localConfig)) {
-    const env = localConfig["env"];
-    if (isPlainRecord(env)) {
-      Object.assign(mergedEnv, env);
-    }
-  }
-
-  const baseUrl = getEnvValue(mergedEnv, "ANTHROPIC_BASE_URL");
-  const authToken =
-    getEnvValue(mergedEnv, "ANTHROPIC_AUTH_TOKEN") ?? getEnvValue(mergedEnv, "ANTHROPIC_API_KEY");
-
-  if (baseUrl === undefined || baseUrl === "" || authToken === undefined || authToken === "") {
-    return results;
-  }
-
-  // Collect unique models
-  const modelSet = new Set<string>();
-  const modelKeys = [
-    "ANTHROPIC_MODEL",
-    "ANTHROPIC_DEFAULT_OPUS_MODEL",
-    "ANTHROPIC_DEFAULT_SONNET_MODEL",
-    "ANTHROPIC_DEFAULT_HAIKU_MODEL",
-  ];
-  for (const key of modelKeys) {
-    const val = getEnvValue(mergedEnv, key);
-    if (val !== undefined && val !== "") modelSet.add(val);
-  }
-  const models = modelSet.size > 0 ? [...modelSet] : ["default"];
-
-  results.push({
-    name: deriveNameFromUrl(baseUrl),
-    apiKey: normalizeApiKey(authToken),
-    format: "anthropic",
-    anthropicBaseUrl: baseUrl,
-    openaiBaseUrl: "",
-    openaiResponsesBaseUrl: "",
-    models,
-    sourceTool: "claude-code",
-    alreadyExists: false, // filled in later
-  });
-
-  return results;
-}
-
-// ── OpenCode ─────────────────────────────────────────────
-
-function detectOpenCodeProviders(): ExternalProvider[] {
-  const home = homedir();
-  const results: ExternalProvider[] = [];
-
-  const config = readJsonSafe(join(home, ".config", "opencode", "opencode.json"));
-  if (config === null) return results;
-
-  // Read auth.json (separate credentials file)
-  const auth = readJsonSafe(join(home, ".local", "share", "opencode", "auth.json"));
-
-  const providersVal = config["provider"];
-  if (!isPlainRecord(providersVal)) {
-    return results;
-  }
-  const providers: Record<string, unknown> = providersVal;
-
-  for (const [providerId, providerObj] of Object.entries(providers)) {
-    if (!isPlainRecord(providerObj)) continue;
-
-    const options = providerObj["options"];
-    const npm: unknown = providerObj["npm"];
-    const npmStr = typeof npm === "string" ? npm : "";
-    const format: "anthropic" | "openai" = npmStr === "@ai-sdk/anthropic" ? "anthropic" : "openai";
-
-    let baseURL = "";
-    let apiKey = "";
-    if (isPlainRecord(options)) {
-      baseURL = typeof options["baseURL"] === "string" ? options["baseURL"].trim() : "";
-      apiKey = typeof options["apiKey"] === "string" ? options["apiKey"].trim() : "";
-    }
-
-    // Resolve apiKey: prefer inline, fallback to auth.json
-    if (apiKey === "" && isPlainRecord(auth)) {
-      const cred = auth[providerId];
-      if (isPlainRecord(cred)) {
-        const key: unknown = cred["key"];
-        if (typeof key === "string" && key !== "") apiKey = key;
-      }
-    }
-
-    if (baseURL === "" || apiKey === "") continue;
-
-    // Collect models
-    const modelSet = new Set<string>();
-    const modelsObj = providerObj["models"];
-
-    if (isPlainRecord(modelsObj)) {
-      for (const [modelId, modelDef] of Object.entries(modelsObj)) {
-        if (typeof modelDef === "string") {
-          modelSet.add(modelDef);
-        } else if (isPlainRecord(modelDef)) {
-          // modelId is the actual model identifier sent to the remote API
-          modelSet.add(modelId);
-        } else {
-          modelSet.add(modelId);
-        }
-      }
-    }
-    const models = modelSet.size > 0 ? [...modelSet] : ["default"];
-
-    results.push({
-      name: providerId,
-      apiKey: normalizeApiKey(apiKey),
-      format,
-      anthropicBaseUrl: format === "anthropic" ? baseURL : "",
-      openaiBaseUrl: format === "openai" ? baseURL : "",
-      openaiResponsesBaseUrl: defaultOpenAIResponsesBaseUrl(providerId),
-      models,
-      sourceTool: "opencode",
-      alreadyExists: false,
-    });
-  }
-
-  return results;
-}
-
-// ── MiMo Code ────────────────────────────────────────────
-
-function stripJsoncComments(raw: string): string {
-  let result = "";
-  let i = 0;
-  let inString = false;
-  let stringChar = "";
-
-  while (i < raw.length) {
-    const ch = raw[i];
-    const next = raw[i + 1];
-
-    if (inString) {
-      if (ch === "\\" && next !== undefined) {
-        result += ch + next;
-        i += 2;
-        continue;
-      }
-      if (ch === stringChar) {
-        inString = false;
-        stringChar = "";
-      }
-      result += ch;
-      i += 1;
-      continue;
-    }
-
-    if (ch === '"' || ch === "'") {
-      inString = true;
-      stringChar = ch;
-      result += ch;
-      i += 1;
-      continue;
-    }
-
-    if (ch === "/" && next === "/") {
-      while (i < raw.length && raw[i] !== "\n") {
-        i += 1;
-      }
-      continue;
-    }
-
-    if (ch === "/" && next === "*") {
-      i += 2;
-      while (i < raw.length - 1 && !(raw[i] === "*" && raw[i + 1] === "/")) {
-        i += 1;
-      }
-      i += 2;
-      continue;
-    }
-
-    result += ch;
-    i += 1;
-  }
-
-  return result;
-}
-
-function readJsonCSafe(filePath: string): Record<string, unknown> | null {
-  try {
-    if (!existsSync(filePath)) return null;
-    const raw = readFileSync(filePath, "utf-8");
-    const stripped = stripJsoncComments(raw);
-    const parsed: unknown = JSON.parse(stripped);
-    return isPlainRecord(parsed) ? parsed : null;
-  } catch {
-    return null;
-  }
-}
-
-function detectMiMoCodeProviders(): ExternalProvider[] {
-  const home = homedir();
-  const results: ExternalProvider[] = [];
-
-  const config =
-    readJsonCSafe(join(home, ".config", "mimocode", "mimocode.jsonc")) ??
-    readJsonCSafe(join(home, ".config", "mimocode", "mimocode.json")) ??
-    readJsonCSafe(join(home, ".config", "mimocode", "config.jsonc")) ??
-    readJsonCSafe(join(home, ".config", "mimocode", "config.json")) ??
-    readJsonCSafe(join(home, ".mimocode", "config.jsonc")) ??
-    readJsonCSafe(join(home, ".mimocode", "config.json"));
-
-  const auth = readJsonSafe(join(home, ".local", "share", "mimocode", "auth.json"));
-
-  // Process providers from config (if config exists and has a provider section)
-  const providersVal = config?.["provider"];
-  const configProviders: Record<string, unknown> = isPlainRecord(providersVal) ? providersVal : {};
-
-  for (const [providerId, providerObj] of Object.entries(configProviders)) {
-    if (!isPlainRecord(providerObj)) continue;
-
-    const options = providerObj["options"];
-    const npm: unknown = providerObj["npm"];
-    const npmStr = typeof npm === "string" ? npm : "";
-    const format: "anthropic" | "openai" = npmStr === "@ai-sdk/anthropic" ? "anthropic" : "openai";
-
-    let baseURL = "";
-    let apiKey = "";
-    if (isPlainRecord(options)) {
-      baseURL = typeof options["baseURL"] === "string" ? options["baseURL"].trim() : "";
-      apiKey = typeof options["apiKey"] === "string" ? options["apiKey"].trim() : "";
-    }
-
-    if (apiKey === "" && isPlainRecord(auth)) {
-      const cred = auth[providerId];
-      if (isPlainRecord(cred)) {
-        const key: unknown = cred["key"];
-        if (typeof key === "string" && key !== "") apiKey = key;
-      }
-    }
-
-    if (baseURL === "" || apiKey === "") continue;
-
-    const modelSet = new Set<string>();
-    const modelsObj = providerObj["models"];
-
-    if (isPlainRecord(modelsObj)) {
-      for (const [modelId, modelDef] of Object.entries(modelsObj)) {
-        if (typeof modelDef === "string") {
-          modelSet.add(modelDef);
-        } else if (isPlainRecord(modelDef)) {
-          modelSet.add(modelId);
-        } else {
-          modelSet.add(modelId);
-        }
-      }
-    }
-    const models = modelSet.size > 0 ? [...modelSet] : ["default"];
-
-    results.push({
-      name: providerId,
-      apiKey: normalizeApiKey(apiKey),
-      format,
-      anthropicBaseUrl: format === "anthropic" ? baseURL : "",
-      openaiBaseUrl: format === "openai" ? baseURL : "",
-      openaiResponsesBaseUrl: defaultOpenAIResponsesBaseUrl(providerId),
-      models,
-      sourceTool: "mimo-code",
-      alreadyExists: false,
-    });
-  }
-
-  // Scan orphan auth.json entries not referenced in config
-  if (isPlainRecord(auth)) {
-    const knownDefaults: Record<
-      string,
-      {
-        anthropicBaseUrl: string;
-        openaiBaseUrl: string;
-        openaiResponsesBaseUrl?: string;
-        format: "anthropic" | "openai";
-      }
-    > = {
-      deepseek: {
-        anthropicBaseUrl: "https://api.deepseek.com/anthropic",
-        openaiBaseUrl: "https://api.deepseek.com",
-        format: "anthropic",
-      },
-      minimax: {
-        anthropicBaseUrl: "https://api.minimaxi.com/anthropic",
-        openaiBaseUrl: MINIMAX_OPENAI_BASE_URL,
-        openaiResponsesBaseUrl: MINIMAX_OPENAI_BASE_URL,
-        format: "anthropic",
-      },
-      "minimax-coding-plan": {
-        anthropicBaseUrl: "https://api.minimaxi.com/anthropic",
-        openaiBaseUrl: MINIMAX_OPENAI_BASE_URL,
-        openaiResponsesBaseUrl: MINIMAX_OPENAI_BASE_URL,
-        format: "anthropic",
-      },
-      openai: {
-        anthropicBaseUrl: "",
-        openaiBaseUrl: "https://api.openai.com",
-        format: "openai",
-      },
-      anthropic: {
-        anthropicBaseUrl: "https://api.anthropic.com",
-        openaiBaseUrl: "",
-        format: "anthropic",
-      },
-      groq: {
-        anthropicBaseUrl: "",
-        openaiBaseUrl: "https://api.groq.com/openai",
-        format: "openai",
-      },
-      openrouter: {
-        anthropicBaseUrl: "",
-        openaiBaseUrl: "https://openrouter.ai/api",
-        format: "openai",
-      },
-      together: {
-        anthropicBaseUrl: "",
-        openaiBaseUrl: "https://api.together.xyz",
-        format: "openai",
-      },
-      zhipu: {
-        anthropicBaseUrl: "",
-        openaiBaseUrl: ZHIPU_OPENAI_BASE_URL,
-        format: "openai",
-      },
-      zhipuai: {
-        anthropicBaseUrl: "",
-        openaiBaseUrl: ZHIPU_OPENAI_BASE_URL,
-        format: "openai",
-      },
-      bigmodel: {
-        anthropicBaseUrl: "",
-        openaiBaseUrl: ZHIPU_OPENAI_BASE_URL,
-        format: "openai",
-      },
-      zai: {
-        anthropicBaseUrl: "",
-        openaiBaseUrl: ZHIPU_OPENAI_BASE_URL,
-        format: "openai",
-      },
-      glm: {
-        anthropicBaseUrl: ZHIPU_CODING_ANTHROPIC_BASE_URL,
-        openaiBaseUrl: ZHIPU_CODING_OPENAI_BASE_URL,
-        format: "anthropic",
-      },
-      "glm-coding-plan": {
-        anthropicBaseUrl: ZHIPU_CODING_ANTHROPIC_BASE_URL,
-        openaiBaseUrl: ZHIPU_CODING_OPENAI_BASE_URL,
-        format: "anthropic",
-      },
-      "zhipu-coding-plan": {
-        anthropicBaseUrl: ZHIPU_CODING_ANTHROPIC_BASE_URL,
-        openaiBaseUrl: ZHIPU_CODING_OPENAI_BASE_URL,
-        format: "anthropic",
-      },
-      "zai-coding-plan": {
-        anthropicBaseUrl: ZHIPU_CODING_ANTHROPIC_BASE_URL,
-        openaiBaseUrl: ZHIPU_CODING_OPENAI_BASE_URL,
-        format: "anthropic",
-      },
-    };
-
-    for (const [key, cred] of Object.entries(auth)) {
-      if (configProviders[key] !== undefined) continue;
-      if (!isPlainRecord(cred)) continue;
-      const apiKey: unknown = cred["key"];
-      if (typeof apiKey !== "string" || apiKey === "") continue;
-
-      let defaults = knownDefaults[key.toLowerCase()];
-      if (defaults === undefined) {
-        for (const [knownKey, cfg] of Object.entries(knownDefaults)) {
-          if (key.toLowerCase().startsWith(knownKey)) {
-            defaults = cfg;
-            break;
-          }
-        }
-      }
-      if (defaults === undefined) continue;
-
-      results.push({
-        name: key,
-        apiKey: normalizeApiKey(apiKey),
-        format: defaults.format,
-        anthropicBaseUrl: defaults.anthropicBaseUrl,
-        openaiBaseUrl: defaults.openaiBaseUrl,
-        openaiResponsesBaseUrl:
-          defaults.openaiResponsesBaseUrl ?? defaultOpenAIResponsesBaseUrl(key),
-        models: ["default"],
-        sourceTool: "mimo-code",
-        alreadyExists: false,
-      });
-    }
-  }
-
-  return results;
-}
-
-// ── Combined scanner ─────────────────────────────────────
-
-export function scanExternalProviders(): { providers: ExternalProvider[]; warnings: string[] } {
-  const warnings: string[] = [];
-
-  let claudeProviders: ExternalProvider[] = [];
-  try {
-    claudeProviders = detectClaudeCodeProviders();
-  } catch (err) {
-    warnings.push(`Claude Code: ${err instanceof Error ? err.message : String(err)}`);
-  }
-
-  let opencodeProviders: ExternalProvider[] = [];
-  try {
-    opencodeProviders = detectOpenCodeProviders();
-  } catch (err) {
-    warnings.push(`OpenCode: ${err instanceof Error ? err.message : String(err)}`);
-  }
-
-  let mimoProviders: ExternalProvider[] = [];
-  try {
-    mimoProviders = detectMiMoCodeProviders();
-  } catch (err) {
-    warnings.push(`MiMo Code: ${err instanceof Error ? err.message : String(err)}`);
-  }
-
-  const allProviders = [...claudeProviders, ...opencodeProviders, ...mimoProviders];
-
-  // Filter out providers already using the localhost proxy (already switched)
-  const filteredProviders = allProviders.filter((p) => {
-    const url = p.anthropicBaseUrl || p.openaiBaseUrl || p.openaiResponsesBaseUrl;
-    return !/(?:localhost|127\.0\.0\.1)/.test(url);
-  });
-
-  // Mark already-existing providers (same apiKey + format-specific baseUrl)
-  let existing: ProviderConfig[] = [];
-  try {
-    existing = getProviders();
-  } catch {
-    // If we can't load existing providers, just skip the duplicate check
-  }
-
-  for (const ext of filteredProviders) {
-    ext.alreadyExists = existing.some((p) => {
-      if (p.apiKey !== ext.apiKey) return false;
-      // Match on the format-specific base URL (external providers only set one)
-      if (ext.format === "anthropic") {
-        return (p.anthropicBaseUrl ?? "") === ext.anthropicBaseUrl;
-      }
-      return (
-        (p.openaiBaseUrl ?? "") === ext.openaiBaseUrl &&
-        openAIResponsesBaseUrlMatchesExisting(p, ext)
-      );
-    });
-  }
-
-  return { providers: filteredProviders, warnings };
-}

package/src/proxy/providerScanStore.ts

@@ -1,87 +0,0 @@
-import { randomUUID } from "node:crypto";
-import { maskApiKey } from "../lib/mask";
-import type { ScannedProviderDto } from "../lib/providerImportContract";
-import type { ExternalProvider } from "./providerImporters";
-
-const SCAN_TTL_MS = 5 * 60 * 1000;
-const MAX_ACTIVE_SCANS = 8;
-const MAX_SCANNED_PROVIDERS = 100;
-
-type ProviderScanSession = {
-  expiresAt: number;
-  providers: ReadonlyMap<string, ExternalProvider>;
-};
-
-const sessions = new Map<string, ProviderScanSession>();
-
-function removeExpired(now: number): void {
-  for (const [scanId, session] of sessions) {
-    if (session.expiresAt <= now) sessions.delete(scanId);
-  }
-}
-
-function enforceSessionLimit(): void {
-  while (sessions.size >= MAX_ACTIVE_SCANS) {
-    const oldest = sessions.keys().next().value;
-    if (typeof oldest !== "string") return;
-    sessions.delete(oldest);
-  }
-}
-
-export function createProviderScan(
-  providers: readonly ExternalProvider[],
-  now = Date.now(),
-): { scanId: string; providers: ScannedProviderDto[] } {
-  removeExpired(now);
-  enforceSessionLimit();
-
-  const scanId = randomUUID();
-  const providerMap = new Map<string, ExternalProvider>();
-  const redacted: ScannedProviderDto[] = [];
-  for (const provider of providers.slice(0, MAX_SCANNED_PROVIDERS)) {
-    const selectionId = randomUUID();
-    providerMap.set(selectionId, provider);
-    redacted.push({
-      selectionId,
-      name: provider.name,
-      apiKeyHint: maskApiKey(provider.apiKey),
-      format: provider.format,
-      anthropicBaseUrl: provider.anthropicBaseUrl,
-      openaiBaseUrl: provider.openaiBaseUrl,
-      openaiResponsesBaseUrl: provider.openaiResponsesBaseUrl,
-      models: provider.models,
-      sourceTool: provider.sourceTool,
-      alreadyExists: provider.alreadyExists,
-    });
-  }
-
-  sessions.set(scanId, {
-    expiresAt: now + SCAN_TTL_MS,
-    providers: providerMap,
-  });
-  return { scanId, providers: redacted };
-}
-
-export function consumeProviderScan(
-  scanId: string,
-  selectionIds: readonly string[],
-  now = Date.now(),
-): ExternalProvider[] | null {
-  removeExpired(now);
-  const session = sessions.get(scanId);
-  if (session === undefined) return null;
-  sessions.delete(scanId);
-
-  const uniqueIds = new Set(selectionIds);
-  const selected: ExternalProvider[] = [];
-  for (const selectionId of uniqueIds) {
-    const provider = session.providers.get(selectionId);
-    if (provider === undefined) return null;
-    selected.push(provider);
-  }
-  return selected;
-}
-
-export function _resetProviderScanStoreForTests(): void {
-  sessions.clear();
-}