@tonyclaw/agent-inspector 3.0.38 → 3.0.39

package/.output/cli.js

@@ -14,12 +14,76 @@ var __export = (target, all) => {
     __defProp(target, name, { get: all[name], enumerable: true });
 };
 
+// src/lib/basePath.ts
+function trimSlashes(value) {
+  return value.replace(/^\/+/u, "").replace(/\/+$/u, "");
+}
+function normalizeBasePath(value) {
+  const trimmed = value?.trim();
+  if (trimmed === void 0 || trimmed.length === 0 || trimmed === "/") return "";
+  const path2 = trimSlashes(trimmed);
+  if (path2.length === 0) return "";
+  return `/${path2}`;
+}
+function readDocumentBasePath() {
+  if (typeof document === "undefined") return void 0;
+  return document.querySelector(`meta[name="${AGENT_INSPECTOR_BASE_PATH_META_NAME}"]`)?.getAttribute("content") ?? void 0;
+}
+function readProcessBasePath() {
+  if (typeof process === "undefined") return void 0;
+  return process.env[AGENT_INSPECTOR_BASE_PATH_ENV];
+}
+function getConfiguredBasePath(env) {
+  return normalizeBasePath(
+    env?.[AGENT_INSPECTOR_BASE_PATH_ENV] ?? readProcessBasePath() ?? readDocumentBasePath() ?? import.meta.env?.BASE_URL ?? DEFAULT_AGENT_INSPECTOR_BASE_PATH
+  );
+}
+function withBasePath(path2, basePath = getConfiguredBasePath()) {
+  const normalized = normalizeBasePath(basePath);
+  if (/^[a-z][a-z0-9+.-]*:/iu.test(path2)) return path2;
+  if (normalized.length === 0) return path2;
+  if (path2.length === 0 || path2 === "/") return normalized;
+  if (path2.startsWith(`${normalized}/`) || path2 === normalized) return path2;
+  return path2.startsWith("/") ? `${normalized}${path2}` : `${normalized}/${path2}`;
+}
+function stripBasePath(pathname, basePath = getConfiguredBasePath()) {
+  const normalized = normalizeBasePath(basePath);
+  if (normalized.length === 0) return pathname;
+  if (pathname === normalized) return "/";
+  if (pathname.startsWith(`${normalized}/`)) return pathname.slice(normalized.length);
+  return pathname;
+}
+function appendBasePathToOrigin(origin, path2, basePath) {
+  const normalized = normalizeBasePath(basePath);
+  if (normalized.length === 0 && path2 === "/") return origin;
+  return `${origin}${withBasePath(path2, normalized)}`;
+}
+function stripBasePathFromRequestPath(rawPath, basePath) {
+  const url2 = new URL(rawPath, "http://localhost");
+  return `${stripBasePath(url2.pathname, basePath)}${url2.search}`;
+}
+var AGENT_INSPECTOR_BASE_PATH_ENV, AGENT_INSPECTOR_INTERNAL_STRIPPED_BASE_PATH_ENV, AGENT_INSPECTOR_BASE_PATH_META_NAME, DEFAULT_AGENT_INSPECTOR_BASE_PATH;
+var init_basePath = __esm({
+  "src/lib/basePath.ts"() {
+    "use strict";
+    AGENT_INSPECTOR_BASE_PATH_ENV = "AGENT_INSPECTOR_BASE_PATH";
+    AGENT_INSPECTOR_INTERNAL_STRIPPED_BASE_PATH_ENV = "AGENT_INSPECTOR_INTERNAL_STRIPPED_BASE_PATH";
+    AGENT_INSPECTOR_BASE_PATH_META_NAME = "agent-inspector-base-path";
+    DEFAULT_AGENT_INSPECTOR_BASE_PATH = "/inspector";
+  }
+});
+
 // src/proxy/privateDataPath.ts
 import { spawnSync } from "node:child_process";
 import { chmodSync, existsSync, lstatSync, mkdirSync, readdirSync, statSync } from "node:fs";
 import { dirname, join } from "node:path";
+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
@@ -1265,6 +1329,11 @@ function actionForStatus(label, state) {
   }
 }
 function parseFlags(argv) {
+  const defaultMcpUrl = appendBasePathToOrigin(
+    DEFAULT_ORIGIN,
+    "/api/mcp",
+    getConfiguredBasePath(process.env)
+  );
   const flags = {
     force: false,
     dryRun: false,
@@ -1276,12 +1345,12 @@ function parseFlags(argv) {
     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,
@@ -2473,10 +2542,11 @@ Next steps:
   }
   return 0;
 }
-var __filename, __dirname, DEFAULT_PORT, DEFAULT_MCP_URL, LEGACY_MCP_URL, SKILL_DIR_NAME, SKILL_FILE_NAME, COMMAND_FILE_NAME, GENERATED_VERSION_PATTERN, FRONTMATTER_PATTERN, SEMVER_PATTERN;
+var __filename, __dirname, DEFAULT_PORT, DEFAULT_ORIGIN, DEFAULT_MCP_URL, LEGACY_MCP_URL, SKILL_DIR_NAME, SKILL_FILE_NAME, COMMAND_FILE_NAME, GENERATED_VERSION_PATTERN, FRONTMATTER_PATTERN, SEMVER_PATTERN;
 var init_onboard = __esm({
   "src/cli/onboard.ts"() {
     "use strict";
+    init_basePath();
     init_detect_tools();
     init_command_onboard();
     init_codex_skill_onboard();
@@ -2484,7 +2554,8 @@ var init_onboard = __esm({
     __filename = fileURLToPath(import.meta.url);
     __dirname = dirname2(__filename);
     DEFAULT_PORT = 9527;
-    DEFAULT_MCP_URL = `http://localhost:${DEFAULT_PORT}/api/mcp`;
+    DEFAULT_ORIGIN = `http://localhost:${DEFAULT_PORT}`;
+    DEFAULT_MCP_URL = `${DEFAULT_ORIGIN}/api/mcp`;
     LEGACY_MCP_URL = "http://localhost:9527/api/mcp";
     SKILL_DIR_NAME = "agent-inspector-onboard";
     SKILL_FILE_NAME = "SKILL.md";
@@ -2682,14 +2753,17 @@ function checkProviderConfig(options, deps) {
   );
 }
 async function checkProxyHealth(port, deps) {
-  const health = await deps.fetchHealth(port);
+  const basePath = getConfiguredBasePath(deps.env);
+  const health = await deps.fetchHealth(port, basePath);
   const url2 = `http://localhost:${port}`;
+  const proxyUrl = appendBasePathToOrigin(url2, "/proxy", basePath);
+  const healthPath = appendBasePathToOrigin("", "/api/health", basePath);
   if (health.ok) {
     return check2(
       "Proxy health",
       "pass",
-      `agent-inspector is healthy at ${url2}.`,
-      `Proxy URL: ${url2}/proxy`
+      `agent-inspector is healthy at ${appendBasePathToOrigin(url2, "/", basePath)}.`,
+      `Proxy URL: ${proxyUrl}`
     );
   }
   if (await deps.isPortOpen(port)) {
@@ -2697,7 +2771,7 @@ async function checkProxyHealth(port, deps) {
     return check2(
       "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."
     );
   }
@@ -2950,14 +3024,17 @@ function doctorHelp() {
     ""
   ].join("\n");
 }
-async function fetchHealth(port) {
+async function fetchHealth(port, basePath) {
   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 };
@@ -3036,6 +3113,7 @@ var DEFAULT_PORT2, PROBE_TIMEOUT_MS, EXTENSION_REQUIRED_FILES;
 var init_doctor = __esm({
   "src/cli/doctor.ts"() {
     "use strict";
+    init_basePath();
     init_dataDir();
     DEFAULT_PORT2 = 9527;
     PROBE_TIMEOUT_MS = 2e3;
@@ -3055,6 +3133,7 @@ var init_doctor = __esm({
 });
 
 // src/cli.ts
+init_basePath();
 import { Buffer as Buffer4 } from "node:buffer";
 import { spawn } from "node:child_process";
 import { createConnection as createConnection2 } from "node:net";
@@ -3063,6 +3142,7 @@ import { dirname as dirname3, join as join7, resolve as resolvePath } from "node
 import { existsSync as existsSync6 } from "node:fs";
 
 // src/cli/networkHints.ts
+init_basePath();
 import { networkInterfaces } from "node:os";
 function localUrlForPort(port) {
   return `http://localhost:${String(port)}`;
@@ -3137,19 +3217,23 @@ function networkUrlsForBindHost(port, host, interfaces = networkInterfaces()) {
   if (isWildcardHost(host)) return collectNetworkUrls(port, interfaces);
   return [urlForHost(port, host)];
 }
-function formatAccessHintLines(port, networkUrls, host = void 0) {
+function accessUrl(origin, path2, basePath) {
+  return appendBasePathToOrigin(origin, path2, basePath);
+}
+function formatAccessHintLines(port, networkUrls, host = void 0, basePath = "") {
+  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");
   }
   const firstNetworkUrl = networkUrls[0];
@@ -3158,8 +3242,8 @@ function formatAccessHintLines(port, networkUrls, host = void 0) {
   } else if (firstNetworkUrl === void 0) {
     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(", ")}`);
@@ -3180,6 +3264,7 @@ function shouldSuppressServerOutputLine(line, context) {
 }
 
 // src/proxy/identityProxy.ts
+init_basePath();
 import http from "node:http";
 import { Buffer as Buffer3 } from "node:buffer";
 import { timingSafeEqual } from "node:crypto";
@@ -18193,6 +18278,30 @@ var DOCUMENT_CONTENT_SECURITY_POLICY = [
   "style-src 'self' 'unsafe-inline'",
   "worker-src 'self' blob:"
 ].join("; ");
+function htmlAttributeEscape(value) {
+  return value.replace(/&/gu, "&amp;").replace(/"/gu, "&quot;").replace(/</gu, "&lt;").replace(/>/gu, "&gt;");
+}
+function rewriteHtmlForBasePath(html, basePath) {
+  const normalized = normalizeBasePath(basePath);
+  if (normalized.length === 0) return html;
+  const escaped = htmlAttributeEscape(normalized);
+  const meta3 = `<meta name="${AGENT_INSPECTOR_BASE_PATH_META_NAME}" content="${escaped}">`;
+  const withMeta = html.includes(`name="${AGENT_INSPECTOR_BASE_PATH_META_NAME}"`) ? html : html.replace(/<head(\s[^>]*)?>/iu, (match) => `${match}${meta3}`);
+  const escapedBase = normalized.replace(/[.*+?^${}()|[\]\\]/gu, "\\$&");
+  return withMeta.replace(
+    new RegExp(`\\b(href|src|action)=("|')/(?!/|${escapedBase.slice(1)}(?:/|$))`, "giu"),
+    (_match, attr, quote) => `${attr}=${quote}${normalized}/`
+  );
+}
+function javaScriptStringEscape(value) {
+  return value.replace(/\\/gu, "\\\\").replace(/"/gu, '\\"');
+}
+function rewriteJavaScriptForBasePath(source, basePath) {
+  const normalized = normalizeBasePath(basePath);
+  if (normalized.length === 0) return source;
+  const escaped = javaScriptStringEscape(normalized);
+  return source.replace(/\bbasepath:\s*""/gu, `basepath:"${escaped}"`).replace(/return"\/"\+([A-Za-z_$][\w$]*)/gu, `return"${escaped}/"+$1`).replace(/(["'])\/assets\//gu, `$1${normalized}/assets/`);
+}
 function isLoopbackPeer(address) {
   if (address === void 0) return false;
   const normalized = address.toLowerCase();
@@ -18240,7 +18349,8 @@ function isSafeMethod(method) {
   return normalized === "GET" || normalized === "HEAD" || normalized === "OPTIONS";
 }
 function isPublicHealthPath(pathname) {
-  return pathname === "/livez" || pathname === "/readyz" || pathname === "/api/health";
+  const path2 = stripBasePath(pathname, getConfiguredBasePath(process.env));
+  return path2 === "/livez" || path2 === "/readyz" || path2 === "/api/health";
 }
 function configuredPositiveInteger(value, fallback) {
   return value !== void 0 && Number.isSafeInteger(value) && value > 0 ? value : fallback;
@@ -18253,7 +18363,10 @@ function declaredContentLength(value) {
 }
 function isBrowserMutationAllowed(input) {
   if (isSafeMethod(input.method)) return true;
-  const pathname = new URL(input.path, "http://localhost").pathname;
+  const pathname = stripBasePath(
+    new URL(input.path, "http://localhost").pathname,
+    getConfiguredBasePath(process.env)
+  );
   if (pathname === "/proxy" || pathname.startsWith("/proxy/")) return true;
   const fetchSite = input.secFetchSite?.toLowerCase();
   const browserRequest = input.origin !== void 0 || fetchSite !== void 0;
@@ -18273,7 +18386,10 @@ function isIdentityProxyRequestAllowed(input) {
   if (input.options.restrictRemoteControl !== true) return true;
   if (input.options.allowRemoteControl === true) return true;
   if (isLoopbackPeer(input.remoteAddress)) return true;
-  const pathname = new URL(input.path, "http://localhost").pathname;
+  const pathname = stripBasePath(
+    new URL(input.path, "http://localhost").pathname,
+    getConfiguredBasePath(process.env)
+  );
   if (pathname === "/proxy" || pathname.startsWith("/proxy/")) {
     if (input.options.allowUnauthenticatedRemoteProxy === true) return true;
     const proxyCredential = bearerToken(input.proxyAuthorization) ?? input.proxyTokenHeader ?? null;
@@ -18364,6 +18480,9 @@ function forceCloseIdentityProxy(server) {
   server.close();
 }
 async function handleRequest(req, res, options) {
+  const basePath = getConfiguredBasePath(process.env);
+  const upstreamPath = stripBasePathFromRequestPath(req.url ?? "/", basePath);
+  const requestUrl = new URL(req.url ?? "/", "http://localhost");
   if (!isTrustedIdentityProxyHost(req.headers.host, options)) {
     res.writeHead(400, {
       "content-type": "application/json; charset=utf-8",
@@ -18373,6 +18492,15 @@ async function handleRequest(req, res, options) {
     req.resume();
     return;
   }
+  if (basePath.length > 0 && requestUrl.pathname.startsWith("/assets/")) {
+    res.writeHead(307, {
+      location: `${basePath}${requestUrl.pathname}${requestUrl.search}`,
+      "cache-control": "no-store"
+    });
+    res.end();
+    req.resume();
+    return;
+  }
   if (!isBrowserMutationAllowed({
     path: req.url ?? "/",
     method: req.method,
@@ -18445,6 +18573,7 @@ async function handleRequest(req, res, options) {
   for (const [name, value] of Object.entries(req.headers)) {
     const lowerName = name.toLowerCase();
     if (REQUEST_HOP_BY_HOP.has(lowerName)) continue;
+    if (basePath.length > 0 && lowerName === "accept-encoding") continue;
     if (lowerName.startsWith(IDENTITY_HEADER_PREFIX)) continue;
     if (value === void 0) continue;
     upstreamHeaders[name] = value;
@@ -18470,7 +18599,7 @@ async function handleRequest(req, res, options) {
     {
       hostname: options.upstreamHost,
       port: options.upstreamPort,
-      path: req.url ?? "/",
+      path: upstreamPath,
       method: req.method,
       headers: upstreamHeaders
     },
@@ -18480,19 +18609,40 @@ async function handleRequest(req, res, options) {
         return;
       }
       const outHeaders = {};
+      const contentType = firstHeader(proxyRes.headers["content-type"]);
+      const shouldRewriteHtml = basePath.length > 0 && contentType?.toLowerCase().includes("text/html") === true;
+      const shouldRewriteJavaScript = basePath.length > 0 && (contentType?.toLowerCase().includes("javascript") === true || upstreamPath.split("?", 1)[0]?.endsWith(".js") === true);
+      const shouldRewriteBody = shouldRewriteHtml || shouldRewriteJavaScript;
       for (const [name, value] of Object.entries(proxyRes.headers)) {
-        if (RESPONSE_HOP_BY_HOP.has(name.toLowerCase())) continue;
+        const lowerName = name.toLowerCase();
+        if (RESPONSE_HOP_BY_HOP.has(lowerName)) continue;
+        if (shouldRewriteBody && lowerName === "content-length") continue;
         if (value === void 0) continue;
         outHeaders[name] = value;
       }
       for (const [name, value] of Object.entries(BASE_SECURITY_HEADERS)) {
         outHeaders[name] = value;
       }
-      const contentType = firstHeader(proxyRes.headers["content-type"]);
       if (contentType?.toLowerCase().includes("text/html") === true) {
         outHeaders["content-security-policy"] = DOCUMENT_CONTENT_SECURITY_POLICY;
       }
       res.writeHead(proxyRes.statusCode ?? 502, outHeaders);
+      if (shouldRewriteBody) {
+        const chunks = [];
+        proxyRes.on("data", (chunk) => {
+          chunks.push(toBuffer(chunk));
+        });
+        proxyRes.on("end", () => {
+          const body = Buffer3.concat(chunks).toString("utf8");
+          res.end(
+            shouldRewriteHtml ? rewriteHtmlForBasePath(body, basePath) : rewriteJavaScriptForBasePath(body, basePath)
+          );
+        });
+        proxyRes.on("error", () => {
+          if (!res.writableEnded) res.destroy();
+        });
+        return;
+      }
       proxyRes.pipe(res);
     }
   );
@@ -18591,14 +18741,17 @@ if (subcommand === "doctor") {
   process.exit(code);
 }
 await runStart(process.argv.slice(2));
-async function isInspectorHealthy(port, host) {
+async function isInspectorHealthy(port, host, basePath = "") {
   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;
@@ -18606,14 +18759,17 @@ async function isInspectorHealthy(port, host) {
     clearTimeout(timeout);
   }
 }
-async function getRunningCaptureMode(port, host) {
+async function getRunningCaptureMode(port, host, basePath = "") {
   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 = await response.json();
     return readCaptureMode(raw);
@@ -18642,10 +18798,10 @@ function sleep(ms) {
     setTimeout(resolve2, ms);
   });
 }
-async function waitForInspectorHealthy(port, timeoutMs, host) {
+async function waitForInspectorHealthy(port, timeoutMs, host, basePath = "") {
   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;
@@ -18720,9 +18876,9 @@ function readCaptureMode(raw) {
   const value = descriptor?.value;
   return typeof value === "string" ? parseCaptureMode(value) : null;
 }
-function printAccessHints(port, host) {
+function printAccessHints(port, host, basePath = "") {
   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)) {
@@ -18966,12 +19122,19 @@ async function runStart(args) {
   const upstreamPort = enableIdentityProxy ? pickUpstreamPort(port, legacyAliasPort) : port;
   const upstreamHost = enableIdentityProxy ? DEFAULT_BIND_HOST : host;
   process.env["PORT"] = String(upstreamPort);
+  const basePath = getConfiguredBasePath(process.env);
   const url2 = urlForHost(port, host);
-  if (!forceRestart && await isInspectorHealthy(port, host)) {
-    console.log(`agent-inspector is already running at ${url2}`);
-    printAccessHints(port, host);
+  const uiUrl = appendBasePathToOrigin(url2, "/", basePath);
+  const proxyUrl = appendBasePathToOrigin(url2, "/proxy", basePath);
+  const proxyMessagesUrl = appendBasePathToOrigin(url2, "/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.`);
@@ -18979,7 +19142,7 @@ async function runStart(args) {
     }
     console.log(`Use --force-restart to restart the existing instance.`);
     if (open && openWasSpecified) {
-      openBrowser(url2);
+      openBrowser(uiUrl);
     }
     return;
   }
@@ -19026,44 +19189,42 @@ async function runStart(args) {
       console.error(`Failed to start Agent Inspector background supervisor: ${err.message}`);
     });
     supervisorProcess.unref();
-    if (await waitForInspectorHealthy(port, 1e4, host)) {
-      console.log(`agent-inspector background server is ready at ${url2}`);
-      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, 1e4, 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(url2);
+        openBrowser(uiUrl);
       }
       return;
     }
-    console.error(`agent-inspector background server did not become ready at ${url2}.`);
+    console.error(`agent-inspector background server did not become ready at ${uiUrl}.`);
     process.exitCode = 1;
     return;
   }
-  console.log(`Server running at ${url2}`);
+  console.log(`Server running at ${uiUrl}`);
   console.log(`   Capture mode: ${captureMode}`);
-  console.log(`   Proxy: ${url2}/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=${url2}/proxy claude`);
-  console.log(`   OpenCode:     LLM_BASE_URL=${url2}/proxy opencode`);
-  console.log(`   MiMo Code:    OPENAI_BASE_URL=${url2}/proxy mimo`);
-  console.log(
-    `   Direct HTTP:  curl ${url2}/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.`
   );
@@ -19075,7 +19236,7 @@ async function runStart(args) {
     `   Example: ROUTES='{"claude-":"https://api.anthropic.com","MiniMax":"https://api.minimaxi.com/anthropic"}'`
   );
   if (open) {
-    openBrowser(url2);
+    openBrowser(uiUrl);
   }
   const outputDir = __dirname2;
   const serverPath = join7(outputDir, "../.output/server/index.mjs");
@@ -19098,6 +19259,9 @@ async function runStart(args) {
   }
   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;
@@ -19173,29 +19337,30 @@ async function runStart(args) {
   }
   if (background) {
     serverProcess.unref();
-    if (await waitForInspectorHealthy(upstreamPort, 5e3, host)) {
-      console.log(`agent-inspector background server is ready at ${url2}`);
+    const upstreamProbeBasePath = enableIdentityProxy ? "" : basePath;
+    if (await waitForInspectorHealthy(upstreamPort, 5e3, 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 ? `   Override the port with --port <n> when needed.` : `   Legacy configs using http://localhost:${legacyAliasPort}/proxy still work.`
+          `   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 ${legacyProxyUrl} still work.`
         );
       }
       return;
     }
-    console.error(`agent-inspector background server did not become ready at ${url2}.`);
+    console.error(`agent-inspector background server did not become ready at ${uiUrl}.`);
     process.exitCode = 1;
     return;
   }

package/.output/nitro.json

@@ -1,5 +1,5 @@
 {
-  "date": "2026-07-14T03:53:34.395Z",
+  "date": "2026-07-14T08:10:19.568Z",
   "preset": "node-server",
   "framework": {
     "name": "nitro",