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

package/dist/src/agent-harness/controlled-bash.d.ts

@@ -0,0 +1,3 @@
+export declare function runControlledBash(args: string[], options: {
+    readonly projectRootFallbackDir: string;
+}): Promise<number>;

package/dist/src/agent-harness/controlled-bash.js

@@ -0,0 +1,45 @@
+// @bun
+// packages/provider-plugin/src/agent-harness/controlled-bash.ts
+import { existsSync } from "fs";
+import { resolve } from "path";
+import { resolveRigLayout } from "@rig/core/layout";
+function controlledBashCandidates(projectRoot) {
+  const layout = resolveRigLayout(projectRoot);
+  const candidates = [
+    process.env.RIG_CONTROLLED_BASH_BIN?.trim() || "",
+    resolve(layout.binDir, "controlled-bash"),
+    Bun.which("controlled-bash") || ""
+  ];
+  return candidates.filter((candidate) => Boolean(candidate));
+}
+function resolveControlledBash(projectRoot) {
+  for (const candidate of controlledBashCandidates(projectRoot)) {
+    if (existsSync(candidate))
+      return candidate;
+  }
+  return null;
+}
+async function runControlledBash(args, options) {
+  const projectRoot = process.env.RIG_HOST_PROJECT_ROOT?.trim() || process.env.PROJECT_RIG_ROOT?.trim() || process.env.RIG_TASK_WORKSPACE?.trim() || process.cwd() || options.projectRootFallbackDir;
+  const controlled = resolveControlledBash(projectRoot);
+  if (!controlled) {
+    console.error("[rig-agent] controlled-bash entrypoint unavailable; refusing to run an unguarded shell.");
+    return 126;
+  }
+  const command = [controlled, ...args];
+  const child = Bun.spawn(command, {
+    stdin: "inherit",
+    stdout: "inherit",
+    stderr: "inherit",
+    cwd: process.cwd(),
+    env: {
+      ...process.env,
+      PROJECT_RIG_ROOT: projectRoot,
+      RIG_BASH_ACTIVE: "1"
+    }
+  });
+  return await child.exited;
+}
+export {
+  runControlledBash
+};

package/dist/src/agent-harness/git-ops.d.ts

@@ -0,0 +1,2 @@
+import { type LifecycleGitAgentService } from "@rig/contracts";
+export declare function loadLifecycleGit(projectRoot: string): Promise<LifecycleGitAgentService>;

package/dist/src/agent-harness/git-ops.js

@@ -0,0 +1,27 @@
+// @bun
+// packages/provider-plugin/src/agent-harness/git-ops.ts
+import { LIFECYCLE_GIT_AGENT } from "@rig/contracts";
+import { defineCapability } from "@rig/core/capability";
+import { buildPluginHostContext } from "@rig/core/plugin-host-context";
+import { loadCapabilityForRoot } from "@rig/core/capability-loaders";
+var LifecycleGitAgentCap = defineCapability(LIFECYCLE_GIT_AGENT);
+var hostContextByRoot = new Map;
+async function ensureHostContext(projectRoot) {
+  let cached = hostContextByRoot.get(projectRoot);
+  if (!cached) {
+    cached = buildPluginHostContext(projectRoot);
+    hostContextByRoot.set(projectRoot, cached);
+  }
+  await cached;
+}
+async function loadLifecycleGit(projectRoot) {
+  await ensureHostContext(projectRoot);
+  const git = await loadCapabilityForRoot(projectRoot, LifecycleGitAgentCap);
+  if (!git) {
+    throw new Error("lifecycle git capability unavailable: load @rig/bundle-default-lifecycle (default bundle) before running rig-agent git commands.");
+  }
+  return git;
+}
+export {
+  loadLifecycleGit
+};

package/dist/src/agent-harness/repo-ops.d.ts

@@ -0,0 +1,8 @@
+type RepoPins = Record<string, string>;
+export declare function repoEnsure(projectRoot: string, taskId?: string): void;
+export declare function repoPins(projectRoot: string, taskId?: string): RepoPins;
+export declare function repoVerify(projectRoot: string, taskId?: string): boolean;
+export declare function repoDiscover(projectRoot: string, taskId?: string): RepoPins;
+export declare function repoBaseline(projectRoot: string, refresh?: boolean): RepoPins;
+export declare function resetBaseline(projectRoot: string, keepTaskStatus: boolean): void;
+export {};

package/dist/src/agent-harness/repo-ops.js

@@ -0,0 +1,471 @@
+// @bun
+// packages/provider-plugin/src/agent-harness/repo-ops.ts
+import { existsSync, mkdirSync, readFileSync, readdirSync, rmSync, writeFileSync } from "fs";
+import { basename, dirname, resolve } from "path";
+import { loadRuntimeContext } from "@rig/core/runtime-context";
+import {
+  MANAGED_REPO_SERVICE_CAPABILITY,
+  TASK_DATA_SERVICE_CAPABILITY
+} from "@rig/contracts";
+import { defineCapability } from "@rig/core/capability";
+import { getInstalledCapability, requireInstalledCapability } from "@rig/core/capability-loaders";
+import { resolveHarnessPaths } from "@rig/core/harness-paths";
+var ManagedRepoCap = defineCapability(MANAGED_REPO_SERVICE_CAPABILITY);
+var getManagedRepoService = () => getInstalledCapability(ManagedRepoCap);
+var TaskDataCap = defineCapability(TASK_DATA_SERVICE_CAPABILITY);
+var taskData = () => requireInstalledCapability(TaskDataCap, "task-data capability unavailable: load @rig/task-sources-plugin (default bundle) before resolving task repos.");
+function runCapture(command, cwd, env) {
+  const result = Bun.spawnSync(command, {
+    cwd,
+    env: env ? { ...process.env, ...env } : process.env,
+    stdout: "pipe",
+    stderr: "pipe",
+    stdin: "ignore"
+  });
+  return {
+    exitCode: result.exitCode,
+    stdout: result.stdout.toString(),
+    stderr: result.stderr.toString()
+  };
+}
+function readJsonFile(path, fallback) {
+  if (!existsSync(path))
+    return fallback;
+  try {
+    return JSON.parse(readFileSync(path, "utf8"));
+  } catch {
+    return fallback;
+  }
+}
+function nowIso() {
+  return new Date().toISOString();
+}
+function managedRepoEntries() {
+  return getManagedRepoService()?.listManagedRepoEntries() ?? [];
+}
+function requireManagedRepoService() {
+  const service = getManagedRepoService();
+  if (!service) {
+    throw new Error("managed-repo service not installed: configure @rig/repos-plugin in rig.config to use managed-repo operations.");
+  }
+  return service;
+}
+function primaryManagedRepoId() {
+  const entries = managedRepoEntries();
+  return entries.length > 0 ? entries[0].id : null;
+}
+function primaryManagedRepoAlias() {
+  const entries = managedRepoEntries();
+  return entries.length > 0 ? entries[0].alias : null;
+}
+function repoEnsure(projectRoot, taskId) {
+  const monorepo = ensureMonorepoReady(projectRoot);
+  const resolvedTask = taskId || taskData().currentTaskId(projectRoot);
+  if (!resolvedTask) {
+    if (monorepo) {
+      const alias = primaryManagedRepoAlias();
+      if (alias) {
+        persistBaselinePins(projectRoot, { [alias]: monorepo.headCommit });
+      }
+    }
+    console.log("No active task. Refreshed baseline repo pins.");
+    return;
+  }
+  const pins = resolvedPins(projectRoot, resolvedTask);
+  applyPins(projectRoot, pins);
+  verifyPins(projectRoot, pins);
+}
+function repoPins(projectRoot, taskId) {
+  const resolvedTask = taskId || taskData().currentTaskId(projectRoot);
+  if (!resolvedTask) {
+    return {};
+  }
+  return resolvedPins(projectRoot, resolvedTask);
+}
+function repoVerify(projectRoot, taskId) {
+  const resolvedTask = taskId || taskData().currentTaskId(projectRoot);
+  if (!resolvedTask) {
+    console.log("No active task. Nothing to verify.");
+    return true;
+  }
+  const pins = resolvedPins(projectRoot, resolvedTask);
+  return verifyPins(projectRoot, pins);
+}
+function repoDiscover(projectRoot, taskId) {
+  const resolvedTask = taskId || taskData().currentTaskId(projectRoot);
+  if (!resolvedTask) {
+    return {};
+  }
+  const explicit = explicitPins(projectRoot, resolvedTask);
+  if (Object.keys(explicit).length > 0) {
+    return explicit;
+  }
+  return discoverPins(projectRoot, resolvedTask);
+}
+function repoBaseline(projectRoot, refresh = false) {
+  const paths = resolveRepoDiscoveryPaths(projectRoot);
+  if (!refresh && existsSync(paths.baseRepoPinsPath)) {
+    const baseline = readJsonFile(paths.baseRepoPinsPath, { recorded_at: nowIso(), repos: {} });
+    return baseline.repos || {};
+  }
+  const id = primaryManagedRepoId();
+  if (!id) {
+    return persistBaselinePins(projectRoot, {});
+  }
+  const synced = requireManagedRepoService().syncManagedRepo(projectRoot, id);
+  const alias = primaryManagedRepoAlias() ?? id;
+  return persistBaselinePins(projectRoot, { [alias]: synced.headCommit });
+}
+function resetBaseline(projectRoot, keepTaskStatus) {
+  const paths = resolveHarnessPaths(projectRoot);
+  const label = primaryManagedRepoAlias() ?? "monorepo";
+  resetRepoToOriginMain(projectRoot, paths.monorepoRoot, label);
+  deleteBranches(projectRoot, paths.monorepoRoot, label, "rig/*");
+  deleteBranches(projectRoot, projectRoot, "project-rig", "codex/*");
+  repoBaseline(projectRoot, true);
+  console.log("OK: refreshed baseline repo pins");
+  if (!keepTaskStatus) {
+    reopenClosedTasks(projectRoot);
+  } else {
+    console.log("INFO: task status unchanged (--keep-task-status)");
+  }
+  clearDirectory(paths.artifactsDir, ".gitkeep");
+  clearDirectory(paths.logsDir, ".gitkeep");
+  for (const stateFile of ["hook_trips.log", "task-repo-commits.json", "current-task-id.txt"]) {
+    rmSync(resolve(paths.stateDir, stateFile), { force: true });
+  }
+  console.log("OK: cleared harness artifacts/logs/runtime state");
+  console.log("");
+  console.log("Baseline reset complete.");
+}
+function ensureMonorepoReady(projectRoot) {
+  const id = primaryManagedRepoId();
+  if (!id) {
+    return null;
+  }
+  const synced = requireManagedRepoService().syncManagedRepo(projectRoot, id);
+  const sha = synced.headCommit.slice(0, 7);
+  console.log(`Monorepo ready: ${synced.layout.alias}@${sha}`);
+  return synced;
+}
+function persistBaselinePins(projectRoot, repos) {
+  const paths = resolveRepoDiscoveryPaths(projectRoot);
+  mkdirSync(resolve(paths.baseRepoPinsPath, ".."), { recursive: true });
+  writeFileSync(paths.baseRepoPinsPath, `${JSON.stringify({ recorded_at: nowIso(), repos }, null, 2)}
+`, "utf-8");
+  return repos;
+}
+function resetRepoToOriginMain(projectRoot, repoPath, label) {
+  if (!existsSync(resolve(repoPath, ".git"))) {
+    console.log(`WARN: ${label} repo missing at ${repoPath}, skipping reset.`);
+    return;
+  }
+  runGitCapture(["git", "-C", repoPath, "fetch", "origin", "main"], projectRoot);
+  const hasMain = runGitCapture(["git", "-C", repoPath, "show-ref", "--verify", "--quiet", "refs/heads/main"], projectRoot).exitCode === 0;
+  if (hasMain) {
+    runGitCapture(["git", "-C", repoPath, "checkout", "main"], projectRoot);
+  } else {
+    runGitCapture(["git", "-C", repoPath, "checkout", "-B", "main", "origin/main"], projectRoot);
+  }
+  const resetResult = runGitCapture(["git", "-C", repoPath, "reset", "--hard", "origin/main"], projectRoot);
+  if (resetResult.exitCode !== 0) {
+    throw new Error(`Failed to reset ${label} to origin/main:
+${resetResult.stderr || resetResult.stdout}`);
+  }
+  runGitCapture(["git", "-C", repoPath, "clean", "-fd"], projectRoot);
+  const head = runGitCapture(["git", "-C", repoPath, "rev-parse", "--short", "HEAD"], projectRoot).stdout.trim();
+  console.log(`OK: ${label} reset to origin/main (${head})`);
+}
+function deleteBranches(projectRoot, repoPath, label, pattern) {
+  if (!existsSync(resolve(repoPath, ".git"))) {
+    return;
+  }
+  const listed = runGitCapture(["git", "-C", repoPath, "for-each-ref", `refs/heads/${pattern}`, "--format=%(refname:short)"], projectRoot).stdout.split(/\r?\n/).filter(Boolean);
+  let deleted = 0;
+  for (const branch of listed) {
+    runGitCapture(["git", "-C", repoPath, "branch", "-D", branch], projectRoot);
+    deleted += 1;
+  }
+  console.log(`OK: ${label} deleted ${deleted} branch(es) matching ${pattern}`);
+}
+function reopenClosedTasks(projectRoot) {
+  const paths = resolveHarnessPaths(projectRoot);
+  const issuesPath = resolve(paths.monorepoRoot, ".beads/issues.jsonl");
+  if (!existsSync(issuesPath)) {
+    console.log("WARN: .beads/issues.jsonl not found, skipping task reopen.");
+    return;
+  }
+  const content = readFileSync(issuesPath, "utf-8");
+  const closed = [];
+  for (const line of content.split(/\r?\n/)) {
+    const trimmed = line.trim();
+    if (!trimmed) {
+      continue;
+    }
+    try {
+      const issue = JSON.parse(trimmed);
+      const normalizedStatus = taskData().normalizeTaskLifecycleStatus(issue.status);
+      if (issue.issue_type === "task" && issue.id && (normalizedStatus === "completed" || normalizedStatus === "cancelled" || normalizedStatus === "blocked")) {
+        closed.push(issue.id);
+      }
+    } catch {}
+  }
+  if (closed.length === 0) {
+    console.log("OK: no terminal tasks to reopen");
+    return;
+  }
+  for (const id of closed) {
+    const update = runCapture(["br", "--no-db", "update", id, "--status", "open"], paths.monorepoRoot);
+    if (update.exitCode === 0) {
+      console.log(`OK: reopened task ${id}`);
+    } else {
+      console.log(`WARN: failed to reopen task ${id}`);
+    }
+  }
+}
+function clearDirectory(dir, keepName) {
+  if (!existsSync(dir)) {
+    return;
+  }
+  for (const entry of readdirSync(dir)) {
+    if (entry === keepName) {
+      continue;
+    }
+    rmSync(resolve(dir, entry), { recursive: true, force: true });
+  }
+}
+function resolvedPins(projectRoot, taskId) {
+  const explicit = explicitPins(projectRoot, taskId);
+  if (Object.keys(explicit).length > 0) {
+    return explicit;
+  }
+  return discoverPins(projectRoot, taskId);
+}
+function explicitPins(projectRoot, taskId) {
+  const repoPins2 = readRepoDiscoveryTaskConfig(projectRoot)[taskId]?.repo_pins || {};
+  const normalized = {};
+  const validAliases = new Set(managedRepoEntries().map((e) => e.alias));
+  for (const [key, value] of Object.entries(repoPins2)) {
+    if (!value) {
+      continue;
+    }
+    if (validAliases.size > 0 && !validAliases.has(key)) {
+      throw new Error(`Unsupported repo pin key for ${taskId}: ${key}. Known aliases: ${[...validAliases].join(", ") || "(none registered)"}`);
+    }
+    const existing = normalized[key];
+    if (existing && existing !== value) {
+      throw new Error(`Conflicting explicit repo pins for ${key}: ${existing} vs ${value}`);
+    }
+    normalized[key] = value;
+  }
+  return normalized;
+}
+function taskDependencies(projectRoot, taskId) {
+  return taskData().taskDependencyIds(projectRoot, taskId);
+}
+function discoverPins(projectRoot, taskId) {
+  const deps = taskDependencies(projectRoot, taskId);
+  if (deps.length === 0) {
+    return repoBaseline(projectRoot, true);
+  }
+  const paths = resolveRepoDiscoveryPaths(projectRoot);
+  const state = readJsonFile(paths.taskRepoCommitsPath, {});
+  const pinKeys = managedRepoEntries().map((e) => e.alias);
+  if (pinKeys.length === 0) {
+    return {};
+  }
+  const discovered = {};
+  for (const key of pinKeys) {
+    const commits = new Set;
+    for (const dep of deps) {
+      const fromState = state[dep]?.repos?.[key];
+      if (fromState) {
+        commits.add(fromState);
+      }
+      const fromArtifact = readPinFromArtifact(projectRoot, dep, key);
+      if (fromArtifact) {
+        commits.add(fromArtifact);
+      }
+    }
+    if (commits.size > 1) {
+      const values = [...commits].join(`
+  - `);
+      throw new Error(`Conflicting discovered pins for ${key} from dependency graph of ${taskId}:
+  - ${values}`);
+    }
+    if (commits.size === 1) {
+      discovered[key] = [...commits][0];
+    }
+  }
+  return discovered;
+}
+function readRepoDiscoveryTaskConfig(projectRoot) {
+  try {
+    return taskData().readSourceTaskConfig(projectRoot);
+  } catch {
+    return taskData().readTaskConfig(projectRoot);
+  }
+}
+function resolveRepoDiscoveryPaths(projectRoot) {
+  const monorepoRoot = requireManagedRepoService().resolveMonorepoRepoLayout(projectRoot).checkoutRoot;
+  const explicitHostProjectRoot = (process.env.RIG_HOST_PROJECT_ROOT || "").trim();
+  const normalizedProjectRoot = resolve(projectRoot);
+  const hostProjectRoot = explicitHostProjectRoot && shouldUseHostProjectStateRoot(normalizedProjectRoot) ? explicitHostProjectRoot : normalizedProjectRoot;
+  const stateDir = resolve(hostProjectRoot, ".rig", "state");
+  return {
+    monorepoRoot,
+    taskRepoCommitsPath: resolve(stateDir, "task-repo-commits.json"),
+    baseRepoPinsPath: resolve(stateDir, "base-repo-pins.json")
+  };
+}
+function shouldUseHostProjectStateRoot(projectRoot) {
+  const runtimeWorkspace = process.env.RIG_TASK_WORKSPACE?.trim();
+  if (runtimeWorkspace && resolve(runtimeWorkspace) === projectRoot) {
+    return true;
+  }
+  return basename(dirname(projectRoot)) === ".worktrees";
+}
+function readPinFromArtifact(projectRoot, depTask, repoKey) {
+  const snapshot = resolve(taskData().artifactDirForId(projectRoot, depTask), "git-state.txt");
+  if (!existsSync(snapshot)) {
+    return "";
+  }
+  const content = readFileSync(snapshot, "utf-8");
+  const chunk = content.split(/\r?\n/);
+  let inSection = false;
+  for (const line of chunk) {
+    if (line.startsWith("## ")) {
+      inSection = line.startsWith(`## ${repoKey}`);
+      continue;
+    }
+    if (!inSection) {
+      continue;
+    }
+    if (line.startsWith("head:")) {
+      return line.replace(/^head:\s*/, "").trim();
+    }
+  }
+  return "";
+}
+function repoPath(projectRoot, key) {
+  const managed = getManagedRepoService()?.resolveManagedRepoLayoutByAlias(projectRoot, key) ?? null;
+  if (managed) {
+    return managed.checkoutRoot;
+  }
+  return key.startsWith("/") ? key : resolve(projectRoot, key);
+}
+function applyPins(projectRoot, pins) {
+  for (const [key, commit] of Object.entries(pins)) {
+    const path = repoPath(projectRoot, key);
+    if (!existsSync(resolve(path, ".git"))) {
+      throw new Error(`Repo for pin not available: ${key} (${path})`);
+    }
+    let hasCommit = runGitCapture(["git", "-C", path, "cat-file", "-e", `${commit}^{commit}`], projectRoot).exitCode === 0;
+    if (!hasCommit) {
+      runGitCapture(["git", "-C", path, "fetch", "--all", "--tags", "--prune"], projectRoot);
+      hasCommit = runGitCapture(["git", "-C", path, "cat-file", "-e", `${commit}^{commit}`], projectRoot).exitCode === 0;
+    }
+    if (!hasCommit) {
+      throw new Error(`Commit not found for ${key}: ${commit}`);
+    }
+    const current = runGitCapture(["git", "-C", path, "rev-parse", "HEAD"], projectRoot).stdout.trim();
+    if (current === commit) {
+      console.log(`Repo pin: ${key} already at ${commit}`);
+      continue;
+    }
+    const branch = runGitCapture(["git", "-C", path, "rev-parse", "--abbrev-ref", "HEAD"], projectRoot).stdout.trim();
+    const checkout = branch.startsWith("rig/") ? runGitCapture(["git", "-C", path, "reset", "--hard", commit], projectRoot) : runGitCapture(["git", "-C", path, "checkout", "--detach", commit], projectRoot);
+    if (checkout.exitCode !== 0) {
+      throw new Error(`Failed to apply repo pin ${key} -> ${commit}:
+${checkout.stderr || checkout.stdout}`);
+    }
+    console.log(`Repo pin: ${key} -> ${commit}`);
+  }
+}
+function verifyPins(projectRoot, pins) {
+  let ok = true;
+  for (const [key, expected] of Object.entries(pins)) {
+    const path = repoPath(projectRoot, key);
+    if (!existsSync(resolve(path, ".git"))) {
+      console.error(`ERROR: repo missing during pin verification: ${key}`);
+      ok = false;
+      continue;
+    }
+    const current = runGitCapture(["git", "-C", path, "rev-parse", "HEAD"], projectRoot).stdout.trim();
+    if (current === expected) {
+      console.log(`Repo verify: ${key} at ${current}`);
+    } else {
+      console.error(`ERROR: repo pin mismatch for ${key}: expected ${expected}, got ${current}`);
+      ok = false;
+    }
+  }
+  return ok;
+}
+function runGitCapture(command, projectRoot) {
+  return runCapture(command, projectRoot, resolveRuntimeGitEnv());
+}
+function resolveRuntimeGitEnv() {
+  if (process.env.GIT_SSH_COMMAND?.trim()) {
+    return {
+      HOME: process.env.HOME ?? "",
+      GIT_SSH_COMMAND: process.env.GIT_SSH_COMMAND
+    };
+  }
+  const runtimeRoot = process.env.RIG_RUNTIME_HOME?.trim() || (process.env.RIG_RUNTIME_CONTEXT_FILE?.trim() ? resolve(process.env.RIG_RUNTIME_CONTEXT_FILE, "..") : inferRuntimeRootFromWorkspace(process.cwd()));
+  const runtimeHome = runtimeRoot ? resolve(runtimeRoot, "home") : process.env.HOME?.trim() || "";
+  if (!runtimeHome) {
+    return;
+  }
+  const knownHostsPath = resolve(runtimeHome, ".ssh", "known_hosts");
+  if (!existsSync(knownHostsPath)) {
+    return { HOME: runtimeHome };
+  }
+  const agentSshKey = resolve(runtimeHome, ".ssh", "rig-agent-key");
+  const sshParts = [
+    "ssh",
+    `-o UserKnownHostsFile="${knownHostsPath}"`,
+    "-o StrictHostKeyChecking=yes",
+    "-F /dev/null"
+  ];
+  if (existsSync(agentSshKey)) {
+    sshParts.splice(1, 0, `-i "${agentSshKey}"`, "-o IdentitiesOnly=yes");
+  }
+  return {
+    HOME: runtimeHome,
+    GIT_SSH_COMMAND: sshParts.join(" ")
+  };
+}
+function inferRuntimeRootFromWorkspace(cwd) {
+  const contextPath = findRuntimeContextFile(cwd);
+  if (!contextPath || !existsSync(contextPath)) {
+    return "";
+  }
+  try {
+    loadRuntimeContext(contextPath);
+    return resolve(contextPath, "..");
+  } catch {
+    return "";
+  }
+}
+function findRuntimeContextFile(startPath) {
+  let current = resolve(startPath);
+  while (true) {
+    const candidate = resolve(current, "runtime-context.json");
+    if (existsSync(candidate)) {
+      return candidate;
+    }
+    const parent = resolve(current, "..");
+    if (parent === current) {
+      return "";
+    }
+    current = parent;
+  }
+}
+export {
+  resetBaseline,
+  repoVerify,
+  repoPins,
+  repoEnsure,
+  repoDiscover,
+  repoBaseline
+};

package/dist/src/agent-harness/rig-agent-entrypoint.d.ts

@@ -0,0 +1 @@
+export declare function runRigAgentEntrypoint(): Promise<void>;