@h-rig/rig-host 0.0.6-alpha.91

package/README.md

@@ -0,0 +1 @@
+# @h-rig/rig-host

package/dist/bin/rig-run.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env bun
+export {};

package/dist/bin/rig-run.js

@@ -0,0 +1,283 @@
+#!/usr/bin/env bun
+// @bun
+
+// packages/rig-host/bin/rig-run.ts
+import { randomUUID as randomUUID2 } from "crypto";
+import { resolve as resolve2 } from "path";
+
+// packages/rig-host/src/local-omp-runner.ts
+import { randomUUID } from "crypto";
+import { resolve } from "path";
+import { createAgentSession, SessionManager } from "@oh-my-pi/pi-coding-agent";
+import { parseArgs } from "@oh-my-pi/pi-coding-agent/cli/args";
+import { runRootCommand } from "@oh-my-pi/pi-coding-agent/main";
+import {
+  ensureAgentRuntime,
+  listAgentRuntimes,
+  resolveRuntimeTaskRecord,
+  runtimeEnv as hydrateRuntimeEnv
+} from "@rig/runtime/control-plane/runtime/isolation";
+import rigExtension from "@rig/rig-extension";
+
+// packages/rig-host/src/pty-spawn.ts
+import { spawn as nodeSpawn } from "child_process";
+import { closeSync as fsCloseSync, mkdirSync, openSync as fsOpenSync } from "fs";
+import { dirname } from "path";
+function buildPtyRunArgv(input) {
+  return ["-L", `rig-${input.runId}`, "new-session", "-d", "-s", `rig-run-${input.runId}`, input.rigRunBin, "--inside-pty", ...input.args];
+}
+async function spawnDetachedPtyRun(input, deps = {}) {
+  const tmux = await (deps.which ?? Bun.which)("tmux");
+  if (!tmux) {
+    throw new Error("tmux is required to launch a detached Rig PTY run. Install tmux or provide a Phase-0-approved PTY fallback.");
+  }
+  mkdirSync(dirname(input.logPath), { recursive: true });
+  const openSync = deps.openSync ?? fsOpenSync;
+  const closeSync = deps.closeSync ?? fsCloseSync;
+  const spawn = deps.spawn ?? nodeSpawn;
+  const logFd = openSync(input.logPath, "a");
+  const child = spawn(tmux, buildPtyRunArgv(input), {
+    cwd: input.cwd,
+    env: input.env,
+    detached: true,
+    stdio: ["ignore", logFd, logFd]
+  });
+  closeSync(logFd);
+  child.unref();
+  if (typeof child.pid !== "number")
+    throw new Error("tmux did not report a child process pid for the detached Rig run.");
+  return { pid: child.pid };
+}
+
+// packages/rig-host/src/local-omp-runner.ts
+async function provisionRunWorkspace(input) {
+  return (input.ensureRuntime ?? ensureAgentRuntime)({
+    projectRoot: input.projectRoot,
+    id: input.runId,
+    taskId: input.taskId,
+    mode: "worktree",
+    provider: "pi"
+  });
+}
+async function loadRunWorkspace(projectRoot, runId) {
+  const runtimes = await listAgentRuntimes(projectRoot);
+  const runtime = runtimes.find((candidate) => candidate.id === runId);
+  if (!runtime)
+    throw new Error(`Rig run workspace is not provisioned for run ${runId}.`);
+  return runtime;
+}
+async function applyRunEnv(input) {
+  const env = await (input.runtimeEnv ?? hydrateRuntimeEnv)(input.projectRoot, input.runtime);
+  for (const [key, value] of Object.entries(env))
+    process.env[key] = value;
+  return env;
+}
+async function launchInteractiveRun(input) {
+  await applyRunEnv({ projectRoot: input.projectRoot, runtime: input.runtime });
+  process.env.RIG_RUN_PROCESS = "1";
+  process.env.RIG_RUN_ID = input.runId;
+  process.env.RIG_TASK_ID = input.taskId;
+  process.env.PROJECT_RIG_ROOT = input.projectRoot;
+  process.env.RIG_HOST_PROJECT_ROOT = input.projectRoot;
+  if (input.title?.trim())
+    process.env.RIG_RUN_TITLE = input.title.trim();
+  if (input.forceSteerOnce)
+    process.env.RIG_RUN_FORCE_STEER_ONCE = "1";
+  const sessionManager = SessionManager.create(input.runtime.workspaceDir, input.runtime.sessionDir);
+  await sessionManager.ensureOnDisk();
+  const initialPrompt = input.prompt?.trim() || await (input.resolveInitialPrompt ?? buildRunInitialPrompt)(input.projectRoot, input.taskId);
+  const args = withRigDefaultConfig([
+    ...input.model?.trim() ? ["--model", input.model.trim()] : [],
+    initialPrompt
+  ]);
+  const createRigAgentSession = async (options = {}) => createAgentSession({
+    ...options,
+    cwd: input.runtime.workspaceDir,
+    agentDir: resolve(input.runtime.homeDir, ".pi", "agent"),
+    sessionManager,
+    extensions: [(api) => rigExtension(api), ...options.extensions ?? []]
+  });
+  await runRootCommand(parseArgs(args), args, { createAgentSession: createRigAgentSession });
+}
+async function runRunProcess(input) {
+  const projectRoot = resolve(input.projectRoot ?? process.cwd());
+  const runId = input.runId?.trim() || `run-${randomUUID()}`;
+  const runtime = await provisionRunWorkspace({
+    projectRoot,
+    taskId: input.taskId,
+    runId,
+    ...input.ensureRuntime ? { ensureRuntime: input.ensureRuntime } : {}
+  });
+  const rigRunBin = input.rigRunBin ?? resolve(import.meta.dir, "../bin/rig-run.ts");
+  const initialPrompt = input.prompt?.trim() || await (input.resolveInitialPrompt ?? buildRunInitialPrompt)(projectRoot, input.taskId);
+  const env = {
+    ...process.env,
+    RIG_RUN_PROCESS: "1",
+    RIG_RUN_ID: runId,
+    RIG_TASK_ID: input.taskId,
+    ...input.title?.trim() ? { RIG_RUN_TITLE: input.title.trim() } : {}
+  };
+  const args = [
+    "--task",
+    input.taskId,
+    "--run-id",
+    runId,
+    "--project",
+    projectRoot,
+    ...input.title?.trim() ? ["--title", input.title.trim()] : [],
+    ...input.model?.trim() ? ["--model", input.model.trim()] : [],
+    ...input.forceSteerOnce || process.env.RIG_RUN_FORCE_STEER_ONCE === "1" ? ["--force-steer-once"] : [],
+    "--prompt",
+    initialPrompt
+  ];
+  const spawnRun = input.spawnPtyRun ?? spawnDetachedPtyRun;
+  const { pid } = await spawnRun({
+    runId,
+    rigRunBin,
+    args,
+    cwd: runtime.workspaceDir,
+    env,
+    logPath: resolve(runtime.logsDir, "run-process.log")
+  });
+  const sessionName = `rig-run-${runId}`;
+  input.writeStdout?.(`${runId}
+${sessionName}
+`);
+  return { runId, pid, sessionName, runtime };
+}
+async function buildRunInitialPrompt(projectRoot, taskId) {
+  const { task } = await resolveRuntimeTaskRecord({ projectRoot, taskId });
+  const record = task;
+  const title = readPromptString(record.title) ?? taskId;
+  const body = readPromptString(record.body) ?? readPromptString(record.description);
+  const acceptance = readPromptString(record.acceptanceCriteria) ?? readPromptString(record.acceptance_criteria);
+  const scope = readPromptList(record.scope);
+  const validation = readPromptList(record.validation).length > 0 ? readPromptList(record.validation) : readPromptList(record.validators);
+  const sections = [
+    `You are working on task ${taskId}: ${title}.`,
+    body ? `Task:
+${body}` : null,
+    acceptance ? `Acceptance criteria:
+${acceptance}` : null,
+    scope.length > 0 ? `Scope:
+- ${scope.join(`
+- `)}` : null,
+    validation.length > 0 ? `Validation:
+- ${validation.join(`
+- `)}` : null,
+    "Work directly in the assigned runtime workspace and leave the result in a reviewable state."
+  ];
+  return sections.filter((value) => Boolean(value)).join(`
+
+`);
+}
+function readPromptString(value) {
+  return typeof value === "string" && value.trim().length > 0 ? value.trim() : null;
+}
+function readPromptList(value) {
+  return Array.isArray(value) ? value.filter((entry) => typeof entry === "string" && entry.trim().length > 0).map((entry) => entry.trim()) : [];
+}
+function withRigDefaultConfig(argv) {
+  return ["--config", resolve(import.meta.dir, "../../cli/config/rig-default-config.yml"), ...argv];
+}
+
+// packages/rig-host/bin/rig-run.ts
+function takeValue(args, index, flag) {
+  const value = args[index + 1]?.trim();
+  if (!value)
+    throw new Error(`${flag} requires a value.`);
+  return value;
+}
+function parseRigRunArgs(argv) {
+  let insidePty = false;
+  let taskId = "";
+  let runId = `run-${randomUUID2()}`;
+  let projectRoot = process.env.RIG_PROJECT_ROOT?.trim() || process.cwd();
+  let title;
+  let model;
+  let prompt;
+  let forceSteerOnce = process.env.RIG_RUN_FORCE_STEER_ONCE === "1";
+  for (let index = 0;index < argv.length; index += 1) {
+    const arg = argv[index];
+    if (arg === "--inside-pty") {
+      insidePty = true;
+    } else if (arg === "--task") {
+      taskId = takeValue(argv, index, arg);
+      index += 1;
+    } else if (arg === "--run-id") {
+      runId = takeValue(argv, index, arg);
+      index += 1;
+    } else if (arg === "--project") {
+      projectRoot = resolve2(takeValue(argv, index, arg));
+      index += 1;
+    } else if (arg === "--title") {
+      title = takeValue(argv, index, arg);
+      index += 1;
+    } else if (arg === "--model") {
+      model = takeValue(argv, index, arg);
+      index += 1;
+    } else if (arg === "--prompt" || arg === "--initial-prompt") {
+      prompt = takeValue(argv, index, arg);
+      index += 1;
+    } else if (arg === "--force-steer-once") {
+      forceSteerOnce = true;
+    } else {
+      throw new Error(`Unknown rig-run argument: ${arg}`);
+    }
+  }
+  if (!taskId.trim())
+    throw new Error("Usage: rig-run --task <id> [--run-id <id>] [--project <path>] [--title <title>] [--model <model>] [--prompt <prompt>]");
+  return {
+    insidePty,
+    taskId,
+    runId,
+    projectRoot: resolve2(projectRoot),
+    ...title !== undefined ? { title } : {},
+    ...model !== undefined ? { model } : {},
+    ...prompt !== undefined ? { prompt } : {},
+    ...forceSteerOnce ? { forceSteerOnce } : {}
+  };
+}
+async function main() {
+  let parsed;
+  try {
+    parsed = parseRigRunArgs(process.argv.slice(2));
+  } catch (error) {
+    process.stderr.write(`${error instanceof Error ? error.message : String(error)}
+`);
+    process.exitCode = 2;
+    return;
+  }
+  if (!parsed.insidePty) {
+    try {
+      await runRunProcess({
+        projectRoot: parsed.projectRoot,
+        taskId: parsed.taskId,
+        runId: parsed.runId,
+        ...parsed.title !== undefined ? { title: parsed.title } : {},
+        ...parsed.model !== undefined ? { model: parsed.model } : {},
+        ...parsed.prompt !== undefined ? { prompt: parsed.prompt } : {},
+        ...parsed.forceSteerOnce ? { forceSteerOnce: true } : {},
+        rigRunBin: import.meta.path,
+        writeStdout: (text) => process.stdout.write(text)
+      });
+    } catch (error) {
+      process.stderr.write(`Rig run bootstrap failed: ${error instanceof Error ? error.message : String(error)}
+`);
+      process.exitCode = 1;
+    }
+    return;
+  }
+  const runtime = await loadRunWorkspace(parsed.projectRoot, parsed.runId);
+  await launchInteractiveRun({
+    projectRoot: parsed.projectRoot,
+    runtime,
+    runId: parsed.runId,
+    taskId: parsed.taskId,
+    ...parsed.title !== undefined ? { title: parsed.title } : {},
+    ...parsed.model !== undefined ? { model: parsed.model } : {},
+    ...parsed.prompt !== undefined ? { prompt: parsed.prompt } : {},
+    ...parsed.forceSteerOnce ? { forceSteerOnce: true } : {}
+  });
+}
+await main();

package/dist/src/cli-entry.d.ts

@@ -0,0 +1 @@
+export declare function runRigHostCli(args: readonly string[]): Promise<void>;