@h-rig/core 0.0.6-alpha.18 → 0.0.6-alpha.181

package/dist/src/exec.js

@@ -0,0 +1,101 @@
+// @bun
+// packages/core/src/exec.ts
+import { existsSync, readFileSync } from "fs";
+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()
+  };
+}
+var DEFAULT_VALIDATION_TIMEOUT_MS = 30000;
+function getValidationTimeoutMs() {
+  const envVal = process.env.RIG_VALIDATION_TIMEOUT_MS;
+  if (envVal) {
+    const parsed = Number(envVal);
+    if (Number.isFinite(parsed) && parsed > 0) {
+      return parsed;
+    }
+  }
+  return DEFAULT_VALIDATION_TIMEOUT_MS;
+}
+async function runCaptureAsync(command, cwd, env, timeoutMs) {
+  const timeout = timeoutMs ?? getValidationTimeoutMs();
+  const proc = Bun.spawn(command, {
+    cwd,
+    env: env ? { ...process.env, ...env } : process.env,
+    stdout: "pipe",
+    stderr: "pipe"
+  });
+  const stdoutPromise = new Response(proc.stdout).text();
+  const stderrPromise = new Response(proc.stderr).text();
+  const timeoutResult = Symbol("timeout");
+  const exitOrTimeout = await Promise.race([
+    proc.exited,
+    Bun.sleep(timeout).then(() => timeoutResult)
+  ]);
+  if (exitOrTimeout === timeoutResult) {
+    proc.kill("SIGKILL");
+    const [stdout2, stderr2] = await Promise.all([
+      Promise.race([stdoutPromise, Bun.sleep(2000).then(() => "")]),
+      Promise.race([stderrPromise, Bun.sleep(2000).then(() => "")])
+    ]);
+    return {
+      exitCode: 124,
+      stdout: stdout2,
+      stderr: `${stderr2}
+[TIMEOUT] Process killed after ${timeout}ms`
+    };
+  }
+  const [stdout, stderr] = await Promise.all([stdoutPromise, stderrPromise]);
+  const exitCode = exitOrTimeout;
+  return { exitCode, stdout, stderr };
+}
+function runInherit(command, cwd, env) {
+  const proc = Bun.spawnSync(command, {
+    cwd,
+    env: env ? { ...process.env, ...env } : process.env,
+    stdin: "inherit",
+    stdout: "inherit",
+    stderr: "inherit"
+  });
+  return proc.exitCode;
+}
+function readJsonFile(path, fallback) {
+  if (!existsSync(path)) {
+    return fallback;
+  }
+  try {
+    return JSON.parse(readFileSync(path, "utf-8"));
+  } catch {
+    return fallback;
+  }
+}
+function nowIso() {
+  return new Date().toISOString();
+}
+function unique(values) {
+  return [...new Set(values)];
+}
+function fileLines(path) {
+  if (!existsSync(path)) {
+    return [];
+  }
+  return readFileSync(path, "utf-8").split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
+}
+export {
+  unique,
+  runInherit,
+  runCaptureAsync,
+  runCapture,
+  readJsonFile,
+  nowIso,
+  getValidationTimeoutMs,
+  fileLines
+};

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

@@ -0,0 +1,9 @@
+export declare function resolveHarnessPaths(projectRoot: string): {
+    harnessRoot: string;
+    stateDir: string;
+    logsDir: string;
+    binDir: string;
+    hooksDir: string;
+    validationDir: string;
+    monorepoRoot: string;
+};

package/dist/src/harness-paths.js

@@ -0,0 +1,126 @@
+// @bun
+// packages/core/src/harness-paths.ts
+import { resolve as resolve3 } from "path";
+
+// packages/core/src/layout.ts
+import { resolve as resolve2 } from "path";
+import {
+  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,
+    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,
+    configPath: resolve2(definitionRoot, "config.sh"),
+    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/harness-paths.ts
+function resolveHarnessPaths(projectRoot) {
+  const hasRuntimeWorkspace = Boolean(process.env.RIG_TASK_WORKSPACE?.trim());
+  const monorepoRoot = resolveCheckoutRoot(projectRoot);
+  const harnessRoot = resolve3(projectRoot, "rig");
+  const stateRoot = resolve3(projectRoot, ".rig");
+  const layout = hasRuntimeWorkspace ? resolveRigLayout(projectRoot) : null;
+  const stateDir = layout?.stateDir ?? resolve3(stateRoot, "state");
+  const logsDir = layout?.logsDir ?? resolve3(stateRoot, "logs");
+  const binDir = layout?.binDir ?? resolve3(stateRoot, "bin");
+  return {
+    harnessRoot,
+    stateDir: process.env.RIG_STATE_DIR || stateDir,
+    logsDir: process.env.RIG_LOGS_DIR || logsDir,
+    binDir,
+    hooksDir: resolve3(harnessRoot, "hooks"),
+    validationDir: resolve3(harnessRoot, "validation"),
+    monorepoRoot
+  };
+}
+export {
+  resolveHarnessPaths
+};

package/dist/src/hook-materializer.d.ts

@@ -0,0 +1,21 @@
+import type { HookRegistration } from "@rig/contracts";
+export type { PluginHookEntry } from "@rig/contracts";
+/**
+ * Resolve the path to the typed-hook runner entrypoint.
+ *
+ * Workspace/dev checkouts (and consumer projects with `@rig/core` in
+ * node_modules of THIS process) resolve the sibling source file directly.
+ * When that file isn't on disk (for example a compiled/virtualized runtime),
+ * fall back to the consumer project's own node_modules via
+ * `$CLAUDE_PROJECT_DIR`; Claude Code expands that variable when it runs the
+ * hook command.
+ */
+export declare function resolveHookRunnerPath(): string;
+/**
+ * Build the shell shim command for a typed hook. The command invokes the
+ * hook-runner, which loads the project's rig config, finds the plugin's typed
+ * implementation, and bridges stdin/stdout to the hook protocol.
+ * `--event` is informational (the runner trusts the metadata registration);
+ * `--plugin`/`--hook`/`--project-root` are the runner's actual inputs.
+ */
+export declare function buildTypedHookShimCommand(pluginName: string, hook: HookRegistration, projectRoot: string): string;

package/dist/src/hook-materializer.js

@@ -0,0 +1,152 @@
+// @bun
+// packages/core/src/hook-materializer.ts
+import { existsSync as existsSync2 } from "fs";
+import { resolve as resolve2 } from "path";
+
+// packages/core/src/hook-runtime.ts
+import { appendFileSync, existsSync, mkdirSync, readFileSync, realpathSync, writeSync } from "fs";
+import { resolve } from "path";
+import { RIG_DEFINITION_DIRNAME, RIG_STATE_DIRNAME } from "@rig/contracts";
+function bunRuntime() {
+  const runtime = globalThis;
+  return runtime.Bun;
+}
+function normalizeBuildConfig(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return {};
+  }
+  return Object.fromEntries(Object.entries(value).filter((entry) => typeof entry[1] === "string"));
+}
+function readBuildConfigForCoreHooks() {
+  if (typeof __RIG_BUILD_CONFIG__ !== "undefined") {
+    return normalizeBuildConfig(__RIG_BUILD_CONFIG__);
+  }
+  const raw = process.env.RIG_BUILD_CONFIG_JSON?.trim();
+  if (!raw) {
+    return {};
+  }
+  try {
+    return normalizeBuildConfig(JSON.parse(raw));
+  } catch {
+    return {};
+  }
+}
+var BUILD_CONFIG = readBuildConfigForCoreHooks();
+var BAKED_PROJECT_ROOT = BUILD_CONFIG.AGENT_PROJECT_ROOT ?? "";
+var BAKED_TASK_ID = BUILD_CONFIG.AGENT_TASK_ID ?? "";
+var BAKED_STATE_DIR = BUILD_CONFIG.AGENT_STATE_DIR ?? "";
+var BAKED_BUN_PATH = BUILD_CONFIG.AGENT_BUN_PATH ?? "";
+var BAKED_TASK_CONFIG = BUILD_CONFIG.AGENT_TASK_CONFIG ?? "";
+var BAKED_POLICY_CONTENT = BUILD_CONFIG.AGENT_POLICY_CONTENT ?? "";
+var BAKED_TASK_SCOPES = BUILD_CONFIG.AGENT_TASK_SCOPES ?? "";
+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");
+}
+function resolveBunBinaryPath() {
+  const explicit = normalizeExecutablePath(process.env.RIG_BUN_PATH?.trim());
+  if (explicit) {
+    return explicit;
+  }
+  const bunWhich = bunRuntime()?.which?.("bun");
+  const pathBun = normalizeExecutablePath(bunWhich?.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 resolveBunCliInvocation() {
+  if (BAKED_BUN_PATH) {
+    return {
+      command: BAKED_BUN_PATH,
+      env: {}
+    };
+  }
+  if (process.env.RIG_BUN_PATH?.trim()) {
+    return {
+      command: process.env.RIG_BUN_PATH.trim(),
+      env: {}
+    };
+  }
+  try {
+    const systemBun = resolveBunBinaryPath();
+    return {
+      command: systemBun,
+      env: {}
+    };
+  } catch {}
+  if (process.execPath?.trim()) {
+    return {
+      command: process.execPath,
+      env: { BUN_BE_BUN: "1" }
+    };
+  }
+  return { command: "bun", env: {} };
+}
+
+// packages/core/src/hook-materializer.ts
+function shellQuote(value) {
+  return `'${value.replaceAll("'", `'\\''`)}'`;
+}
+function resolveHookRunnerPath() {
+  const sibling = resolve2(import.meta.dirname, "hook-runner.ts");
+  if (existsSync2(sibling)) {
+    return sibling;
+  }
+  return "$CLAUDE_PROJECT_DIR/node_modules/@rig/core/src/hook-runner.ts";
+}
+function buildTypedHookShimCommand(pluginName, hook, projectRoot) {
+  const runnerPath = resolveHookRunnerPath();
+  const runnerArg = runnerPath.startsWith("$CLAUDE_PROJECT_DIR") ? `"${runnerPath}"` : shellQuote(runnerPath);
+  const bun = resolveBunCliInvocation();
+  const envPrefix = Object.entries(bun.env).map(([key, value]) => `${key}=${shellQuote(value)}`).join(" ");
+  const parts = [
+    envPrefix,
+    shellQuote(bun.command),
+    runnerArg,
+    "--plugin",
+    shellQuote(pluginName),
+    "--hook",
+    shellQuote(hook.id),
+    "--event",
+    shellQuote(hook.event),
+    "--project-root",
+    shellQuote(projectRoot)
+  ].filter(Boolean);
+  return parts.join(" ");
+}
+export {
+  resolveHookRunnerPath,
+  buildTypedHookShimCommand
+};

package/dist/src/hook-protocol.d.ts

@@ -0,0 +1,2 @@
+export type { HookInput, ParsedHookInput, TypedHookOptions } from "./hook-runtime";
+export { BAKED_BUN_PATH, BAKED_POLICY_CONTENT, BAKED_PROJECT_ROOT, BAKED_STATE_DIR, BAKED_TASK_CONFIG, BAKED_TASK_ID, BAKED_TASK_SCOPES, block, buildPluginHookContext, escapeRegExp, extractToolFilePaths, hookResultToProtocol, isTestFilePath, readHookInput, resolveBunCli, resolveBunCliInvocation, resolvePolicyContent, resolveProjectRoot, resolveTaskConfig, resolveTaskIdForHook, resolveTaskScopes, runTypedHook, } from "./hook-runtime";