@tonyclaw/agent-inspector 3.0.7 → 3.0.8

package/src/proxy/ecosystemTasks.ts

@@ -0,0 +1,153 @@
+import { Buffer } from "node:buffer";
+import { spawn } from "node:child_process";
+import { randomUUID } from "node:crypto";
+import type {
+  EcosystemTask,
+  EcosystemTaskAction,
+  EcosystemTaskStatus,
+} from "../lib/ecosystemContract";
+import { findEcosystemPackage } from "./ecosystemRegistry";
+import { npmCommand, npmSpawnCommand } from "./platformCommands";
+
+const MAX_TASKS = 50;
+const OUTPUT_LIMIT = 40_000;
+const INSTALL_TIMEOUT_MS = 120_000;
+const HELP_TIMEOUT_MS = 30_000;
+
+const tasks = new Map<string, EcosystemTask>();
+
+function nowIso(): string {
+  return new Date().toISOString();
+}
+
+function trimOutput(output: string): string {
+  if (output.length <= OUTPUT_LIMIT) return output;
+  return output.slice(output.length - OUTPUT_LIMIT);
+}
+
+function appendTaskOutput(task: EcosystemTask, chunk: string): void {
+  task.output = trimOutput(`${task.output}${chunk}`);
+}
+
+function rememberTask(task: EcosystemTask): void {
+  tasks.set(task.id, task);
+  while (tasks.size > MAX_TASKS) {
+    const oldest = tasks.keys().next().value;
+    if (typeof oldest !== "string") return;
+    tasks.delete(oldest);
+  }
+}
+
+function packageActionArgs(action: EcosystemTaskAction, npmName: string): string[] {
+  switch (action) {
+    case "install":
+    case "upgrade":
+      return ["install", "-g", npmName];
+    case "help":
+      return ["exec", "--yes", npmName, "--", "--help"];
+    case "runner-presets":
+      return ["exec", "--yes", "@tonyclaw/eval-harness", "--", "runner-presets"];
+  }
+}
+
+function packageActionTimeout(action: EcosystemTaskAction): number {
+  switch (action) {
+    case "install":
+    case "upgrade":
+      return INSTALL_TIMEOUT_MS;
+    case "help":
+    case "runner-presets":
+      return HELP_TIMEOUT_MS;
+  }
+}
+
+function taskCommand(args: readonly string[]): string {
+  return `${npmCommand()} ${args.join(" ")}`;
+}
+
+function completeTask(
+  task: EcosystemTask,
+  status: Exclude<EcosystemTaskStatus, "queued" | "running">,
+  exitCode: number | null,
+  error: string | null,
+): void {
+  task.status = status;
+  task.exitCode = exitCode;
+  task.error = error;
+  task.finishedAt = nowIso();
+}
+
+export function getEcosystemTask(taskId: string): EcosystemTask | null {
+  return tasks.get(taskId) ?? null;
+}
+
+export function listEcosystemTasks(): EcosystemTask[] {
+  return [...tasks.values()].sort((left, right) => right.createdAt.localeCompare(left.createdAt));
+}
+
+export function startEcosystemTask(
+  packageId: string,
+  action: EcosystemTaskAction,
+): EcosystemTask | null {
+  const definition =
+    action === "runner-presets"
+      ? findEcosystemPackage("eval-harness")
+      : findEcosystemPackage(packageId);
+  if (definition === null) return null;
+  if (action === "runner-presets" && packageId !== "eval-harness") return null;
+
+  const args = packageActionArgs(action, definition.npmName);
+  const task: EcosystemTask = {
+    id: randomUUID(),
+    packageId: definition.id,
+    npmName: definition.npmName,
+    action,
+    status: "queued",
+    command: taskCommand(args),
+    output: "",
+    createdAt: nowIso(),
+    startedAt: null,
+    finishedAt: null,
+    exitCode: null,
+    error: 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(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")}`);
+  });
+
+  return task;
+}

package/src/proxy/platformCommands.ts

@@ -0,0 +1,212 @@
+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") {
+      execFileSync("taskkill.exe", ["/PID", String(pid), "/F"], {
+        encoding: "utf8",
+        timeout: 5000,
+        windowsHide: true,
+        stdio: ["ignore", "pipe", "ignore"],
+      });
+      return true;
+    }
+    process.kill(pid, "SIGKILL");
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export const platformCommandParsersForTests = {
+  parseUnixLsofPids,
+  parseUnixSsPids,
+  parseWindowsNetstatPids,
+};