@tonyclaw/agent-inspector 4.0.1 → 4.0.3

package/src/lib/useStripConfig.ts

@@ -1,154 +0,0 @@
-import useSWR, { type SWRResponse, useSWRConfig } from "swr";
-import { fetchJson } from "./apiClient";
-import {
-  DEFAULT_CAPTURE_MODE,
-  DEFAULT_PROVIDER_TEST_TIMEOUT_SECONDS,
-  DEFAULT_SLOW_RESPONSE_THRESHOLD_SECONDS,
-  DEFAULT_TIME_DISPLAY_FORMAT,
-  type CaptureMode,
-  RuntimeConfigSchema,
-  type TimeDisplayFormat,
-  type RuntimeConfig,
-} from "./runtimeConfig";
-
-export const STRIP_CONFIG_SWR_KEY = "/api/config";
-
-async function fetcher(url: string): Promise<RuntimeConfig> {
-  return fetchJson(
-    url,
-    RuntimeConfigSchema,
-    undefined,
-    (response) => `Failed to fetch ${url}: ${response.status}`,
-  );
-}
-
-/**
- * PATCH the runtime config. Exported separately for testability.
- */
-type RuntimeConfigPatch = Partial<Omit<RuntimeConfig, "captureMode">>;
-
-export async function setRuntimeConfig(patch: RuntimeConfigPatch): Promise<RuntimeConfig> {
-  return fetchJson(
-    STRIP_CONFIG_SWR_KEY,
-    RuntimeConfigSchema,
-    {
-      method: "PATCH",
-      headers: { "content-type": "application/json" },
-      body: JSON.stringify(patch),
-    },
-    (response) => `PATCH failed with status ${response.status}`,
-  );
-}
-
-export type UseStripConfig = {
-  strip: boolean;
-  captureMode: CaptureMode;
-  slowResponseThresholdSeconds: number;
-  providerTestTimeoutSeconds: number;
-  timeDisplayFormat: TimeDisplayFormat;
-  isLoading: boolean;
-  isError: boolean;
-  setStrip: (next: boolean) => Promise<void>;
-  setSlowResponseThresholdSeconds: (next: number) => Promise<void>;
-  setProviderTestTimeoutSeconds: (next: number) => Promise<void>;
-  setTimeDisplayFormat: (next: TimeDisplayFormat) => Promise<void>;
-};
-
-/**
- * Hook reading the runtime config from /api/config.
- *
- * - `strip` is the live value from the server (or the optimistic value mid-PATCH).
- * - `slowResponseThresholdSeconds` controls the UI's slow-response indicator.
- * - `providerTestTimeoutSeconds` controls each per-model Provider Test probe.
- * - `setStrip(next)` PATCHes the server with optimistic update; on failure
- *   it throws and SWR rolls back the optimistic value.
- */
-export function useStripConfig(): UseStripConfig {
-  const response: SWRResponse<RuntimeConfig, Error> = useSWR<RuntimeConfig, Error>(
-    STRIP_CONFIG_SWR_KEY,
-    fetcher,
-    {
-      revalidateOnFocus: false,
-      revalidateIfStale: false,
-    },
-  );
-  const { mutate: globalMutate } = useSWRConfig();
-
-  const strip = response.data?.stripClaudeCodeBillingHeader ?? false;
-  const captureMode = response.data?.captureMode ?? DEFAULT_CAPTURE_MODE;
-  const slowResponseThresholdSeconds =
-    response.data?.slowResponseThresholdSeconds ?? DEFAULT_SLOW_RESPONSE_THRESHOLD_SECONDS;
-  const providerTestTimeoutSeconds =
-    response.data?.providerTestTimeoutSeconds ?? DEFAULT_PROVIDER_TEST_TIMEOUT_SECONDS;
-  const timeDisplayFormat = response.data?.timeDisplayFormat ?? DEFAULT_TIME_DISPLAY_FORMAT;
-
-  const optimisticConfig = (patch: RuntimeConfigPatch): RuntimeConfig => ({
-    stripClaudeCodeBillingHeader: response.data?.stripClaudeCodeBillingHeader ?? false,
-    hasSeenOnboarding: response.data?.hasSeenOnboarding ?? false,
-    slowResponseThresholdSeconds:
-      response.data?.slowResponseThresholdSeconds ?? DEFAULT_SLOW_RESPONSE_THRESHOLD_SECONDS,
-    providerTestTimeoutSeconds:
-      response.data?.providerTestTimeoutSeconds ?? DEFAULT_PROVIDER_TEST_TIMEOUT_SECONDS,
-    timeDisplayFormat: response.data?.timeDisplayFormat ?? DEFAULT_TIME_DISPLAY_FORMAT,
-    captureMode,
-    ...patch,
-  });
-
-  const setStrip = async (next: boolean): Promise<void> => {
-    await globalMutate(
-      STRIP_CONFIG_SWR_KEY,
-      setRuntimeConfig({ stripClaudeCodeBillingHeader: next }),
-      {
-        optimisticData: optimisticConfig({ stripClaudeCodeBillingHeader: next }),
-        rollbackOnError: true,
-        revalidate: false,
-      },
-    );
-  };
-
-  const setSlowResponseThresholdSeconds = async (next: number): Promise<void> => {
-    await globalMutate(
-      STRIP_CONFIG_SWR_KEY,
-      setRuntimeConfig({ slowResponseThresholdSeconds: next }),
-      {
-        optimisticData: optimisticConfig({ slowResponseThresholdSeconds: next }),
-        rollbackOnError: true,
-        revalidate: false,
-      },
-    );
-  };
-
-  const setTimeDisplayFormat = async (next: TimeDisplayFormat): Promise<void> => {
-    await globalMutate(STRIP_CONFIG_SWR_KEY, setRuntimeConfig({ timeDisplayFormat: next }), {
-      optimisticData: optimisticConfig({ timeDisplayFormat: next }),
-      rollbackOnError: true,
-      revalidate: false,
-    });
-  };
-
-  const setProviderTestTimeoutSeconds = async (next: number): Promise<void> => {
-    await globalMutate(
-      STRIP_CONFIG_SWR_KEY,
-      setRuntimeConfig({ providerTestTimeoutSeconds: next }),
-      {
-        optimisticData: optimisticConfig({ providerTestTimeoutSeconds: next }),
-        rollbackOnError: true,
-        revalidate: false,
-      },
-    );
-  };
-
-  return {
-    strip,
-    captureMode,
-    slowResponseThresholdSeconds,
-    providerTestTimeoutSeconds,
-    timeDisplayFormat,
-    isLoading: response.isLoading,
-    isError: response.error !== undefined,
-    setStrip,
-    setSlowResponseThresholdSeconds,
-    setProviderTestTimeoutSeconds,
-    setTimeDisplayFormat,
-  };
-}

package/src/lib/useThemeMode.ts

@@ -1,40 +0,0 @@
-import { useCallback, useEffect, useState } from "react";
-import {
-  applyThemeMode,
-  normalizeThemeMode,
-  persistThemeMode,
-  readStoredThemeMode,
-  THEME_MODE_STORAGE_KEY,
-  type ThemeMode,
-} from "./themeMode";
-
-export function useThemeMode(): {
-  themeMode: ThemeMode;
-  setThemeMode: (themeMode: ThemeMode) => void;
-} {
-  const [themeMode, setThemeModeState] = useState<ThemeMode>(readStoredThemeMode);
-
-  const setThemeMode = useCallback((nextThemeMode: ThemeMode) => {
-    setThemeModeState(nextThemeMode);
-    applyThemeMode(nextThemeMode);
-    persistThemeMode(nextThemeMode);
-  }, []);
-
-  useEffect(() => {
-    applyThemeMode(themeMode);
-  }, [themeMode]);
-
-  useEffect(() => {
-    function handleStorage(event: StorageEvent): void {
-      if (event.key !== THEME_MODE_STORAGE_KEY) return;
-      const nextThemeMode = normalizeThemeMode(event.newValue);
-      setThemeModeState(nextThemeMode);
-      applyThemeMode(nextThemeMode);
-    }
-
-    window.addEventListener("storage", handleStorage);
-    return () => window.removeEventListener("storage", handleStorage);
-  }, []);
-
-  return { themeMode, setThemeMode };
-}

package/src/lib/useUiScale.ts

@@ -1,52 +0,0 @@
-import { useCallback, useEffect, useState } from "react";
-import {
-  applyUiScalePreference,
-  normalizeUiScalePreference,
-  persistUiScalePreference,
-  readStoredUiScalePreference,
-  UI_SCALE_STORAGE_KEY,
-  type UiScalePreference,
-} from "./uiScale";
-
-export function useUiScale(): {
-  uiScalePreference: UiScalePreference;
-  resolvedUiScale: number;
-  setUiScalePreference: (preference: UiScalePreference) => void;
-} {
-  const [uiScalePreference, setUiScalePreferenceState] = useState<UiScalePreference>(
-    readStoredUiScalePreference,
-  );
-  const [resolvedUiScale, setResolvedUiScale] = useState(1);
-
-  const setUiScalePreference = useCallback((nextPreference: UiScalePreference) => {
-    setUiScalePreferenceState(nextPreference);
-    persistUiScalePreference(nextPreference);
-    setResolvedUiScale(applyUiScalePreference(nextPreference));
-  }, []);
-
-  useEffect(() => {
-    const refreshScale = (): void => {
-      setResolvedUiScale(applyUiScalePreference(uiScalePreference));
-    };
-
-    refreshScale();
-    if (uiScalePreference !== "auto") return;
-
-    window.addEventListener("resize", refreshScale);
-    return () => window.removeEventListener("resize", refreshScale);
-  }, [uiScalePreference]);
-
-  useEffect(() => {
-    const handleStorage = (event: StorageEvent): void => {
-      if (event.key !== UI_SCALE_STORAGE_KEY) return;
-      const nextPreference = normalizeUiScalePreference(event.newValue);
-      setUiScalePreferenceState(nextPreference);
-      setResolvedUiScale(applyUiScalePreference(nextPreference));
-    };
-
-    window.addEventListener("storage", handleStorage);
-    return () => window.removeEventListener("storage", handleStorage);
-  }, []);
-
-  return { uiScalePreference, resolvedUiScale, setUiScalePreference };
-}

package/src/lib/utils.ts

@@ -1,78 +0,0 @@
-import { type ClassValue, clsx } from "clsx";
-import { twMerge } from "tailwind-merge";
-
-export function cn(...inputs: ClassValue[]): string {
-  return twMerge(clsx(inputs));
-}
-
-export function formatTokens(count: number): string {
-  const absoluteCount = Math.abs(count);
-  if (absoluteCount < 1000) return String(count);
-  if (absoluteCount >= 1_000_000) {
-    return (count / 1_000_000).toFixed(1).replace(/\.0$/, "") + "M";
-  }
-  return (count / 1000).toFixed(1).replace(/\.0$/, "") + "K";
-}
-
-export function formatContextWindowTokens(count: number): string {
-  if (count >= 1024 * 1024) {
-    return (count / (1024 * 1024)).toFixed(1).replace(/\.0$/, "") + "M";
-  }
-  return (count / 1024).toFixed(1).replace(/\.0$/, "") + "K";
-}
-
-function formatExactContextUnit(count: number, multiplier: number, unit: "K" | "M"): string | null {
-  const tenths = count * 10;
-  if (!Number.isSafeInteger(tenths) || tenths % multiplier !== 0) return null;
-  return (tenths / multiplier / 10).toFixed(1).replace(/\.0$/, "") + unit;
-}
-
-export function formatContextWindowInput(count: number): string {
-  if (!Number.isSafeInteger(count) || count <= 0) return count.toString();
-  if (count >= 1024 * 1024) {
-    const megaValue = formatExactContextUnit(count, 1024 * 1024, "M");
-    if (megaValue !== null) return megaValue;
-  }
-  const kiloValue = formatExactContextUnit(count, 1024, "K");
-  if (kiloValue !== null) return kiloValue;
-  return count.toString();
-}
-
-function contextWindowUnitMultiplier(unit: string | undefined): number | null {
-  if (unit === undefined || unit === "") return 1;
-  switch (unit.toLowerCase()) {
-    case "k":
-      return 1024;
-    case "m":
-      return 1024 * 1024;
-    default:
-      return null;
-  }
-}
-
-export function parseContextWindowTokensInput(value: string): number | null {
-  const trimmed = value.trim().replaceAll(",", "");
-  if (trimmed === "") return null;
-  const match = /^(\d+(?:\.\d+)?)\s*([kKmM])?$/.exec(trimmed);
-  if (match === null) return null;
-  const amountText = match[1];
-  if (amountText === undefined) return null;
-  const amount = Number(amountText);
-  const unit = match[2];
-  const multiplier = contextWindowUnitMultiplier(unit);
-  if (!Number.isFinite(amount) || amount <= 0 || multiplier === null) return null;
-  if ((unit === undefined || unit === "") && !Number.isInteger(amount)) return null;
-  const tokens = Math.round(amount * multiplier);
-  if (!Number.isSafeInteger(tokens) || tokens <= 0) return null;
-  return tokens;
-}
-
-export type StatusCategory = "success" | "client_error" | "server_error" | "pending";
-
-export function getStatusCategory(status: number | null): StatusCategory {
-  if (status === null) return "pending";
-  if (status >= 200 && status < 300) return "success";
-  if (status >= 400 && status < 500) return "client_error";
-  if (status >= 500) return "server_error";
-  return "pending";
-}

package/src/mcp/currentContext.ts

@@ -1,65 +0,0 @@
-import type { JsonValue } from "../contracts";
-
-export type InspectorCurrentContext = {
-  groupId: string | null;
-  runId: string | null;
-  sessionId: string | null;
-  model: string | null;
-  provider: string | null;
-  agent: string | null;
-  project: string | null;
-  task: string | null;
-  metadata: Record<string, JsonValue>;
-  updatedAt: string;
-};
-
-export type InspectorCurrentContextPatch = Partial<
-  Omit<InspectorCurrentContext, "metadata" | "updatedAt">
-> & {
-  metadata?: Record<string, JsonValue>;
-};
-
-function envString(name: string): string | null {
-  const value = process.env[name];
-  if (value === undefined) return null;
-  const trimmed = value.trim();
-  return trimmed.length === 0 ? null : trimmed;
-}
-
-function initialContext(): InspectorCurrentContext {
-  return {
-    groupId: envString("INSPECTOR_GROUP_ID"),
-    runId: envString("INSPECTOR_RUN_ID"),
-    sessionId: envString("INSPECTOR_SESSION_ID"),
-    model: envString("INSPECTOR_MODEL"),
-    provider: envString("INSPECTOR_PROVIDER"),
-    agent: envString("INSPECTOR_AGENT"),
-    project: envString("INSPECTOR_PROJECT"),
-    task: envString("INSPECTOR_TASK"),
-    metadata: {},
-    updatedAt: new Date().toISOString(),
-  };
-}
-
-let currentContext = initialContext();
-
-export function getCurrentContext(): InspectorCurrentContext {
-  return currentContext;
-}
-
-export function setCurrentContext(patch: InspectorCurrentContextPatch): InspectorCurrentContext {
-  currentContext = {
-    ...currentContext,
-    ...patch,
-    metadata:
-      patch.metadata === undefined
-        ? currentContext.metadata
-        : { ...currentContext.metadata, ...patch.metadata },
-    updatedAt: new Date().toISOString(),
-  };
-  return currentContext;
-}
-
-export function _resetCurrentContextForTests(): void {
-  currentContext = initialContext();
-}

package/src/mcp/instanceHandlers.ts

@@ -1,151 +0,0 @@
-import { z } from "zod";
-import {
-  InstanceConnectionOutputSchema,
-  InstanceEmptyRequestSchema,
-  InstanceErrorOutputSchema,
-  InstanceListOutputSchema,
-  InstanceOperationOutputSchema,
-  InstanceStartRequestSchema,
-  InstanceStatusOutputSchema,
-  type InstanceStartRequest,
-} from "../lib/instanceContract";
-import type { CallApiOptions } from "./loopback";
-import type { ToolResult } from "./toolHandlers";
-
-export const INSTANCE_LIFECYCLE_TIMEOUT_MS = 60_000;
-
-export const InstanceToolNameSchema = z.string().trim().min(1).max(64);
-
-export const InstanceLifecycleToolInputSchema = InstanceStartRequestSchema.extend({
-  name: InstanceToolNameSchema,
-});
-
-export const InstanceNameToolInputSchema = z
-  .object({
-    name: InstanceToolNameSchema,
-  })
-  .strict();
-
-export type InstanceCallApiFn = (path: string, options?: CallApiOptions) => Promise<Response>;
-
-export type InstanceLifecycleToolInput = InstanceStartRequest & { name: string };
-
-function textJson(data: unknown): ToolResult {
-  return { content: [{ type: "text", text: JSON.stringify(data, null, 2) }] };
-}
-
-function toolError(message: string): ToolResult {
-  return { content: [{ type: "text", text: message }], isError: true };
-}
-
-async function responseJson(response: Response): Promise<unknown | null> {
-  try {
-    const value: unknown = await response.json();
-    return value;
-  } catch {
-    return null;
-  }
-}
-
-async function validatedInstanceResponse(
-  response: Response,
-  schema: z.ZodType,
-  operation: string,
-): Promise<ToolResult> {
-  const value = await responseJson(response);
-  if (!response.ok) {
-    const error = InstanceErrorOutputSchema.safeParse(value);
-    return error.success
-      ? { ...textJson(error.data), isError: true }
-      : toolError(
-          `${operation} returned HTTP ${String(response.status)} with an invalid error body`,
-        );
-  }
-
-  const parsed = schema.safeParse(value);
-  return parsed.success
-    ? textJson(parsed.data)
-    : toolError(`${operation} returned an invalid public instance document`);
-}
-
-function instancePath(name: string, suffix = ""): string {
-  return `/api/instances/${encodeURIComponent(name)}${suffix}`;
-}
-
-function jsonPost(body: unknown): CallApiOptions {
-  return {
-    method: "POST",
-    headers: {
-      accept: "application/json",
-      "content-type": "application/json",
-    },
-    body: JSON.stringify(body),
-    timeoutMs: INSTANCE_LIFECYCLE_TIMEOUT_MS,
-  };
-}
-
-function lifecycleRequest(input: InstanceLifecycleToolInput): InstanceStartRequest {
-  return {
-    port: input.port,
-    basePath: input.basePath,
-    host: input.host,
-    captureMode: input.captureMode,
-    backend: input.backend,
-    uiEnabled: input.uiEnabled,
-    dataDir: input.dataDir,
-  };
-}
-
-export async function listInstancesImpl(callApi: InstanceCallApiFn): Promise<ToolResult> {
-  const response = await callApi("/api/instances", {
-    headers: { accept: "application/json" },
-  });
-  return validatedInstanceResponse(response, InstanceListOutputSchema, "GET /api/instances");
-}
-
-export async function getInstanceImpl(
-  callApi: InstanceCallApiFn,
-  name: string,
-): Promise<ToolResult> {
-  const path = instancePath(name);
-  const response = await callApi(path, { headers: { accept: "application/json" } });
-  return validatedInstanceResponse(response, InstanceStatusOutputSchema, `GET ${path}`);
-}
-
-export async function getInstanceConnectionImpl(
-  callApi: InstanceCallApiFn,
-  name: string,
-): Promise<ToolResult> {
-  const path = instancePath(name, "/connection");
-  const response = await callApi(path, { headers: { accept: "application/json" } });
-  return validatedInstanceResponse(response, InstanceConnectionOutputSchema, `GET ${path}`);
-}
-
-export async function startInstanceImpl(
-  callApi: InstanceCallApiFn,
-  input: InstanceLifecycleToolInput,
-): Promise<ToolResult> {
-  const path = instancePath(input.name, "/start");
-  const request = lifecycleRequest(input);
-  const response = await callApi(path, jsonPost(InstanceStartRequestSchema.parse(request)));
-  return validatedInstanceResponse(response, InstanceOperationOutputSchema, `POST ${path}`);
-}
-
-export async function stopInstanceImpl(
-  callApi: InstanceCallApiFn,
-  name: string,
-): Promise<ToolResult> {
-  const path = instancePath(name, "/stop");
-  const response = await callApi(path, jsonPost(InstanceEmptyRequestSchema.parse({})));
-  return validatedInstanceResponse(response, InstanceOperationOutputSchema, `POST ${path}`);
-}
-
-export async function restartInstanceImpl(
-  callApi: InstanceCallApiFn,
-  input: InstanceLifecycleToolInput,
-): Promise<ToolResult> {
-  const path = instancePath(input.name, "/restart");
-  const request = lifecycleRequest(input);
-  const response = await callApi(path, jsonPost(InstanceStartRequestSchema.parse(request)));
-  return validatedInstanceResponse(response, InstanceOperationOutputSchema, `POST ${path}`);
-}

package/src/mcp/loopback.ts

@@ -1,88 +0,0 @@
-/* eslint-disable functional/no-throw-statements */
-/**
- * HTTP loopback helper for MCP tool handlers.
- *
- * Why HTTP loopback (not direct function calls): see
- * `openspec/changes/add-mcp-server/design.md` decision D2. All MCP tools
- * delegate to existing `/api/*` endpoints so any future cross-cutting
- * middleware (auth, rate-limit, audit, metrics) added to `/api` is
- * automatically inherited by MCP without duplicate plumbing.
- *
- * NOTE: TanStack Start / Nitro may expose an in-process route invocation
- * API (e.g. Nitro's `$fetch` helper) that would let us skip the real HTTP
- * round-trip while preserving the routing contract. As of this writing
- * that investigation is open (tasks.md 2.3). If/when adopted, the public
- * surface of this module — `callApi(path, init?)` returning a `Response`
- * — should stay identical so callers don't change.
- */
-
-import {
-  AGENT_INSPECTOR_PUBLIC_BASE_PATH_HEADER,
-  AGENT_INSPECTOR_PUBLIC_PORT_HEADER,
-  withBasePath,
-} from "../lib/basePath";
-import { getPublicBasePath, getPublicPort } from "../lib/publicBasePathContext";
-
-const DEFAULT_TIMEOUT_MS = 30_000;
-
-export type CallApiOptions = RequestInit & {
-  /** Override default 30s timeout. */
-  timeoutMs?: number;
-};
-
-export class LoopbackTimeoutError extends Error {
-  constructor(
-    public readonly path: string,
-    public readonly timeoutMs: number,
-  ) {
-    super(`Loopback call to ${path} timed out after ${timeoutMs}ms`);
-    this.name = "LoopbackTimeoutError";
-  }
-}
-
-/**
- * Make an HTTP request to one of the inspector's own /api/* endpoints
- * via 127.0.0.1 loopback. The returned Response is a standard Web
- * Response; callers decide whether to call .json(), .text(), .arrayBuffer().
- *
- * `path` MUST start with `/` (e.g. `/api/logs`).
- */
-export async function callApi(path: string, options: CallApiOptions = {}): Promise<Response> {
-  if (!path.startsWith("/")) {
-    throw new Error(`callApi: path must start with '/', got: ${path}`);
-  }
-  const port = getPublicPort();
-  const publicBasePath = getPublicBasePath();
-  const url = `http://127.0.0.1:${port}${withBasePath(path, publicBasePath)}`;
-
-  const { timeoutMs = DEFAULT_TIMEOUT_MS, signal: userSignal, ...rest } = options;
-  const headers = new Headers(rest.headers);
-  headers.set(
-    AGENT_INSPECTOR_PUBLIC_BASE_PATH_HEADER,
-    publicBasePath.length === 0 ? "/" : publicBasePath,
-  );
-  headers.set(AGENT_INSPECTOR_PUBLIC_PORT_HEADER, String(port));
-
-  const controller = new AbortController();
-  const timeoutHandle = setTimeout(() => controller.abort(), timeoutMs);
-
-  // If caller passed their own signal, chain it.
-  if (userSignal !== undefined && userSignal !== null) {
-    if (userSignal.aborted) {
-      controller.abort();
-    } else {
-      userSignal.addEventListener("abort", () => controller.abort(), { once: true });
-    }
-  }
-
-  try {
-    return await fetch(url, { ...rest, headers, signal: controller.signal });
-  } catch (err) {
-    if (err instanceof Error && err.name === "AbortError") {
-      throw new LoopbackTimeoutError(path, timeoutMs);
-    }
-    throw err;
-  } finally {
-    clearTimeout(timeoutHandle);
-  }
-}