@h-rig/native-toolchain-plugin 0.0.0-e2e-live.20260630085347

package/README.md

@@ -0,0 +1 @@
+# @h-rig/native-toolchain-plugin

package/dist/src/git-binary.d.ts

@@ -0,0 +1,2 @@
+import type { NativeToolchainBinaryBuildService } from "@rig/contracts";
+export declare const binaryBuildService: NativeToolchainBinaryBuildService;

package/dist/src/git-binary.js

@@ -0,0 +1,221 @@
+// @bun
+// packages/native-toolchain-plugin/src/git-binary.ts
+import { chmodSync, copyFileSync, existsSync, mkdirSync, renameSync, rmSync } from "fs";
+import { tmpdir } from "os";
+import { basename, dirname, extname, resolve } from "path";
+var sharedNativeOutputDir = resolve(tmpdir(), "rig-native");
+function isWindowsTarget(target) {
+  const platform = target?.platform ?? process.platform;
+  return platform === "win32" || platform === "windows" || target?.triple?.includes("windows") === true;
+}
+function targetPlatform(target) {
+  return target?.platform || process.platform;
+}
+function targetArch(target) {
+  return target?.arch || process.arch;
+}
+function nativeBuildManifestPath(outputPath) {
+  return `${outputPath}.build-manifest.json`;
+}
+function temporaryOutputPath(outputPath, name = basename(outputPath)) {
+  const suffix = extname(name);
+  const stem = suffix ? name.slice(0, -suffix.length) : name;
+  return resolve(dirname(outputPath), `.${stem}-${process.pid}-${Date.now()}-${Math.random().toString(36).slice(2)}${suffix}`);
+}
+function publishNativeBinary(tempOutputPath, outputPath) {
+  try {
+    renameSync(tempOutputPath, outputPath);
+  } catch (error) {
+    if (process.platform === "win32" && existsSync(outputPath)) {
+      rmSync(outputPath, { force: true });
+      renameSync(tempOutputPath, outputPath);
+      return;
+    }
+    throw error;
+  }
+}
+async function sha256File(path) {
+  const hasher = new Bun.CryptoHasher("sha256");
+  hasher.update(await Bun.file(path).arrayBuffer());
+  return hasher.digest("hex");
+}
+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;
+  }
+}
+function artifact(name, path, kind, target) {
+  const base = { name, path, kind };
+  return target ? { ...base, target } : base;
+}
+function envKey(name) {
+  return name.replace(/\.exe$/i, "").replace(/[^A-Za-z0-9]+/g, "_").replace(/^_+|_+$/g, "").toUpperCase();
+}
+function nativePackageBinaryCandidates(fromDir, fileName, target) {
+  const candidates = [];
+  let cursor = resolve(fromDir);
+  const tag = `${targetPlatform(target)}-${targetArch(target)}`;
+  for (let index = 0;index < 8; index += 1) {
+    candidates.push(resolve(cursor, "native", tag, fileName), resolve(cursor, "native", tag, "bin", fileName), resolve(cursor, "native", fileName), resolve(cursor, "native", "bin", fileName));
+    const parent = dirname(cursor);
+    if (parent === cursor)
+      break;
+    cursor = parent;
+  }
+  return candidates;
+}
+async function copyMaterializedBinary(input) {
+  mkdirSync(dirname(input.targetPath), { recursive: true });
+  const sourceDigest = await sha256File(input.sourcePath);
+  const buildKey = JSON.stringify({ version: 1, sourcePath: input.sourcePath, sourceDigest });
+  const manifestPath = nativeBuildManifestPath(input.targetPath);
+  const needsCopy = !existsSync(input.targetPath) || !await hasMatchingNativeBuildManifest(manifestPath, buildKey);
+  if (needsCopy) {
+    copyFileSync(input.sourcePath, input.targetPath);
+    if (input.kind === "executable")
+      chmodSync(input.targetPath, 493);
+    await Bun.write(manifestPath, `${JSON.stringify({ version: 1, buildKey }, null, 2)}
+`);
+  } else if (input.kind === "executable") {
+    chmodSync(input.targetPath, 493);
+  }
+  return artifact(input.name, input.targetPath, input.kind, input.target);
+}
+function nativeBinaryFileName(name, kind, target) {
+  if (kind === "executable" && isWindowsTarget(target) && !name.toLowerCase().endsWith(".exe")) {
+    return `${name}.exe`;
+  }
+  return name;
+}
+function inferBinaryKind(nameOrPath) {
+  const lower = nameOrPath.toLowerCase();
+  return lower.endsWith(".so") || lower.endsWith(".dylib") || lower.endsWith(".dll") ? "dynamic-library" : "executable";
+}
+function nativeBinaryCandidates(name, target) {
+  const key = envKey(name);
+  const kind = inferBinaryKind(name);
+  const fileName = nativeBinaryFileName(name, kind, target);
+  const execDir = process.execPath?.trim() ? dirname(process.execPath.trim()) : "";
+  return [...new Set([
+    process.env[`RIG_NATIVE_${key}_BIN`]?.trim() || "",
+    ...nativePackageBinaryCandidates(import.meta.dir, fileName, target),
+    execDir ? resolve(execDir, fileName) : "",
+    execDir ? resolve(execDir, "..", fileName) : "",
+    execDir ? resolve(execDir, "..", "bin", fileName) : "",
+    resolve(sharedNativeOutputDir, `${name}-${targetPlatform(target)}-${targetArch(target)}${kind === "executable" && isWindowsTarget(target) ? ".exe" : ""}`)
+  ].filter(Boolean))];
+}
+function resolveNativeBinaryPath(name, target) {
+  for (const candidate of nativeBinaryCandidates(name, target)) {
+    if (candidate && existsSync(candidate))
+      return candidate;
+  }
+  return null;
+}
+function resolveNativeSourcePath(name) {
+  const value = process.env[`RIG_NATIVE_${envKey(name)}_SOURCE`]?.trim() || "";
+  return value && existsSync(value) ? value : null;
+}
+function genericBuildCommand(input, tempOutputPath, zigBinary) {
+  const mode = input.kind === "dynamic-library" ? "build-lib" : "build-exe";
+  const defines = Object.entries(input.defines ?? {}).flatMap(([key, value]) => [`-D${key}=${value}`]);
+  return [
+    zigBinary,
+    mode,
+    input.sourcePath,
+    ...input.kind === "dynamic-library" ? ["-dynamic"] : [],
+    "-O",
+    "ReleaseFast",
+    ...input.target?.triple ? ["-target", input.target.triple] : [],
+    ...input.buildArgs ?? [],
+    ...defines,
+    `-femit-bin=${tempOutputPath}`
+  ];
+}
+async function buildNativeBinary(input) {
+  if (!existsSync(input.sourcePath))
+    throw new Error(`Native source file not found: ${input.sourcePath}`);
+  const zigBinary = Bun.which("zig");
+  if (!zigBinary)
+    throw new Error("zig is required to build native binaries.");
+  mkdirSync(dirname(input.outputPath), { recursive: true });
+  const sourceDigest = await sha256File(input.sourcePath);
+  const buildKey = JSON.stringify({
+    version: 1,
+    zigBinary,
+    name: input.name,
+    kind: input.kind,
+    platform: targetPlatform(input.target),
+    arch: targetArch(input.target),
+    sourcePath: input.sourcePath,
+    sourceDigest,
+    buildArgs: input.buildArgs ?? [],
+    defines: input.defines ?? {},
+    triple: input.target?.triple ?? ""
+  });
+  const manifestPath = nativeBuildManifestPath(input.outputPath);
+  if (existsSync(input.outputPath) && await hasMatchingNativeBuildManifest(manifestPath, buildKey)) {
+    if (input.kind === "executable")
+      chmodSync(input.outputPath, 493);
+    return artifact(input.name, input.outputPath, input.kind, input.target);
+  }
+  const tempOutputPath = temporaryOutputPath(input.outputPath);
+  const build = Bun.spawn(genericBuildCommand(input, tempOutputPath, zigBinary), {
+    cwd: dirname(input.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(tempOutputPath)) {
+    const details = [stderr.trim(), stdout.trim()].filter(Boolean).join(`
+`);
+    throw new Error(`Failed to build native binary ${input.name}: ${details || `zig exited with code ${exitCode}`}`);
+  }
+  if (input.kind === "executable")
+    chmodSync(tempOutputPath, 493);
+  publishNativeBinary(tempOutputPath, input.outputPath);
+  await Bun.write(manifestPath, `${JSON.stringify({ version: 1, buildKey }, null, 2)}
+`);
+  return artifact(input.name, input.outputPath, input.kind, input.target);
+}
+var binaryBuildService = {
+  buildNativeBinary,
+  async materializeNativeBinary(input) {
+    const kind = inferBinaryKind(input.name);
+    const targetPath = resolve(input.targetDir, nativeBinaryFileName(input.name, kind, input.target));
+    const sourcePath = resolveNativeBinaryPath(input.name, input.target);
+    if (sourcePath) {
+      return copyMaterializedBinary({
+        name: input.name,
+        sourcePath,
+        targetPath,
+        kind,
+        ...input.target ? { target: input.target } : {}
+      });
+    }
+    const source = resolveNativeSourcePath(input.name);
+    if (source) {
+      return buildNativeBinary({
+        projectRoot: input.projectRoot,
+        name: input.name,
+        sourcePath: source,
+        outputPath: targetPath,
+        kind,
+        ...input.target ? { target: input.target } : {}
+      });
+    }
+    throw new Error(`Native binary ${input.name} was not found; set RIG_NATIVE_${envKey(input.name)}_BIN or RIG_NATIVE_${envKey(input.name)}_SOURCE.`);
+  }
+};
+export {
+  binaryBuildService
+};

package/dist/src/plugin.d.ts

@@ -0,0 +1,4 @@
+export declare const NATIVE_TOOLCHAIN_PLUGIN_NAME = "@rig/native-toolchain-plugin";
+export declare const nativeToolchainPlugin: import("@rig/core/config").RigPlugin;
+export declare function createNativeToolchainPlugin(): import("@rig/core/config").RigPlugin;
+export default nativeToolchainPlugin;

package/dist/src/plugin.js

@@ -0,0 +1,270 @@
+// @bun
+var __defProp = Object.defineProperty;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+
+// packages/native-toolchain-plugin/src/git-binary.ts
+var exports_git_binary = {};
+__export(exports_git_binary, {
+  binaryBuildService: () => binaryBuildService
+});
+import { chmodSync, copyFileSync, existsSync, mkdirSync, renameSync, rmSync } from "fs";
+import { tmpdir } from "os";
+import { basename, dirname, extname, resolve } from "path";
+function isWindowsTarget(target) {
+  const platform = target?.platform ?? process.platform;
+  return platform === "win32" || platform === "windows" || target?.triple?.includes("windows") === true;
+}
+function targetPlatform(target) {
+  return target?.platform || process.platform;
+}
+function targetArch(target) {
+  return target?.arch || process.arch;
+}
+function nativeBuildManifestPath(outputPath) {
+  return `${outputPath}.build-manifest.json`;
+}
+function temporaryOutputPath(outputPath, name = basename(outputPath)) {
+  const suffix = extname(name);
+  const stem = suffix ? name.slice(0, -suffix.length) : name;
+  return resolve(dirname(outputPath), `.${stem}-${process.pid}-${Date.now()}-${Math.random().toString(36).slice(2)}${suffix}`);
+}
+function publishNativeBinary(tempOutputPath, outputPath) {
+  try {
+    renameSync(tempOutputPath, outputPath);
+  } catch (error) {
+    if (process.platform === "win32" && existsSync(outputPath)) {
+      rmSync(outputPath, { force: true });
+      renameSync(tempOutputPath, outputPath);
+      return;
+    }
+    throw error;
+  }
+}
+async function sha256File(path) {
+  const hasher = new Bun.CryptoHasher("sha256");
+  hasher.update(await Bun.file(path).arrayBuffer());
+  return hasher.digest("hex");
+}
+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;
+  }
+}
+function artifact(name, path, kind, target) {
+  const base = { name, path, kind };
+  return target ? { ...base, target } : base;
+}
+function envKey(name) {
+  return name.replace(/\.exe$/i, "").replace(/[^A-Za-z0-9]+/g, "_").replace(/^_+|_+$/g, "").toUpperCase();
+}
+function nativePackageBinaryCandidates(fromDir, fileName, target) {
+  const candidates = [];
+  let cursor = resolve(fromDir);
+  const tag = `${targetPlatform(target)}-${targetArch(target)}`;
+  for (let index = 0;index < 8; index += 1) {
+    candidates.push(resolve(cursor, "native", tag, fileName), resolve(cursor, "native", tag, "bin", fileName), resolve(cursor, "native", fileName), resolve(cursor, "native", "bin", fileName));
+    const parent = dirname(cursor);
+    if (parent === cursor)
+      break;
+    cursor = parent;
+  }
+  return candidates;
+}
+async function copyMaterializedBinary(input) {
+  mkdirSync(dirname(input.targetPath), { recursive: true });
+  const sourceDigest = await sha256File(input.sourcePath);
+  const buildKey = JSON.stringify({ version: 1, sourcePath: input.sourcePath, sourceDigest });
+  const manifestPath = nativeBuildManifestPath(input.targetPath);
+  const needsCopy = !existsSync(input.targetPath) || !await hasMatchingNativeBuildManifest(manifestPath, buildKey);
+  if (needsCopy) {
+    copyFileSync(input.sourcePath, input.targetPath);
+    if (input.kind === "executable")
+      chmodSync(input.targetPath, 493);
+    await Bun.write(manifestPath, `${JSON.stringify({ version: 1, buildKey }, null, 2)}
+`);
+  } else if (input.kind === "executable") {
+    chmodSync(input.targetPath, 493);
+  }
+  return artifact(input.name, input.targetPath, input.kind, input.target);
+}
+function nativeBinaryFileName(name, kind, target) {
+  if (kind === "executable" && isWindowsTarget(target) && !name.toLowerCase().endsWith(".exe")) {
+    return `${name}.exe`;
+  }
+  return name;
+}
+function inferBinaryKind(nameOrPath) {
+  const lower = nameOrPath.toLowerCase();
+  return lower.endsWith(".so") || lower.endsWith(".dylib") || lower.endsWith(".dll") ? "dynamic-library" : "executable";
+}
+function nativeBinaryCandidates(name, target) {
+  const key = envKey(name);
+  const kind = inferBinaryKind(name);
+  const fileName = nativeBinaryFileName(name, kind, target);
+  const execDir = process.execPath?.trim() ? dirname(process.execPath.trim()) : "";
+  return [...new Set([
+    process.env[`RIG_NATIVE_${key}_BIN`]?.trim() || "",
+    ...nativePackageBinaryCandidates(import.meta.dir, fileName, target),
+    execDir ? resolve(execDir, fileName) : "",
+    execDir ? resolve(execDir, "..", fileName) : "",
+    execDir ? resolve(execDir, "..", "bin", fileName) : "",
+    resolve(sharedNativeOutputDir, `${name}-${targetPlatform(target)}-${targetArch(target)}${kind === "executable" && isWindowsTarget(target) ? ".exe" : ""}`)
+  ].filter(Boolean))];
+}
+function resolveNativeBinaryPath(name, target) {
+  for (const candidate of nativeBinaryCandidates(name, target)) {
+    if (candidate && existsSync(candidate))
+      return candidate;
+  }
+  return null;
+}
+function resolveNativeSourcePath(name) {
+  const value = process.env[`RIG_NATIVE_${envKey(name)}_SOURCE`]?.trim() || "";
+  return value && existsSync(value) ? value : null;
+}
+function genericBuildCommand(input, tempOutputPath, zigBinary) {
+  const mode = input.kind === "dynamic-library" ? "build-lib" : "build-exe";
+  const defines = Object.entries(input.defines ?? {}).flatMap(([key, value]) => [`-D${key}=${value}`]);
+  return [
+    zigBinary,
+    mode,
+    input.sourcePath,
+    ...input.kind === "dynamic-library" ? ["-dynamic"] : [],
+    "-O",
+    "ReleaseFast",
+    ...input.target?.triple ? ["-target", input.target.triple] : [],
+    ...input.buildArgs ?? [],
+    ...defines,
+    `-femit-bin=${tempOutputPath}`
+  ];
+}
+async function buildNativeBinary(input) {
+  if (!existsSync(input.sourcePath))
+    throw new Error(`Native source file not found: ${input.sourcePath}`);
+  const zigBinary = Bun.which("zig");
+  if (!zigBinary)
+    throw new Error("zig is required to build native binaries.");
+  mkdirSync(dirname(input.outputPath), { recursive: true });
+  const sourceDigest = await sha256File(input.sourcePath);
+  const buildKey = JSON.stringify({
+    version: 1,
+    zigBinary,
+    name: input.name,
+    kind: input.kind,
+    platform: targetPlatform(input.target),
+    arch: targetArch(input.target),
+    sourcePath: input.sourcePath,
+    sourceDigest,
+    buildArgs: input.buildArgs ?? [],
+    defines: input.defines ?? {},
+    triple: input.target?.triple ?? ""
+  });
+  const manifestPath = nativeBuildManifestPath(input.outputPath);
+  if (existsSync(input.outputPath) && await hasMatchingNativeBuildManifest(manifestPath, buildKey)) {
+    if (input.kind === "executable")
+      chmodSync(input.outputPath, 493);
+    return artifact(input.name, input.outputPath, input.kind, input.target);
+  }
+  const tempOutputPath = temporaryOutputPath(input.outputPath);
+  const build = Bun.spawn(genericBuildCommand(input, tempOutputPath, zigBinary), {
+    cwd: dirname(input.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(tempOutputPath)) {
+    const details = [stderr.trim(), stdout.trim()].filter(Boolean).join(`
+`);
+    throw new Error(`Failed to build native binary ${input.name}: ${details || `zig exited with code ${exitCode}`}`);
+  }
+  if (input.kind === "executable")
+    chmodSync(tempOutputPath, 493);
+  publishNativeBinary(tempOutputPath, input.outputPath);
+  await Bun.write(manifestPath, `${JSON.stringify({ version: 1, buildKey }, null, 2)}
+`);
+  return artifact(input.name, input.outputPath, input.kind, input.target);
+}
+var sharedNativeOutputDir, binaryBuildService;
+var init_git_binary = __esm(() => {
+  sharedNativeOutputDir = resolve(tmpdir(), "rig-native");
+  binaryBuildService = {
+    buildNativeBinary,
+    async materializeNativeBinary(input) {
+      const kind = inferBinaryKind(input.name);
+      const targetPath = resolve(input.targetDir, nativeBinaryFileName(input.name, kind, input.target));
+      const sourcePath = resolveNativeBinaryPath(input.name, input.target);
+      if (sourcePath) {
+        return copyMaterializedBinary({
+          name: input.name,
+          sourcePath,
+          targetPath,
+          kind,
+          ...input.target ? { target: input.target } : {}
+        });
+      }
+      const source = resolveNativeSourcePath(input.name);
+      if (source) {
+        return buildNativeBinary({
+          projectRoot: input.projectRoot,
+          name: input.name,
+          sourcePath: source,
+          outputPath: targetPath,
+          kind,
+          ...input.target ? { target: input.target } : {}
+        });
+      }
+      throw new Error(`Native binary ${input.name} was not found; set RIG_NATIVE_${envKey(input.name)}_BIN or RIG_NATIVE_${envKey(input.name)}_SOURCE.`);
+    }
+  };
+});
+
+// packages/native-toolchain-plugin/src/plugin.ts
+import { defineCapability } from "@rig/core/capability";
+import { definePlugin } from "@rig/core/config";
+import { NATIVE_TOOLCHAIN_BINARY_BUILD } from "@rig/contracts";
+var NATIVE_TOOLCHAIN_PLUGIN_NAME = "@rig/native-toolchain-plugin";
+var NativeToolchainBinaryBuildCap = defineCapability(NATIVE_TOOLCHAIN_BINARY_BUILD);
+var nativeToolchainPlugin = definePlugin({
+  name: NATIVE_TOOLCHAIN_PLUGIN_NAME,
+  version: "0.0.0-alpha.1",
+  contributes: {
+    capabilities: [
+      NativeToolchainBinaryBuildCap.provide(async () => (await Promise.resolve().then(() => (init_git_binary(), exports_git_binary))).binaryBuildService, {
+        title: "Native binary build/materialization",
+        description: "Build or materialize Rig-owned native binaries without repo/task semantics."
+      })
+    ]
+  }
+});
+function createNativeToolchainPlugin() {
+  return nativeToolchainPlugin;
+}
+var plugin_default = nativeToolchainPlugin;
+export {
+  nativeToolchainPlugin,
+  plugin_default as default,
+  createNativeToolchainPlugin,
+  NATIVE_TOOLCHAIN_PLUGIN_NAME
+};

package/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "@h-rig/native-toolchain-plugin",
+  "version": "0.0.0-e2e-live.20260630085347",
+  "type": "module",
+  "description": "First-party mechanical native binary toolchain capability plugin for Rig.",
+  "license": "UNLICENSED",
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/src/plugin.d.ts",
+      "import": "./dist/src/plugin.js"
+    },
+    "./plugin": {
+      "types": "./dist/src/plugin.d.ts",
+      "import": "./dist/src/plugin.js"
+    },
+    "./git-binary": {
+      "types": "./dist/src/git-binary.d.ts",
+      "import": "./dist/src/git-binary.js"
+    }
+  },
+  "engines": {
+    "bun": ">=1.3.11"
+  },
+  "dependencies": {
+    "@rig/contracts": "npm:@h-rig/contracts@0.0.0-e2e-live.20260630085347",
+    "@rig/core": "npm:@h-rig/core@0.0.0-e2e-live.20260630085347"
+  }
+}