@tonyclaw/agent-inspector 3.0.7 → 3.0.9

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,
+};

package/src/proxy/socketTracker.ts

@@ -1,9 +1,9 @@
-import { exec, execFile } from "node:child_process";
+import { execFile } from "node:child_process";
+import { readFile } from "node:fs/promises";
 import { promisify } from "node:util";
 import { z } from "zod";
 import { logger } from "./logger";
 
-const execAsync = promisify(exec);
 const execFileAsync = promisify(execFile);
 
 type ClientInfo = {
@@ -102,7 +102,7 @@ function setCache(port: number, info: ClientInfo): void {
  * 2. Bun-style: `request.socket` accessor.
  * 3. Direct `socket` / `connection` properties on the request (legacy Node
  *    IncomingMessage-style wrapping).
- * Returns `null` when nothing matches — the caller will then leave `pid`
+ * Returns `null` when nothing matches 鈥?the caller will then leave `pid`
  * (and downstream `clientPid`) as `null`.
  */
 export function extractRemotePort(request: Request): number | null {
@@ -154,90 +154,6 @@ function pick(value: unknown, key: string): unknown {
   return value[key];
 }
 
-/**
- * Combined lookup: PID from port, then process info from PID.
- * On Windows, uses a single PowerShell call to get PID + command line.
- */
-async function lookupClientInfo(port: number): Promise<ClientInfo> {
-  const platform = process.platform;
-
-  try {
-    if (platform === "win32") {
-      // Single PowerShell call: get PID and command line in one shot
-      const psScript = [
-        `$conn = Get-NetTCPConnection -LocalPort ${port} -State Established -ErrorAction SilentlyContinue | Select-Object -First 1`,
-        `if ($conn) {`,
-        `  $pid = $conn.OwningProcess`,
-        `  $proc = Get-CimInstance Win32_Process -Filter "ProcessId=$pid" -ErrorAction SilentlyContinue`,
-        `  $cmd = if ($proc) { $proc.CommandLine } else { "" }`,
-        `  Write-Output "$pid|$cmd"`,
-        `}`,
-      ].join("; ");
-      const { stdout } = await execFileAsync(
-        "powershell.exe",
-        ["-NoProfile", "-NonInteractive", "-ExecutionPolicy", "Bypass", "-Command", psScript],
-        {
-          windowsHide: true,
-          timeout: 3000,
-          maxBuffer: 64 * 1024,
-        },
-      );
-      const trimmed = stdout.trim();
-      if (trimmed === "") {
-        return { port, pid: null, cwd: null, projectFolder: null };
-      }
-      const [pidStr, ...cmdParts] = trimmed.split("|");
-      const pid = parseInt(pidStr ?? "", 10);
-      if (isNaN(pid) || pid <= 0) {
-        return { port, pid: null, cwd: null, projectFolder: null };
-      }
-      const commandLine = cmdParts.join("|").trim();
-      const { cwd, projectFolder } = parseCommandLine(commandLine, "\\");
-      return { port, pid, cwd, projectFolder };
-    }
-
-    // Unix: two-step lookup (PID from port, then process info from PID)
-    let pid: number | null = null;
-
-    if (platform === "darwin") {
-      const { stdout } = await execAsync(`lsof -i :${port} -sTCP:ESTABLISHED -t 2>/dev/null`, {
-        shell: "/bin/sh",
-      });
-      const parsed = parseInt(stdout.trim(), 10);
-      if (!isNaN(parsed) && parsed > 0) pid = parsed;
-    } else {
-      try {
-        const { stdout } = await execAsync(
-          `ss -tlnp 'sport = :${port}' 2>/dev/null | grep ESTAB | awk '{print $6}' | grep -o 'pid=[0-9]*' | cut -d= -f2`,
-          { shell: "/bin/sh" },
-        );
-        const parsed = parseInt(stdout.trim(), 10);
-        if (!isNaN(parsed) && parsed > 0) pid = parsed;
-      } catch {
-        // Fall back to netstat
-      }
-      if (pid === null) {
-        const { stdout } = await execAsync(
-          `netstat -tan 2>/dev/null | grep ':${port}' | grep ESTABLISHED | awk '{print $7}' | cut -d/ -f1`,
-          { shell: "/bin/sh" },
-        );
-        const parsed = parseInt(stdout.trim(), 10);
-        if (!isNaN(parsed) && parsed > 0) pid = parsed;
-      }
-    }
-
-    if (pid === null) {
-      return { port, pid: null, cwd: null, projectFolder: null };
-    }
-
-    const { cwd, projectFolder } = await lookupProcessInfo(pid);
-    return { port, pid, cwd, projectFolder };
-  } catch (err) {
-    logger.debug(`[socketTracker] Failed to lookup info for port ${port}:`, String(err));
-    return { port, pid: null, cwd: null, projectFolder: null };
-  }
-}
-
 function parseCommandLine(
   commandLine: string,
   sep: string,
@@ -265,30 +181,25 @@ async function lookupProcessInfo(
 
   try {
     if (platform === "win32") {
+      const psScript = [
+        `$proc = Get-CimInstance Win32_Process -Filter "ProcessId=${pid}" -ErrorAction SilentlyContinue`,
+        `if ($proc) { Write-Output $proc.CommandLine }`,
+      ].join("; ");
       const { stdout } = await execFileAsync(
-        "wmic.exe",
-        ["process", "where", `processid=${pid}`, "get", "commandline", "/value"],
+        "powershell.exe",
+        ["-NoProfile", "-NonInteractive", "-ExecutionPolicy", "Bypass", "-Command", psScript],
         {
           windowsHide: true,
           timeout: 3000,
           maxBuffer: 64 * 1024,
         },
       );
-      const lines = stdout.trim().split("\n").filter(Boolean);
-      for (const line of lines) {
-        if (line.includes("=")) {
-          const commandLine = (line.split("=")[1] ?? "").trim();
-          if (commandLine) {
-            return parseCommandLine(commandLine, "\\");
-          }
-        }
-      }
+      const commandLine = stdout.trim();
+      if (commandLine.length > 0) return parseCommandLine(commandLine, "\\");
     } else {
       try {
-        const { stdout } = await execAsync(`cat /proc/${pid}/cmdline 2>/dev/null | tr '\\0' ' '`, {
-          shell: "/bin/sh",
-        });
-        const commandLine = stdout.trim();
+        const raw = await readFile(`/proc/${String(pid)}/cmdline`, "utf8");
+        const commandLine = raw.replace(/\0/g, " ").trim();
         if (commandLine) {
           return parseCommandLine(commandLine, "/");
         }
@@ -297,8 +208,9 @@ async function lookupProcessInfo(
       }
 
       if (platform === "darwin") {
-        const { stdout } = await execAsync(`ps -p ${pid} -o comm= 2>/dev/null`, {
-          shell: "/bin/sh",
+        const { stdout } = await execFileAsync("ps", ["-p", String(pid), "-o", "comm="], {
+          timeout: 3000,
+          maxBuffer: 64 * 1024,
         });
         const exePath = stdout.trim();
         if (exePath) {
@@ -313,7 +225,7 @@ async function lookupProcessInfo(
 }
 
 /**
- * Scan the OS connection table for the freshest client→proxy connection and
+ * Scan the OS connection table for the freshest client鈫抪roxy connection and
  * return the matching PID plus its cwd/projectFolder.
  */
 async function lookupRecentClient(): Promise<ClientInfo> {
@@ -346,16 +258,9 @@ async function lookupRecentClient(): Promise<ClientInfo> {
     // Unix: netstat with -p prints `pid/program` next to each entry. Pick
     // the row matching our proxy port on the remote side (i.e. the client's
     // ephemeral port + the proxy's listen port). When multiple clients are
-    // connected we take the highest ephemeral port — Linux/macOS assign
+    // connected we take the highest ephemeral port 鈥?Linux/macOS assign
     // ports in ascending order, so the largest one is the freshest.
-    const { stdout } = await execAsync(
-      `netstat -tanp 2>/dev/null | grep ':${port}' | grep ESTAB || ss -tanp 2>/dev/null | grep ':${port}' | grep ESTAB`,
-      { shell: "/bin/sh" },
-    );
-    const lines = stdout
-      .trim()
-      .split("\n")
-      .filter((line) => line.includes("ESTAB"));
+    const lines = await readUnixEstablishedConnectionLines(port);
     const clientPid = pickNewestClientPidFromNetstat(lines, port);
     if (clientPid === null) {
       return { port: null, pid: null, cwd: null, projectFolder: null };
@@ -378,14 +283,14 @@ function pickNewestClientPidFromNetstat(lines: string[], proxyPort: number): num
   for (const line of lines) {
     order++;
     const cols = line.trim().split(/\s+/);
-    if (cols.length < 7) continue;
+    if (cols.length < 5) continue;
     const localAddr = cols[3] ?? "";
     const remoteAddr = cols[4] ?? "";
     const pidField = cols[6] ?? "";
     // Client-side rows: `RemoteAddress` (5th col) is the proxy's listen port;
     // `LocalAddress` (4th col) is the client's ephemeral port.
     if (!remoteAddr.endsWith(proxyToken)) continue;
-    const pidMatch = pidField.match(/^(\d+)/);
+    const pidMatch = pidField.match(/^(\d+)/) ?? line.match(/pid=(\d+)/);
     if (pidMatch === null) continue;
     const pid = parseInt(pidMatch[1] ?? "", 10);
     if (!Number.isInteger(pid) || pid <= 0) continue;
@@ -398,6 +303,30 @@ function pickNewestClientPidFromNetstat(lines: string[], proxyPort: number): num
   return candidates[0]?.pid ?? null;
 }
 
+async function readUnixEstablishedConnectionLines(port: number): Promise<string[]> {
+  const commands = [
+    { command: "netstat", args: ["-tanp"] },
+    { command: "ss", args: ["-tanp"] },
+  ];
+  for (const spec of commands) {
+    try {
+      const { stdout } = await execFileAsync(spec.command, spec.args, {
+        timeout: 2000,
+        maxBuffer: 2 * 1024 * 1024,
+      });
+      const portToken = `:${port}`;
+      const lines = stdout
+        .trim()
+        .split("\n")
+        .filter((line) => line.includes(portToken) && line.includes("ESTAB"));
+      if (lines.length > 0) return lines;
+    } catch {
+      // Try the next socket table command.
+    }
+  }
+  return [];
+}
+
 function parseAddressPort(address: string): number | null {
   const match = address.match(/:(\d+)$/);
   if (match === null) return null;
@@ -448,6 +377,13 @@ export function _pickNewestClientFromWindowsNetstatForTests(
   return pickNewestClientFromWindowsNetstat(lines, proxyPort);
 }
 
+export function _pickNewestClientPidFromNetstatForTests(
+  lines: string[],
+  proxyPort: number,
+): number | null {
+  return pickNewestClientPidFromNetstat(lines, proxyPort);
+}
+
 /** Custom request headers the client (or a wrapper script) may set so we
  *  can identify the originating process without scanning the OS connection
  *  table. Recognized names:
@@ -479,7 +415,7 @@ function readIntHeader(headers: Headers, name: string): number | null {
 }
 
 /** Read client-supplied headers. Returns `null` when no PID header is
- *  present — caller falls back to OS scanning. */
+ *  present 鈥?caller falls back to OS scanning. */
 function readClientHeaders(request: Request): ClientInfo | null {
   const pid = readIntHeader(request.headers, CLIENT_HEADERS.pid);
   if (pid === null || pid === 0) return null;
@@ -502,7 +438,7 @@ function readClientHeaders(request: Request): ClientInfo | null {
  *
  * Strategy: enumerate the OS-level TCP connections to our proxy's listen
  * port and pick the most recently established client-side connection. This
- * is essentially "who is currently talking to us" — for a session with many
+ * is essentially "who is currently talking to us" 鈥?for a session with many
  * rapid-fire requests the same client holds a long-lived connection, so
  * consecutive lookups within the cache TTL converge on the same PID.
  *
@@ -513,8 +449,8 @@ function readClientHeaders(request: Request): ClientInfo | null {
 export async function getClientInfo(request: Request): Promise<ClientInfo> {
   // Preferred path: explicit client identity in headers. AI coding tools
   // (or the wrapper scripts that launch them) attach
-  // `X-Agent-Inspector-Client-Pid` (and optionally …-Cwd /
-  // …-Project-Folder / …-Port) so we never have to guess.
+  // `X-Agent-Inspector-Client-Pid` (and optionally 鈥?Cwd /
+  // 鈥?Project-Folder / 鈥?Port) so we never have to guess.
   const fromHeaders = readClientHeaders(request);
   if (fromHeaders !== null) return fromHeaders;
 
@@ -550,7 +486,7 @@ export async function getClientInfo(request: Request): Promise<ClientInfo> {
   }
 
   // Fallback: scan the OS connection table for the most recently opened
-  // client→proxy connection. Best-effort — in environments with many
+  // client鈫抪roxy connection. Best-effort 鈥?in environments with many
   // long-lived keep-alive connections (browsers, background processes) the
   // picked connection may not belong to the current request.
   const cached = getRecentClientFromCache();
@@ -582,7 +518,7 @@ export async function getClientInfo(request: Request): Promise<ClientInfo> {
  * `req.socket.remotePort` (the client's ephemeral port) and needs to know
  * which process opened the connection.
  *
- * Results are cached by `clientPort` for `PORT_LOOKUP_TTL_MS` — a single
+ * Results are cached by `clientPort` for `PORT_LOOKUP_TTL_MS` 鈥?a single
  * keep-alive connection typically reuses the same client port for many
  * requests, so we don't want to spawn a subprocess per request.
  */
@@ -626,27 +562,24 @@ async function lookupPidByLocalPort(clientPort: number): Promise<number | null>
   const platform = process.platform;
   try {
     if (platform === "win32") {
-      // We deliberately use `netstat -ano | findstr` instead of
-      // `Get-NetTCPConnection -LocalPort`. The PowerShell cmdlet
-      // enumerates the entire socket table before filtering, which on a
-      // busy machine takes 10+ seconds — longer than our per-request
-      // timeout. `netstat -ano` streams its output and `findstr` filters
-      // line by line, completing in ~0.5s.
+      // `Get-NetTCPConnection -LocalPort` can enumerate the entire socket table
+      // before filtering on busy machines. `netstat.exe` streams quickly and
+      // avoids PowerShell process startup for this hot lookup path.
       //
-      // `netstat -ano` lists every TCP connection twice — once for each
-      // endpoint. The format is:
+      // `netstat -ano` lists every TCP connection twice: once for each endpoint.
       //
       //   Proto  LocalAddress        RemoteAddress       State            PID
-      //   TCP    [::1]:25949         [::1]:55193         ESTABLISHED     10936   ← server-side row (proxy owns the listener)
-      //   TCP    [::1]:55193         [::1]:25949         ESTABLISHED     29356   ← client-side row (curl owns the ephemeral port)
+      //   TCP    [::1]:25949         [::1]:55193         ESTABLISHED     10936   鈫?server-side row (proxy owns the listener)
+      //   TCP    [::1]:55193         [::1]:25949         ESTABLISHED     29356   鈫?client-side row (curl owns the ephemeral port)
       //
       // For `clientPort` (the client's ephemeral port) we want the row
-      // whose LOCAL column ends with `:<clientPort>` — that's the row
+      // whose LOCAL column ends with `:<clientPort>` 鈥?that's the row
       // attributed to the client process.
-      const { stdout } = await execAsync(
-        `netstat -ano | findstr :${clientPort} | findstr ESTABLISHED`,
-        { shell: "cmd.exe", timeout: 2000, windowsHide: true },
-      );
+      const { stdout } = await execFileAsync("netstat.exe", ["-ano", "-p", "TCP"], {
+        windowsHide: true,
+        timeout: 2000,
+        maxBuffer: 2 * 1024 * 1024,
+      });
       const clientToken = `:${clientPort}`;
       for (const rawLine of stdout.split("\n")) {
         const line = rawLine.trim();
@@ -654,6 +587,8 @@ async function lookupPidByLocalPort(clientPort: number): Promise<number | null>
         const cols = line.split(/\s+/);
         if (cols.length < 5) continue;
         const localAddr = cols[1] ?? "";
+        const state = cols[3] ?? "";
+        if (state !== "ESTABLISHED") continue;
         if (!localAddr.endsWith(clientToken)) continue;
         const pidStr = cols[cols.length - 1] ?? "";
         const parsed = parseInt(pidStr, 10);
@@ -665,9 +600,13 @@ async function lookupPidByLocalPort(clientPort: number): Promise<number | null>
     // CAP_NET_ADMIN to see PIDs of processes owned by other users; when
     // permission is denied the command exits non-zero and we return null.
     try {
-      const { stdout } = await execAsync(
-        `ss -tanp state established 'sport = :${clientPort}' 2>/dev/null | tail -n +2 | head -n 1`,
-        { shell: "/bin/sh" },
+      const { stdout } = await execFileAsync(
+        "ss",
+        ["-tanp", "state", "established", "sport", `= :${clientPort}`],
+        {
+          timeout: 2000,
+          maxBuffer: 2 * 1024 * 1024,
+        },
       );
       const match = stdout.match(/pid=(\d+)/);
       if (match !== null) {
@@ -678,10 +617,12 @@ async function lookupPidByLocalPort(clientPort: number): Promise<number | null>
       // fall through
     }
     try {
-      const { stdout } = await execAsync(
-        `lsof -ti tcp:${clientPort} -sTCP:ESTABLISHED 2>/dev/null`,
+      const { stdout } = await execFileAsync(
+        "lsof",
+        ["-ti", `tcp:${clientPort}`, "-sTCP:ESTABLISHED"],
         {
-          shell: "/bin/sh",
+          timeout: 2000,
+          maxBuffer: 64 * 1024,
         },
       );
       const trimmed = stdout.trim().split("\n")[0] ?? "";

package/src/routes/api/ecosystem.packages.$packageId.help.ts

@@ -0,0 +1,16 @@
+import { createFileRoute } from "@tanstack/react-router";
+import { startEcosystemTask } from "../../proxy/ecosystemTasks";
+
+export const Route = createFileRoute("/api/ecosystem/packages/$packageId/help")({
+  server: {
+    handlers: {
+      POST: ({ params }: { params: { packageId: string } }) => {
+        const task = startEcosystemTask(params.packageId, "help");
+        if (task === null) {
+          return Response.json({ error: "Unknown ecosystem package" }, { status: 404 });
+        }
+        return Response.json({ task });
+      },
+    },
+  },
+});

package/src/routes/api/ecosystem.packages.$packageId.install.ts

@@ -0,0 +1,16 @@
+import { createFileRoute } from "@tanstack/react-router";
+import { startEcosystemTask } from "../../proxy/ecosystemTasks";
+
+export const Route = createFileRoute("/api/ecosystem/packages/$packageId/install")({
+  server: {
+    handlers: {
+      POST: ({ params }: { params: { packageId: string } }) => {
+        const task = startEcosystemTask(params.packageId, "install");
+        if (task === null) {
+          return Response.json({ error: "Unknown ecosystem package" }, { status: 404 });
+        }
+        return Response.json({ task });
+      },
+    },
+  },
+});

package/src/routes/api/ecosystem.packages.$packageId.runner-presets.ts

@@ -0,0 +1,19 @@
+import { createFileRoute } from "@tanstack/react-router";
+import { startEcosystemTask } from "../../proxy/ecosystemTasks";
+
+export const Route = createFileRoute("/api/ecosystem/packages/$packageId/runner-presets")({
+  server: {
+    handlers: {
+      POST: ({ params }: { params: { packageId: string } }) => {
+        const task = startEcosystemTask(params.packageId, "runner-presets");
+        if (task === null) {
+          return Response.json(
+            { error: "Runner presets are only available for Eval Harness" },
+            { status: 404 },
+          );
+        }
+        return Response.json({ task });
+      },
+    },
+  },
+});

package/src/routes/api/ecosystem.packages.$packageId.upgrade.ts

@@ -0,0 +1,16 @@
+import { createFileRoute } from "@tanstack/react-router";
+import { startEcosystemTask } from "../../proxy/ecosystemTasks";
+
+export const Route = createFileRoute("/api/ecosystem/packages/$packageId/upgrade")({
+  server: {
+    handlers: {
+      POST: ({ params }: { params: { packageId: string } }) => {
+        const task = startEcosystemTask(params.packageId, "upgrade");
+        if (task === null) {
+          return Response.json({ error: "Unknown ecosystem package" }, { status: 404 });
+        }
+        return Response.json({ task });
+      },
+    },
+  },
+});