@h-rig/runtime 0.0.6-alpha.0

package/dist/src/control-plane/runtime/tooling/index.js

@@ -0,0 +1,1290 @@
+// @bun
+// packages/runtime/src/control-plane/runtime/tooling/shell.ts
+import { chmodSync, copyFileSync, existsSync, mkdirSync } from "fs";
+import { tmpdir } from "os";
+import { basename, dirname, resolve } from "path";
+var sharedNativeShellOutputDir = resolve(tmpdir(), "rig-native");
+var sharedNativeShellOutputPath = resolve(sharedNativeShellOutputDir, `rig-shell-${process.platform}-${process.arch}${process.platform === "win32" ? ".exe" : ""}`);
+function runtimeRigShellFileName() {
+  return `rig-shell${process.platform === "win32" ? ".exe" : ""}`;
+}
+async function ensureRigShellBinaryPath(outputPath = sharedNativeShellOutputPath) {
+  const sourcePath = resolveRigShellSourcePath();
+  if (!sourcePath) {
+    const bundledBinary = resolveBundledRigShellBinaryPath();
+    if (bundledBinary) {
+      return bundledBinary;
+    }
+    throw new Error("rig-shell.zig source file not found.");
+  }
+  const zigBinary = Bun.which("zig");
+  if (!zigBinary) {
+    throw new Error("zig is required to build the native Rig shell.");
+  }
+  mkdirSync(dirname(outputPath), { recursive: true });
+  const sourceDigest = await sha256File(sourcePath);
+  const buildKey = JSON.stringify({
+    version: 1,
+    zigBinary,
+    platform: process.platform,
+    arch: process.arch,
+    sourcePath,
+    sourceDigest
+  });
+  const manifestPath = nativeBuildManifestPath(outputPath);
+  const needsBuild = !existsSync(outputPath) || !await hasMatchingNativeBuildManifest(manifestPath, buildKey);
+  if (!needsBuild) {
+    return outputPath;
+  }
+  const build = Bun.spawn([
+    zigBinary,
+    "build-exe",
+    sourcePath,
+    "-O",
+    "ReleaseFast",
+    `-femit-bin=${outputPath}`
+  ], {
+    cwd: dirname(sourcePath),
+    stdout: "pipe",
+    stderr: "pipe"
+  });
+  const [exitCode, stdout, stderr] = await Promise.all([
+    build.exited,
+    new Response(build.stdout).text(),
+    new Response(build.stderr).text()
+  ]);
+  if (exitCode !== 0 || !existsSync(outputPath)) {
+    const details = [stderr.trim(), stdout.trim()].filter(Boolean).join(`
+`);
+    throw new Error(`Failed to build native Rig shell: ${details || `zig exited with code ${exitCode}`}`);
+  }
+  await Bun.write(manifestPath, `${JSON.stringify({ version: 1, buildKey }, null, 2)}
+`);
+  return outputPath;
+}
+async function materializeRigShellBinary(targetDir) {
+  const sourcePath = await ensureRigShellBinaryPath();
+  const targetPath = resolve(targetDir, runtimeRigShellFileName());
+  mkdirSync(targetDir, { recursive: true });
+  const sourceDigest = await sha256File(sourcePath);
+  const buildKey = JSON.stringify({
+    version: 1,
+    sourcePath,
+    sourceDigest
+  });
+  const needsCopy = !existsSync(targetPath) || !await hasMatchingNativeBuildManifest(nativeBuildManifestPath(targetPath), buildKey);
+  if (needsCopy) {
+    copyFileSync(sourcePath, targetPath);
+    chmodSync(targetPath, 493);
+    await Bun.write(nativeBuildManifestPath(targetPath), `${JSON.stringify({ version: 1, buildKey }, null, 2)}
+`);
+  }
+  return targetPath;
+}
+function resolveRigShellSourcePath() {
+  for (const candidate of rigShellSourceCandidates()) {
+    if (candidate && existsSync(candidate)) {
+      return candidate;
+    }
+  }
+  return null;
+}
+function resolveBundledRigShellBinaryPath() {
+  for (const candidate of rigShellBinaryCandidates()) {
+    if (candidate && existsSync(candidate)) {
+      return candidate;
+    }
+  }
+  return null;
+}
+function rigShellSourceCandidates() {
+  const execDir = process.execPath?.trim() ? dirname(process.execPath.trim()) : "";
+  const cwd = process.cwd()?.trim() || "";
+  const projectRoot = process.env.PROJECT_RIG_ROOT?.trim() || "";
+  const hostProjectRoot = process.env.RIG_HOST_PROJECT_ROOT?.trim() || "";
+  return [...new Set([
+    process.env.RIG_NATIVE_SHELL_SOURCE?.trim() || "",
+    cwd ? resolve(cwd, "packages/runtime/native/rig-shell.zig") : "",
+    projectRoot ? resolve(projectRoot, "packages/runtime/native/rig-shell.zig") : "",
+    hostProjectRoot ? resolve(hostProjectRoot, "packages/runtime/native/rig-shell.zig") : "",
+    execDir ? resolve(execDir, "..", "..", "packages/runtime/native/rig-shell.zig") : "",
+    execDir ? resolve(execDir, "..", "native", "rig-shell.zig") : "",
+    resolve(import.meta.dir, "../../../../native/rig-shell.zig")
+  ].filter(Boolean))];
+}
+function nativePackageBinaryCandidates(fromDir, fileName) {
+  const candidates = [];
+  let cursor = resolve(fromDir);
+  for (let index = 0;index < 8; index += 1) {
+    candidates.push(resolve(cursor, "native", `${process.platform}-${process.arch}`, fileName), resolve(cursor, "native", `${process.platform}-${process.arch}`, "bin", fileName), resolve(cursor, "native", fileName), resolve(cursor, "native", "bin", fileName));
+    const parent = dirname(cursor);
+    if (parent === cursor)
+      break;
+    cursor = parent;
+  }
+  return candidates;
+}
+function rigShellBinaryCandidates() {
+  const execDir = process.execPath?.trim() ? dirname(process.execPath.trim()) : "";
+  const fileName = runtimeRigShellFileName();
+  return [...new Set([
+    process.env.RIG_NATIVE_SHELL_BIN?.trim() || "",
+    ...nativePackageBinaryCandidates(import.meta.dir, fileName),
+    execDir ? resolve(execDir, fileName) : "",
+    execDir ? resolve(execDir, "..", fileName) : "",
+    execDir ? resolve(execDir, "..", "bin", fileName) : ""
+  ].filter(Boolean))];
+}
+function runtimeToolGatewayNames() {
+  return [
+    "bash",
+    "sh",
+    "zsh",
+    "git",
+    "bun",
+    "node",
+    "python3",
+    "rg",
+    "grep",
+    "sed",
+    "cat",
+    "ls",
+    "find",
+    "tsc",
+    "gh",
+    "mkdir",
+    "rm",
+    "mv",
+    "cp",
+    "touch",
+    "pwd",
+    "head",
+    "tail",
+    "wc",
+    "sort",
+    "uniq",
+    "awk",
+    "xargs",
+    "dirname",
+    "basename",
+    "realpath",
+    "env",
+    "jq",
+    "tee",
+    "which"
+  ];
+}
+function shellBinaryBasename(path) {
+  return basename(path);
+}
+function nativeBuildManifestPath(outputPath) {
+  return `${outputPath}.build-manifest.json`;
+}
+async function hasMatchingNativeBuildManifest(manifestPath, buildKey) {
+  if (!existsSync(manifestPath)) {
+    return false;
+  }
+  try {
+    const manifest = await Bun.file(manifestPath).json();
+    return manifest.version === 1 && manifest.buildKey === buildKey;
+  } catch {
+    return false;
+  }
+}
+async function sha256File(path) {
+  const hasher = new Bun.CryptoHasher("sha256");
+  hasher.update(await Bun.file(path).arrayBuffer());
+  return hasher.digest("hex");
+}
+// packages/runtime/src/control-plane/runtime/tooling/browser-tools.ts
+import { existsSync as existsSync2, rmSync, symlinkSync } from "fs";
+import { resolve as resolve2 } from "path";
+function runtimeBrowserToolBinaryName() {
+  return `rig-browser-tool${process.platform === "win32" ? ".exe" : ""}`;
+}
+function runtimeBrowserToolNames() {
+  return [
+    "rig-browser-launch",
+    "rig-browser-check",
+    "rig-browser-attach-info",
+    "rig-browser-e2e",
+    "rig-browser-reset-profile"
+  ];
+}
+async function materializeRuntimeBrowserTools(targetDir) {
+  const binaryPath = resolve2(targetDir, runtimeBrowserToolBinaryName());
+  for (const tool of runtimeBrowserToolNames()) {
+    const toolPath = resolve2(targetDir, tool);
+    if (existsSync2(toolPath)) {
+      rmSync(toolPath, { force: true, recursive: true });
+    }
+    symlinkSync(binaryPath, toolPath);
+  }
+  return binaryPath;
+}
+// packages/runtime/src/control-plane/runtime/tooling/file-tools.ts
+import { chmodSync as chmodSync2, copyFileSync as copyFileSync2, existsSync as existsSync3, mkdirSync as mkdirSync2, rmSync as rmSync2, symlinkSync as symlinkSync2 } from "fs";
+import { tmpdir as tmpdir2 } from "os";
+import { basename as basename2, dirname as dirname2, resolve as resolve3 } from "path";
+var sharedNativeToolsOutputDir = resolve3(tmpdir2(), "rig-native");
+var sharedNativeToolsOutputPath = resolve3(sharedNativeToolsOutputDir, `rig-tools-${process.platform}-${process.arch}${process.platform === "win32" ? ".exe" : ""}`);
+function runtimeRigToolsFileName() {
+  return `rig-tools${process.platform === "win32" ? ".exe" : ""}`;
+}
+function runtimeFileToolNames() {
+  return [
+    "rig-read",
+    "rig-write",
+    "rig-edit",
+    "rig-glob",
+    "rig-grep"
+  ];
+}
+async function ensureRigToolsBinaryPath(outputPath = sharedNativeToolsOutputPath) {
+  const sourcePath = resolveRigToolsSourcePath();
+  if (!sourcePath) {
+    const bundledBinary = resolveBundledRigToolsBinaryPath();
+    if (bundledBinary) {
+      return bundledBinary;
+    }
+    throw new Error("rig-tools.zig source file not found.");
+  }
+  const zigBinary = Bun.which("zig");
+  if (!zigBinary) {
+    throw new Error("zig is required to build native Rig file tools.");
+  }
+  mkdirSync2(dirname2(outputPath), { recursive: true });
+  const sourceDigest = await sha256File2(sourcePath);
+  const buildKey = JSON.stringify({
+    version: 1,
+    zigBinary,
+    platform: process.platform,
+    arch: process.arch,
+    sourcePath,
+    sourceDigest
+  });
+  const manifestPath = nativeBuildManifestPath2(outputPath);
+  const needsBuild = !existsSync3(outputPath) || !await hasMatchingNativeBuildManifest2(manifestPath, buildKey);
+  if (!needsBuild) {
+    return outputPath;
+  }
+  const build = Bun.spawn([
+    zigBinary,
+    "build-exe",
+    sourcePath,
+    "-O",
+    "ReleaseFast",
+    `-femit-bin=${outputPath}`
+  ], {
+    cwd: dirname2(sourcePath),
+    stdout: "pipe",
+    stderr: "pipe"
+  });
+  const [exitCode, stdout, stderr] = await Promise.all([
+    build.exited,
+    new Response(build.stdout).text(),
+    new Response(build.stderr).text()
+  ]);
+  if (exitCode !== 0 || !existsSync3(outputPath)) {
+    const details = [stderr.trim(), stdout.trim()].filter(Boolean).join(`
+`);
+    throw new Error(`Failed to build native Rig file tools: ${details || `zig exited with code ${exitCode}`}`);
+  }
+  await Bun.write(manifestPath, `${JSON.stringify({ version: 1, buildKey }, null, 2)}
+`);
+  return outputPath;
+}
+async function materializeRuntimeFileTools(targetDir) {
+  const sourcePath = await ensureRigToolsBinaryPath();
+  const targetPath = resolve3(targetDir, runtimeRigToolsFileName());
+  mkdirSync2(targetDir, { recursive: true });
+  const sourceDigest = await sha256File2(sourcePath);
+  const buildKey = JSON.stringify({
+    version: 1,
+    sourcePath,
+    sourceDigest
+  });
+  const needsCopy = !existsSync3(targetPath) || !await hasMatchingNativeBuildManifest2(nativeBuildManifestPath2(targetPath), buildKey);
+  if (needsCopy) {
+    copyFileSync2(sourcePath, targetPath);
+    chmodSync2(targetPath, 493);
+    await Bun.write(nativeBuildManifestPath2(targetPath), `${JSON.stringify({ version: 1, buildKey }, null, 2)}
+`);
+  }
+  for (const tool of runtimeFileToolNames()) {
+    const toolPath = resolve3(targetDir, tool);
+    if (existsSync3(toolPath)) {
+      rmSync2(toolPath, { force: true, recursive: true });
+    }
+    symlinkSync2(targetPath, toolPath);
+  }
+  return targetPath;
+}
+function resolveRigToolsSourcePath() {
+  for (const candidate of rigToolsSourceCandidates()) {
+    if (candidate && existsSync3(candidate)) {
+      return candidate;
+    }
+  }
+  return null;
+}
+function resolveBundledRigToolsBinaryPath() {
+  for (const candidate of rigToolsBinaryCandidates()) {
+    if (candidate && existsSync3(candidate)) {
+      return candidate;
+    }
+  }
+  return null;
+}
+function rigToolsSourceCandidates() {
+  const execDir = process.execPath?.trim() ? dirname2(process.execPath.trim()) : "";
+  const cwd = process.cwd()?.trim() || "";
+  const projectRoot = process.env.PROJECT_RIG_ROOT?.trim() || "";
+  const hostProjectRoot = process.env.RIG_HOST_PROJECT_ROOT?.trim() || "";
+  return [...new Set([
+    process.env.RIG_NATIVE_TOOLS_SOURCE?.trim() || "",
+    cwd ? resolve3(cwd, "packages/runtime/native/rig-tools.zig") : "",
+    projectRoot ? resolve3(projectRoot, "packages/runtime/native/rig-tools.zig") : "",
+    hostProjectRoot ? resolve3(hostProjectRoot, "packages/runtime/native/rig-tools.zig") : "",
+    execDir ? resolve3(execDir, "..", "..", "packages/runtime/native/rig-tools.zig") : "",
+    execDir ? resolve3(execDir, "..", "native", "rig-tools.zig") : "",
+    resolve3(import.meta.dir, "../../../../native/rig-tools.zig")
+  ].filter(Boolean))];
+}
+function nativePackageBinaryCandidates2(fromDir, fileName) {
+  const candidates = [];
+  let cursor = resolve3(fromDir);
+  for (let index = 0;index < 8; index += 1) {
+    candidates.push(resolve3(cursor, "native", `${process.platform}-${process.arch}`, fileName), resolve3(cursor, "native", `${process.platform}-${process.arch}`, "bin", fileName), resolve3(cursor, "native", fileName), resolve3(cursor, "native", "bin", fileName));
+    const parent = dirname2(cursor);
+    if (parent === cursor)
+      break;
+    cursor = parent;
+  }
+  return candidates;
+}
+function rigToolsBinaryCandidates() {
+  const execDir = process.execPath?.trim() ? dirname2(process.execPath.trim()) : "";
+  const fileName = runtimeRigToolsFileName();
+  return [...new Set([
+    process.env.RIG_NATIVE_TOOLS_BIN?.trim() || "",
+    ...nativePackageBinaryCandidates2(import.meta.dir, fileName),
+    execDir ? resolve3(execDir, fileName) : "",
+    execDir ? resolve3(execDir, "..", fileName) : "",
+    execDir ? resolve3(execDir, "..", "bin", fileName) : ""
+  ].filter(Boolean))];
+}
+function runtimeFileToolBasename(path) {
+  return basename2(path);
+}
+function nativeBuildManifestPath2(outputPath) {
+  return `${outputPath}.build-manifest.json`;
+}
+async function hasMatchingNativeBuildManifest2(manifestPath, buildKey) {
+  if (!existsSync3(manifestPath)) {
+    return false;
+  }
+  try {
+    const manifest = await Bun.file(manifestPath).json();
+    return manifest.version === 1 && manifest.buildKey === buildKey;
+  } catch {
+    return false;
+  }
+}
+async function sha256File2(path) {
+  const hasher = new Bun.CryptoHasher("sha256");
+  hasher.update(await Bun.file(path).arrayBuffer());
+  return hasher.digest("hex");
+}
+// packages/runtime/src/control-plane/runtime/tooling/gateway.ts
+import { existsSync as existsSync4, rmSync as rmSync3, symlinkSync as symlinkSync3 } from "fs";
+import { resolve as resolve4 } from "path";
+function runtimeGatewayToolNames() {
+  return runtimeToolGatewayNames();
+}
+async function materializeRuntimeToolGateway(binDir) {
+  const shellPath = await materializeRigShellBinary(binDir);
+  for (const tool of runtimeGatewayToolNames()) {
+    const toolPath = resolve4(binDir, tool);
+    if (existsSync4(toolPath)) {
+      rmSync3(toolPath, { force: true, recursive: true });
+    }
+    symlinkSync3(shellPath, toolPath);
+  }
+  await materializeRuntimeBrowserTools(binDir);
+  return resolve4(binDir, runtimeRigShellFileName());
+}
+// packages/runtime/src/control-plane/runtime/tooling/claude-router.ts
+import { existsSync as existsSync5, mkdirSync as mkdirSync3, statSync as statSync2, writeFileSync } from "fs";
+import { resolve as resolve5 } from "path";
+import { createInterface } from "readline";
+var CLAUDE_ROUTER_SERVER_NAME = "rig_runtime_tools";
+var CLAUDE_DISABLED_FILE_TOOLS = [
+  "Read",
+  "Edit",
+  "Write",
+  "NotebookEdit",
+  "Glob",
+  "Grep"
+];
+var ROUTER_VERSION = "0.1.0";
+var CLAUDE_ROUTER_TOOL_DEFINITIONS = [
+  {
+    name: "read",
+    description: "Read a UTF-8 file from the current Rig task worktree, the outer control-plane repo ($PROJECT_RIG_ROOT), or the host monorepo checkout ($MONOREPO_MAIN_ROOT).",
+    inputSchema: {
+      type: "object",
+      properties: {
+        path: { type: "string", description: "Absolute or workspace-relative file path." },
+        offset: { type: "integer", minimum: 0 },
+        limit: { type: "integer", minimum: 1, maximum: 2097152 }
+      },
+      required: ["path"],
+      additionalProperties: false
+    }
+  },
+  {
+    name: "write",
+    description: "Write UTF-8 content to a file inside the current Rig task workspace only.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        path: { type: "string", description: "Absolute or workspace-relative file path." },
+        content: { type: "string" },
+        create_parents: { type: "boolean" }
+      },
+      required: ["path", "content"],
+      additionalProperties: false
+    }
+  },
+  {
+    name: "edit",
+    description: "Replace one or more exact string occurrences in a UTF-8 file inside the current Rig task workspace only.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        path: { type: "string", description: "Absolute or workspace-relative file path." },
+        old_string: { type: "string" },
+        new_string: { type: "string" },
+        replace_all: { type: "boolean" }
+      },
+      required: ["path", "old_string", "new_string"],
+      additionalProperties: false
+    }
+  },
+  {
+    name: "glob",
+    description: "Search files using a glob pattern across the current task worktree, $PROJECT_RIG_ROOT, or $MONOREPO_MAIN_ROOT.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        pattern: { type: "string" },
+        path: { type: "string", description: "Optional workspace-relative search root." },
+        include_hidden: { type: "boolean" },
+        max_results: { type: "integer", minimum: 1, maximum: 5000 }
+      },
+      required: ["pattern"],
+      additionalProperties: false
+    }
+  },
+  {
+    name: "grep",
+    description: "Search file contents across the current task worktree, $PROJECT_RIG_ROOT, or $MONOREPO_MAIN_ROOT.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        pattern: { type: "string" },
+        path: { type: "string", description: "Optional workspace-relative search root." },
+        literal: { type: "boolean" },
+        include_hidden: { type: "boolean" },
+        max_results: { type: "integer", minimum: 1, maximum: 500 },
+        glob: { type: "string", description: "Optional file glob filter passed through to ripgrep." }
+      },
+      required: ["pattern"],
+      additionalProperties: false
+    }
+  }
+];
+function claudeRuntimeToolCliArgs(configPath) {
+  return [
+    "--disallowedTools",
+    CLAUDE_DISABLED_FILE_TOOLS.join(","),
+    "--mcp-config",
+    configPath
+  ];
+}
+function buildRuntimeToolRouterServerConfig(options) {
+  return {
+    type: "stdio",
+    command: resolve5(options.binDir, "rig-tool-router"),
+    args: [],
+    env: {
+      RIG_RUNTIME_CONTEXT_FILE: options.contextFile,
+      RIG_RUNTIME_BIN_DIR: options.binDir
+    }
+  };
+}
+function escapeTomlString(value) {
+  return value.replaceAll("\\", "\\\\").replaceAll('"', "\\\"");
+}
+function tomlString(value) {
+  return `"${escapeTomlString(value)}"`;
+}
+function tomlStringArray(values) {
+  return `[${values.map((value) => tomlString(value)).join(", ")}]`;
+}
+function tomlInlineTable(entries) {
+  return `{ ${Object.entries(entries).map(([key, value]) => `${key} = ${tomlString(value)}`).join(", ")} }`;
+}
+function codexRuntimeToolCliArgs(options) {
+  const serverConfig = buildRuntimeToolRouterServerConfig(options);
+  return [
+    "-a",
+    "never",
+    "-c",
+    `mcp_servers.${CLAUDE_ROUTER_SERVER_NAME}.command=${tomlString(serverConfig.command)}`,
+    "-c",
+    `mcp_servers.${CLAUDE_ROUTER_SERVER_NAME}.args=${tomlStringArray(serverConfig.args)}`,
+    "-c",
+    `mcp_servers.${CLAUDE_ROUTER_SERVER_NAME}.env=${tomlInlineTable(serverConfig.env)}`
+  ];
+}
+function writeClaudeRuntimeToolRouterConfig(options) {
+  const configPath = resolve5(options.stateDir, "claude-runtime-tools.mcp.json");
+  mkdirSync3(options.stateDir, { recursive: true });
+  const payload = {
+    mcpServers: {
+      [CLAUDE_ROUTER_SERVER_NAME]: buildRuntimeToolRouterServerConfig(options)
+    }
+  };
+  writeFileSync(configPath, `${JSON.stringify(payload, null, 2)}
+`, "utf-8");
+  return configPath;
+}
+async function runClaudeToolRouterServer() {
+  const lineReader = createInterface({
+    input: process.stdin,
+    crlfDelay: Infinity
+  });
+  const inFlightToolCalls = new Set;
+  const trackToolCall = (call) => {
+    inFlightToolCalls.add(call);
+    call.finally(() => inFlightToolCalls.delete(call)).catch((err) => {
+      console.warn("[claude-router] in-flight tool call failure:", err);
+    });
+  };
+  for await (const line of lineReader) {
+    const trimmed = line.trim();
+    if (!trimmed) {
+      continue;
+    }
+    let request;
+    try {
+      request = JSON.parse(trimmed);
+    } catch {
+      continue;
+    }
+    if (!request.method) {
+      continue;
+    }
+    if (request.method === "notifications/initialized") {
+      continue;
+    }
+    if (request.method === "initialize") {
+      writeMessage({
+        jsonrpc: "2.0",
+        id: request.id ?? null,
+        result: {
+          protocolVersion: "2024-11-05",
+          capabilities: {
+            tools: {}
+          },
+          serverInfo: {
+            name: CLAUDE_ROUTER_SERVER_NAME,
+            version: ROUTER_VERSION
+          }
+        }
+      });
+      continue;
+    }
+    if (request.method === "ping") {
+      writeMessage({
+        jsonrpc: "2.0",
+        id: request.id ?? null,
+        result: {}
+      });
+      continue;
+    }
+    if (request.method === "tools/list") {
+      writeMessage({
+        jsonrpc: "2.0",
+        id: request.id ?? null,
+        result: {
+          tools: CLAUDE_ROUTER_TOOL_DEFINITIONS
+        }
+      });
+      continue;
+    }
+    if (request.method === "tools/call") {
+      const toolName = typeof request.params?.name === "string" ? request.params.name : "";
+      const args = isRecord(request.params?.arguments) ? request.params.arguments : {};
+      const requestId = request.id ?? null;
+      const toolCall = (async () => {
+        try {
+          const result = await invokeRuntimeTool(toolName, args);
+          writeMessage({
+            jsonrpc: "2.0",
+            id: requestId,
+            result
+          });
+        } catch (error) {
+          writeMessage({
+            jsonrpc: "2.0",
+            id: requestId,
+            error: {
+              code: -32603,
+              message: error instanceof Error ? error.message : String(error)
+            }
+          });
+        }
+      })();
+      trackToolCall(toolCall);
+      continue;
+    }
+    writeMessage({
+      jsonrpc: "2.0",
+      id: request.id ?? null,
+      error: {
+        code: -32601,
+        message: `Unsupported method: ${request.method}`
+      }
+    });
+  }
+  if (inFlightToolCalls.size > 0) {
+    await Promise.allSettled(Array.from(inFlightToolCalls));
+  }
+}
+async function invokeRuntimeTool(toolName, args, options = {}) {
+  if (toolName === "shell") {
+    return invokeRuntimeShellTool(args, options);
+  }
+  const invocationEnv = options.env ?? process.env;
+  const binaryPath = resolveRuntimeToolBinary(toolName, invocationEnv);
+  if (!binaryPath) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: `Unknown Rig runtime tool: ${toolName}`
+        }
+      ],
+      isError: true
+    };
+  }
+  const proc = Bun.spawn([binaryPath], {
+    stdin: "pipe",
+    stdout: "pipe",
+    stderr: "pipe",
+    env: invocationEnv
+  });
+  const requestBody = `${JSON.stringify(args)}
+`;
+  if (proc.stdin) {
+    await proc.stdin.write(requestBody);
+    await proc.stdin.end();
+  }
+  const [exitCode, stdout, stderr] = await Promise.all([
+    proc.exited,
+    readBunProcessPipe(proc.stdout),
+    readBunProcessPipe(proc.stderr)
+  ]);
+  if (exitCode !== 0) {
+    const text = [stdout.trim(), stderr.trim()].filter(Boolean).join(`
+`) || `Tool ${toolName} exited with code ${exitCode}`;
+    return {
+      content: [{ type: "text", text }],
+      isError: true
+    };
+  }
+  let payload;
+  try {
+    payload = JSON.parse(stdout);
+  } catch {
+    return {
+      content: [{ type: "text", text: stdout.trim() || `(empty output from ${toolName})` }],
+      isError: false
+    };
+  }
+  if (payload.ok === false) {
+    return {
+      content: [{ type: "text", text: String(payload.message ?? `Tool ${toolName} failed`) }],
+      structuredContent: payload,
+      isError: true
+    };
+  }
+  return {
+    content: [{ type: "text", text: renderToolText(toolName, payload) }],
+    structuredContent: payload,
+    isError: false
+  };
+}
+async function readBunProcessPipe(pipe) {
+  if (typeof pipe === "number" || !pipe) {
+    return "";
+  }
+  return new Response(pipe).text();
+}
+function resolveRuntimeToolBinary(toolName, env) {
+  const binDir = env.RIG_RUNTIME_BIN_DIR?.trim() || "";
+  if (!binDir) {
+    return "";
+  }
+  const mapping = {
+    read: "rig-read",
+    write: "rig-write",
+    edit: "rig-edit",
+    glob: "rig-glob",
+    grep: "rig-grep"
+  };
+  const executable = mapping[toolName];
+  return executable ? resolve5(binDir, executable) : "";
+}
+function renderToolText(toolName, payload) {
+  if (toolName === "shell") {
+    const command = typeof payload.command === "string" ? payload.command : "(unknown command)";
+    const stdout = typeof payload.stdout === "string" ? payload.stdout.trim() : "";
+    const stderr = typeof payload.stderr === "string" ? payload.stderr.trim() : "";
+    const exitCode = typeof payload.exit_code === "number" ? payload.exit_code : null;
+    const output = [stdout, stderr].filter(Boolean).join(`
+`);
+    const summary = exitCode === null ? command : `${command}
+
+exit_code=${String(exitCode)}`;
+    return output ? `${summary}
+
+${output}` : summary;
+  }
+  if (toolName === "read") {
+    const path = typeof payload.path === "string" ? payload.path : "(unknown path)";
+    const content = typeof payload.content === "string" ? payload.content : "";
+    const truncated = payload.truncated === true ? `
+
+[truncated]` : "";
+    return `${path}
+
+${content}${truncated}`;
+  }
+  if (toolName === "glob") {
+    const matches = Array.isArray(payload.matches) ? payload.matches.filter((value) => typeof value === "string") : [];
+    return matches.length > 0 ? matches.join(`
+`) : "(no matches)";
+  }
+  if (toolName === "grep") {
+    const matches = Array.isArray(payload.matches) ? payload.matches.filter(isRecord) : [];
+    if (matches.length === 0) {
+      return "(no matches)";
+    }
+    return matches.map((match) => `${String(match.path ?? "(unknown)")}:${String(match.line_number ?? "?")}: ${String(match.line ?? "")}`).join(`
+`);
+  }
+  if (toolName === "write") {
+    return `Wrote ${String(payload.bytes_written ?? 0)} bytes to ${String(payload.path ?? "(unknown path)")}.`;
+  }
+  if (toolName === "edit") {
+    return `Edited ${String(payload.path ?? "(unknown path)")}; replacements: ${String(payload.replacements ?? 0)}.`;
+  }
+  return JSON.stringify(payload, null, 2);
+}
+async function invokeRuntimeShellTool(args, options = {}) {
+  const command = typeof args.command === "string" ? args.command.trim() : "";
+  if (!command) {
+    return {
+      content: [{ type: "text", text: "Missing required shell `command` string." }],
+      isError: true
+    };
+  }
+  const invocationEnv = options.env ?? process.env;
+  const shellName = args.shell === "sh" ? "sh" : args.shell === "zsh" ? "zsh" : "bash";
+  const shellBinary = resolveRuntimeShellBinary(shellName, invocationEnv);
+  if (!shellBinary) {
+    return {
+      content: [{ type: "text", text: `Missing Rig runtime shell binary for ${shellName}.` }],
+      isError: true
+    };
+  }
+  const workspaceRoot = resolve5(invocationEnv.RIG_TASK_WORKSPACE?.trim() || process.cwd());
+  const requestedWorkdir = typeof args.workdir === "string" ? args.workdir.trim() : "";
+  const workdir = requestedWorkdir ? resolveWithinWorkspace(workspaceRoot, requestedWorkdir) : workspaceRoot;
+  if (!existsSync5(workdir)) {
+    return {
+      content: [{
+        type: "text",
+        text: `Shell workdir does not exist inside the task workspace: ${requestedWorkdir || "."}`
+      }],
+      isError: true
+    };
+  }
+  try {
+    if (!statSync2(workdir).isDirectory()) {
+      return {
+        content: [{
+          type: "text",
+          text: `Shell workdir is not a directory inside the task workspace: ${requestedWorkdir || "."}`
+        }],
+        isError: true
+      };
+    }
+  } catch (error) {
+    return {
+      content: [{
+        type: "text",
+        text: error instanceof Error ? error.message : String(error)
+      }],
+      isError: true
+    };
+  }
+  let proc = null;
+  try {
+    proc = Bun.spawn([shellBinary, shellName === "bash" ? "-lc" : "-c", command], {
+      cwd: workdir,
+      env: invocationEnv,
+      stdout: "pipe",
+      stderr: "pipe"
+    });
+  } catch (error) {
+    return {
+      content: [{
+        type: "text",
+        text: error instanceof Error ? error.message : String(error)
+      }],
+      isError: true
+    };
+  }
+  const [exitCode, stdout, stderr] = await Promise.all([
+    proc.exited,
+    readBunProcessPipe(proc.stdout),
+    readBunProcessPipe(proc.stderr)
+  ]);
+  const payload = {
+    ok: exitCode === 0,
+    shell: shellName,
+    cwd: workdir,
+    command,
+    stdout,
+    stderr,
+    exit_code: exitCode
+  };
+  return {
+    content: [{ type: "text", text: renderToolText("shell", payload) }],
+    structuredContent: payload,
+    isError: exitCode !== 0
+  };
+}
+function resolveRuntimeShellBinary(shellName, env) {
+  const binDir = env.RIG_RUNTIME_BIN_DIR?.trim() || "";
+  return binDir ? resolve5(binDir, shellName) : "";
+}
+function resolveWithinWorkspace(workspaceRoot, target) {
+  const resolvedTarget = resolve5(workspaceRoot, normalizeWorkspaceRelativeTarget(target));
+  const normalizedWorkspace = workspaceRoot.endsWith("/") ? workspaceRoot : `${workspaceRoot}/`;
+  const normalizedTarget = resolvedTarget.endsWith("/") ? resolvedTarget : `${resolvedTarget}/`;
+  if (resolvedTarget === workspaceRoot || normalizedTarget.startsWith(normalizedWorkspace)) {
+    return resolvedTarget;
+  }
+  throw new Error(`Shell workdir must stay inside the task workspace: ${target}`);
+}
+function normalizeWorkspaceRelativeTarget(target) {
+  const trimmed = target.trim();
+  if (!trimmed) {
+    return ".";
+  }
+  if (trimmed === "$MONOREPO_ROOT" || trimmed === "$RIG_TASK_WORKSPACE") {
+    return ".";
+  }
+  if (trimmed.startsWith("$MONOREPO_ROOT/")) {
+    return trimmed.slice("$MONOREPO_ROOT/".length);
+  }
+  if (trimmed.startsWith("$RIG_TASK_WORKSPACE/")) {
+    return trimmed.slice("$RIG_TASK_WORKSPACE/".length);
+  }
+  if (trimmed === "repos/spliter-monorepo") {
+    return ".";
+  }
+  if (trimmed.startsWith("repos/spliter-monorepo/")) {
+    return trimmed.slice("repos/spliter-monorepo/".length);
+  }
+  return trimmed;
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function writeMessage(payload) {
+  process.stdout.write(`${JSON.stringify(payload)}
+`);
+}
+if (false) {}
+// packages/runtime/src/control-plane/runtime/tooling/claude-router-binary.ts
+import { chmodSync as chmodSync4, copyFileSync as copyFileSync3, existsSync as existsSync7, mkdirSync as mkdirSync5, statSync as statSync3 } from "fs";
+import { tmpdir as tmpdir3 } from "os";
+import { dirname as dirname4, resolve as resolve7 } from "path";
+
+// packages/runtime/src/binary-run.ts
+import { chmodSync as chmodSync3, cpSync, existsSync as existsSync6, mkdirSync as mkdirSync4, renameSync, rmSync as rmSync4, writeFileSync as writeFileSync2 } from "fs";
+import { basename as basename3, dirname as dirname3, resolve as resolve6 } from "path";
+import { fileURLToPath } from "url";
+import { drainMicrotasks, gcAndSweep } from "bun:jsc";
+var runtimeBinaryBuildQueue = Promise.resolve();
+async function buildRuntimeBinary(options) {
+  return runSerializedRuntimeBinaryBuild(async () => {
+    const resolved = resolveRuntimeBinaryBuildOptions(options);
+    runBestEffortBuildGc();
+    const manifestPath = runtimeBinaryCacheManifestPath(resolved.outputPath);
+    const buildKey = createRuntimeBinaryBuildKey({
+      entrypoint: resolved.entrypoint,
+      define: resolved.define,
+      env: resolved.env
+    });
+    if (await isRuntimeBinaryBuildFresh({ outputPath: resolved.outputPath, manifestPath, buildKey })) {
+      return;
+    }
+    if (shouldUseRuntimeBinaryBuildWorker()) {
+      await buildRuntimeBinaryViaWorker(resolved);
+    } else {
+      await buildRuntimeBinaryInProcess(resolved, { manifestPath, buildKey });
+    }
+    runBestEffortBuildGc();
+  });
+}
+async function buildRuntimeBinaryInProcess(options, manifest) {
+  const tempBuildDir = resolve6(dirname3(options.outputPath), `.bun-build-${process.pid}-${Date.now()}-${Math.random().toString(36).slice(2)}`);
+  const tempOutputPath = resolve6(tempBuildDir, basename3(options.outputPath));
+  mkdirSync4(tempBuildDir, { recursive: true });
+  await withTemporaryEnv({
+    ...options.env,
+    ...options.define ? { RIG_BUILD_CONFIG_JSON: JSON.stringify(options.define) } : {}
+  }, async () => withTemporaryCwd(tempBuildDir, async () => {
+    const buildResult = await Bun.build({
+      entrypoints: [options.entrypoint],
+      compile: {
+        target: currentCompileTarget(),
+        outfile: tempOutputPath
+      },
+      target: "bun",
+      format: "esm",
+      minify: true,
+      bytecode: true,
+      metafile: true,
+      define: options.define ? {
+        __RIG_BUILD_CONFIG__: JSON.stringify(options.define)
+      } : undefined
+    });
+    if (!buildResult.success) {
+      const details = buildResult.logs.map((log) => [log.message, log.position?.file ? `${log.position.file}:${log.position.line}:${log.position.column}` : ""].filter(Boolean).join(" ")).filter(Boolean).join(`
+`);
+      throw new Error(`Failed to build ${options.entrypoint}: ${details || "Bun.build() returned errors"}`);
+    }
+    if (!existsSync6(tempOutputPath)) {
+      const emitted = buildResult.outputs.map((output) => output.path).join(", ") || "(none)";
+      throw new Error(`Failed to build ${options.entrypoint}: Bun.build() did not emit ${tempOutputPath}. Emitted: ${emitted}`);
+    }
+    renameSync(tempOutputPath, options.outputPath);
+    chmodSync3(options.outputPath, 493);
+    if (manifest) {
+      await writeRuntimeBinaryCacheManifest({
+        manifestPath: manifest.manifestPath,
+        buildKey: manifest.buildKey,
+        cwd: tempBuildDir,
+        metafile: buildResult.metafile
+      });
+    }
+  })).finally(() => {
+    rmSync4(tempBuildDir, { recursive: true, force: true });
+  });
+}
+function runBestEffortBuildGc() {
+  try {
+    drainMicrotasks();
+  } catch {}
+  try {
+    gcAndSweep();
+  } catch {}
+}
+function runtimeBinaryCacheManifestPath(outputPath) {
+  return `${outputPath}.build-manifest.json`;
+}
+function resolveRuntimeBinaryBuildOptions(options) {
+  return {
+    ...options,
+    entrypoint: resolve6(options.cwd, options.sourcePath),
+    outputPath: resolve6(options.outputPath)
+  };
+}
+function shouldUseRuntimeBinaryBuildWorker() {
+  if (process.env.RIG_RUNTIME_BUILD_WORKER === "1") {
+    return false;
+  }
+  if (process.env.RIG_RUNTIME_BUILD_IN_PROCESS === "1") {
+    return false;
+  }
+  return true;
+}
+async function buildRuntimeBinaryViaWorker(options) {
+  const workerSourcePath = resolveRuntimeBinaryBuildWorkerSourcePath(options);
+  if (!workerSourcePath || !existsSync6(workerSourcePath)) {
+    await buildRuntimeBinaryInProcess(options, {
+      manifestPath: runtimeBinaryCacheManifestPath(options.outputPath),
+      buildKey: createRuntimeBinaryBuildKey({
+        entrypoint: options.entrypoint,
+        define: options.define,
+        env: options.env
+      })
+    });
+    return;
+  }
+  const payloadPath = createRuntimeBinaryBuildWorkerPayloadPath(options.outputPath);
+  const bunCli = resolveRuntimeBinaryBuildWorkerInvocation();
+  await Bun.write(payloadPath, `${JSON.stringify(options)}
+`);
+  const build = Bun.spawn([bunCli.command, workerSourcePath, payloadPath], {
+    cwd: options.cwd,
+    stdout: "pipe",
+    stderr: "pipe",
+    env: {
+      ...process.env,
+      ...options.env,
+      ...bunCli.env,
+      RIG_RUNTIME_BUILD_WORKER: "1"
+    }
+  });
+  const [exitCode, stdout, stderr] = await Promise.all([
+    build.exited,
+    new Response(build.stdout).text(),
+    new Response(build.stderr).text()
+  ]);
+  rmSync4(payloadPath, { force: true });
+  if (exitCode !== 0) {
+    throw new Error(`Failed to build ${options.entrypoint}: ${(stderr || stdout || `worker exited ${exitCode}`).trim()}`);
+  }
+}
+function createRuntimeBinaryBuildWorkerPayloadPath(outputPath) {
+  return resolve6(dirname3(outputPath), `.bun-build-worker-${process.pid}-${Date.now()}-${Math.random().toString(36).slice(2)}.json`);
+}
+function resolveRuntimeBinaryBuildWorkerSourcePath(options) {
+  const envRoots = [
+    options.cwd?.trim(),
+    process.env.RIG_HOST_PROJECT_ROOT?.trim(),
+    process.env.PROJECT_RIG_ROOT?.trim()
+  ].filter(Boolean);
+  for (const root of envRoots) {
+    const candidate = resolve6(root, "packages/runtime/src/binary-build-worker.ts");
+    if (existsSync6(candidate)) {
+      return candidate;
+    }
+  }
+  const localCandidate = resolve6(import.meta.dir, "binary-build-worker.ts");
+  return existsSync6(localCandidate) ? localCandidate : null;
+}
+function resolveRuntimeBinaryBuildWorkerInvocation() {
+  const bunPath = Bun.which("bun");
+  if (bunPath) {
+    return { command: bunPath, env: {} };
+  }
+  if (process.execPath?.trim()) {
+    return {
+      command: process.execPath,
+      env: { BUN_BE_BUN: "1" }
+    };
+  }
+  throw new Error("bun is required to run the runtime binary build worker.");
+}
+function currentCompileTarget() {
+  if (process.platform === "darwin") {
+    return process.arch === "arm64" ? "bun-darwin-arm64" : "bun-darwin-x64";
+  }
+  if (process.platform === "linux") {
+    return process.arch === "arm64" ? "bun-linux-arm64" : "bun-linux-x64";
+  }
+  return "bun-windows-x64";
+}
+function createRuntimeBinaryBuildKey(input) {
+  return JSON.stringify({
+    version: 1,
+    bunVersion: Bun.version,
+    platform: process.platform,
+    arch: process.arch,
+    entrypoint: input.entrypoint,
+    define: sortRecord(input.define),
+    env: sortRecord(input.env)
+  });
+}
+async function isRuntimeBinaryBuildFresh(input) {
+  if (!existsSync6(input.outputPath) || !existsSync6(input.manifestPath)) {
+    return false;
+  }
+  let manifest = null;
+  try {
+    manifest = await Bun.file(input.manifestPath).json();
+  } catch {
+    return false;
+  }
+  if (!manifest || manifest.version !== 1 || manifest.buildKey !== input.buildKey) {
+    return false;
+  }
+  for (const [filePath, expectedDigest] of Object.entries(manifest.inputs || {})) {
+    if (!existsSync6(filePath)) {
+      return false;
+    }
+    if (await sha256File3(filePath) !== expectedDigest) {
+      return false;
+    }
+  }
+  return true;
+}
+async function writeRuntimeBinaryCacheManifest(input) {
+  const inputs = {};
+  for (const inputPath of Object.keys(input.metafile?.inputs || {}).sort()) {
+    const normalized = normalizeBuildInputPath(input.cwd, inputPath);
+    if (!normalized || !existsSync6(normalized)) {
+      continue;
+    }
+    inputs[normalized] = await sha256File3(normalized);
+  }
+  const manifest = {
+    version: 1,
+    buildKey: input.buildKey,
+    inputs
+  };
+  await Bun.write(input.manifestPath, `${JSON.stringify(manifest, null, 2)}
+`);
+}
+function normalizeBuildInputPath(cwd, inputPath) {
+  if (!inputPath) {
+    return null;
+  }
+  if (inputPath.startsWith("file://")) {
+    return fileURLToPath(inputPath);
+  }
+  if (inputPath.startsWith("<")) {
+    return null;
+  }
+  return resolve6(cwd, inputPath);
+}
+async function sha256File3(path) {
+  const hasher = new Bun.CryptoHasher("sha256");
+  hasher.update(await Bun.file(path).arrayBuffer());
+  return hasher.digest("hex");
+}
+function sortRecord(value) {
+  if (!value) {
+    return;
+  }
+  return Object.fromEntries(Object.entries(value).sort(([left], [right]) => left.localeCompare(right)));
+}
+async function runSerializedRuntimeBinaryBuild(action) {
+  const previous = runtimeBinaryBuildQueue;
+  let release;
+  runtimeBinaryBuildQueue = new Promise((resolve7) => {
+    release = resolve7;
+  });
+  await previous;
+  try {
+    return await action();
+  } finally {
+    release();
+  }
+}
+async function withTemporaryEnv(env, action) {
+  if (!env) {
+    return action();
+  }
+  const previousValues = new Map;
+  for (const [key, value] of Object.entries(env)) {
+    previousValues.set(key, process.env[key]);
+    if (value === undefined) {
+      delete process.env[key];
+    } else {
+      process.env[key] = value;
+    }
+  }
+  try {
+    return await action();
+  } finally {
+    for (const [key, value] of previousValues.entries()) {
+      if (value === undefined) {
+        delete process.env[key];
+      } else {
+        process.env[key] = value;
+      }
+    }
+  }
+}
+async function withTemporaryCwd(cwd, action) {
+  const previousCwd = process.cwd();
+  process.chdir(cwd);
+  try {
+    return await action();
+  } finally {
+    process.chdir(previousCwd);
+  }
+}
+
+// packages/runtime/src/control-plane/runtime/tooling/claude-router-binary.ts
+var sharedRouterOutputDir = resolve7(tmpdir3(), "rig-native");
+var sharedRouterOutputPath = resolve7(sharedRouterOutputDir, `rig-tool-router-${process.platform}-${process.arch}${process.platform === "win32" ? ".exe" : ""}`);
+function runtimeClaudeToolRouterFileName() {
+  return `rig-tool-router${process.platform === "win32" ? ".exe" : ""}`;
+}
+async function ensureClaudeToolRouterBinaryPath(projectRoot, outputPath = sharedRouterOutputPath) {
+  const sourcePath = resolve7(projectRoot, "packages/runtime/src/control-plane/runtime/tooling/claude-router.ts");
+  mkdirSync5(dirname4(outputPath), { recursive: true });
+  const needsBuild = !existsSync7(outputPath) || statSync3(sourcePath).mtimeMs > statSync3(outputPath).mtimeMs;
+  if (!needsBuild) {
+    return outputPath;
+  }
+  await buildRuntimeBinary({
+    sourcePath: "packages/runtime/src/control-plane/runtime/tooling/claude-router.ts",
+    outputPath,
+    cwd: projectRoot
+  });
+  chmodSync4(outputPath, 493);
+  return outputPath;
+}
+async function materializeClaudeToolRouterBinary(projectRoot, targetDir) {
+  const sourcePath = await ensureClaudeToolRouterBinaryPath(projectRoot);
+  const targetPath = resolve7(targetDir, runtimeClaudeToolRouterFileName());
+  mkdirSync5(targetDir, { recursive: true });
+  const needsCopy = !existsSync7(targetPath) || statSync3(sourcePath).mtimeMs > statSync3(targetPath).mtimeMs;
+  if (needsCopy) {
+    copyFileSync3(sourcePath, targetPath);
+    chmodSync4(targetPath, 493);
+  }
+  return targetPath;
+}
+export {
+  writeClaudeRuntimeToolRouterConfig,
+  shellBinaryBasename,
+  runtimeToolGatewayNames,
+  runtimeRigToolsFileName,
+  runtimeRigShellFileName,
+  runtimeGatewayToolNames,
+  runtimeFileToolNames,
+  runtimeFileToolBasename,
+  runtimeClaudeToolRouterFileName,
+  runtimeBrowserToolNames,
+  runtimeBrowserToolBinaryName,
+  runClaudeToolRouterServer,
+  materializeRuntimeToolGateway,
+  materializeRuntimeFileTools,
+  materializeRuntimeBrowserTools,
+  materializeRigShellBinary,
+  materializeClaudeToolRouterBinary,
+  invokeRuntimeTool,
+  ensureRigToolsBinaryPath,
+  ensureRigShellBinaryPath,
+  ensureClaudeToolRouterBinaryPath,
+  codexRuntimeToolCliArgs,
+  claudeRuntimeToolCliArgs,
+  CLAUDE_ROUTER_TOOL_DEFINITIONS,
+  CLAUDE_ROUTER_SERVER_NAME,
+  CLAUDE_DISABLED_FILE_TOOLS
+};