@h-rig/runtime 0.0.6-alpha.0

package/dist/src/events.js

@@ -0,0 +1,218 @@
+// @bun
+// packages/runtime/src/events.ts
+import { appendFile, mkdir } from "fs/promises";
+import { randomUUID } from "crypto";
+import { dirname as dirname2, resolve as resolve2 } from "path";
+
+// packages/runtime/src/layout.ts
+import { existsSync } from "fs";
+import { basename, dirname, resolve } from "path";
+var RIG_DEFINITION_DIRNAME = "rig";
+var RIG_ARTIFACTS_DIRNAME = "artifacts";
+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;
+}
+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")
+  };
+}
+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 resolve(explicit);
+}
+function resolveRigLayout(projectRoot) {
+  const monorepoRoot = resolveMonorepoRoot(projectRoot);
+  const definitionRoot = resolve(projectRoot, RIG_DEFINITION_DIRNAME);
+  const runtimeWorkspaceRoot = resolveActiveRuntimeWorkspaceRoot(monorepoRoot);
+  const runtimeLayout = resolveRuntimeWorkspaceLayout(runtimeWorkspaceRoot);
+  const policyDir = resolve(definitionRoot, "policy");
+  return {
+    projectRoot,
+    monorepoRoot,
+    definitionRoot,
+    runtimeWorkspaceRoot,
+    stateRoot: runtimeLayout.rigRoot,
+    artifactsRoot: runtimeLayout.artifactsRoot,
+    configPath: resolve(definitionRoot, "config.sh"),
+    taskConfigPath: resolve(runtimeWorkspaceRoot, ".rig", "task-config.json"),
+    policyDir,
+    policyFile: resolve(policyDir, "policy.json"),
+    pluginsDir: resolve(definitionRoot, "plugins"),
+    hooksDir: resolve(definitionRoot, "hooks"),
+    toolsDir: resolve(definitionRoot, "tools"),
+    templatesDir: resolve(definitionRoot, "templates"),
+    validationDir: resolve(definitionRoot, "validation"),
+    stateDir: runtimeLayout.stateDir,
+    logsDir: runtimeLayout.logsDir,
+    notificationsDir: resolve(definitionRoot, "notifications"),
+    runtimeDir: runtimeLayout.runtimeDir,
+    distDir: runtimeLayout.distDir,
+    binDir: runtimeLayout.binDir,
+    pluginBinDir: runtimeLayout.pluginBinDir,
+    keybindingsPath: resolve(definitionRoot, "keybindings.json"),
+    controlPlaneEventsFile: runtimeLayout.controlPlaneEventsFile
+  };
+}
+
+// packages/runtime/src/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 ?? resolve2(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/execution.js

@@ -0,0 +1,35 @@
+// @bun
+// packages/runtime/src/execution.ts
+function assertMatchingIds(bundle, lease) {
+  if (bundle.runId !== lease.runId) {
+    throw new Error(`Remote bundle runId ${bundle.runId} does not match lease runId ${lease.runId}`);
+  }
+  if (bundle.leaseId !== lease.leaseId) {
+    throw new Error(`Remote bundle leaseId ${bundle.leaseId} does not match lease leaseId ${lease.leaseId}`);
+  }
+  if (bundle.workspaceId !== lease.workspaceId) {
+    throw new Error(`Remote bundle workspaceId ${bundle.workspaceId} does not match lease workspaceId ${lease.workspaceId}`);
+  }
+}
+function createRuntimeExecutionSession(args) {
+  assertMatchingIds(args.bundle, args.lease);
+  return {
+    runId: args.bundle.runId,
+    leaseId: args.bundle.leaseId,
+    workspaceId: args.bundle.workspaceId,
+    hostId: args.lease.remoteHostId,
+    runtimeAdapter: args.bundle.runtimeAdapter,
+    runtimeMode: args.bundle.runtimeMode,
+    interactionMode: args.bundle.interactionMode,
+    model: args.bundle.model,
+    prompt: args.bundle.prompt,
+    workspacePath: args.bundle.workspacePath,
+    taskId: args.bundle.taskId,
+    taskTitle: args.bundle.taskTitle,
+    conversationLength: args.bundle.conversation.length,
+    startedAt: args.startedAt ?? new Date().toISOString()
+  };
+}
+export {
+  createRuntimeExecutionSession
+};