@tonyclaw/agent-inspector 3.0.44 → 3.0.46

package/src/mcp/toolHandlers.ts

@@ -20,7 +20,7 @@ import { existsSync, readFileSync, statSync, writeFileSync } from "node:fs";
 import { dirname, join } from "node:path";
 import JSZip from "jszip";
 import { z } from "zod";
-import { getCurrentPort } from "../lib/serverPort";
+import { getPublicPort } from "../lib/publicBasePathContext";
 import { LoopbackTimeoutError, type CallApiOptions } from "./loopback";
 import { extractLastUserMessagePreview, extractResponsePreview } from "./previewExtractor";
 import {
@@ -138,7 +138,7 @@ function redactedProvidersResult(value: unknown): ToolResult {
 }
 
 function inspectorBaseUrl(): string {
-  return `http://127.0.0.1:${String(getCurrentPort())}`;
+  return `http://127.0.0.1:${String(getPublicPort())}`;
 }
 
 function hasBodyText(value: string | null, byteLength: number | null | undefined): boolean {

package/src/proxy/config.ts

@@ -1,11 +1,4 @@
-import {
-  writeFileSync,
-  readFileSync,
-  unlinkSync,
-  existsSync,
-  renameSync,
-  copyFileSync,
-} from "node:fs";
+import { writeFileSync, readFileSync, unlinkSync, existsSync, renameSync } from "node:fs";
 import { join } from "node:path";
 import { logger } from "./logger";
 import { getDataDir } from "./dataDir";
@@ -128,19 +121,19 @@ export function getConfig(): RuntimeConfig {
 }
 
 /**
- * Applies a partial update to the in-memory config and persists to disk.
- * Returns the updated full config. Persistence failures are logged but
- * do not throw — the in-memory value is always updated so the caller
- * sees a consistent response.
+ * Applies a partial update after atomically persisting it to disk.
+ * Returns the updated full config on success or null when persistence
+ * fails. A failed write leaves both the in-memory value and the existing
+ * on-disk value unchanged.
  */
-export function setConfig(patch: Partial<MutableRuntimeConfig>): RuntimeConfig {
+export function setConfig(patch: Partial<MutableRuntimeConfig>): RuntimeConfig | null {
   const next: RuntimeConfig = {
     ...currentConfig,
     ...patch,
     captureMode: currentConfig.captureMode,
   };
+  if (!persistConfig(next)) return null;
   currentConfig = next;
-  persistConfig(next);
   return next;
 }
 
@@ -164,8 +157,10 @@ export function _rebootForTests(): void {
 // --- Atomic write ---
 
 /**
- * Atomic write: temp file + rename. Mirrors the pattern in chunkStorage.ts.
- * Returns true on success, false on failure (logged but not thrown).
+ * Atomic write: secure temp file + rename in the same directory.
+ * Returns true on success, false on failure (logged but not thrown). There is
+ * deliberately no copy fallback because replacing the target through a copy
+ * could expose a partially written config after a crash.
  */
 function persistConfig(value: RuntimeConfig): boolean {
   const dir = getDataDir();
@@ -181,13 +176,15 @@ function persistConfig(value: RuntimeConfig): boolean {
     writeFileSync(tempPath, JSON.stringify(toPersistedConfig(value)), {
       encoding: "utf-8",
       mode: PRIVATE_FILE_MODE,
+      flush: true,
     });
     if (!securePrivateFileSync(tempPath)) {
-      unlinkSync(tempPath);
+      removeConfigTempFile(tempPath);
       logger.error(`[config] Failed to secure config temp file ${tempPath}`);
       return false;
     }
   } catch (err) {
+    removeConfigTempFile(tempPath);
     logger.error(`[config] Failed to write config temp file: ${String(err)}`);
     return false;
   }
@@ -196,19 +193,17 @@ function persistConfig(value: RuntimeConfig): boolean {
     renameSync(tempPath, targetPath);
     return true;
   } catch (err) {
-    logger.warn(`[config] Rename failed, falling back to copy+delete: ${String(err)}`);
-    try {
-      copyFileSync(tempPath, targetPath);
-      if (!securePrivateFileSync(targetPath)) {
-        logger.error(`[config] Failed to secure config file ${targetPath}`);
-        return false;
-      }
-      unlinkSync(tempPath);
-      return true;
-    } catch (copyErr) {
-      logger.error(`[config] Failed to copy config file: ${String(copyErr)}`);
-      return false;
-    }
+    removeConfigTempFile(tempPath);
+    logger.error(`[config] Failed to atomically replace config file: ${String(err)}`);
+    return false;
+  }
+}
+
+function removeConfigTempFile(tempPath: string): void {
+  try {
+    unlinkSync(tempPath);
+  } catch {
+    // Best effort. A stale temp path is never read as runtime configuration.
   }
 }
 

package/src/proxy/dataDir.ts

@@ -1,6 +1,10 @@
-import { cpSync, existsSync, rmSync } from "node:fs";
+import { cpSync, existsSync, readdirSync, renameSync, rmSync } from "node:fs";
 import { isAbsolute, join } from "node:path";
-import { ensurePrivateDirectorySync, securePrivateTreeSync } from "./privateDataPath";
+import {
+  ensurePrivateDirectorySync,
+  isPathTreeFreeOfIndirectionSync,
+  securePrivateTreeSync,
+} from "./privateDataPath";
 
 const CURRENT_DATA_DIR_NAME = ".agent-inspector";
 const LEGACY_DATA_DIR_NAMES = [".llm-inspector", ".llm-agent"];
@@ -98,14 +102,46 @@ export function migrateLegacyDataDirs(): void {
     const legacyDir = join(base, legacyName);
     if (!existsSync(legacyDir)) continue;
 
+    const stagingDir = join(
+      base,
+      `${CURRENT_DATA_DIR_NAME}.migration-${String(process.pid)}-${String(Date.now())}`,
+    );
+
     try {
-      if (!ensurePrivateDirectorySync(currentDir)) return;
-      cpSync(legacyDir, currentDir, { recursive: true, force: true });
-      if (!securePrivateTreeSync(currentDir)) return;
+      // cpSync may dereference junctions on some Windows runtimes. Reject the source tree before
+      // copying and recheck it afterwards so migration never imports through an indirection.
+      if (!isPathTreeFreeOfIndirectionSync(legacyDir)) return;
+      if (existsSync(currentDir)) {
+        // Never merge legacy state into an unknown or partially initialized destination. A caller
+        // can inspect it and retry after resolving the conflict; the authoritative legacy source
+        // remains untouched.
+        if (readdirSync(currentDir).length > 0) return;
+        rmSync(currentDir, { recursive: true, force: false });
+      }
+      if (!ensurePrivateDirectorySync(stagingDir)) return;
+      for (const entry of readdirSync(legacyDir)) {
+        cpSync(join(legacyDir, entry), join(stagingDir, entry), {
+          recursive: true,
+          force: false,
+          errorOnExist: true,
+        });
+      }
+      if (!isPathTreeFreeOfIndirectionSync(legacyDir)) {
+        rmSync(stagingDir, { recursive: true, force: true });
+        return;
+      }
+      if (!securePrivateTreeSync(stagingDir)) {
+        rmSync(stagingDir, { recursive: true, force: true });
+        return;
+      }
+      renameSync(stagingDir, currentDir);
       rmSync(legacyDir, { recursive: true, force: true });
+      return;
     } catch {
-      // Best-effort migration: startup must continue even when the old
-      // directory is locked or partially unreadable. The next call can retry.
+      // A failed staged migration never deletes the legacy source. Remove only this attempt's
+      // private sibling and retry on a later startup.
+      if (existsSync(stagingDir)) rmSync(stagingDir, { recursive: true, force: true });
+      return;
     }
   }
 }

package/src/proxy/ecosystemTasks.ts

@@ -1,5 +1,5 @@
 import { Buffer } from "node:buffer";
-import { spawn } from "node:child_process";
+import { spawn, type ChildProcess } from "node:child_process";
 import { randomUUID } from "node:crypto";
 import type {
   EcosystemExecutionPlan,
@@ -8,15 +8,31 @@ import type {
   EcosystemTaskStatus,
 } from "../lib/ecosystemContract";
 import { findEcosystemPackage, findEcosystemRecipe } from "./ecosystemRegistry";
-import { npmCommand, npmSpawnCommand } from "./platformCommands";
+import {
+  npmCommand,
+  npmSpawnCommand,
+  signalProcessTree,
+  type CommandSpec,
+} from "./platformCommands";
 
 const MAX_TASKS = 50;
 const OUTPUT_LIMIT = 40_000;
 const INSTALL_TIMEOUT_MS = 120_000;
 const HELP_TIMEOUT_MS = 30_000;
 const RECIPE_TIMEOUT_MS = 90_000;
+const SHUTDOWN_GRACE_MS = 2_000;
 
 const tasks = new Map<string, EcosystemTask>();
+type ActiveTask = {
+  child: ChildProcess;
+  closed: Promise<void>;
+  resolveClosed: () => void;
+  timeout: ReturnType<typeof setTimeout>;
+};
+
+const activeTasks = new Map<string, ActiveTask>();
+let acceptingTasks = true;
+let shutdownForceTimer: ReturnType<typeof setTimeout> | null = null;
 
 function nowIso(): string {
   return new Date().toISOString();
@@ -152,6 +168,77 @@ function completeTask(
   task.finishedAt = nowIso();
 }
 
+function finishActiveTask(taskId: string): void {
+  const active = activeTasks.get(taskId);
+  if (active === undefined) return;
+  clearTimeout(active.timeout);
+  activeTasks.delete(taskId);
+  active.resolveClosed();
+  if (activeTasks.size === 0 && shutdownForceTimer !== null) {
+    clearTimeout(shutdownForceTimer);
+    shutdownForceTimer = null;
+  }
+}
+
+function failTaskForShutdown(task: EcosystemTask): void {
+  if (task.status !== "running" && task.status !== "queued") return;
+  const error = "Runtime shutdown terminated the ecosystem command";
+  appendTaskOutput(task, `\n${error}.\n`);
+  completeTask(task, "failed", null, error);
+}
+
+function forceActiveTaskTrees(): void {
+  for (const active of activeTasks.values()) {
+    const pid = active.child.pid;
+    if (pid !== undefined) signalProcessTree(pid, "SIGKILL");
+  }
+}
+
+function launchTask(task: EcosystemTask, spawnCommand: CommandSpec, timeoutMs: number): void {
+  const child = spawn(spawnCommand.command, spawnCommand.args, {
+    detached: process.platform !== "win32",
+    windowsHide: true,
+    shell: false,
+    stdio: ["ignore", "pipe", "pipe"],
+  });
+  let resolveClosed = (): void => {};
+  const closed = new Promise<void>((resolve) => {
+    resolveClosed = resolve;
+  });
+  const timeout = setTimeout(() => {
+    const pid = child.pid;
+    if (pid !== undefined) signalProcessTree(pid, "SIGKILL");
+    appendTaskOutput(task, `\nTimed out after ${String(timeoutMs / 1000)}s.\n`);
+  }, timeoutMs);
+  activeTasks.set(task.id, { child, closed, resolveClosed, timeout });
+
+  task.status = "running";
+  task.startedAt = nowIso();
+  appendTaskOutput(task, `$ ${task.command}\n`);
+
+  child.stdout?.on("data", (chunk: Buffer) => {
+    appendTaskOutput(task, chunk.toString("utf8"));
+  });
+  child.stderr?.on("data", (chunk: Buffer) => {
+    appendTaskOutput(task, chunk.toString("utf8"));
+  });
+  child.on("error", (error) => {
+    appendTaskOutput(task, `\n${error.message}\n`);
+    if (task.status !== "failed") completeTask(task, "failed", null, error.message);
+    finishActiveTask(task.id);
+  });
+  child.on("close", (code) => {
+    if (task.status !== "failed") {
+      if (code === 0) {
+        completeTask(task, "succeeded", code, null);
+      } else {
+        completeTask(task, "failed", code, `Command exited with code ${String(code ?? "unknown")}`);
+      }
+    }
+    finishActiveTask(task.id);
+  });
+}
+
 export function getEcosystemTask(taskId: string): EcosystemTask | null {
   return tasks.get(taskId) ?? null;
 }
@@ -164,6 +251,7 @@ export function startEcosystemTask(
   packageId: string,
   action: EcosystemTaskAction,
 ): EcosystemTask | null {
+  if (!acceptingTasks) return null;
   if (action === "recipe") return null;
   const definition =
     action === "runner-presets"
@@ -190,46 +278,13 @@ export function startEcosystemTask(
   };
   rememberTask(task);
 
-  const spawnCommand = npmSpawnCommand(args);
-  const child = spawn(spawnCommand.command, spawnCommand.args, {
-    windowsHide: true,
-    shell: false,
-    stdio: ["ignore", "pipe", "pipe"],
-  });
-  const timeout = setTimeout(() => {
-    child.kill();
-    appendTaskOutput(task, `\nTimed out after ${String(packageActionTimeout(action) / 1000)}s.\n`);
-  }, packageActionTimeout(action));
-
-  task.status = "running";
-  task.startedAt = nowIso();
-  appendTaskOutput(task, `$ ${task.command}\n`);
-
-  child.stdout.on("data", (chunk: Buffer) => {
-    appendTaskOutput(task, chunk.toString("utf8"));
-  });
-  child.stderr.on("data", (chunk: Buffer) => {
-    appendTaskOutput(task, chunk.toString("utf8"));
-  });
-  child.on("error", (error) => {
-    clearTimeout(timeout);
-    appendTaskOutput(task, `\n${error.message}\n`);
-    completeTask(task, "failed", null, error.message);
-  });
-  child.on("close", (code) => {
-    clearTimeout(timeout);
-    if (task.status === "failed") return;
-    if (code === 0) {
-      completeTask(task, "succeeded", code, null);
-      return;
-    }
-    completeTask(task, "failed", code, `Command exited with code ${String(code ?? "unknown")}`);
-  });
+  launchTask(task, npmSpawnCommand(args), packageActionTimeout(action));
 
   return task;
 }
 
 export function startEcosystemRecipeTask(recipeId: string): EcosystemTask | null {
+  if (!acceptingTasks) return null;
   const recipe = findEcosystemRecipe(recipeId);
   if (recipe === null) return null;
   if (!recipe.runnable) return null;
@@ -255,41 +310,77 @@ export function startEcosystemRecipeTask(recipeId: string): EcosystemTask | null
   };
   rememberTask(task);
 
-  const spawnCommand = npmSpawnCommand(args);
-  const child = spawn(spawnCommand.command, spawnCommand.args, {
-    windowsHide: true,
-    shell: false,
-    stdio: ["ignore", "pipe", "pipe"],
-  });
-  const timeout = setTimeout(() => {
-    child.kill();
-    appendTaskOutput(task, `\nTimed out after ${String(RECIPE_TIMEOUT_MS / 1000)}s.\n`);
-  }, RECIPE_TIMEOUT_MS);
+  launchTask(task, npmSpawnCommand(args), RECIPE_TIMEOUT_MS);
 
-  task.status = "running";
-  task.startedAt = nowIso();
-  appendTaskOutput(task, `$ ${task.command}\n`);
+  return task;
+}
 
-  child.stdout.on("data", (chunk: Buffer) => {
-    appendTaskOutput(task, chunk.toString("utf8"));
-  });
-  child.stderr.on("data", (chunk: Buffer) => {
-    appendTaskOutput(task, chunk.toString("utf8"));
-  });
-  child.on("error", (error) => {
-    clearTimeout(timeout);
-    appendTaskOutput(task, `\n${error.message}\n`);
-    completeTask(task, "failed", null, error.message);
-  });
-  child.on("close", (code) => {
-    clearTimeout(timeout);
-    if (task.status === "failed") return;
-    if (code === 0) {
-      completeTask(task, "succeeded", code, null);
-      return;
-    }
-    completeTask(task, "failed", code, `Command exited with code ${String(code ?? "unknown")}`);
-  });
+/** Stop admitting commands and begin terminating every tracked child process tree. */
+export function beginEcosystemTaskShutdown(): void {
+  acceptingTasks = false;
+  for (const [taskId, active] of activeTasks) {
+    const task = tasks.get(taskId);
+    if (task !== undefined) failTaskForShutdown(task);
+    clearTimeout(active.timeout);
+    const pid = active.child.pid;
+    if (pid !== undefined) signalProcessTree(pid, "SIGTERM");
+  }
+  if (activeTasks.size > 0 && shutdownForceTimer === null) {
+    shutdownForceTimer = setTimeout(() => {
+      shutdownForceTimer = null;
+      forceActiveTaskTrees();
+    }, SHUTDOWN_GRACE_MS);
+    shutdownForceTimer.unref();
+  }
+}
+
+/** Wait until children signalled by beginEcosystemTaskShutdown have closed. */
+export async function waitForEcosystemTasksToClose(): Promise<void> {
+  await Promise.all([...activeTasks.values()].map(async (active) => await active.closed));
+}
+
+/** Immediate deadline fallback used by the runtime shutdown coordinator. */
+export function forceCloseEcosystemTasks(): void {
+  acceptingTasks = false;
+  if (shutdownForceTimer !== null) {
+    clearTimeout(shutdownForceTimer);
+    shutdownForceTimer = null;
+  }
+  for (const taskId of activeTasks.keys()) {
+    const task = tasks.get(taskId);
+    if (task !== undefined) failTaskForShutdown(task);
+  }
+  forceActiveTaskTrees();
+}
 
+export function _startEcosystemTaskForTests(
+  spawnCommand: CommandSpec,
+  timeoutMs = RECIPE_TIMEOUT_MS,
+): EcosystemTask | null {
+  if (!acceptingTasks) return null;
+  const task: EcosystemTask = {
+    id: randomUUID(),
+    packageId: "test-package",
+    npmName: "test-package",
+    recipeId: null,
+    action: "help",
+    status: "queued",
+    command: `${spawnCommand.command} ${spawnCommand.args.join(" ")}`,
+    output: "",
+    createdAt: nowIso(),
+    startedAt: null,
+    finishedAt: null,
+    exitCode: null,
+    error: null,
+  };
+  rememberTask(task);
+  launchTask(task, spawnCommand, timeoutMs);
   return task;
 }
+
+export function _resetEcosystemTasksForTests(): void {
+  forceCloseEcosystemTasks();
+  tasks.clear();
+  activeTasks.clear();
+  acceptingTasks = true;
+}

package/src/proxy/formats/registry.ts

@@ -1,12 +1,8 @@
 import type { FormatHandler } from "./handler";
 import type { ApiFormat } from "../schemas";
-import {
-  PATH_V1_CHAT_COMPLETIONS,
-  PATH_CHAT_COMPLETIONS,
-  PATH_V1_RESPONSES,
-  PATH_RESPONSES,
-  PATH_V1_MESSAGES,
-} from "../constants";
+import { API_FORMAT_PATH_ENTRIES, apiFormatForPath } from "../../lib/apiFormat";
+
+export { apiFormatForPath };
 
 /**
  * API format registry maps request paths and API formats to their FormatHandler.
@@ -63,18 +59,7 @@ export function formatForPath(path: string): FormatHandler | null {
   return formatRegistry.getByPath(path) ?? null;
 }
 
-/**
- * Resolve the API format from the request endpoint. The endpoint is
- * authoritative because Anthropic and OpenAI request bodies overlap for
- * simple message-only calls.
- */
-export function apiFormatForPath(path: string): ApiFormat {
-  return formatRegistry.getApiFormatByPath(path) ?? "unknown";
-}
-
 // Register known paths
-formatRegistry.registerPath(PATH_V1_MESSAGES, "anthropic");
-formatRegistry.registerPath(PATH_V1_CHAT_COMPLETIONS, "openai");
-formatRegistry.registerPath(PATH_CHAT_COMPLETIONS, "openai");
-formatRegistry.registerPath(PATH_V1_RESPONSES, "openai");
-formatRegistry.registerPath(PATH_RESPONSES, "openai");
+for (const [path, format] of API_FORMAT_PATH_ENTRIES) {
+  formatRegistry.registerPath(path, format);
+}