@h-rig/runtime 0.0.6-alpha.0

package/dist/src/control-plane/runtime/isolation/shared.js

@@ -0,0 +1,501 @@
+// @bun
+// packages/runtime/src/control-plane/runtime/isolation/shared.ts
+import { existsSync as existsSync3, readFileSync, rmSync as rmSync2 } from "fs";
+import { resolve as resolve3 } from "path";
+import { randomUUID } from "crypto";
+
+// packages/runtime/src/layout.ts
+import { existsSync } from "fs";
+import { basename, dirname, resolve } from "path";
+function resolveMonorepoRoot(projectRoot) {
+  const normalizedProjectRoot = resolve(projectRoot);
+  const explicit = process.env.MONOREPO_ROOT?.trim();
+  if (explicit) {
+    const explicitRoot = resolve(explicit);
+    const explicitParent = dirname(explicitRoot);
+    if (basename(explicitParent) === ".worktrees") {
+      const owner = dirname(explicitParent);
+      const ownerHasGit = existsSync(resolve(owner, ".git"));
+      const ownerHasTaskConfig = existsSync(resolve(owner, ".rig", "task-config.json"));
+      const ownerHasRigConfig = existsSync(resolve(owner, "rig.config.ts"));
+      if (ownerHasGit && (ownerHasTaskConfig || ownerHasRigConfig)) {
+        return owner;
+      }
+      throw new Error(`MONOREPO_ROOT points to worktree ${explicitRoot}, but the owner checkout is incomplete at ${owner}.`);
+    }
+    if (!existsSync(resolve(explicitRoot, ".git"))) {
+      throw new Error(`MONOREPO_ROOT points to ${explicitRoot}, but no git checkout was found there.`);
+    }
+    const hasTaskConfig = existsSync(resolve(explicitRoot, ".rig", "task-config.json"));
+    const hasRigConfig = existsSync(resolve(explicitRoot, "rig.config.ts"));
+    if (!hasTaskConfig && !hasRigConfig) {
+      throw new Error(`MONOREPO_ROOT points to ${explicitRoot}, but neither .rig/task-config.json nor rig.config.ts exists there.`);
+    }
+    return explicitRoot;
+  }
+  const projectParent = dirname(normalizedProjectRoot);
+  if (basename(projectParent) === ".worktrees") {
+    const worktreeOwner = dirname(projectParent);
+    const ownerHasGit = existsSync(resolve(worktreeOwner, ".git"));
+    const ownerHasTaskConfig = existsSync(resolve(worktreeOwner, ".rig", "task-config.json"));
+    const ownerHasRigConfig = existsSync(resolve(worktreeOwner, "rig.config.ts"));
+    if (ownerHasGit && (ownerHasTaskConfig || ownerHasRigConfig)) {
+      return worktreeOwner;
+    }
+  }
+  return normalizedProjectRoot;
+}
+
+// packages/runtime/src/control-plane/native/runtime-native.ts
+import { dlopen, ptr, suffix, toBuffer } from "bun:ffi";
+import { copyFileSync, existsSync as existsSync2, mkdirSync, renameSync, rmSync, statSync } from "fs";
+import { tmpdir } from "os";
+import { dirname as dirname2, resolve as resolve2 } from "path";
+var sharedNativeRuntimeOutputDir = resolve2(tmpdir(), "rig-native");
+var sharedNativeRuntimeOutputPath = resolve2(sharedNativeRuntimeOutputDir, `runtime-native-${process.platform}-${process.arch}.${suffix}`);
+var colocatedNativeRuntimeFileName = `runtime-native.${suffix}`;
+var nativeRuntimeLibrary = await loadNativeRuntimeLibrary();
+async function ensureNativeRuntimeLibraryPath(outputPath = sharedNativeRuntimeOutputPath, options = {}) {
+  if (await buildNativeRuntimeLibrary(outputPath, options)) {
+    return outputPath;
+  }
+  return !options.force && existsSync2(outputPath) ? outputPath : null;
+}
+async function loadNativeRuntimeLibrary() {
+  if (process.env.RIG_DISABLE_ZIG_NATIVE === "1") {
+    return null;
+  }
+  for (const candidate of nativeRuntimeLibraryCandidates()) {
+    if (!candidate || !existsSync2(candidate)) {
+      continue;
+    }
+    const loaded = tryDlopenNativeRuntimeLibrary(candidate);
+    if (loaded) {
+      return loaded;
+    }
+  }
+  const builtLibraryPath = await ensureNativeRuntimeLibraryPath(sharedNativeRuntimeOutputPath, { force: true });
+  if (!builtLibraryPath) {
+    return null;
+  }
+  return tryDlopenNativeRuntimeLibrary(builtLibraryPath);
+}
+function nativePackageLibraryCandidates(fromDir, names) {
+  const candidates = [];
+  let cursor = resolve2(fromDir);
+  for (let index = 0;index < 8; index += 1) {
+    for (const name of names) {
+      candidates.push(resolve2(cursor, "native", `${process.platform}-${process.arch}`, name), resolve2(cursor, "native", `${process.platform}-${process.arch}`, "lib", name), resolve2(cursor, "native", name), resolve2(cursor, "native", "lib", name));
+    }
+    const parent = dirname2(cursor);
+    if (parent === cursor)
+      break;
+    cursor = parent;
+  }
+  return candidates;
+}
+function nativeRuntimeLibraryCandidates() {
+  const explicit = process.env.RIG_NATIVE_RUNTIME_LIB?.trim() || "";
+  const execDir = process.execPath?.trim() ? dirname2(process.execPath.trim()) : "";
+  const platformSpecific = `runtime-native-${process.platform}-${process.arch}.${suffix}`;
+  return [...new Set([
+    explicit,
+    ...nativePackageLibraryCandidates(import.meta.dir, [colocatedNativeRuntimeFileName, platformSpecific]),
+    execDir ? resolve2(execDir, colocatedNativeRuntimeFileName) : "",
+    execDir ? resolve2(execDir, platformSpecific) : "",
+    execDir ? resolve2(execDir, "..", colocatedNativeRuntimeFileName) : "",
+    execDir ? resolve2(execDir, "..", platformSpecific) : "",
+    execDir ? resolve2(execDir, "lib", colocatedNativeRuntimeFileName) : "",
+    execDir ? resolve2(execDir, "..", "lib", colocatedNativeRuntimeFileName) : "",
+    sharedNativeRuntimeOutputPath
+  ].filter(Boolean))];
+}
+function resolveNativeRuntimeSourcePath() {
+  const explicit = process.env.RIG_NATIVE_RUNTIME_SOURCE?.trim();
+  if (explicit && existsSync2(explicit)) {
+    return explicit;
+  }
+  const bundled = resolve2(import.meta.dir, "../../../native/snapshot.zig");
+  return existsSync2(bundled) ? bundled : null;
+}
+async function buildNativeRuntimeLibrary(outputPath, options = {}) {
+  if (process.env.RIG_DISABLE_ZIG_NATIVE === "1") {
+    return false;
+  }
+  const zigBinary = Bun.which("zig");
+  const sourcePath = resolveNativeRuntimeSourcePath();
+  if (!zigBinary || !sourcePath) {
+    return false;
+  }
+  const tempOutputPath = `${outputPath}.${process.pid}.${Date.now()}.${Math.random().toString(36).slice(2)}.tmp`;
+  try {
+    mkdirSync(dirname2(outputPath), { recursive: true });
+    const needsBuild = options.force === true || !existsSync2(outputPath) || statSync(sourcePath).mtimeMs > statSync(outputPath).mtimeMs;
+    if (!needsBuild) {
+      return true;
+    }
+    const build = Bun.spawn([
+      zigBinary,
+      "build-lib",
+      sourcePath,
+      "-dynamic",
+      "-O",
+      "ReleaseFast",
+      `-femit-bin=${tempOutputPath}`
+    ], {
+      cwd: import.meta.dir,
+      stdout: "pipe",
+      stderr: "pipe"
+    });
+    const exitCode = await build.exited;
+    if (exitCode !== 0 || !existsSync2(tempOutputPath)) {
+      rmSync(tempOutputPath, { force: true });
+      return false;
+    }
+    renameSync(tempOutputPath, outputPath);
+    return true;
+  } catch {
+    rmSync(tempOutputPath, { force: true });
+    return false;
+  }
+}
+function tryDlopenNativeRuntimeLibrary(outputPath) {
+  try {
+    return dlopen(outputPath, {
+      rig_scope_match: {
+        args: ["ptr", "ptr"],
+        returns: "u8"
+      },
+      snapshot_capture: {
+        args: ["ptr", "u64", "ptr", "u64"],
+        returns: "ptr"
+      },
+      snapshot_delta: {
+        args: ["ptr", "ptr"],
+        returns: "ptr"
+      },
+      snapshot_store_delta: {
+        args: ["ptr", "ptr", "ptr", "u64", "ptr", "u64", "ptr", "u64", "ptr", "u64"],
+        returns: "ptr"
+      },
+      snapshot_inspect_delta: {
+        args: ["ptr", "u64"],
+        returns: "ptr"
+      },
+      snapshot_apply_delta: {
+        args: ["ptr", "u64", "ptr", "u64"],
+        returns: "ptr"
+      },
+      snapshot_release: {
+        args: ["ptr"],
+        returns: "void"
+      },
+      runtime_hash_file: {
+        args: ["ptr", "u64"],
+        returns: "ptr"
+      },
+      runtime_hash_tree: {
+        args: ["ptr", "u64"],
+        returns: "ptr"
+      },
+      runtime_prepare_paths: {
+        args: ["ptr", "u64", "ptr", "u64", "ptr", "u64", "ptr", "u64", "ptr", "u64"],
+        returns: "ptr"
+      },
+      runtime_link_dependency_layer: {
+        args: ["ptr", "u64", "ptr", "u64"],
+        returns: "ptr"
+      },
+      runtime_scan_worktrees: {
+        args: ["ptr", "u64"],
+        returns: "ptr"
+      }
+    });
+  } catch {
+    return null;
+  }
+}
+
+// packages/runtime/src/control-plane/native/utils.ts
+function resolveMonorepoRoot2(projectRoot) {
+  return resolveMonorepoRoot(projectRoot);
+}
+var scopeRegexCache = new Map;
+
+// packages/runtime/src/control-plane/runtime/isolation/shared.ts
+var generatedCredentialFiles = new Set;
+var credentialCleanupRegistered = false;
+function resolveMonorepoRoot3(projectRoot) {
+  return resolveMonorepoRoot2(projectRoot);
+}
+function isRuntimeGatewayGitPath(candidate) {
+  return /\/\.rig\/bin\/git$/.test(candidate.replace(/\\/g, "/"));
+}
+function resolveHostGitBinary() {
+  const candidates = [
+    process.env.RIG_GIT_BIN?.trim() || "",
+    "/usr/bin/git",
+    "/opt/homebrew/bin/git",
+    "/usr/local/bin/git"
+  ];
+  const bunResolved = Bun.which("git");
+  if (bunResolved && !isRuntimeGatewayGitPath(bunResolved)) {
+    candidates.push(bunResolved);
+  }
+  for (const candidate of candidates) {
+    if (!candidate || isRuntimeGatewayGitPath(candidate)) {
+      continue;
+    }
+    if (existsSync3(candidate)) {
+      return candidate;
+    }
+  }
+  return "git";
+}
+async function runGitCommand(repoRoot, args) {
+  const gitBinary = resolveHostGitBinary();
+  return Bun.$`${gitBinary} -C ${repoRoot} ${args}`.quiet().nothrow();
+}
+async function readGitConfigValue(repoRoot, key, global = false) {
+  const args = ["config", ...global ? ["--global"] : [], "--get", key];
+  const result = await runGitCommand(repoRoot, args);
+  if (result.exitCode !== 0) {
+    return "";
+  }
+  return String(result.stdout).trim();
+}
+async function readGitStdout(repoRoot, args) {
+  const result = await runGitCommand(repoRoot, args);
+  if (result.exitCode !== 0) {
+    throw new Error(`git -C ${repoRoot} ${args.join(" ")} failed: ${result.stderr || result.stdout}`);
+  }
+  return String(result.stdout).trim();
+}
+async function hasGitRemote(repoRoot, remote) {
+  const result = await runGitCommand(repoRoot, ["remote", "get-url", remote]);
+  return result.exitCode === 0;
+}
+async function ensureFullGitHistory(repoRoot) {
+  const shallow = await runGitCommand(repoRoot, ["rev-parse", "--is-shallow-repository"]);
+  if (shallow.exitCode !== 0 || String(shallow.stdout).trim() !== "true") {
+    return;
+  }
+  const unshallow = await runGitCommand(repoRoot, ["fetch", "--unshallow", "--tags", "origin"]);
+  if (unshallow.exitCode === 0) {
+    return;
+  }
+  const output = `${unshallow.stderr}
+${unshallow.stdout}`.trim();
+  if (/--unshallow on a complete repository|does not make sense/i.test(output)) {
+    return;
+  }
+  throw new Error(`Failed to expand git history for ${repoRoot}: ${output}`);
+}
+async function refreshOriginMain(repoRoot) {
+  await refreshRemoteBranch(repoRoot, "origin", "main");
+}
+async function refreshRemoteBranch(repoRoot, remote, branch) {
+  if (!await hasGitRemote(repoRoot, remote)) {
+    return;
+  }
+  try {
+    await ensureFullGitHistory(repoRoot);
+    const fetch = await runGitCommand(repoRoot, [
+      "fetch",
+      "--prune",
+      "--tags",
+      remote,
+      `+refs/heads/${branch}:refs/remotes/${remote}/${branch}`
+    ]);
+    if (fetch.exitCode !== 0) {
+      return;
+    }
+  } catch {
+    return;
+  }
+}
+async function tryReadGitHead(repoRoot) {
+  if (!existsSync3(resolve3(repoRoot, ".git"))) {
+    return;
+  }
+  const result = await runGitCommand(repoRoot, ["rev-parse", "HEAD"]);
+  if (result.exitCode !== 0) {
+    return;
+  }
+  const value = String(result.stdout).trim();
+  return value || undefined;
+}
+async function captureRepoDirtyFiles(repoRoot) {
+  if (!existsSync3(resolve3(repoRoot, ".git"))) {
+    return [];
+  }
+  const files = new Set;
+  for (const args of [
+    ["diff", "--name-only"],
+    ["diff", "--cached", "--name-only"],
+    ["ls-files", "--others", "--exclude-standard"]
+  ]) {
+    const result = await runGitCommand(repoRoot, args);
+    if (result.exitCode !== 0) {
+      continue;
+    }
+    for (const line of String(result.stdout).split(/\r?\n/)) {
+      const trimmed = line.trim();
+      if (trimmed) {
+        files.add(trimmed);
+      }
+    }
+  }
+  return [...files].sort();
+}
+function sha256Hex(input) {
+  const hasher = new Bun.CryptoHasher("sha256");
+  hasher.update(input);
+  return hasher.digest("hex");
+}
+function registerCredentialCleanup(path) {
+  generatedCredentialFiles.add(path);
+  if (credentialCleanupRegistered) {
+    return;
+  }
+  credentialCleanupRegistered = true;
+  const cleanup = () => {
+    for (const filePath of generatedCredentialFiles) {
+      try {
+        rmSync2(filePath, { force: true });
+      } catch {}
+    }
+    generatedCredentialFiles.clear();
+  };
+  process.on("exit", cleanup);
+  process.on("beforeExit", cleanup);
+}
+async function captureStdout(fn) {
+  const chunks = [];
+  const originalWrite = process.stdout.write.bind(process.stdout);
+  const originalLog = console.log;
+  const originalError = console.error;
+  process.stdout.write = (chunk, encoding, cb) => {
+    chunks.push(typeof chunk === "string" ? chunk : Buffer.from(chunk).toString(typeof encoding === "string" ? encoding : undefined));
+    const callback = typeof encoding === "function" ? encoding : cb;
+    callback?.(null);
+    return true;
+  };
+  console.log = (...args) => {
+    chunks.push(`${args.map((value) => String(value)).join(" ")}
+`);
+  };
+  console.error = (...args) => {
+    chunks.push(`${args.map((value) => String(value)).join(" ")}
+`);
+  };
+  try {
+    await fn();
+    return chunks.join("");
+  } finally {
+    process.stdout.write = originalWrite;
+    console.log = originalLog;
+    console.error = originalError;
+  }
+}
+function sanitizeRuntimeRefSegment(value) {
+  const sanitized = value.trim().replace(/[^A-Za-z0-9._-]+/g, "-").replace(/^-+|-+$/g, "");
+  return (sanitized || "runtime").slice(0, 64);
+}
+function runtimeBranchBackupName(branch) {
+  const branchId = branch.replace(/^rig\//, "");
+  return `rig-backup/${sanitizeRuntimeRefSegment(branchId)}-${Date.now()}`;
+}
+function agentId(prefix = "agent") {
+  return `${prefix}-${randomUUID().slice(0, 8)}`;
+}
+function taskRuntimeId(taskId) {
+  return `task-${taskId}`;
+}
+function hashProjectPath(workspaceDir) {
+  return sha256Hex(workspaceDir).slice(0, 16);
+}
+function resolveGithubCliBinaryPath() {
+  const explicit = process.env.RIG_GH_BIN?.trim();
+  if (explicit && existsSync3(explicit)) {
+    return explicit;
+  }
+  const bunResolved = Bun.which("gh");
+  if (bunResolved && existsSync3(bunResolved)) {
+    return bunResolved;
+  }
+  for (const candidate of ["/opt/homebrew/bin/gh", "/usr/local/bin/gh", "/usr/bin/gh"]) {
+    if (existsSync3(candidate)) {
+      return candidate;
+    }
+  }
+  return "";
+}
+async function resolveGithubCliAuthToken(ghBinary = "") {
+  const gh = ghBinary || resolveGithubCliBinaryPath();
+  if (!gh) {
+    return "";
+  }
+  const auth = Bun.spawn([gh, "auth", "token"], {
+    stdout: "pipe",
+    stderr: "pipe"
+  });
+  const [exitCode, stdout] = await Promise.all([
+    auth.exited,
+    new Response(auth.stdout).text()
+  ]);
+  if (exitCode !== 0) {
+    return "";
+  }
+  return stdout.trim();
+}
+function resolveSystemCertBundlePath() {
+  const candidates = [
+    process.env.SSL_CERT_FILE?.trim(),
+    "/etc/ssl/cert.pem",
+    "/private/etc/ssl/cert.pem",
+    "/opt/homebrew/etc/openssl@3/cert.pem"
+  ];
+  for (const candidate of candidates) {
+    if (candidate && existsSync3(candidate)) {
+      return resolve3(candidate);
+    }
+  }
+  return "";
+}
+var __testOnly = {
+  cleanupGeneratedCredentialFiles() {
+    generatedCredentialFiles.clear();
+  }
+};
+function readKnownHosts(path) {
+  if (!existsSync3(path)) {
+    return new Set;
+  }
+  return new Set(readFileSync(path, "utf-8").split(/\r?\n/).map((line) => line.trim()).filter(Boolean));
+}
+export {
+  tryReadGitHead,
+  taskRuntimeId,
+  sha256Hex,
+  sanitizeRuntimeRefSegment,
+  runtimeBranchBackupName,
+  runGitCommand,
+  resolveSystemCertBundlePath,
+  resolveMonorepoRoot3 as resolveMonorepoRoot,
+  resolveGithubCliBinaryPath,
+  resolveGithubCliAuthToken,
+  registerCredentialCleanup,
+  refreshRemoteBranch,
+  refreshOriginMain,
+  readKnownHosts,
+  readGitStdout,
+  readGitConfigValue,
+  hashProjectPath,
+  hasGitRemote,
+  ensureFullGitHistory,
+  captureStdout,
+  captureRepoDirtyFiles,
+  agentId,
+  __testOnly
+};