@h-rig/runtime 0.0.6-alpha.0

package/dist/src/control-plane/project-main-pre-run-sync.js

@@ -0,0 +1,630 @@
+// @bun
+// 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
+var scopeRegexCache = new Map;
+function runCapture(command, cwd, env) {
+  const result = Bun.spawnSync(command, {
+    cwd,
+    env: env ? { ...process.env, ...env } : process.env,
+    stdout: "pipe",
+    stderr: "pipe"
+  });
+  return {
+    exitCode: result.exitCode,
+    stdout: result.stdout.toString(),
+    stderr: result.stderr.toString()
+  };
+}
+
+// packages/runtime/src/control-plane/repos/registry.ts
+var MANAGED_REPOS = new Map;
+function getManagedRepoEntry(repoId) {
+  const entry = MANAGED_REPOS.get(repoId);
+  if (!entry) {
+    throw new Error(`managed repo not registered: ${repoId}. Plugins contribute repos via RigPlugin.contributes.repoSources; ` + `make sure a plugin declares this id and the plugin host has been initialized.`);
+  }
+  return entry;
+}
+function listManagedRepoEntries() {
+  return Array.from(MANAGED_REPOS.values());
+}
+// packages/runtime/src/control-plane/repos/layout.ts
+import { existsSync as existsSync3 } from "fs";
+import { basename as basename2, dirname as dirname3, join, resolve as resolve3 } from "path";
+function resolveRepoStateDir(projectRoot) {
+  const normalizedProjectRoot = resolve3(projectRoot);
+  const projectParent = dirname3(normalizedProjectRoot);
+  if (basename2(projectParent) === ".worktrees") {
+    const ownerRoot = dirname3(projectParent);
+    const ownerHasRepoMarkers = existsSync3(resolve3(ownerRoot, ".git")) || existsSync3(resolve3(ownerRoot, ".rig", "state"));
+    if (ownerHasRepoMarkers) {
+      return resolve3(ownerRoot, ".rig", "state");
+    }
+  }
+  return resolve3(projectRoot, ".rig", "state");
+}
+function resolveManagedRepoLayout(projectRoot, repoId) {
+  const normalizedProjectRoot = resolve3(projectRoot);
+  const entry = getManagedRepoEntry(repoId);
+  const stateDir = resolveRepoStateDir(normalizedProjectRoot);
+  const metadataRelativePath = join("repos", entry.id);
+  const metadataRoot = resolve3(stateDir, metadataRelativePath);
+  const runtimeWorkspace = process.env.RIG_TASK_WORKSPACE?.trim();
+  const runsInsideTaskWorktree = runtimeWorkspace && resolve3(runtimeWorkspace) === normalizedProjectRoot || basename2(dirname3(normalizedProjectRoot)) === ".worktrees";
+  const isPrimaryManagedRepo = listManagedRepoEntries()[0]?.id === repoId;
+  const checkoutRoot = isPrimaryManagedRepo && runsInsideTaskWorktree ? resolveMonorepoRoot(normalizedProjectRoot) : entry.checkoutEnvVar && process.env[entry.checkoutEnvVar]?.trim() ? resolve3(process.env[entry.checkoutEnvVar].trim()) : resolve3(normalizedProjectRoot, entry.alias);
+  return {
+    projectRoot: normalizedProjectRoot,
+    repoId: entry.id,
+    alias: entry.alias,
+    defaultBranch: entry.defaultBranch,
+    remoteUrl: entry.remoteEnvVar && process.env[entry.remoteEnvVar]?.trim() ? process.env[entry.remoteEnvVar].trim() : entry.defaultRemoteUrl,
+    checkoutRoot,
+    worktreesRoot: resolve3(checkoutRoot, ".worktrees"),
+    stateDir,
+    metadataRoot,
+    metadataRelativePath,
+    mirrorRoot: resolve3(metadataRoot, "mirror.git"),
+    mirrorStatePath: resolve3(metadataRoot, "mirror-state.json"),
+    mirrorStateRelativePath: join(metadataRelativePath, "mirror-state.json")
+  };
+}
+// packages/runtime/src/control-plane/repos/mirror/bootstrap.ts
+import { existsSync as existsSync5, mkdirSync as mkdirSync3, realpathSync } from "fs";
+import { resolve as resolve5 } from "path";
+
+// packages/runtime/src/control-plane/authority-files.ts
+import { existsSync as existsSync4, mkdirSync as mkdirSync2, readFileSync, writeFileSync, appendFileSync, copyFileSync as copyFileSync2, statSync as statSync2, readdirSync, chmodSync } from "fs";
+import { dirname as dirname4, join as join2, relative, resolve as resolve4 } from "path";
+import { parse as parseToml, stringify as stringifyToml } from "smol-toml";
+function resolveAuthorityProjectStateDir(projectRoot) {
+  const explicit = process.env.RIG_STATE_DIR?.trim();
+  if (explicit) {
+    return resolve4(explicit);
+  }
+  return resolve4(resolve4(projectRoot), ".rig", "state");
+}
+function readJsonAtPath(path, fallback) {
+  if (!existsSync4(path)) {
+    return fallback;
+  }
+  try {
+    return JSON.parse(readFileSync(path, "utf-8"));
+  } catch {
+    return fallback;
+  }
+}
+function writeJsonAtPath(path, value) {
+  mkdirSync2(dirname4(path), { recursive: true });
+  writeFileSync(path, `${JSON.stringify(value, null, 2)}
+`, "utf8");
+  return path;
+}
+function readAuthorityProjectStateJson(projectRoot, relativePath, fallback) {
+  return readJsonAtPath(resolve4(resolveAuthorityProjectStateDir(projectRoot), relativePath), fallback);
+}
+function writeAuthorityProjectStateJson(projectRoot, relativePath, value) {
+  return writeJsonAtPath(resolve4(resolveAuthorityProjectStateDir(projectRoot), relativePath), value);
+}
+
+// packages/runtime/src/control-plane/repos/mirror/state.ts
+var STATE_VERSION = 1;
+function defaultMirrorState(projectRoot, repoId) {
+  const layout = resolveManagedRepoLayout(projectRoot, repoId);
+  return {
+    version: STATE_VERSION,
+    repoId,
+    remoteUrl: layout.remoteUrl,
+    defaultBranch: layout.defaultBranch
+  };
+}
+function readManagedRepoMirrorState(projectRoot, repoId) {
+  const layout = resolveManagedRepoLayout(projectRoot, repoId);
+  return readAuthorityProjectStateJson(projectRoot, layout.mirrorStateRelativePath, null);
+}
+function writeManagedRepoMirrorState(projectRoot, repoId, patch) {
+  const current = readManagedRepoMirrorState(projectRoot, repoId) || defaultMirrorState(projectRoot, repoId);
+  const next = {
+    ...current,
+    ...patch,
+    version: STATE_VERSION,
+    repoId
+  };
+  const layout = resolveManagedRepoLayout(projectRoot, repoId);
+  writeAuthorityProjectStateJson(projectRoot, layout.mirrorStateRelativePath, next);
+  return next;
+}
+
+// packages/runtime/src/control-plane/repos/mirror/bootstrap.ts
+function nowIso() {
+  return new Date().toISOString();
+}
+function runGit(command, cwd) {
+  const result = Bun.spawnSync(command, {
+    cwd,
+    stdout: "pipe",
+    stderr: "pipe",
+    env: process.env
+  });
+  return {
+    exitCode: result.exitCode,
+    stdout: result.stdout.toString(),
+    stderr: result.stderr.toString()
+  };
+}
+function ensureGitSuccess(result, command) {
+  if (result.exitCode !== 0) {
+    throw new Error(result.stderr || result.stdout || `git command failed: ${command.join(" ")}`);
+  }
+}
+function isUsableRemoteUrl(candidate, layout) {
+  return candidate.length > 0 && candidate !== layout.mirrorRoot && candidate !== layout.checkoutRoot;
+}
+function sameExistingPath(left, right) {
+  try {
+    return realpathSync(left) === realpathSync(right);
+  } catch {
+    return resolve5(left) === resolve5(right);
+  }
+}
+function repoLooksUsable(repoRoot, projectRoot) {
+  const probe = runGit(["git", "-C", repoRoot, "rev-parse", "--show-toplevel"], projectRoot);
+  return probe.exitCode === 0 && sameExistingPath(probe.stdout.trim(), repoRoot);
+}
+function checkoutLooksUsable(layout) {
+  return repoLooksUsable(layout.checkoutRoot, layout.projectRoot);
+}
+function resolveMirrorRemoteUrl(layout) {
+  const entry = getManagedRepoEntry(layout.repoId);
+  const explicit = entry.remoteEnvVar ? process.env[entry.remoteEnvVar]?.trim() : "";
+  if (explicit) {
+    return explicit;
+  }
+  const persisted = readManagedRepoMirrorState(layout.projectRoot, layout.repoId)?.remoteUrl?.trim();
+  if (persisted && isUsableRemoteUrl(persisted, layout)) {
+    return persisted;
+  }
+  const mirrorOrigin = runGit(["git", "--git-dir", layout.mirrorRoot, "remote", "get-url", "origin"], layout.projectRoot);
+  if (mirrorOrigin.exitCode === 0) {
+    const currentOrigin = mirrorOrigin.stdout.trim();
+    if (isUsableRemoteUrl(currentOrigin, layout)) {
+      return currentOrigin;
+    }
+  }
+  if (repoLooksUsable(layout.projectRoot, layout.projectRoot)) {
+    const projectOrigin = runGit(["git", "-C", layout.projectRoot, "remote", "get-url", "origin"], layout.projectRoot);
+    if (projectOrigin.exitCode === 0) {
+      const currentOrigin = projectOrigin.stdout.trim();
+      if (isUsableRemoteUrl(currentOrigin, layout)) {
+        return currentOrigin;
+      }
+    }
+  }
+  if (existsSync5(resolve5(layout.checkoutRoot, ".git")) && checkoutLooksUsable(layout)) {
+    const checkoutOrigin = runGit(["git", "-C", layout.checkoutRoot, "remote", "get-url", "origin"], layout.projectRoot);
+    if (checkoutOrigin.exitCode === 0) {
+      const currentOrigin = checkoutOrigin.stdout.trim();
+      if (isUsableRemoteUrl(currentOrigin, layout)) {
+        return currentOrigin;
+      }
+    }
+  }
+  return layout.remoteUrl;
+}
+function ensureManagedRepoMirror(projectRoot, repoId) {
+  const layout = resolveManagedRepoLayout(projectRoot, repoId);
+  mkdirSync3(layout.metadataRoot, { recursive: true });
+  const remoteUrl = resolveMirrorRemoteUrl(layout);
+  if (!existsSync5(resolve5(layout.mirrorRoot, "HEAD"))) {
+    ensureGitSuccess(runGit(["git", "init", "--bare", layout.mirrorRoot], layout.projectRoot), ["git", "init", "--bare", layout.mirrorRoot]);
+  }
+  const getOrigin = runGit(["git", "--git-dir", layout.mirrorRoot, "remote", "get-url", "origin"], layout.projectRoot);
+  if (getOrigin.exitCode === 0) {
+    const currentOrigin = getOrigin.stdout.trim();
+    if (currentOrigin !== remoteUrl) {
+      ensureGitSuccess(runGit(["git", "--git-dir", layout.mirrorRoot, "remote", "set-url", "origin", remoteUrl], layout.projectRoot), ["git", "--git-dir", layout.mirrorRoot, "remote", "set-url", "origin", remoteUrl]);
+    }
+  } else {
+    ensureGitSuccess(runGit(["git", "--git-dir", layout.mirrorRoot, "remote", "add", "origin", remoteUrl], layout.projectRoot), ["git", "--git-dir", layout.mirrorRoot, "remote", "add", "origin", remoteUrl]);
+  }
+  writeManagedRepoMirrorState(projectRoot, repoId, {
+    remoteUrl,
+    defaultBranch: layout.defaultBranch,
+    initializedAt: nowIso()
+  });
+  return layout;
+}
+// packages/runtime/src/control-plane/repos/mirror/refresh.ts
+import { existsSync as existsSync6, mkdirSync as mkdirSync4, realpathSync as realpathSync2, rmSync as rmSync2 } from "fs";
+import { resolve as resolve6 } from "path";
+function nowIso2() {
+  return new Date().toISOString();
+}
+function runGit2(command, cwd) {
+  const result = Bun.spawnSync(command, {
+    cwd,
+    stdout: "pipe",
+    stderr: "pipe",
+    env: process.env
+  });
+  return {
+    exitCode: result.exitCode,
+    stdout: result.stdout.toString(),
+    stderr: result.stderr.toString()
+  };
+}
+function ensureGitSuccess2(result, command) {
+  if (result.exitCode !== 0) {
+    throw new Error(result.stderr || result.stdout || `git command failed: ${command.join(" ")}`);
+  }
+  return result.stdout.trim();
+}
+function sameExistingPath2(left, right) {
+  try {
+    return realpathSync2(left) === realpathSync2(right);
+  } catch {
+    return resolve6(left) === resolve6(right);
+  }
+}
+function ensureMirrorHead(layout) {
+  ensureGitSuccess2(runGit2([
+    "git",
+    "--git-dir",
+    layout.mirrorRoot,
+    "fetch",
+    "--prune",
+    "origin",
+    "+refs/heads/*:refs/heads/*",
+    "+refs/tags/*:refs/tags/*"
+  ], layout.projectRoot), [
+    "git",
+    "--git-dir",
+    layout.mirrorRoot,
+    "fetch",
+    "--prune",
+    "origin",
+    "+refs/heads/*:refs/heads/*",
+    "+refs/tags/*:refs/tags/*"
+  ]);
+  const headRef = `refs/heads/${layout.defaultBranch}`;
+  const headCommit = ensureGitSuccess2(runGit2(["git", "--git-dir", layout.mirrorRoot, "rev-parse", headRef], layout.projectRoot), ["git", "--git-dir", layout.mirrorRoot, "rev-parse", headRef]);
+  const remoteUrl = ensureGitSuccess2(runGit2(["git", "--git-dir", layout.mirrorRoot, "remote", "get-url", "origin"], layout.projectRoot), ["git", "--git-dir", layout.mirrorRoot, "remote", "get-url", "origin"]);
+  ensureGitSuccess2(runGit2(["git", "--git-dir", layout.mirrorRoot, "symbolic-ref", "HEAD", headRef], layout.projectRoot), ["git", "--git-dir", layout.mirrorRoot, "symbolic-ref", "HEAD", headRef]);
+  writeManagedRepoMirrorState(layout.projectRoot, layout.repoId, {
+    remoteUrl,
+    defaultBranch: layout.defaultBranch,
+    lastSyncedAt: nowIso2(),
+    headRef,
+    headCommit
+  });
+  return headCommit;
+}
+function refreshManagedRepoMirror(projectRoot, repoId) {
+  const layout = ensureManagedRepoMirror(projectRoot, repoId);
+  const headCommit = ensureMirrorHead(layout);
+  return { layout, headCommit };
+}
+function checkoutLooksUsable2(layout) {
+  const probe = runGit2(["git", "-C", layout.checkoutRoot, "rev-parse", "--show-toplevel"], layout.projectRoot);
+  return probe.exitCode === 0 && sameExistingPath2(probe.stdout.trim(), layout.checkoutRoot);
+}
+function ensureCheckoutFromMirror(layout) {
+  mkdirSync4(resolve6(layout.checkoutRoot, ".."), { recursive: true });
+  const gitPath = resolve6(layout.checkoutRoot, ".git");
+  if (existsSync6(layout.checkoutRoot) && (!existsSync6(gitPath) || !checkoutLooksUsable2(layout))) {
+    rmSync2(layout.checkoutRoot, { recursive: true, force: true });
+  }
+  if (!existsSync6(gitPath)) {
+    ensureGitSuccess2(runGit2(["git", "clone", layout.mirrorRoot, layout.checkoutRoot], layout.projectRoot), ["git", "clone", layout.mirrorRoot, layout.checkoutRoot]);
+  }
+  const getOrigin = runGit2(["git", "-C", layout.checkoutRoot, "remote", "get-url", "origin"], layout.projectRoot);
+  if (getOrigin.exitCode === 0) {
+    const currentOrigin = getOrigin.stdout.trim();
+    if (currentOrigin !== layout.mirrorRoot) {
+      ensureGitSuccess2(runGit2(["git", "-C", layout.checkoutRoot, "remote", "set-url", "origin", layout.mirrorRoot], layout.projectRoot), ["git", "-C", layout.checkoutRoot, "remote", "set-url", "origin", layout.mirrorRoot]);
+    }
+  } else {
+    ensureGitSuccess2(runGit2(["git", "-C", layout.checkoutRoot, "remote", "add", "origin", layout.mirrorRoot], layout.projectRoot), ["git", "-C", layout.checkoutRoot, "remote", "add", "origin", layout.mirrorRoot]);
+  }
+  ensureGitSuccess2(runGit2(["git", "-C", layout.checkoutRoot, "fetch", "origin", layout.defaultBranch], layout.projectRoot), ["git", "-C", layout.checkoutRoot, "fetch", "origin", layout.defaultBranch]);
+  ensureGitSuccess2(runGit2(["git", "-C", layout.checkoutRoot, "reset", "--hard"], layout.projectRoot), ["git", "-C", layout.checkoutRoot, "reset", "--hard"]);
+  ensureGitSuccess2(runGit2(["git", "-C", layout.checkoutRoot, "clean", "-fd"], layout.projectRoot), ["git", "-C", layout.checkoutRoot, "clean", "-fd"]);
+  ensureGitSuccess2(runGit2([
+    "git",
+    "-C",
+    layout.checkoutRoot,
+    "checkout",
+    "--force",
+    "-B",
+    layout.defaultBranch,
+    `origin/${layout.defaultBranch}`
+  ], layout.projectRoot), [
+    "git",
+    "-C",
+    layout.checkoutRoot,
+    "checkout",
+    "--force",
+    "-B",
+    layout.defaultBranch,
+    `origin/${layout.defaultBranch}`
+  ]);
+  ensureGitSuccess2(runGit2(["git", "-C", layout.checkoutRoot, "reset", "--hard", `origin/${layout.defaultBranch}`], layout.projectRoot), ["git", "-C", layout.checkoutRoot, "reset", "--hard", `origin/${layout.defaultBranch}`]);
+  ensureGitSuccess2(runGit2(["git", "-C", layout.checkoutRoot, "clean", "-fd"], layout.projectRoot), ["git", "-C", layout.checkoutRoot, "clean", "-fd"]);
+  return ensureGitSuccess2(runGit2(["git", "-C", layout.checkoutRoot, "rev-parse", "HEAD"], layout.projectRoot), ["git", "-C", layout.checkoutRoot, "rev-parse", "HEAD"]);
+}
+function syncManagedRepo(projectRoot, repoId) {
+  const { layout, headCommit } = refreshManagedRepoMirror(projectRoot, repoId);
+  const checkoutCommit = ensureCheckoutFromMirror(layout);
+  if (checkoutCommit !== headCommit) {
+    throw new Error(`Managed repo checkout ${layout.alias} is out of sync with mirror: expected ${headCommit}, got ${checkoutCommit}.`);
+  }
+  return { layout, headCommit };
+}
+// packages/runtime/src/control-plane/errors.ts
+class CliError extends Error {
+  exitCode;
+  constructor(message, exitCode = 1) {
+    super(message);
+    this.name = "CliError";
+    this.exitCode = exitCode;
+  }
+}
+
+// packages/runtime/src/control-plane/project-main-pre-run-sync.ts
+function runGit3(projectRoot, args, failureSummary) {
+  const result = runCapture(["git", ...args], projectRoot);
+  if (result.exitCode !== 0) {
+    const details = result.stderr.trim() || result.stdout.trim() || "unknown git failure";
+    throw new CliError(`${failureSummary}: ${details}`, 2);
+  }
+  return result.stdout.trim();
+}
+async function ensureProjectMainFreshBeforeRun(options) {
+  if (options.disabled) {
+    return { status: "disabled" };
+  }
+  const defaultSync = (projectRoot) => {
+    for (const entry of listManagedRepoEntries()) {
+      syncManagedRepo(projectRoot, entry.id);
+    }
+  };
+  await (options.syncMonorepo ?? defaultSync)(options.projectRoot);
+  runGit3(options.projectRoot, ["fetch", "origin", "main"], "Failed to fetch origin/main");
+  const branch = runGit3(options.projectRoot, ["rev-parse", "--abbrev-ref", "HEAD"], "Failed to read current branch");
+  if (branch !== "main") {
+    return { status: "skipped_not_main", branch };
+  }
+  const countsText = runGit3(options.projectRoot, ["rev-list", "--left-right", "--count", "main...origin/main"], "Failed to compare local main to origin/main");
+  const [localAheadRaw, remoteAheadRaw] = countsText.split(/\s+/);
+  const localAhead = Number.parseInt(localAheadRaw || "0", 10);
+  const remoteAhead = Number.parseInt(remoteAheadRaw || "0", 10);
+  if (!Number.isFinite(localAhead) || !Number.isFinite(remoteAhead)) {
+    throw new CliError(`Failed to compare local main to origin/main: unexpected rev-list output "${countsText}"`, 2);
+  }
+  if (remoteAhead === 0) {
+    if (localAhead > 0) {
+      return { status: "local_ahead", localAhead };
+    }
+    return { status: "up_to_date" };
+  }
+  if (localAhead > 0) {
+    throw new CliError("Local main has diverged from origin/main. Resolve the branch state manually or rerun with --skip-project-sync.", 2);
+  }
+  runGit3(options.projectRoot, ["merge", "--ff-only", "origin/main"], "Failed to fast-forward local main to origin/main");
+  await options.runBootstrap();
+  return { status: "updated", remoteAhead };
+}
+export {
+  ensureProjectMainFreshBeforeRun
+};