@tonyclaw/agent-inspector 3.0.47 → 3.1.0

package/src/cli.ts

@@ -4,7 +4,7 @@ import { spawn, type ChildProcess } from "node:child_process";
 import { createConnection } from "node:net";
 import { fileURLToPath } from "node:url";
 import { dirname, join, resolve as resolvePath } from "node:path";
-import { existsSync } from "node:fs";
+import { appendFileSync, existsSync, mkdirSync } from "node:fs";
 import type { Readable, Writable } from "node:stream";
 import packageJson from "../package.json";
 import {
@@ -40,7 +40,10 @@ import {
   shouldSuppressServerOutputLine,
   type ServerOutputFilterContext,
 } from "./cli/startupOutput.js";
-import { resolveRustBackendPackage } from "./cli/rustBackendPackage.js";
+import {
+  resolvePreferredBackendImplementation,
+  resolveRustBackendPackage,
+} from "./cli/rustBackendPackage.js";
 import { handleNamedInstanceApi } from "./cli/instanceApi.js";
 import {
   closeIdentityProxyGracefully,
@@ -51,6 +54,7 @@ import {
   type ManagedInstanceControlOptions,
 } from "./proxy/identityProxy.js";
 import { findPidsByPort, killPid, openUrlCommand } from "./proxy/platformCommands.js";
+import { resolveDataDir } from "./proxy/dataDir.js";
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
@@ -68,6 +72,7 @@ const BRANDED_WINDOWS_RUNTIME_EXE = "agent-inspector.exe";
 const DEFAULT_CAPTURE_MODE = "simple";
 const DEFAULT_SHUTDOWN_DEADLINE_MS = 15_000;
 const SUPERVISOR_SHUTDOWN_GRACE_MS = 2_000;
+const AGENT_INSPECTOR_BACKGROUND_SUPERVISOR_ENV = "AGENT_INSPECTOR_BACKGROUND_SUPERVISOR";
 
 type CaptureMode = "simple" | "full";
 
@@ -96,7 +101,7 @@ Global options:
   -v, --version   Print the package version
 
 Start options:
-  --backend <typescript|rust> Select the backend implementation (default: typescript)
+  --backend <typescript|rust> Select the backend implementation (default: rust when native package is available)
   --backend-only, --headless  Start the API, proxy, and MCP runtime without serving the UI
   --with-ui                  Serve the independently built UI through the protected ingress
   --port, -p <port>          Public ingress port (default: 9527)
@@ -298,6 +303,30 @@ function pipeServerOutput(child: ChildProcess, context: ServerOutputFilterContex
   pipeServerOutputStream(child.stderr, process.stderr, context);
 }
 
+type BackgroundSupervisorLogs = {
+  stdoutPath: string;
+  stderrPath: string;
+};
+
+function createBackgroundSupervisorLogs(
+  env: Readonly<Record<string, string | undefined>>,
+): BackgroundSupervisorLogs | null {
+  try {
+    const logsDir = join(resolveDataDir(existsSync, env), "logs");
+    mkdirSync(logsDir, { recursive: true });
+    const stdoutPath = join(logsDir, "backend.stdout.log");
+    const stderrPath = join(logsDir, "backend.stderr.log");
+    const header = `\n[${new Date().toISOString()}] Agent Inspector backend process started\n`;
+    appendFileSync(stdoutPath, header, { encoding: "utf8" });
+    appendFileSync(stderrPath, header, { encoding: "utf8" });
+    return { stdoutPath, stderrPath };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    process.stderr.write(`Failed to open Agent Inspector background logs: ${message}\n`);
+    return null;
+  }
+}
+
 function pipeServerOutputStream(
   stream: Readable | null,
   target: Writable,
@@ -325,6 +354,42 @@ function pipeServerOutputStream(
   });
 }
 
+function appendBackgroundLog(path: string, text: string): void {
+  try {
+    appendFileSync(path, text, { encoding: "utf8" });
+  } catch {
+    // Background supervisor output is best-effort: startup must not fail just
+    // because a diagnostic log file is temporarily unavailable.
+  }
+}
+
+function pipeServerOutputStreamToFile(
+  stream: Readable | null,
+  targetPath: string,
+  context: ServerOutputFilterContext,
+): void {
+  if (stream === null) return;
+
+  let buffered = "";
+  stream.on("data", (chunk: unknown) => {
+    const text = Buffer.isBuffer(chunk) ? chunk.toString("utf8") : String(chunk);
+    const lines = `${buffered}${text}`.split(/\r?\n/);
+    buffered = lines.pop() ?? "";
+    for (const line of lines) {
+      if (!shouldSuppressServerOutputLine(line, context)) {
+        appendBackgroundLog(targetPath, `${line}\n`);
+      }
+    }
+  });
+  stream.on("end", () => {
+    if (buffered.length === 0) return;
+    if (!shouldSuppressServerOutputLine(buffered, context)) {
+      appendBackgroundLog(targetPath, buffered);
+    }
+    buffered = "";
+  });
+}
+
 type ServerCommand = {
   command: string;
   args: string[];
@@ -568,7 +633,9 @@ async function runStart(args: string[]): Promise<void> {
   const envHost = process.env["NITRO_HOST"] ?? process.env["HOST"];
   const envMode =
     process.env["AGENT_INSPECTOR_CAPTURE_MODE"] ?? process.env["AGENT_INSPECTOR_MODE"];
-  const envBackend = parseBackendImplementation(process.env[AGENT_INSPECTOR_BACKEND_ENV]);
+  const rawEnvBackend = process.env[AGENT_INSPECTOR_BACKEND_ENV];
+  const envBackend =
+    rawEnvBackend === undefined ? undefined : parseBackendImplementation(rawEnvBackend);
   if (envBackend === null) {
     console.error(
       `Invalid ${AGENT_INSPECTOR_BACKEND_ENV}. Use typescript or rust; no backend was started.`,
@@ -591,7 +658,8 @@ async function runStart(args: string[]): Promise<void> {
   let enableIdentityProxy = true;
   let legacyAliasEnabled = false;
   let serveUi = process.env["AGENT_INSPECTOR_BACKEND_ONLY"] !== "1";
-  let backend: BackendImplementation = envBackend;
+  let backend: BackendImplementation = envBackend ?? "typescript";
+  let backendWasSpecified = envBackend !== undefined;
 
   if (envMode !== undefined && envMode !== "") {
     const parsedMode = parseCaptureMode(envMode);
@@ -651,6 +719,7 @@ async function runStart(args: string[]): Promise<void> {
         return;
       }
       backend = parsedBackend.data;
+      backendWasSpecified = true;
       continue;
     }
     switch (arg) {
@@ -681,6 +750,7 @@ async function runStart(args: string[]): Promise<void> {
           return;
         }
         backend = parsedBackend.data;
+        backendWasSpecified = true;
         i++;
         break;
       }
@@ -772,6 +842,12 @@ async function runStart(args: string[]): Promise<void> {
     return;
   }
 
+  if (!backendWasSpecified) {
+    backend =
+      managedLaunch?.backend ??
+      resolvePreferredBackendImplementation({ rootVersion: packageJson.version });
+  }
+
   if (managedLaunch !== null && managedLaunch.backend !== backend) {
     console.error(
       `Managed instance backend mismatch: launch identity requires ${managedLaunch.backend}, but ${backend} was selected.`,
@@ -967,7 +1043,11 @@ async function runStart(args: string[]): Promise<void> {
     const supervisorProcess = spawn(process.execPath, [cliEntry, ...supervisorArgs], {
       stdio: "ignore",
       detached: true,
-      env: { ...process.env, [AGENT_INSPECTOR_CLI_ENTRY_ENV]: cliEntry },
+      env: {
+        ...process.env,
+        [AGENT_INSPECTOR_CLI_ENTRY_ENV]: cliEntry,
+        [AGENT_INSPECTOR_BACKGROUND_SUPERVISOR_ENV]: "1",
+      },
       windowsHide: true,
     });
     supervisorProcess.once("error", (err) => {
@@ -1042,6 +1122,11 @@ async function runStart(args: string[]): Promise<void> {
   if (existsSync(workerDir)) {
     serverEnv["AGENT_INSPECTOR_WORKER_DIR"] = workerDir;
   }
+  const runningInBackgroundSupervisor =
+    process.env[AGENT_INSPECTOR_BACKGROUND_SUPERVISOR_ENV] === "1";
+  const backgroundSupervisorLogs = runningInBackgroundSupervisor
+    ? createBackgroundSupervisorLogs(serverEnv)
+    : null;
   const serverProcess = spawn(serverCommand.command, serverCommand.args, {
     stdio:
       managedLaunch === null
@@ -1057,18 +1142,32 @@ async function runStart(args: string[]): Promise<void> {
             : ["ignore", "pipe", "pipe"],
     detached: background,
     env: serverEnv,
-    windowsHide: background,
+    windowsHide: background || runningInBackgroundSupervisor,
   });
   serverProcess.once("error", (err) => {
     console.error(`Failed to start Agent Inspector runtime: ${err.message}`);
   });
   const serverExit = waitForProcessExit(serverProcess);
   if (!background) {
-    pipeServerOutput(serverProcess, {
+    const outputContext = {
       enableIdentityProxy,
       publicPort: port,
       upstreamPort,
-    });
+    };
+    if (backgroundSupervisorLogs === null) {
+      pipeServerOutput(serverProcess, outputContext);
+    } else {
+      pipeServerOutputStreamToFile(
+        serverProcess.stdout,
+        backgroundSupervisorLogs.stdoutPath,
+        outputContext,
+      );
+      pipeServerOutputStreamToFile(
+        serverProcess.stderr,
+        backgroundSupervisorLogs.stderrPath,
+        outputContext,
+      );
+    }
   }
 
   // Identity proxy — a native Node HTTP server that sits in front of

package/src/components/ProxyViewer.tsx

@@ -61,6 +61,7 @@ import { useProviders } from "../lib/useProviders";
 import { groupLogsByConversation, type ConversationGroupData } from "./proxy-viewer";
 import {
   buildSessionSlateStats,
+  buildHomeConnectionCommands,
   COPYABLE_COMMAND_CONTAINER_CLASS_NAME,
   COPYABLE_COMMAND_TEXT_CLASS_NAME,
   exportRequiresConfirmation,
@@ -2148,19 +2149,9 @@ export function ProxyViewer({
                     {liveEmptyStateCopy.showConnectionCommands && connectionEndpoints !== null && (
                       <>
                         <div className="flex flex-col items-center gap-2">
-                          <CopyableCommand
-                            command={`ANTHROPIC_BASE_URL=${connectionEndpoints.proxy} <your-tool>`}
-                          />
-                          <CopyableCommand
-                            command={`LLM_BASE_URL=${connectionEndpoints.proxy} opencode`}
-                          />
-                          <CopyableCommand
-                            command={`OPENAI_BASE_URL=${connectionEndpoints.openAiV1} <your-tool>`}
-                          />
-                          <CopyableCommand
-                            command={`base_url = "${connectionEndpoints.openAiV1}"`}
-                          />
-                          <CopyableCommand command={`MCP_URL=${connectionEndpoints.mcp}`} />
+                          {buildHomeConnectionCommands(connectionEndpoints).map((command) => (
+                            <CopyableCommand key={command} command={command} />
+                          ))}
                         </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/proxy-viewer/proxyViewerLogic.ts

@@ -24,11 +24,20 @@ export type ConversationLogs = {
   logs: CapturedLog[];
 };
 
+export type HomeConnectionEndpoints = {
+  proxy: string;
+  mcp: string;
+};
+
 export const COPYABLE_COMMAND_CONTAINER_CLASS_NAME =
   "flex w-full min-w-0 items-center gap-2 rounded-md border border-border/70 bg-muted/35 px-3 py-2 sm:w-auto sm:max-w-full";
 export const COPYABLE_COMMAND_TEXT_CLASS_NAME =
   "m-0 min-w-0 flex-1 overflow-x-auto font-mono text-xs text-foreground sm:text-sm";
 
+export function buildHomeConnectionCommands(endpoints: HomeConnectionEndpoints): readonly string[] {
+  return [`PROXY_BASE_URL=${endpoints.proxy}`, `MCP_URL=${endpoints.mcp}`];
+}
+
 export type SessionSlateStats = {
   status: SessionSlateStatus;
   statusLabel: string;