@tonyclaw/agent-inspector 4.0.1 → 4.0.2

package/src/proxy/openaiOrphanToolStrip.ts

@@ -1,142 +0,0 @@
-/**
- * OpenAI Chat Completions format guard: orphan `tool` messages.
- *
- * The OpenAI Chat Completions spec requires every message with
- * `role: "tool"` to reference a `tool_call_id` that appears in a preceding
- * `assistant` message's `tool_calls` array. When this invariant is broken
- * (typically by a buggy client that records a tool result without the
- * matching assistant tool_call), the upstream rejects the request with a
- * 400 like:
- *
- *   {"type":"error","error":{"type":"bad_request_error",
- *     "message":"invalid params, tool result's tool id(call_xxx) not found"}}
- *
- * This module finds such orphan tool messages and returns a rewritten body
- * with them removed so the proxy can forward a valid request. The original
- * body is preserved by the caller for the captured log, so the inspector UI
- * still shows the broken request the client actually sent.
- */
-
-const ROLE_ASSISTANT = "assistant";
-const ROLE_TOOL = "tool";
-
-export type OrphanToolStripResult = {
-  /** The new request body. Equal to input (by reference) when no change was made. */
-  body: string;
-  /** Number of orphan tool messages removed. */
-  removed: number;
-  /**
-   * The `tool_call_id` values of the removed messages, in document order.
-   * `null` is used when a tool message had no `tool_call_id` at all.
-   */
-  orphanIds: Array<string | null>;
-};
-
-import { safeGetOwnProperty, isPlainRecord } from "../lib/objectUtils";
-
-function isObjectWithMessages(value: unknown): value is { messages: unknown[] } {
-  if (!isPlainRecord(value)) return false;
-  if (!Object.prototype.hasOwnProperty.call(value, "messages")) return false;
-  const messages = safeGetOwnProperty(value, "messages");
-  return Array.isArray(messages);
-}
-
-/**
- * Collects the set of tool_call ids from an assistant message's `tool_calls`
- * array. Tolerant of malformed entries: anything without a string `id` is
- * skipped silently (those ids cannot be referenced by a tool message anyway).
- */
-function collectAssistantToolCallIds(message: unknown, into: Set<string>): void {
-  if (!isPlainRecord(message)) return;
-  const toolCalls = safeGetOwnProperty(message, "tool_calls");
-  if (!Array.isArray(toolCalls)) return;
-  for (const tc of toolCalls) {
-    if (!isPlainRecord(tc)) continue;
-    const id = safeGetOwnProperty(tc, "id");
-    if (typeof id === "string" && id.length > 0) {
-      into.add(id);
-    }
-  }
-}
-
-/**
- * Returns the indices of `tool`-role messages whose `tool_call_id` does not
- * appear in any *preceding* assistant message's `tool_calls`. A tool message
- * with no `tool_call_id` at all is also considered orphan.
- *
- * Pure, exported for unit tests. Used by `stripOpenAIOrphanToolMessages`.
- */
-export function findOrphanToolMessageIndices(messages: readonly unknown[]): {
-  indices: number[];
-  orphanIds: Array<string | null>;
-} {
-  const knownToolCallIds = new Set<string>();
-  const indices: number[] = [];
-  const orphanIds: Array<string | null> = [];
-
-  for (let i = 0; i < messages.length; i++) {
-    const msg = messages[i];
-    if (!isPlainRecord(msg)) continue;
-
-    const role = safeGetOwnProperty(msg, "role");
-
-    if (role === ROLE_ASSISTANT) {
-      collectAssistantToolCallIds(msg, knownToolCallIds);
-      continue;
-    }
-
-    if (role === ROLE_TOOL) {
-      const id = safeGetOwnProperty(msg, "tool_call_id");
-      if (typeof id !== "string" || id.length === 0) {
-        indices.push(i);
-        orphanIds.push(null);
-        continue;
-      }
-      if (!knownToolCallIds.has(id)) {
-        indices.push(i);
-        orphanIds.push(id);
-      }
-    }
-  }
-
-  return { indices, orphanIds };
-}
-
-/**
- * Inspects an OpenAI-format request body and, if its `messages` array
- * contains one or more orphan `tool` messages (see `findOrphanToolMessageIndices`),
- * returns a new body with those messages removed. The original string is
- * returned unchanged (by reference equality) when no edit is needed so the
- * caller can skip a re-serialization.
- *
- * Tolerant of bodies that are not valid JSON, not OpenAI-format, or that
- * have no `messages` array — all such inputs are returned unchanged.
- */
-export function stripOpenAIOrphanToolMessages(rawBody: string): OrphanToolStripResult {
-  let parsed: unknown;
-  try {
-    parsed = JSON.parse(rawBody);
-  } catch {
-    return { body: rawBody, removed: 0, orphanIds: [] };
-  }
-
-  if (!isObjectWithMessages(parsed)) {
-    return { body: rawBody, removed: 0, orphanIds: [] };
-  }
-
-  const messages = parsed.messages;
-  const { indices, orphanIds } = findOrphanToolMessageIndices(messages);
-
-  if (indices.length === 0) {
-    return { body: rawBody, removed: 0, orphanIds: [] };
-  }
-
-  const dropSet = new Set(indices);
-  const kept: unknown[] = [];
-  for (let i = 0; i < messages.length; i++) {
-    if (!dropSet.has(i)) kept.push(messages[i]);
-  }
-  parsed.messages = kept;
-
-  return { body: JSON.stringify(parsed), removed: indices.length, orphanIds };
-}

package/src/proxy/platformCommands.ts

@@ -1,258 +0,0 @@
-import { statSync } from "node:fs";
-import { execFileSync } from "node:child_process";
-import { delimiter, isAbsolute, join } from "node:path";
-
-export type PlatformName = typeof process.platform;
-type PathEnv = Record<string, string | undefined>;
-
-export type CommandSpec = {
-  command: string;
-  args: string[];
-};
-
-export function platformCommand(
-  command: string,
-  args: readonly string[],
-  platform: PlatformName = process.platform,
-): CommandSpec {
-  if (platform !== "win32") return { command, args: [...args] };
-  return { command: "cmd.exe", args: ["/d", "/s", "/c", command, ...args] };
-}
-
-export function npmCommand(platform: PlatformName = process.platform): string {
-  return platform === "win32" ? "npm.cmd" : "npm";
-}
-
-export function npmSpawnCommand(
-  args: readonly string[],
-  platform: PlatformName = process.platform,
-): CommandSpec {
-  return platformCommand(npmCommand(platform), args, platform);
-}
-
-function pathEntries(envPath: string | undefined): string[] {
-  if (envPath === undefined || envPath.length === 0) return [];
-  return envPath.split(delimiter).filter((entry) => entry.length > 0);
-}
-
-function windowsExecutableExtensions(envPathExt: string | undefined): string[] {
-  const defaults = [".COM", ".EXE", ".BAT", ".CMD"];
-  if (envPathExt === undefined || envPathExt.trim().length === 0) return defaults;
-  const parsed = envPathExt
-    .split(";")
-    .map((entry) => entry.trim())
-    .filter((entry) => entry.length > 0);
-  return parsed.length > 0 ? parsed : defaults;
-}
-
-function isExecutableCandidate(path: string, platform: PlatformName): boolean {
-  try {
-    const stat = statSync(path);
-    if (!stat.isFile()) return false;
-    if (platform === "win32" || process.platform === "win32") return true;
-    return (stat.mode & 0o111) !== 0;
-  } catch {
-    return false;
-  }
-}
-
-function executableCandidates(bin: string, platform: PlatformName, env: PathEnv): string[] {
-  if (isAbsolute(bin)) return [bin];
-  const entries = pathEntries(env["PATH"] ?? env["Path"] ?? env["path"]);
-  if (platform !== "win32") return entries.map((entry) => join(entry, bin));
-
-  const hasExtension = /\.[^\\/]+$/.test(bin);
-  const extensions = hasExtension ? [""] : windowsExecutableExtensions(env["PATHEXT"]);
-  const candidates: string[] = [];
-  for (const entry of entries) {
-    for (const extension of extensions) {
-      candidates.push(join(entry, `${bin}${extension.toLowerCase()}`));
-      candidates.push(join(entry, `${bin}${extension.toUpperCase()}`));
-    }
-  }
-  return candidates;
-}
-
-export function resolveExecutableOnPath(
-  bin: string,
-  platform: PlatformName = process.platform,
-  env: PathEnv = process.env,
-): string | null {
-  if (bin.trim().length === 0) return null;
-  for (const candidate of executableCandidates(bin, platform, env)) {
-    if (isExecutableCandidate(candidate, platform)) return candidate;
-  }
-  return null;
-}
-
-export function openUrlCommand(
-  targetUrl: string,
-  platform: PlatformName = process.platform,
-): CommandSpec | null {
-  switch (platform) {
-    case "darwin":
-      return { command: "open", args: [targetUrl] };
-    case "linux":
-    case "freebsd":
-    case "openbsd":
-    case "netbsd":
-      return { command: "xdg-open", args: [targetUrl] };
-    case "win32":
-      return { command: "cmd.exe", args: ["/d", "/s", "/c", "start", "", targetUrl] };
-    case "aix":
-    case "android":
-    case "cygwin":
-    case "haiku":
-    case "sunos":
-      return null;
-  }
-
-  return null;
-}
-
-function parseWindowsNetstatPids(output: string, targetPort: number): number[] {
-  const pids = new Set<number>();
-  const targetToken = `:${targetPort}`;
-  for (const line of output.split(/\r?\n/)) {
-    const parts = line.trim().split(/\s+/);
-    if (parts.length < 5) continue;
-    const localAddress = parts[1] ?? "";
-    const pidStr = parts[4] ?? "";
-    if (!localAddress.endsWith(targetToken)) continue;
-    const pid = Number.parseInt(pidStr, 10);
-    if (Number.isInteger(pid) && pid > 0) pids.add(pid);
-  }
-  return [...pids];
-}
-
-function parseUnixLsofPids(output: string): number[] {
-  const pids = new Set<number>();
-  for (const line of output.split(/\r?\n/)) {
-    const pid = Number.parseInt(line.trim(), 10);
-    if (Number.isInteger(pid) && pid > 0) pids.add(pid);
-  }
-  return [...pids];
-}
-
-function parseUnixSsPids(output: string): number[] {
-  const pids = new Set<number>();
-  for (const match of output.matchAll(/pid=(\d+)/g)) {
-    const pid = Number.parseInt(match[1] ?? "", 10);
-    if (Number.isInteger(pid) && pid > 0) pids.add(pid);
-  }
-  return [...pids];
-}
-
-export function findPidsByPort(
-  targetPort: number,
-  platform: PlatformName = process.platform,
-): number[] {
-  if (!Number.isInteger(targetPort) || targetPort <= 0 || targetPort > 65_535) return [];
-  try {
-    if (platform === "win32") {
-      const output = execFileSync("netstat.exe", ["-ano", "-p", "TCP"], {
-        encoding: "utf8",
-        timeout: 5000,
-        windowsHide: true,
-      });
-      return parseWindowsNetstatPids(output, targetPort);
-    }
-
-    try {
-      const output = execFileSync("lsof", [`-ti:${String(targetPort)}`], {
-        encoding: "utf8",
-        timeout: 5000,
-        stdio: ["ignore", "pipe", "ignore"],
-      });
-      const pids = parseUnixLsofPids(output);
-      if (pids.length > 0) return pids;
-    } catch {
-      // Fall back to ss below.
-    }
-
-    const output = execFileSync("ss", ["-tanp"], {
-      encoding: "utf8",
-      timeout: 5000,
-      stdio: ["ignore", "pipe", "ignore"],
-    });
-    return parseUnixSsPids(
-      output
-        .split(/\r?\n/)
-        .filter((line) => line.includes(`:${String(targetPort)}`))
-        .join("\n"),
-    );
-  } catch {
-    return [];
-  }
-}
-
-export function killPid(pid: number, platform: PlatformName = process.platform): boolean {
-  if (!Number.isInteger(pid) || pid <= 0) return false;
-  try {
-    if (platform === "win32") {
-      try {
-        execFileSync("taskkill.exe", ["/PID", String(pid), "/T", "/F"], {
-          encoding: "utf8",
-          timeout: 5000,
-          windowsHide: true,
-          stdio: ["ignore", "pipe", "ignore"],
-        });
-        return true;
-      } catch {
-        process.kill(pid, "SIGKILL");
-        return true;
-      }
-    }
-    process.kill(pid, "SIGKILL");
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-export type ProcessTreeSignal = "SIGTERM" | "SIGKILL";
-
-/**
- * Signal a child process and every descendant created in its process tree.
- *
- * Unix callers must spawn the root with `detached: true`, which makes its PID the process-group
- * ID. Windows has no equivalent portable Node signal, so taskkill owns descendant traversal.
- */
-export function signalProcessTree(
-  pid: number,
-  signal: ProcessTreeSignal,
-  platform: PlatformName = process.platform,
-): boolean {
-  if (!Number.isInteger(pid) || pid <= 0) return false;
-  try {
-    if (platform === "win32") {
-      const args = ["/PID", String(pid), "/T"];
-      if (signal === "SIGKILL") args.push("/F");
-      execFileSync("taskkill.exe", args, {
-        encoding: "utf8",
-        timeout: 5000,
-        windowsHide: true,
-        stdio: ["ignore", "pipe", "ignore"],
-      });
-      return true;
-    }
-    process.kill(-pid, signal);
-    return true;
-  } catch {
-    // Killing only the Windows root would orphan descendants and could make the runtime report a
-    // false clean shutdown. Let the caller retry taskkill with /F instead.
-    if (platform === "win32") return false;
-    try {
-      process.kill(pid, signal);
-      return true;
-    } catch {
-      return false;
-    }
-  }
-}
-
-export const platformCommandParsersForTests = {
-  parseUnixLsofPids,
-  parseUnixSsPids,
-  parseWindowsNetstatPids,
-};