@h-rig/provider-plugin 0.0.6-alpha.157 → 0.0.6-alpha.158

package/dist/src/tooling/file-tools.js

@@ -0,0 +1,224 @@
+// @bun
+// packages/provider-plugin/src/tooling/file-tools.ts
+import { chmodSync, copyFileSync, existsSync as existsSync2, mkdirSync as mkdirSync2, rmSync, symlinkSync } from "fs";
+import { tmpdir as tmpdir2 } from "os";
+import { basename, dirname, resolve as resolve2 } from "path";
+import { RUNTIME_FILE_TOOL_NAMES } from "@rig/contracts";
+
+// packages/provider-plugin/src/tooling/native-extract.ts
+import { existsSync, mkdirSync, readFileSync, renameSync, statSync, writeFileSync } from "fs";
+import { tmpdir } from "os";
+import { resolve } from "path";
+
+// packages/provider-plugin/src/tooling/embedded-native-assets.ts
+var embeddedNatives = null;
+
+// packages/provider-plugin/src/tooling/native-extract.ts
+var sharedNativeOutputDir = resolve(tmpdir(), "rig-native");
+var extractionCache = {};
+function extractEmbeddedNative(name) {
+  if (name in extractionCache) {
+    return extractionCache[name] ?? null;
+  }
+  const entry = embeddedNatives?.[name];
+  if (!entry) {
+    extractionCache[name] = null;
+    return null;
+  }
+  try {
+    const targetPath = resolve(sharedNativeOutputDir, entry.fileName);
+    mkdirSync(sharedNativeOutputDir, { recursive: true });
+    const upToDate = existsSync(targetPath) && statSync(targetPath).size === entry.size;
+    if (!upToDate) {
+      const bytes = readFileSync(entry.filePath);
+      const tempPath = `${targetPath}.${process.pid}.${Date.now()}.tmp`;
+      writeFileSync(tempPath, bytes, { mode: 493 });
+      renameSync(tempPath, targetPath);
+    }
+    extractionCache[name] = targetPath;
+  } catch {
+    extractionCache[name] = null;
+  }
+  return extractionCache[name] ?? null;
+}
+
+// packages/provider-plugin/src/tooling/file-tools.ts
+var sharedNativeToolsOutputDir = resolve2(tmpdir2(), "rig-native");
+var sharedNativeToolsOutputPath = resolve2(sharedNativeToolsOutputDir, `rig-tools-${process.platform}-${process.arch}${process.platform === "win32" ? ".exe" : ""}`);
+function runtimeRigToolsFileName() {
+  return `rig-tools${process.platform === "win32" ? ".exe" : ""}`;
+}
+function runtimeFileToolNames() {
+  return [...RUNTIME_FILE_TOOL_NAMES];
+}
+async function ensureRigToolsBinaryPath(outputPath = sharedNativeToolsOutputPath) {
+  const explicitBin = process.env.RIG_NATIVE_TOOLS_BIN?.trim();
+  if (explicitBin && existsSync2(explicitBin)) {
+    return explicitBin;
+  }
+  const embedded = extractEmbeddedNative("rig-tools");
+  if (embedded) {
+    return embedded;
+  }
+  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(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 = !existsSync2(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 || !existsSync2(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 = resolve2(targetDir, runtimeRigToolsFileName());
+  mkdirSync2(targetDir, { recursive: true });
+  const sourceDigest = await sha256File(sourcePath);
+  const buildKey = JSON.stringify({
+    version: 1,
+    sourcePath,
+    sourceDigest
+  });
+  const needsCopy = !existsSync2(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 = resolve2(targetDir, tool);
+    if (existsSync2(toolPath)) {
+      rmSync(toolPath, { force: true, recursive: true });
+    }
+    symlinkSync(targetPath, toolPath);
+  }
+  return targetPath;
+}
+function resolveRigToolsSourcePath() {
+  for (const candidate of rigToolsSourceCandidates()) {
+    if (candidate && existsSync2(candidate)) {
+      return candidate;
+    }
+  }
+  return null;
+}
+function resolveBundledRigToolsBinaryPath() {
+  for (const candidate of rigToolsBinaryCandidates()) {
+    if (candidate && existsSync2(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 ? resolve2(cwd, "packages/provider-plugin/native/rig-tools.zig") : "",
+    projectRoot ? resolve2(projectRoot, "packages/provider-plugin/native/rig-tools.zig") : "",
+    hostProjectRoot ? resolve2(hostProjectRoot, "packages/provider-plugin/native/rig-tools.zig") : "",
+    execDir ? resolve2(execDir, "..", "..", "packages/provider-plugin/native/rig-tools.zig") : "",
+    execDir ? resolve2(execDir, "..", "native", "rig-tools.zig") : "",
+    resolve2(import.meta.dir, "../../native/rig-tools.zig")
+  ].filter(Boolean))];
+}
+function nativePackageBinaryCandidates(fromDir, fileName) {
+  const candidates = [];
+  let cursor = resolve2(fromDir);
+  for (let index = 0;index < 8; index += 1) {
+    candidates.push(resolve2(cursor, "native", `${process.platform}-${process.arch}`, fileName), resolve2(cursor, "native", `${process.platform}-${process.arch}`, "bin", fileName), resolve2(cursor, "native", fileName), resolve2(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 ? resolve2(execDir, fileName) : "",
+    execDir ? resolve2(execDir, "..", fileName) : "",
+    execDir ? resolve2(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 (!existsSync2(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
+};

package/dist/src/tooling/gateway.d.ts

@@ -0,0 +1,4 @@
+export declare function runtimeGatewayToolNames(): string[];
+export { materializeRuntimeBrowserTools, runtimeBrowserToolNames, } from "./browser-tools";
+export { materializeRuntimeFileTools, runtimeFileToolNames, } from "./file-tools";
+export declare function materializeRuntimeToolGateway(binDir: string): Promise<string>;

package/dist/src/tooling/gateway.js

@@ -0,0 +1,430 @@
+// @bun
+// packages/provider-plugin/src/tooling/gateway.ts
+import { existsSync as existsSync5, rmSync as rmSync3, symlinkSync as symlinkSync3 } from "fs";
+import { resolve as resolve5 } from "path";
+import { RUNTIME_SHELL_TOOL_NAMES as RUNTIME_SHELL_TOOL_NAMES2 } from "@rig/contracts";
+
+// packages/provider-plugin/src/tooling/shell-tools.ts
+import { chmodSync, copyFileSync, existsSync as existsSync2, mkdirSync as mkdirSync2 } from "fs";
+import { tmpdir as tmpdir2 } from "os";
+import { basename, dirname, resolve as resolve2 } from "path";
+import { RUNTIME_SHELL_TOOL_NAMES } from "@rig/contracts";
+
+// packages/provider-plugin/src/tooling/native-extract.ts
+import { existsSync, mkdirSync, readFileSync, renameSync, statSync, writeFileSync } from "fs";
+import { tmpdir } from "os";
+import { resolve } from "path";
+
+// packages/provider-plugin/src/tooling/embedded-native-assets.ts
+var embeddedNatives = null;
+
+// packages/provider-plugin/src/tooling/native-extract.ts
+var sharedNativeOutputDir = resolve(tmpdir(), "rig-native");
+var extractionCache = {};
+function extractEmbeddedNative(name) {
+  if (name in extractionCache) {
+    return extractionCache[name] ?? null;
+  }
+  const entry = embeddedNatives?.[name];
+  if (!entry) {
+    extractionCache[name] = null;
+    return null;
+  }
+  try {
+    const targetPath = resolve(sharedNativeOutputDir, entry.fileName);
+    mkdirSync(sharedNativeOutputDir, { recursive: true });
+    const upToDate = existsSync(targetPath) && statSync(targetPath).size === entry.size;
+    if (!upToDate) {
+      const bytes = readFileSync(entry.filePath);
+      const tempPath = `${targetPath}.${process.pid}.${Date.now()}.tmp`;
+      writeFileSync(tempPath, bytes, { mode: 493 });
+      renameSync(tempPath, targetPath);
+    }
+    extractionCache[name] = targetPath;
+  } catch {
+    extractionCache[name] = null;
+  }
+  return extractionCache[name] ?? null;
+}
+
+// packages/provider-plugin/src/tooling/shell-tools.ts
+var sharedNativeShellOutputDir = resolve2(tmpdir2(), "rig-native");
+var sharedNativeShellOutputPath = resolve2(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 explicitBin = process.env.RIG_NATIVE_SHELL_BIN?.trim();
+  if (explicitBin && existsSync2(explicitBin)) {
+    return explicitBin;
+  }
+  const embedded = extractEmbeddedNative("rig-shell");
+  if (embedded) {
+    return embedded;
+  }
+  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.");
+  }
+  mkdirSync2(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 = !existsSync2(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 || !existsSync2(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 = resolve2(targetDir, runtimeRigShellFileName());
+  mkdirSync2(targetDir, { recursive: true });
+  const sourceDigest = await sha256File(sourcePath);
+  const buildKey = JSON.stringify({
+    version: 1,
+    sourcePath,
+    sourceDigest
+  });
+  const needsCopy = !existsSync2(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 && existsSync2(candidate)) {
+      return candidate;
+    }
+  }
+  return null;
+}
+function resolveBundledRigShellBinaryPath() {
+  for (const candidate of rigShellBinaryCandidates()) {
+    if (candidate && existsSync2(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 ? resolve2(cwd, "packages/provider-plugin/native/rig-shell.zig") : "",
+    projectRoot ? resolve2(projectRoot, "packages/provider-plugin/native/rig-shell.zig") : "",
+    hostProjectRoot ? resolve2(hostProjectRoot, "packages/provider-plugin/native/rig-shell.zig") : "",
+    execDir ? resolve2(execDir, "..", "..", "packages/provider-plugin/native/rig-shell.zig") : "",
+    execDir ? resolve2(execDir, "..", "native", "rig-shell.zig") : "",
+    resolve2(import.meta.dir, "../../native/rig-shell.zig")
+  ].filter(Boolean))];
+}
+function nativePackageBinaryCandidates(fromDir, fileName) {
+  const candidates = [];
+  let cursor = resolve2(fromDir);
+  for (let index = 0;index < 8; index += 1) {
+    candidates.push(resolve2(cursor, "native", `${process.platform}-${process.arch}`, fileName), resolve2(cursor, "native", `${process.platform}-${process.arch}`, "bin", fileName), resolve2(cursor, "native", fileName), resolve2(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 ? resolve2(execDir, fileName) : "",
+    execDir ? resolve2(execDir, "..", fileName) : "",
+    execDir ? resolve2(execDir, "..", "bin", fileName) : ""
+  ].filter(Boolean))];
+}
+function nativeBuildManifestPath(outputPath) {
+  return `${outputPath}.build-manifest.json`;
+}
+async function hasMatchingNativeBuildManifest(manifestPath, buildKey) {
+  if (!existsSync2(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/provider-plugin/src/tooling/browser-tools.ts
+import { existsSync as existsSync3, rmSync, symlinkSync } from "fs";
+import { resolve as resolve3 } from "path";
+import { RUNTIME_BROWSER_TOOL_NAMES } from "@rig/contracts";
+function runtimeBrowserToolBinaryName() {
+  return `rig-browser-tool${process.platform === "win32" ? ".exe" : ""}`;
+}
+function runtimeBrowserToolNames() {
+  return [...RUNTIME_BROWSER_TOOL_NAMES];
+}
+async function materializeRuntimeBrowserTools(targetDir) {
+  const binaryPath = resolve3(targetDir, runtimeBrowserToolBinaryName());
+  for (const tool of runtimeBrowserToolNames()) {
+    const toolPath = resolve3(targetDir, tool);
+    if (existsSync3(toolPath)) {
+      rmSync(toolPath, { force: true, recursive: true });
+    }
+    symlinkSync(binaryPath, toolPath);
+  }
+  return binaryPath;
+}
+// packages/provider-plugin/src/tooling/file-tools.ts
+import { chmodSync as chmodSync2, copyFileSync as copyFileSync2, existsSync as existsSync4, mkdirSync as mkdirSync3, rmSync as rmSync2, symlinkSync as symlinkSync2 } from "fs";
+import { tmpdir as tmpdir3 } from "os";
+import { basename as basename2, dirname as dirname2, resolve as resolve4 } from "path";
+import { RUNTIME_FILE_TOOL_NAMES } from "@rig/contracts";
+var sharedNativeToolsOutputDir = resolve4(tmpdir3(), "rig-native");
+var sharedNativeToolsOutputPath = resolve4(sharedNativeToolsOutputDir, `rig-tools-${process.platform}-${process.arch}${process.platform === "win32" ? ".exe" : ""}`);
+function runtimeRigToolsFileName() {
+  return `rig-tools${process.platform === "win32" ? ".exe" : ""}`;
+}
+function runtimeFileToolNames() {
+  return [...RUNTIME_FILE_TOOL_NAMES];
+}
+async function ensureRigToolsBinaryPath(outputPath = sharedNativeToolsOutputPath) {
+  const explicitBin = process.env.RIG_NATIVE_TOOLS_BIN?.trim();
+  if (explicitBin && existsSync4(explicitBin)) {
+    return explicitBin;
+  }
+  const embedded = extractEmbeddedNative("rig-tools");
+  if (embedded) {
+    return embedded;
+  }
+  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.");
+  }
+  mkdirSync3(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 = !existsSync4(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 || !existsSync4(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 = resolve4(targetDir, runtimeRigToolsFileName());
+  mkdirSync3(targetDir, { recursive: true });
+  const sourceDigest = await sha256File2(sourcePath);
+  const buildKey = JSON.stringify({
+    version: 1,
+    sourcePath,
+    sourceDigest
+  });
+  const needsCopy = !existsSync4(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 = resolve4(targetDir, tool);
+    if (existsSync4(toolPath)) {
+      rmSync2(toolPath, { force: true, recursive: true });
+    }
+    symlinkSync2(targetPath, toolPath);
+  }
+  return targetPath;
+}
+function resolveRigToolsSourcePath() {
+  for (const candidate of rigToolsSourceCandidates()) {
+    if (candidate && existsSync4(candidate)) {
+      return candidate;
+    }
+  }
+  return null;
+}
+function resolveBundledRigToolsBinaryPath() {
+  for (const candidate of rigToolsBinaryCandidates()) {
+    if (candidate && existsSync4(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 ? resolve4(cwd, "packages/provider-plugin/native/rig-tools.zig") : "",
+    projectRoot ? resolve4(projectRoot, "packages/provider-plugin/native/rig-tools.zig") : "",
+    hostProjectRoot ? resolve4(hostProjectRoot, "packages/provider-plugin/native/rig-tools.zig") : "",
+    execDir ? resolve4(execDir, "..", "..", "packages/provider-plugin/native/rig-tools.zig") : "",
+    execDir ? resolve4(execDir, "..", "native", "rig-tools.zig") : "",
+    resolve4(import.meta.dir, "../../native/rig-tools.zig")
+  ].filter(Boolean))];
+}
+function nativePackageBinaryCandidates2(fromDir, fileName) {
+  const candidates = [];
+  let cursor = resolve4(fromDir);
+  for (let index = 0;index < 8; index += 1) {
+    candidates.push(resolve4(cursor, "native", `${process.platform}-${process.arch}`, fileName), resolve4(cursor, "native", `${process.platform}-${process.arch}`, "bin", fileName), resolve4(cursor, "native", fileName), resolve4(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 ? resolve4(execDir, fileName) : "",
+    execDir ? resolve4(execDir, "..", fileName) : "",
+    execDir ? resolve4(execDir, "..", "bin", fileName) : ""
+  ].filter(Boolean))];
+}
+function nativeBuildManifestPath2(outputPath) {
+  return `${outputPath}.build-manifest.json`;
+}
+async function hasMatchingNativeBuildManifest2(manifestPath, buildKey) {
+  if (!existsSync4(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/provider-plugin/src/tooling/gateway.ts
+function runtimeGatewayToolNames() {
+  return [...RUNTIME_SHELL_TOOL_NAMES2];
+}
+async function materializeRuntimeToolGateway(binDir) {
+  const shellPath = await materializeRigShellBinary(binDir);
+  for (const tool of runtimeGatewayToolNames()) {
+    const toolPath = resolve5(binDir, tool);
+    if (existsSync5(toolPath)) {
+      rmSync3(toolPath, { force: true, recursive: true });
+    }
+    symlinkSync3(shellPath, toolPath);
+  }
+  await materializeRuntimeBrowserTools(binDir);
+  return resolve5(binDir, runtimeRigShellFileName());
+}
+export {
+  runtimeGatewayToolNames,
+  runtimeFileToolNames,
+  runtimeBrowserToolNames,
+  materializeRuntimeToolGateway,
+  materializeRuntimeFileTools,
+  materializeRuntimeBrowserTools
+};

package/dist/src/tooling/native-extract.d.ts

@@ -0,0 +1,2 @@
+export declare function hasEmbeddedNatives(): boolean;
+export declare function extractEmbeddedNative(name: string): string | null;