@h-rig/core 0.0.6-alpha.17 → 0.0.6-alpha.170

package/dist/src/runtime-events.js

@@ -0,0 +1,212 @@
+// @bun
+// packages/core/src/runtime-events.ts
+import { appendFile, mkdir } from "fs/promises";
+import { randomUUID } from "crypto";
+import { dirname as dirname2, resolve as resolve3 } from "path";
+
+// packages/core/src/layout.ts
+import { resolve as resolve2 } from "path";
+import {
+  RIG_ARTIFACTS_DIRNAME,
+  RIG_DEFINITION_DIRNAME,
+  RIG_STATE_DIRNAME
+} from "@rig/contracts";
+
+// packages/core/src/checkout-root.ts
+import { dirname, resolve } from "path";
+import { existsSync } from "fs";
+function findNearestGitCheckoutRoot(startDir) {
+  let current = resolve(startDir);
+  for (;; ) {
+    if (existsSync(resolve(current, ".git")))
+      return current;
+    const parent = dirname(current);
+    if (parent === current)
+      return null;
+    current = parent;
+  }
+}
+function resolveCheckoutRoot(projectRoot) {
+  const normalizedProjectRoot = resolve(projectRoot);
+  const explicit = process.env.MONOREPO_ROOT?.trim();
+  if (explicit) {
+    const explicitRoot = resolve(explicit);
+    const gitRoot = findNearestGitCheckoutRoot(explicitRoot);
+    if (gitRoot)
+      return gitRoot;
+    throw new Error(`MONOREPO_ROOT points to ${explicitRoot}, but no git checkout was found there or above it.`);
+  }
+  return findNearestGitCheckoutRoot(normalizedProjectRoot) ?? normalizedProjectRoot;
+}
+
+// packages/core/src/layout.ts
+var resolveMonorepoRoot = resolveCheckoutRoot;
+function resolveRuntimeWorkspaceLayout(workspaceDir) {
+  const root = resolve2(workspaceDir);
+  const rigRoot = resolve2(root, ".rig");
+  const logsDir = resolve2(rigRoot, "logs");
+  const stateDir = resolve2(rigRoot, "state");
+  const runtimeDir = resolve2(rigRoot, "runtime");
+  const binDir = resolve2(rigRoot, "bin");
+  return {
+    workspaceDir: root,
+    rigRoot,
+    stateDir,
+    logsDir,
+    artifactsRoot: resolve2(root, RIG_ARTIFACTS_DIRNAME),
+    runtimeDir,
+    homeDir: resolve2(rigRoot, "home"),
+    tmpDir: resolve2(rigRoot, "tmp"),
+    cacheDir: resolve2(rigRoot, "cache"),
+    sessionDir: resolve2(rigRoot, "session"),
+    binDir,
+    distDir: resolve2(rigRoot, "dist"),
+    pluginBinDir: resolve2(binDir, "plugins"),
+    contextPath: resolve2(rigRoot, "runtime-context.json"),
+    controlPlaneEventsFile: resolve2(logsDir, "control-plane.events.jsonl")
+  };
+}
+function resolveActiveRuntimeWorkspaceRoot(_monorepoRoot) {
+  const explicit = process.env.RIG_TASK_WORKSPACE?.trim();
+  if (!explicit) {
+    throw new Error("No active runtime workspace. Set RIG_TASK_WORKSPACE or provision a task runtime first.");
+  }
+  return resolve2(explicit);
+}
+function resolveRigLayout(projectRoot) {
+  const monorepoRoot = resolveMonorepoRoot(projectRoot);
+  const definitionRoot = resolve2(projectRoot, RIG_DEFINITION_DIRNAME);
+  const runtimeWorkspaceRoot = resolveActiveRuntimeWorkspaceRoot(monorepoRoot);
+  const runtimeLayout = resolveRuntimeWorkspaceLayout(runtimeWorkspaceRoot);
+  const policyDir = resolve2(definitionRoot, "policy");
+  return {
+    projectRoot,
+    monorepoRoot,
+    definitionRoot,
+    runtimeWorkspaceRoot,
+    stateRoot: runtimeLayout.rigRoot,
+    artifactsRoot: runtimeLayout.artifactsRoot,
+    configPath: resolve2(definitionRoot, "config.sh"),
+    taskConfigPath: resolve2(runtimeWorkspaceRoot, ".rig", "task-config.json"),
+    policyDir,
+    policyFile: resolve2(policyDir, "policy.json"),
+    pluginsDir: resolve2(definitionRoot, "plugins"),
+    hooksDir: resolve2(definitionRoot, "hooks"),
+    toolsDir: resolve2(definitionRoot, "tools"),
+    templatesDir: resolve2(definitionRoot, "templates"),
+    validationDir: resolve2(definitionRoot, "validation"),
+    stateDir: runtimeLayout.stateDir,
+    logsDir: runtimeLayout.logsDir,
+    notificationsDir: resolve2(definitionRoot, "notifications"),
+    runtimeDir: runtimeLayout.runtimeDir,
+    distDir: runtimeLayout.distDir,
+    binDir: runtimeLayout.binDir,
+    pluginBinDir: runtimeLayout.pluginBinDir,
+    keybindingsPath: resolve2(definitionRoot, "keybindings.json"),
+    controlPlaneEventsFile: runtimeLayout.controlPlaneEventsFile
+  };
+}
+
+// packages/core/src/runtime-events.ts
+async function appendEvent(eventsFile, event) {
+  await mkdir(dirname2(eventsFile), { recursive: true });
+  await appendFile(eventsFile, `${JSON.stringify(event)}
+`, "utf-8");
+}
+function createEvent(runId, type, payload) {
+  return {
+    id: randomUUID(),
+    runId,
+    timestamp: new Date().toISOString(),
+    type,
+    payload
+  };
+}
+
+class RuntimeEventBus {
+  runId;
+  eventsFile;
+  memoryEvents = [];
+  constructor(options) {
+    this.runId = options.runId || randomUUID();
+    this.eventsFile = options.eventsFile ?? resolveRigLayout(options.projectRoot).controlPlaneEventsFile;
+  }
+  getRunId() {
+    return this.runId;
+  }
+  getEventsFile() {
+    return this.eventsFile;
+  }
+  getMemoryEvents() {
+    return [...this.memoryEvents];
+  }
+  async attachRuntimeBus(runtimeBus) {
+    if (runtimeBus.getEventsFile() === this.eventsFile) {
+      return;
+    }
+    for (const event of this.memoryEvents) {
+      await runtimeBus.ingest(event);
+    }
+  }
+  async attachRuntimeWorkspace(projectRoot) {
+    const runtimeBus = new RuntimeEventBus({ projectRoot, runId: this.runId });
+    await this.attachRuntimeBus(runtimeBus);
+    return runtimeBus;
+  }
+  async ingest(event) {
+    this.memoryEvents.push(event);
+    await appendEvent(this.eventsFile, event);
+  }
+  async emit(type, payload) {
+    const event = createEvent(this.runId, type, payload);
+    await this.ingest(event);
+    return event;
+  }
+}
+
+class GeneralCliEventBus {
+  runId;
+  eventsFile;
+  memoryEvents = [];
+  runtimeBuses = new Map;
+  constructor(options) {
+    this.runId = options.runId || randomUUID();
+    this.eventsFile = options.eventsFile ?? resolve3(options.projectRoot, ".rig", "logs", "control-plane.events.jsonl");
+  }
+  getRunId() {
+    return this.runId;
+  }
+  getEventsFile() {
+    return this.eventsFile;
+  }
+  getMemoryEvents() {
+    return [...this.memoryEvents];
+  }
+  async attachRuntimeBus(runtimeBus) {
+    const key = runtimeBus.getEventsFile();
+    if (this.runtimeBuses.has(key)) {
+      return;
+    }
+    this.runtimeBuses.set(key, runtimeBus);
+    for (const event of this.memoryEvents) {
+      await runtimeBus.ingest(event);
+    }
+  }
+  async attachRuntimeWorkspace(projectRoot) {
+    const runtimeBus = new RuntimeEventBus({ projectRoot, runId: this.runId });
+    await this.attachRuntimeBus(runtimeBus);
+    return runtimeBus;
+  }
+  async emit(type, payload) {
+    const event = createEvent(this.runId, type, payload);
+    this.memoryEvents.push(event);
+    await appendEvent(this.eventsFile, event);
+    await Promise.all(Array.from(this.runtimeBuses.values()).map((bus) => bus.ingest(event)));
+    return event;
+  }
+}
+export {
+  RuntimeEventBus,
+  GeneralCliEventBus,
+  GeneralCliEventBus as EventBus
+};

package/dist/src/runtime-overlay.d.ts

@@ -0,0 +1,11 @@
+export type RuntimeOverlay = {
+    rootDir: string;
+    homeDir: string;
+    tmpDir: string;
+    cacheDir: string;
+    logsDir: string;
+    stateDir: string;
+    sessionDir: string;
+    contextPath: string;
+};
+export declare function ensureRuntimeOverlay(projectRoot: string, runtimeId: string, workspaceDir?: string): RuntimeOverlay;

package/dist/src/runtime-overlay.js

@@ -0,0 +1,71 @@
+// @bun
+// packages/core/src/runtime-overlay.ts
+import { mkdirSync } from "fs";
+
+// packages/core/src/layout.ts
+import { resolve } from "path";
+import {
+  RIG_ARTIFACTS_DIRNAME,
+  RIG_DEFINITION_DIRNAME,
+  RIG_STATE_DIRNAME
+} from "@rig/contracts";
+function resolveRuntimeWorkspaceLayout(workspaceDir) {
+  const root = resolve(workspaceDir);
+  const rigRoot = resolve(root, ".rig");
+  const logsDir = resolve(rigRoot, "logs");
+  const stateDir = resolve(rigRoot, "state");
+  const runtimeDir = resolve(rigRoot, "runtime");
+  const binDir = resolve(rigRoot, "bin");
+  return {
+    workspaceDir: root,
+    rigRoot,
+    stateDir,
+    logsDir,
+    artifactsRoot: resolve(root, RIG_ARTIFACTS_DIRNAME),
+    runtimeDir,
+    homeDir: resolve(rigRoot, "home"),
+    tmpDir: resolve(rigRoot, "tmp"),
+    cacheDir: resolve(rigRoot, "cache"),
+    sessionDir: resolve(rigRoot, "session"),
+    binDir,
+    distDir: resolve(rigRoot, "dist"),
+    pluginBinDir: resolve(binDir, "plugins"),
+    contextPath: resolve(rigRoot, "runtime-context.json"),
+    controlPlaneEventsFile: resolve(logsDir, "control-plane.events.jsonl")
+  };
+}
+
+// packages/core/src/runtime-overlay.ts
+function ensureRuntimeOverlay(projectRoot, runtimeId, workspaceDir) {
+  const layout = resolveRuntimeWorkspaceLayout(workspaceDir ?? projectRoot);
+  const rootDir = layout.rigRoot;
+  const homeDir = layout.homeDir;
+  const tmpDir = layout.tmpDir;
+  const cacheDir = layout.cacheDir;
+  const logsDir = layout.logsDir;
+  const stateDir = layout.stateDir;
+  const sessionDir = layout.sessionDir;
+  const runtimeDir = layout.runtimeDir;
+  const contextPath = layout.contextPath;
+  mkdirSync(rootDir, { recursive: true });
+  mkdirSync(homeDir, { recursive: true });
+  mkdirSync(tmpDir, { recursive: true });
+  mkdirSync(cacheDir, { recursive: true });
+  mkdirSync(logsDir, { recursive: true });
+  mkdirSync(stateDir, { recursive: true });
+  mkdirSync(sessionDir, { recursive: true });
+  mkdirSync(runtimeDir, { recursive: true });
+  return {
+    rootDir,
+    homeDir,
+    tmpDir,
+    cacheDir,
+    logsDir,
+    stateDir,
+    sessionDir,
+    contextPath
+  };
+}
+export {
+  ensureRuntimeOverlay
+};

package/dist/src/runtime-paths.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Resolve the real Bun binary path.
+ *
+ * Runtime PATH often starts with `.rig/bin`, where `bun` is our injected
+ * gateway symlink. That path is not a real Bun install and cannot be used to
+ * derive `${bunDir}/bin`, so skip it and fall back to a host Bun binary.
+ */
+export declare function resolveBunBinaryPath(): string;
+/** Resolve the real Claude CLI binary path. */
+export declare function resolveClaudeBinaryPath(): string;
+/** Resolve the bun install root directory (parent-of-parent of the bun binary). */
+export declare function resolveBunInstallDir(bunBinaryPath?: string): string;
+/** Resolve the claude CLI install directory (parent of the real claude binary). */
+export declare function resolveClaudeInstallDir(): string;
+/**
+ * Resolve the Node.js install root directory.
+ * Prefers `RIG_NODE_BIN` env var, then NVM, then PATH lookup.
+ */
+export declare function resolveNodeInstallDir(): string | null;
+/** Resolve additional dependency roots sandbox backends need to bind-mount. */
+export declare function resolveRuntimeDependencyRoots(runtimeDirs: string[]): string[];

package/dist/src/runtime-paths.js

@@ -0,0 +1,181 @@
+// @bun
+// packages/core/src/runtime-paths.ts
+import { existsSync, readdirSync, realpathSync } from "fs";
+import { resolve } from "path";
+function uniq(values) {
+  return [...new Set(values)];
+}
+function resolveBunBinaryPath() {
+  const explicit = normalizeExecutablePath(process.env.RIG_BUN_PATH?.trim());
+  if (explicit) {
+    return explicit;
+  }
+  const pathBun = normalizeExecutablePath(Bun.which("bun")?.trim());
+  if (pathBun && !looksLikeRuntimeGateway(pathBun)) {
+    return pathBun;
+  }
+  const home = process.env.HOME?.trim();
+  const fallbackCandidates = [
+    home ? resolve(home, ".bun/bin/bun") : "",
+    "/opt/homebrew/bin/bun",
+    "/usr/local/bin/bun",
+    "/usr/bin/bun"
+  ];
+  for (const candidate of fallbackCandidates) {
+    const normalized = normalizeExecutablePath(candidate);
+    if (normalized) {
+      return normalized;
+    }
+  }
+  const execPath = normalizeExecutablePath(process.execPath?.trim());
+  if (execPath && !looksLikeRuntimeGateway(execPath)) {
+    return execPath;
+  }
+  throw new Error("bun not found in PATH");
+}
+function resolveClaudeBinaryPath() {
+  const explicit = normalizeExecutablePath(process.env.RIG_CLAUDE_PATH?.trim());
+  if (explicit) {
+    return explicit;
+  }
+  const pathClaude = normalizeExecutablePath(Bun.which("claude")?.trim());
+  if (pathClaude && !looksLikeRuntimeGateway(pathClaude)) {
+    return pathClaude;
+  }
+  const home = process.env.HOME?.trim();
+  const fallbackCandidates = [
+    home ? resolve(home, ".local/bin/claude") : "",
+    home ? resolve(home, ".local/share/claude/local/claude") : "",
+    "/opt/homebrew/bin/claude",
+    "/usr/local/bin/claude",
+    "/usr/bin/claude"
+  ];
+  for (const candidate of fallbackCandidates) {
+    const normalized = normalizeExecutablePath(candidate);
+    if (normalized) {
+      return normalized;
+    }
+  }
+  throw new Error("claude not found in PATH");
+}
+function resolveBunInstallDir(bunBinaryPath = resolveBunBinaryPath()) {
+  return resolve(bunBinaryPath, "../..");
+}
+function resolveClaudeInstallDir() {
+  const realPath = resolveClaudeBinaryPath();
+  return resolve(realPath, "..");
+}
+function resolveNodeInstallDir() {
+  const preferredNode = resolvePreferredNodeBinary();
+  if (!preferredNode)
+    return null;
+  const explicitNode = process.env.RIG_NODE_BIN?.trim();
+  if (explicitNode && resolve(explicitNode) === resolve(preferredNode)) {
+    return preferredNode.endsWith("/bin/node") ? resolve(preferredNode, "../..") : resolve(preferredNode, "..");
+  }
+  try {
+    const realPath = realpathSync(preferredNode);
+    if (realPath.endsWith("/bin/node")) {
+      return resolve(realPath, "../..");
+    }
+    return resolve(realPath, "..");
+  } catch {
+    return resolve(preferredNode, "..");
+  }
+}
+function resolveRuntimeDependencyRoots(runtimeDirs) {
+  const roots = [];
+  if (process.platform === "darwin") {
+    for (const macPath of ["/opt/homebrew", "/opt/homebrew/opt"]) {
+      if (existsSync(macPath)) {
+        roots.push(macPath);
+      }
+    }
+  }
+  for (const dir of runtimeDirs) {
+    if (dir.startsWith("/opt/homebrew/Cellar/")) {
+      roots.push("/opt/homebrew/opt");
+    } else if (dir.startsWith("/usr/local/Cellar/")) {
+      roots.push("/usr/local/opt");
+    }
+  }
+  return uniq(roots);
+}
+function resolvePreferredNodeBinary() {
+  const candidates = [];
+  const envNode = process.env.RIG_NODE_BIN?.trim();
+  if (envNode) {
+    const explicit = resolve(envNode);
+    if (existsSync(explicit)) {
+      return explicit;
+    }
+  }
+  const nvmBin = process.env.NVM_BIN?.trim();
+  if (nvmBin) {
+    candidates.push(resolve(nvmBin, "node"));
+  }
+  const home = process.env.HOME?.trim();
+  if (home) {
+    const nvmVersionsDir = resolve(home, ".nvm/versions/node");
+    if (existsSync(nvmVersionsDir)) {
+      try {
+        const versionDirs = readdirSync(nvmVersionsDir).map((entry) => entry.trim()).filter((entry) => /^v\d+\.\d+\.\d+$/.test(entry)).sort((a, b) => Bun.semver.order(b.replace(/^v/, ""), a.replace(/^v/, "")));
+        for (const versionDir of versionDirs) {
+          candidates.push(resolve(nvmVersionsDir, versionDir, "bin/node"));
+        }
+      } catch {}
+    }
+  }
+  const whichNode = Bun.which("node");
+  if (whichNode) {
+    candidates.push(whichNode);
+  }
+  const deduped = uniq(candidates.map((candidate) => resolve(candidate)));
+  const existing = deduped.filter((candidate) => existsSync(candidate));
+  if (existing.length === 0) {
+    return null;
+  }
+  const stable = existing.find((candidate) => {
+    const major = inferNodeMajor(candidate);
+    return typeof major === "number" && major >= 18 && major <= 24;
+  });
+  if (stable) {
+    return stable;
+  }
+  return existing[0] ?? null;
+}
+function inferNodeMajor(nodeBinaryPath) {
+  const normalized = resolve(nodeBinaryPath).replace(/\\/g, "/");
+  const match = normalized.match(/(?:^|\/)(?:node-)?v?(\d+)\.\d+\.\d+(?:\/|$)/);
+  if (!match) {
+    return null;
+  }
+  const major = Number.parseInt(match[1], 10);
+  return Number.isFinite(major) ? major : null;
+}
+function normalizeExecutablePath(candidate) {
+  if (!candidate) {
+    return "";
+  }
+  const normalized = resolve(candidate);
+  if (!existsSync(normalized)) {
+    return "";
+  }
+  try {
+    return realpathSync(normalized);
+  } catch {
+    return normalized;
+  }
+}
+function looksLikeRuntimeGateway(candidate) {
+  const normalized = resolve(candidate).replace(/\\/g, "/");
+  return normalized.includes("/.rig/bin/") || normalized.endsWith("/rig-shell") || normalized.endsWith("/rig-agent");
+}
+export {
+  resolveRuntimeDependencyRoots,
+  resolveNodeInstallDir,
+  resolveClaudeInstallDir,
+  resolveClaudeBinaryPath,
+  resolveBunInstallDir,
+  resolveBunBinaryPath
+};

package/dist/src/runtime-provisioning-env.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Build a clean host environment for runtime provisioning steps (bun build/install).
+ * This strips sandbox wrapper markers so provisioning does not recurse into controlled-bash.
+ */
+export declare function runtimeProvisioningEnv(baseEnv?: Record<string, string | undefined>): Record<string, string>;