@tonyclaw/agent-inspector 3.0.38 → 3.0.40

package/.output/workers/logFinalizer.worker.js

@@ -43,8 +43,13 @@ var PRIVATE_FILE_MODE = 384;
 var securedPaths = /* @__PURE__ */ new Set();
 var securedFileIdentities = /* @__PURE__ */ new Map();
 var cachedWindowsSid = null;
+function windowsSystemPath(executable) {
+  const systemRoot = process.env["SystemRoot"] ?? "C:\\Windows";
+  return `${systemRoot}\\System32\\${executable}`;
+}
 function runWindowsCommand(executable, args) {
-  const result = spawnSync(executable, [...args], {
+  const resolved = process.platform === "win32" && /^(whoami|icacls)\.exe$/iu.test(executable) ? windowsSystemPath(executable) : executable;
+  const result = spawnSync(resolved, [...args], {
     encoding: "utf8",
     shell: false,
     windowsHide: true

package/.output/workers/sessionWorkerEntry.js

@@ -40,8 +40,13 @@ var PRIVATE_FILE_MODE = 384;
 var securedPaths = /* @__PURE__ */ new Set();
 var securedFileIdentities = /* @__PURE__ */ new Map();
 var cachedWindowsSid = null;
+function windowsSystemPath(executable) {
+  const systemRoot = process.env["SystemRoot"] ?? "C:\\Windows";
+  return `${systemRoot}\\System32\\${executable}`;
+}
 function runWindowsCommand(executable, args) {
-  const result = spawnSync(executable, [...args], {
+  const resolved = process.platform === "win32" && /^(whoami|icacls)\.exe$/iu.test(executable) ? windowsSystemPath(executable) : executable;
+  const result = spawnSync(resolved, [...args], {
     encoding: "utf8",
     shell: false,
     windowsHide: true

package/README.md

@@ -147,12 +147,44 @@ agent-inspector doctor --chrome-extension
 Then point an AI coding tool at the proxy:
 
 ```bash
-ANTHROPIC_BASE_URL=http://localhost:9527/proxy <tool>
+ANTHROPIC_BASE_URL=http://localhost:9527/inspector/proxy <tool>
 ```
 
-The web UI runs at http://localhost:9527. The public proxy endpoint is also
-`http://localhost:9527/proxy`; internally Agent Inspector may run the app on a private helper port,
-but AI tools should use the public URL printed by the CLI.
+The web UI runs at http://localhost:9527/inspector by default. The public proxy endpoint is
+`http://localhost:9527/inspector/proxy`; internally Agent Inspector may run the app on a private
+helper port, but AI tools should use the public URL printed by the CLI.
+
+### Base path
+
+Agent Inspector defaults to the `/inspector` public base path:
+
+```bash
+agent-inspector
+```
+
+This generates prefixed public URLs for the UI, assets, REST API, MCP, sessions, and model proxy:
+
+- Web UI: `http://localhost:9527/inspector`
+- Assets: `http://localhost:9527/inspector/assets/...`
+- REST API: `http://localhost:9527/inspector/api/...`
+- MCP: `http://localhost:9527/inspector/api/mcp`
+- Sessions: `http://localhost:9527/inspector/session/...`
+- Proxy: `http://localhost:9527/inspector/proxy`
+
+AI tools should use the prefixed proxy URL:
+
+```bash
+ANTHROPIC_BASE_URL=http://localhost:9527/inspector/proxy <tool>
+```
+
+To run at the domain root instead, explicitly set the base path to `/`:
+
+```bash
+AGENT_INSPECTOR_BASE_PATH=/ agent-inspector
+```
+
+Reverse proxies should preserve the `/inspector` prefix when forwarding public requests to Agent
+Inspector.
 
 The legacy `http://localhost:9527` port is closed by default. If you need a temporary alias for
 older AI tool or MCP configs, start with `agent-inspector --legacy-port`.
@@ -163,12 +195,12 @@ Agent Inspector v3.0 changes the default public port from `9527` to `9527`. The
 opens only `9527` by default. Existing AI coding tool and MCP configs that still point at `9527`
 should be moved to `9527`, or you can temporarily start with `agent-inspector --legacy-port`.
 
-Use these endpoints for new configs:
+Use these default endpoints for new configs:
 
-- Web UI: `http://localhost:9527`
-- Proxy: `http://localhost:9527/proxy`
-- OpenAI-compatible `/v1` proxy: `http://localhost:9527/proxy/v1`
-- MCP: `http://localhost:9527/api/mcp`
+- Web UI: `http://localhost:9527/inspector`
+- Proxy: `http://localhost:9527/inspector/proxy`
+- OpenAI-compatible `/v1` proxy: `http://localhost:9527/inspector/proxy/v1`
+- MCP: `http://localhost:9527/inspector/api/mcp`
 
 If you intentionally need the old compatibility port, start with `agent-inspector --legacy-port`.
 
@@ -178,7 +210,7 @@ For Codex-style OpenAI Responses clients, configure the proxy as an OpenAI-compa
 model_provider = "agent-inspector"
 
 [model_providers."agent-inspector"]
-base_url = "http://127.0.0.1:9527/proxy/v1"
+base_url = "http://127.0.0.1:9527/inspector/proxy/v1"
 wire_api = "responses"
 ```
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tonyclaw/agent-inspector",
-  "version": "3.0.38",
+  "version": "3.0.40",
   "type": "module",
   "description": "Agent observability and knowledge capture layer for AI coding tools.",
   "license": "MIT",

package/src/cli/doctor.ts

@@ -1,6 +1,7 @@
 import { existsSync, readFileSync, readdirSync, statSync } from "node:fs";
 import { isAbsolute, join, resolve } from "node:path";
 import { createConnection } from "node:net";
+import { appendBasePathToOrigin, getConfiguredBasePath } from "../lib/basePath";
 import { migrateLegacyDataDirs, resolveDataDir } from "../proxy/dataDir";
 
 const DEFAULT_PORT = 9527;
@@ -55,7 +56,7 @@ export type DoctorDeps = {
   exists: (path: string) => boolean;
   listDir: (path: string) => readonly string[] | null;
   stat: (path: string) => { isDirectory: boolean; size: number } | null;
-  fetchHealth: (port: number) => Promise<HealthProbe>;
+  fetchHealth: (port: number, basePath: string) => Promise<HealthProbe>;
   isPortOpen: (port: number) => Promise<boolean>;
 };
 
@@ -261,14 +262,17 @@ function checkProviderConfig(options: DoctorOptions, deps: DoctorDeps): DoctorCh
 }
 
 async function checkProxyHealth(port: number, deps: DoctorDeps): Promise<DoctorCheck> {
-  const health = await deps.fetchHealth(port);
+  const basePath = getConfiguredBasePath(deps.env);
+  const health = await deps.fetchHealth(port, basePath);
   const url = `http://localhost:${port}`;
+  const proxyUrl = appendBasePathToOrigin(url, "/proxy", basePath);
+  const healthPath = appendBasePathToOrigin("", "/api/health", basePath);
   if (health.ok) {
     return check(
       "Proxy health",
       "pass",
-      `agent-inspector is healthy at ${url}.`,
-      `Proxy URL: ${url}/proxy`,
+      `agent-inspector is healthy at ${appendBasePathToOrigin(url, "/", basePath)}.`,
+      `Proxy URL: ${proxyUrl}`,
     );
   }
 
@@ -277,7 +281,7 @@ async function checkProxyHealth(port: number, deps: DoctorDeps): Promise<DoctorC
     return check(
       "Proxy health",
       "fail",
-      `Port ${port} is accepting connections, but /api/health is not healthy${suffix}.`,
+      `Port ${port} is accepting connections, but ${healthPath} is not healthy${suffix}.`,
       "Stop that process, choose --port <n>, or start agent-inspector with --force-restart.",
     );
   }
@@ -583,14 +587,17 @@ export function doctorHelp(): string {
   ].join("\n");
 }
 
-async function fetchHealth(port: number): Promise<HealthProbe> {
+async function fetchHealth(port: number, basePath: string): Promise<HealthProbe> {
   const controller = new AbortController();
   const timeout = setTimeout(() => controller.abort(), PROBE_TIMEOUT_MS);
   try {
-    const response = await fetch(`http://127.0.0.1:${port}/api/health`, {
-      cache: "no-store",
-      signal: controller.signal,
-    });
+    const response = await fetch(
+      appendBasePathToOrigin(`http://127.0.0.1:${port}`, "/api/health", basePath),
+      {
+        cache: "no-store",
+        signal: controller.signal,
+      },
+    );
     return { ok: response.ok, status: response.status };
   } catch {
     return { ok: false, status: null };

package/src/cli/networkHints.ts

@@ -1,4 +1,5 @@
 import { networkInterfaces } from "node:os";
+import { appendBasePathToOrigin, normalizeBasePath } from "../lib/basePath";
 
 export type NetworkInterfaceMap = ReturnType<typeof networkInterfaces>;
 
@@ -107,24 +108,30 @@ export function networkUrlsForBindHost(
   return [urlForHost(port, host)];
 }
 
+function accessUrl(origin: string, path: string, basePath: string): string {
+  return appendBasePathToOrigin(origin, path, basePath);
+}
+
 export function formatAccessHintLines(
   port: number,
   networkUrls: readonly string[],
   host: BindHost = undefined,
+  basePath = "",
 ): string[] {
+  const normalizedBasePath = normalizeBasePath(basePath);
   const localUrl = localUrlForPort(port);
   const hostLabel = isWildcardHost(host) ? "all interfaces (0.0.0.0)" : (trimHost(host) ?? "");
   const lines = ["Access URLs:", `   Bind host:      ${hostLabel}`];
 
   if (isLoopbackHost(host) || isWildcardHost(host)) {
-    lines.push(`   Local UI:       ${localUrl}`);
-    lines.push(`   Local proxy:    ${localUrl}/proxy`);
-    lines.push(`   Local MCP:      ${localUrl}/api/mcp`);
+    lines.push(`   Local UI:       ${accessUrl(localUrl, "/", normalizedBasePath)}`);
+    lines.push(`   Local proxy:    ${accessUrl(localUrl, "/proxy", normalizedBasePath)}`);
+    lines.push(`   Local MCP:      ${accessUrl(localUrl, "/api/mcp", normalizedBasePath)}`);
   } else {
     const boundUrl = urlForHost(port, host);
-    lines.push(`   Bound UI:       ${boundUrl}`);
-    lines.push(`   Bound proxy:    ${boundUrl}/proxy`);
-    lines.push(`   Bound MCP:      ${boundUrl}/api/mcp`);
+    lines.push(`   Bound UI:       ${accessUrl(boundUrl, "/", normalizedBasePath)}`);
+    lines.push(`   Bound proxy:    ${accessUrl(boundUrl, "/proxy", normalizedBasePath)}`);
+    lines.push(`   Bound MCP:      ${accessUrl(boundUrl, "/api/mcp", normalizedBasePath)}`);
     lines.push("   Localhost:      may not work because the server is bound to a specific host");
   }
 
@@ -134,8 +141,8 @@ export function formatAccessHintLines(
   } else if (firstNetworkUrl === undefined) {
     lines.push("   Network:        no non-loopback IPv4 address detected");
   } else {
-    lines.push(`   Network UI:     ${firstNetworkUrl}`);
-    lines.push(`   Network proxy:  ${firstNetworkUrl}/proxy`);
+    lines.push(`   Network UI:     ${accessUrl(firstNetworkUrl, "/", normalizedBasePath)}`);
+    lines.push(`   Network proxy:  ${accessUrl(firstNetworkUrl, "/proxy", normalizedBasePath)}`);
     const moreUrls = networkUrls.slice(1);
     if (moreUrls.length > 0) {
       lines.push(`   Other IPs:      ${moreUrls.join(", ")}`);

package/src/cli/onboard.ts

@@ -24,6 +24,7 @@ import { homedir } from "node:os";
 import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
 
+import { appendBasePathToOrigin, getConfiguredBasePath } from "../lib/basePath.js";
 import { detectAll, detectFirst } from "./detect-tools.js";
 import { renderCommandOnboard } from "./templates/command-onboard.js";
 import {
@@ -36,7 +37,8 @@ const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
 
 const DEFAULT_PORT = 9527;
-const DEFAULT_MCP_URL = `http://localhost:${DEFAULT_PORT}/api/mcp`;
+const DEFAULT_ORIGIN = `http://localhost:${DEFAULT_PORT}`;
+const DEFAULT_MCP_URL = `${DEFAULT_ORIGIN}/api/mcp`;
 const LEGACY_MCP_URL = "http://localhost:9527/api/mcp";
 const SKILL_DIR_NAME = "agent-inspector-onboard";
 const SKILL_FILE_NAME = "SKILL.md";
@@ -181,6 +183,11 @@ function actionForStatus(label: string, state: GeneratedFileState): string {
 }
 
 function parseFlags(argv: readonly string[]): OnboardFlags {
+  const defaultMcpUrl = appendBasePathToOrigin(
+    DEFAULT_ORIGIN,
+    "/api/mcp",
+    getConfiguredBasePath(process.env),
+  );
   const flags: OnboardFlags = {
     force: false,
     dryRun: false,
@@ -192,12 +199,12 @@ function parseFlags(argv: readonly string[]): OnboardFlags {
     opencodeOnly: false,
     opencodeConfig: null,
     opencodeTransport: "local",
-    opencodeMcpUrl: DEFAULT_MCP_URL,
+    opencodeMcpUrl: defaultMcpUrl,
     mimo: false,
     mimoOnly: false,
     mimoConfig: null,
     mimoTransport: "local",
-    mimoMcpUrl: DEFAULT_MCP_URL,
+    mimoMcpUrl: defaultMcpUrl,
     uninstall: false,
     status: false,
     json: false,

package/src/cli.ts

@@ -6,6 +6,11 @@ import { fileURLToPath } from "node:url";
 import { dirname, join, resolve as resolvePath } from "node:path";
 import { existsSync } from "node:fs";
 import type { Readable, Writable } from "node:stream";
+import {
+  AGENT_INSPECTOR_INTERNAL_STRIPPED_BASE_PATH_ENV,
+  appendBasePathToOrigin,
+  getConfiguredBasePath,
+} from "./lib/basePath.js";
 import {
   formatAccessHintLines,
   isLoopbackHost,
@@ -74,14 +79,17 @@ await runStart(process.argv.slice(2));
 // Legacy `start` behavior — start the proxy on the configured port. Extracted
 // into a function so the router above can keep the top-level flow readable.
 // -----------------------------------------------------------------------------
-async function isInspectorHealthy(port: number, host?: string): Promise<boolean> {
+async function isInspectorHealthy(port: number, host?: string, basePath = ""): Promise<boolean> {
   const controller = new AbortController();
   const timeout = setTimeout(() => controller.abort(), LOCAL_PROBE_TIMEOUT_MS);
   try {
-    const response = await fetch(`${urlForHost(port, probeHostForBindHost(host))}/api/health`, {
-      cache: "no-store",
-      signal: controller.signal,
-    });
+    const response = await fetch(
+      appendBasePathToOrigin(urlForHost(port, probeHostForBindHost(host)), "/api/health", basePath),
+      {
+        cache: "no-store",
+        signal: controller.signal,
+      },
+    );
     return response.ok;
   } catch {
     return false;
@@ -90,14 +98,21 @@ async function isInspectorHealthy(port: number, host?: string): Promise<boolean>
   }
 }
 
-async function getRunningCaptureMode(port: number, host?: string): Promise<CaptureMode | null> {
+async function getRunningCaptureMode(
+  port: number,
+  host?: string,
+  basePath = "",
+): Promise<CaptureMode | null> {
   const controller = new AbortController();
   const timeout = setTimeout(() => controller.abort(), LOCAL_PROBE_TIMEOUT_MS);
   try {
-    const response = await fetch(`${urlForHost(port, probeHostForBindHost(host))}/api/config`, {
-      cache: "no-store",
-      signal: controller.signal,
-    });
+    const response = await fetch(
+      appendBasePathToOrigin(urlForHost(port, probeHostForBindHost(host)), "/api/config", basePath),
+      {
+        cache: "no-store",
+        signal: controller.signal,
+      },
+    );
     if (!response.ok) return null;
     const raw: unknown = await response.json();
     return readCaptureMode(raw);
@@ -134,10 +149,11 @@ async function waitForInspectorHealthy(
   port: number,
   timeoutMs: number,
   host?: string,
+  basePath = "",
 ): Promise<boolean> {
   const start = Date.now();
   while (Date.now() - start < timeoutMs) {
-    if (await isInspectorHealthy(port, host)) return true;
+    if (await isInspectorHealthy(port, host, basePath)) return true;
     await sleep(250);
   }
   return false;
@@ -233,9 +249,9 @@ function readCaptureMode(raw: unknown): CaptureMode | null {
   return typeof value === "string" ? parseCaptureMode(value) : null;
 }
 
-function printAccessHints(port: number, host?: string): void {
+function printAccessHints(port: number, host?: string, basePath = ""): void {
   const networkUrls = networkUrlsForBindHost(port, host);
-  for (const line of formatAccessHintLines(port, networkUrls, host)) {
+  for (const line of formatAccessHintLines(port, networkUrls, host, basePath)) {
     console.log(line);
   }
   if (!isLoopbackHost(host)) {
@@ -539,13 +555,29 @@ async function runStart(args: string[]): Promise<void> {
   const upstreamHost = enableIdentityProxy ? DEFAULT_BIND_HOST : host;
   process.env["PORT"] = String(upstreamPort);
 
+  const basePath = getConfiguredBasePath(process.env);
   const url = urlForHost(port, host);
-
-  if (!forceRestart && (await isInspectorHealthy(port, host))) {
-    console.log(`agent-inspector is already running at ${url}`);
-    printAccessHints(port, host);
+  const uiUrl = appendBasePathToOrigin(url, "/", basePath);
+  const proxyUrl = appendBasePathToOrigin(url, "/proxy", basePath);
+  const proxyMessagesUrl = appendBasePathToOrigin(url, "/proxy/v1/messages", basePath);
+  const legacyUrl =
+    legacyAliasPort === null
+      ? null
+      : appendBasePathToOrigin(localUrlForPort(legacyAliasPort), "/", basePath);
+  const legacyProxyUrl =
+    legacyAliasPort === null
+      ? null
+      : appendBasePathToOrigin(localUrlForPort(legacyAliasPort), "/proxy", basePath);
+  const legacyMcpUrl =
+    legacyAliasPort === null
+      ? null
+      : appendBasePathToOrigin(localUrlForPort(legacyAliasPort), "/api/mcp", basePath);
+
+  if (!forceRestart && (await isInspectorHealthy(port, host, basePath))) {
+    console.log(`agent-inspector is already running at ${uiUrl}`);
+    printAccessHints(port, host, basePath);
     if (captureModeWasSpecified) {
-      const runningMode = await getRunningCaptureMode(port, host);
+      const runningMode = await getRunningCaptureMode(port, host, basePath);
       if (runningMode !== null && runningMode !== captureMode) {
         console.log(`Existing instance capture mode is ${runningMode}; requested ${captureMode}.`);
         console.log(`Use --force-restart to restart with ${captureMode} mode.`);
@@ -553,7 +585,7 @@ async function runStart(args: string[]): Promise<void> {
     }
     console.log(`Use --force-restart to restart the existing instance.`);
     if (open && openWasSpecified) {
-      openBrowser(url);
+      openBrowser(uiUrl);
     }
     return;
   }
@@ -605,46 +637,44 @@ async function runStart(args: string[]): Promise<void> {
     });
     supervisorProcess.unref();
 
-    if (await waitForInspectorHealthy(port, 10000, host)) {
-      console.log(`agent-inspector background server is ready at ${url}`);
-      printAccessHints(port, host);
-      if (legacyAliasPort !== null) {
-        console.log(`   Legacy proxy:  http://localhost:${legacyAliasPort}/proxy`);
-        console.log(`   Legacy MCP:    http://localhost:${legacyAliasPort}/api/mcp`);
+    if (await waitForInspectorHealthy(port, 10000, host, basePath)) {
+      console.log(`agent-inspector background server is ready at ${uiUrl}`);
+      printAccessHints(port, host, basePath);
+      if (legacyProxyUrl !== null && legacyMcpUrl !== null) {
+        console.log(`   Legacy proxy:  ${legacyProxyUrl}`);
+        console.log(`   Legacy MCP:    ${legacyMcpUrl}`);
       }
       console.log(``);
       console.log(`Route AI coding tools through the identity proxy for accurate PID attribution:`);
-      console.log(`   Claude Code:  ANTHROPIC_BASE_URL=http://localhost:${port}/proxy claude`);
-      console.log(`   OpenCode:     LLM_BASE_URL=http://localhost:${port}/proxy opencode`);
-      console.log(`   MiMo Code:    OPENAI_BASE_URL=http://localhost:${port}/proxy mimo`);
+      console.log(`   Claude Code:  ANTHROPIC_BASE_URL=${proxyUrl} claude`);
+      console.log(`   OpenCode:     LLM_BASE_URL=${proxyUrl} opencode`);
+      console.log(`   MiMo Code:    OPENAI_BASE_URL=${proxyUrl} mimo`);
       if (open && openWasSpecified) {
-        openBrowser(url);
+        openBrowser(uiUrl);
       }
       return;
     }
 
-    console.error(`agent-inspector background server did not become ready at ${url}.`);
+    console.error(`agent-inspector background server did not become ready at ${uiUrl}.`);
     process.exitCode = 1;
     return;
   }
 
-  console.log(`Server running at ${url}`);
+  console.log(`Server running at ${uiUrl}`);
   console.log(`   Capture mode: ${captureMode}`);
-  console.log(`   Proxy: ${url}/proxy`);
-  printAccessHints(port, host);
-  if (legacyAliasPort !== null) {
-    console.log(`   Legacy UI:      http://localhost:${legacyAliasPort}`);
-    console.log(`   Legacy proxy:   http://localhost:${legacyAliasPort}/proxy`);
-    console.log(`   Legacy MCP:     http://localhost:${legacyAliasPort}/api/mcp`);
+  console.log(`   Proxy: ${proxyUrl}`);
+  printAccessHints(port, host, basePath);
+  if (legacyUrl !== null && legacyProxyUrl !== null && legacyMcpUrl !== null) {
+    console.log(`   Legacy UI:      ${legacyUrl}`);
+    console.log(`   Legacy proxy:   ${legacyProxyUrl}`);
+    console.log(`   Legacy MCP:     ${legacyMcpUrl}`);
   }
   console.log(``);
   console.log(`Route AI coding tools through the proxy:`);
-  console.log(`   Claude Code:  ANTHROPIC_BASE_URL=${url}/proxy claude`);
-  console.log(`   OpenCode:     LLM_BASE_URL=${url}/proxy opencode`);
-  console.log(`   MiMo Code:    OPENAI_BASE_URL=${url}/proxy mimo`);
-  console.log(
-    `   Direct HTTP:  curl ${url}/proxy/v1/messages -d '{"model":"...","messages":[...]}'`,
-  );
+  console.log(`   Claude Code:  ANTHROPIC_BASE_URL=${proxyUrl} claude`);
+  console.log(`   OpenCode:     LLM_BASE_URL=${proxyUrl} opencode`);
+  console.log(`   MiMo Code:    OPENAI_BASE_URL=${proxyUrl} mimo`);
+  console.log(`   Direct HTTP:  curl ${proxyMessagesUrl} -d '{"model":"...","messages":[...]}'`);
   console.log(
     `   Remote/container tools: use the Network proxy URL above when shown; otherwise restart with --host 0.0.0.0 or a reachable IP.`,
   );
@@ -657,7 +687,7 @@ async function runStart(args: string[]): Promise<void> {
   );
 
   if (open) {
-    openBrowser(url);
+    openBrowser(uiUrl);
   }
 
   // Compute server path
@@ -691,6 +721,9 @@ async function runStart(args: string[]): Promise<void> {
   }
   serverEnv["HOST"] = upstreamHost;
   serverEnv["NITRO_HOST"] = upstreamHost;
+  if (enableIdentityProxy && basePath.length > 0) {
+    serverEnv[AGENT_INSPECTOR_INTERNAL_STRIPPED_BASE_PATH_ENV] = "1";
+  }
   serverEnv["AGENT_INSPECTOR_PUBLIC_PORT"] = String(port);
   serverEnv["PROXY_PORT"] = String(port);
   serverEnv["AGENT_INSPECTOR_CAPTURE_MODE"] = captureMode;
@@ -784,31 +817,32 @@ async function runStart(args: string[]): Promise<void> {
     serverProcess.unref();
     // Probe the upstream TanStack port directly — the identity proxy is
     // not started yet so the public port is not yet accepting traffic.
-    if (await waitForInspectorHealthy(upstreamPort, 5000, host)) {
-      console.log(`agent-inspector background server is ready at ${url}`);
+    const upstreamProbeBasePath = enableIdentityProxy ? "" : basePath;
+    if (await waitForInspectorHealthy(upstreamPort, 5000, host, upstreamProbeBasePath)) {
+      console.log(`agent-inspector background server is ready at ${uiUrl}`);
       if (identityProxies.length > 0) {
         console.log(`Identity proxy ready on port ${port} (PID-attributing proxy).`);
       }
-      printAccessHints(port, host);
-      if (legacyAliasPort !== null) {
-        console.log(`   Legacy proxy:  http://localhost:${legacyAliasPort}/proxy`);
-        console.log(`   Legacy MCP:    http://localhost:${legacyAliasPort}/api/mcp`);
+      printAccessHints(port, host, basePath);
+      if (legacyProxyUrl !== null && legacyMcpUrl !== null) {
+        console.log(`   Legacy proxy:  ${legacyProxyUrl}`);
+        console.log(`   Legacy MCP:    ${legacyMcpUrl}`);
       }
       if (identityProxies.length > 0) {
         console.log(
           ``,
           `Route AI coding tools through the identity proxy for accurate PID attribution:`,
-          `   Claude Code:  ANTHROPIC_BASE_URL=http://localhost:${port}/proxy claude`,
-          `   OpenCode:     LLM_BASE_URL=http://localhost:${port}/proxy opencode`,
-          `   MiMo Code:    OPENAI_BASE_URL=http://localhost:${port}/proxy mimo`,
-          legacyAliasPort === null
+          `   Claude Code:  ANTHROPIC_BASE_URL=${proxyUrl} claude`,
+          `   OpenCode:     LLM_BASE_URL=${proxyUrl} opencode`,
+          `   MiMo Code:    OPENAI_BASE_URL=${proxyUrl} mimo`,
+          legacyProxyUrl === null
             ? `   Override the port with --port <n> when needed.`
-            : `   Legacy configs using http://localhost:${legacyAliasPort}/proxy still work.`,
+            : `   Legacy configs using ${legacyProxyUrl} still work.`,
         );
       }
       return;
     }
-    console.error(`agent-inspector background server did not become ready at ${url}.`);
+    console.error(`agent-inspector background server did not become ready at ${uiUrl}.`);
     process.exitCode = 1;
     return;
   }

package/src/components/ProxyViewer.tsx

@@ -42,6 +42,7 @@ import {
 
 import type { CapturedLog } from "../contracts";
 import { exportLogsAsZip, type ExportMode } from "../lib/export-logs";
+import { withBasePath } from "../lib/basePath";
 import type { ImportLogsResponse } from "../lib/logImportContract";
 import { copyTextToClipboard } from "../lib/clipboard";
 import type { InspectorGroupEvidence, InspectorGroupMember } from "../lib/groupContract";
@@ -1340,6 +1341,10 @@ export function ProxyViewer({
   const exportAbortRef = useRef<AbortController | null>(null);
   const exportRequestIdRef = useRef(0);
   useKeyboardNavigation(logListRef, logListWrapperRef, { pageWide: true });
+  const proxyEndpoint = useMemo(() => {
+    const origin = typeof window === "undefined" ? "http://localhost:9527" : window.location.origin;
+    return `${origin}${withBasePath("/proxy")}`;
+  }, []);
 
   const cancelTransientTasks = useCallback(() => {
     exportRequestIdRef.current += 1;
@@ -2026,8 +2031,12 @@ export function ProxyViewer({
                     {liveEmptyStateCopy.showConnectionCommands && (
                       <>
                         <div className="flex flex-col items-center gap-2">
-                          <CopyableCommand command="ANTHROPIC_BASE_URL=http://localhost:9527/proxy <your-tool>" />
-                          <CopyableCommand command="OPENAI_BASE_URL=http://localhost:9527/proxy <your-tool>" />
+                          <CopyableCommand
+                            command={`ANTHROPIC_BASE_URL=${proxyEndpoint} <your-tool>`}
+                          />
+                          <CopyableCommand
+                            command={`OPENAI_BASE_URL=${proxyEndpoint} <your-tool>`}
+                          />
                         </div>
                         <p className="mx-auto max-w-xl text-xs leading-relaxed text-muted-foreground">
                           Container note: if your AI tool runs in a different container or host than

package/src/components/ProxyViewerContainer.tsx

@@ -2,6 +2,7 @@ import { useState, useEffect, useCallback, useRef, useMemo, useTransition, type
 import { z } from "zod";
 import { CapturedLogSchema, type CapturedLog } from "../contracts";
 import { fetchJson, fetchJsonWithTimeout } from "../lib/apiClient";
+import { withBasePath } from "../lib/basePath";
 import {
   DeleteInspectorGroupsResponseSchema,
   InspectorGroupsListResponseSchema,
@@ -139,7 +140,7 @@ function buildLogsStreamUrl(sessionId: string | undefined): string {
     params.set("sessionId", sessionId);
   }
   const query = params.toString();
-  return query.length > 0 ? `/api/logs/stream?${query}` : "/api/logs/stream";
+  return withBasePath(query.length > 0 ? `/api/logs/stream?${query}` : "/api/logs/stream");
 }
 
 function buildSessionLogsPageUrl(

package/src/components/pi-agent/PiAgentPanel.tsx

@@ -13,6 +13,7 @@ import {
   type PiAgentResponseView,
 } from "./piAgentChatLogic";
 import { useProviders } from "../../lib/useProviders";
+import { withBasePath } from "../../lib/basePath";
 import { dispatchLogFocusRequest } from "../proxy-viewer/logFocus";
 import { AnswerMarkdown } from "../proxy-viewer/AnswerMarkdown";
 import { Select, SelectContent, SelectItem, SelectTrigger, SelectValue } from "../ui/select";
@@ -273,7 +274,7 @@ export function PiAgentPanel({
       logLimit: 16,
     };
 
-    void fetch("/api/pi-agent", {
+    void fetch(withBasePath("/api/pi-agent"), {
       method: "POST",
       headers: {
         "content-type": "application/json",