@h-rig/runtime 0.0.6-alpha.0

package/dist/src/control-plane/runtime/tooling/claude-router.js

@@ -0,0 +1,524 @@
+#!/usr/bin/env bun
+// @bun
+
+// packages/runtime/src/control-plane/runtime/tooling/claude-router.ts
+import { existsSync, mkdirSync, statSync, writeFileSync } from "fs";
+import { resolve } 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: resolve(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 = resolve(options.stateDir, "claude-runtime-tools.mcp.json");
+  mkdirSync(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 ? resolve(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 = resolve(invocationEnv.RIG_TASK_WORKSPACE?.trim() || process.cwd());
+  const requestedWorkdir = typeof args.workdir === "string" ? args.workdir.trim() : "";
+  const workdir = requestedWorkdir ? resolveWithinWorkspace(workspaceRoot, requestedWorkdir) : workspaceRoot;
+  if (!existsSync(workdir)) {
+    return {
+      content: [{
+        type: "text",
+        text: `Shell workdir does not exist inside the task workspace: ${requestedWorkdir || "."}`
+      }],
+      isError: true
+    };
+  }
+  try {
+    if (!statSync(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 ? resolve(binDir, shellName) : "";
+}
+function resolveWithinWorkspace(workspaceRoot, target) {
+  const resolvedTarget = resolve(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 (import.meta.main) {
+  await runClaudeToolRouterServer();
+}
+export {
+  writeClaudeRuntimeToolRouterConfig,
+  runClaudeToolRouterServer,
+  invokeRuntimeTool,
+  codexRuntimeToolCliArgs,
+  claudeRuntimeToolCliArgs,
+  CLAUDE_ROUTER_TOOL_DEFINITIONS,
+  CLAUDE_ROUTER_SERVER_NAME,
+  CLAUDE_DISABLED_FILE_TOOLS
+};

package/dist/src/control-plane/runtime/tooling/file-tools.js

@@ -0,0 +1,182 @@
+// @bun
+// packages/runtime/src/control-plane/runtime/tooling/file-tools.ts
+import { chmodSync, copyFileSync, existsSync, mkdirSync, rmSync, symlinkSync } from "fs";
+import { tmpdir } from "os";
+import { basename, dirname, resolve } from "path";
+var sharedNativeToolsOutputDir = resolve(tmpdir(), "rig-native");
+var sharedNativeToolsOutputPath = resolve(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.");
+  }
+  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 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 = resolve(targetDir, runtimeRigToolsFileName());
+  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)}
+`);
+  }
+  for (const tool of runtimeFileToolNames()) {
+    const toolPath = resolve(targetDir, tool);
+    if (existsSync(toolPath)) {
+      rmSync(toolPath, { force: true, recursive: true });
+    }
+    symlinkSync(targetPath, toolPath);
+  }
+  return targetPath;
+}
+function resolveRigToolsSourcePath() {
+  for (const candidate of rigToolsSourceCandidates()) {
+    if (candidate && existsSync(candidate)) {
+      return candidate;
+    }
+  }
+  return null;
+}
+function resolveBundledRigToolsBinaryPath() {
+  for (const candidate of rigToolsBinaryCandidates()) {
+    if (candidate && existsSync(candidate)) {
+      return candidate;
+    }
+  }
+  return null;
+}
+function rigToolsSourceCandidates() {
+  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_TOOLS_SOURCE?.trim() || "",
+    cwd ? resolve(cwd, "packages/runtime/native/rig-tools.zig") : "",
+    projectRoot ? resolve(projectRoot, "packages/runtime/native/rig-tools.zig") : "",
+    hostProjectRoot ? resolve(hostProjectRoot, "packages/runtime/native/rig-tools.zig") : "",
+    execDir ? resolve(execDir, "..", "..", "packages/runtime/native/rig-tools.zig") : "",
+    execDir ? resolve(execDir, "..", "native", "rig-tools.zig") : "",
+    resolve(import.meta.dir, "../../../../native/rig-tools.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 rigToolsBinaryCandidates() {
+  const execDir = process.execPath?.trim() ? dirname(process.execPath.trim()) : "";
+  const fileName = runtimeRigToolsFileName();
+  return [...new Set([
+    process.env.RIG_NATIVE_TOOLS_BIN?.trim() || "",
+    ...nativePackageBinaryCandidates(import.meta.dir, fileName),
+    execDir ? resolve(execDir, fileName) : "",
+    execDir ? resolve(execDir, "..", fileName) : "",
+    execDir ? resolve(execDir, "..", "bin", fileName) : ""
+  ].filter(Boolean))];
+}
+function runtimeFileToolBasename(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");
+}
+export {
+  runtimeRigToolsFileName,
+  runtimeFileToolNames,
+  runtimeFileToolBasename,
+  materializeRuntimeFileTools,
+  ensureRigToolsBinaryPath
+};