@h-rig/cli 0.0.6-alpha.0

package/dist/src/commands/agent.js

@@ -0,0 +1,497 @@
+// @bun
+// packages/cli/src/commands/agent.ts
+import { resolve as resolve2 } from "path";
+
+// packages/cli/src/runner.ts
+import { EventBus } from "@rig/runtime/control-plane/runtime/events";
+import { CliError } from "@rig/runtime/control-plane/errors";
+import { evaluate, loadPolicy, resolveAction } from "@rig/runtime/control-plane/runtime/guard";
+import { PluginManager } from "@rig/runtime/control-plane/runtime/plugins";
+import { loadRuntimeContextFromEnv } from "@rig/runtime/control-plane/runtime/context";
+import { buildBinary } from "@rig/runtime/control-plane/runtime/isolation";
+import { CliError as CliError2 } from "@rig/runtime/control-plane/errors";
+function takeFlag(args, flag) {
+  const rest = [];
+  let value = false;
+  for (const arg of args) {
+    if (arg === flag) {
+      value = true;
+      continue;
+    }
+    rest.push(arg);
+  }
+  return { value, rest };
+}
+function takeOption(args, option) {
+  const rest = [];
+  let value;
+  for (let index = 0;index < args.length; index += 1) {
+    const current = args[index];
+    if (current === option) {
+      const next = args[index + 1];
+      if (!next || next.startsWith("-")) {
+        throw new CliError(`Missing value for ${option}`);
+      }
+      value = next;
+      index += 1;
+      continue;
+    }
+    if (current !== undefined) {
+      rest.push(current);
+    }
+  }
+  return { value, rest };
+}
+function requireNoExtraArgs(args, usage) {
+  if (args.length > 0) {
+    throw new CliError(`Unexpected arguments: ${args.join(" ")}
+Usage: ${usage}`);
+  }
+}
+
+// packages/cli/src/commands/agent.ts
+import {
+  agentId,
+  cleanupAgentRuntime,
+  ensureAgentRuntime,
+  listAgentRuntimes,
+  runInAgentRuntime
+} from "@rig/runtime/control-plane/runtime/isolation";
+
+// packages/cli/src/commands/_authority-runs.ts
+import { existsSync } from "fs";
+import { resolve } from "path";
+import {
+  readAuthorityRun,
+  readJsonlFile,
+  resolveAuthorityRunDir,
+  writeJsonFile
+} from "@rig/runtime/control-plane/authority-files";
+
+// packages/cli/src/commands/_paths.ts
+import { resolveMonorepoRoot } from "@rig/runtime/control-plane/native/utils";
+function resolveControlPlaneMonorepoRoot(projectRoot) {
+  return resolveMonorepoRoot(projectRoot);
+}
+
+// packages/cli/src/commands/_authority-runs.ts
+var RIG_WORKSPACE_ID = "rig-local-workspace";
+function normalizeRuntimeAdapter(value) {
+  const normalized = value?.trim().toLowerCase();
+  if (!normalized) {
+    return "pi";
+  }
+  if (normalized === "codex" || normalized === "codex-cli" || normalized === "codex-app-server" || normalized === "gpt-codex") {
+    return "codex";
+  }
+  if (normalized === "pi" || normalized === "rig-pi" || normalized === "@rig/pi") {
+    return "pi";
+  }
+  return "claude-code";
+}
+function readLatestBeadRecord(projectRoot, taskId) {
+  const issuesPath = resolve(resolveControlPlaneMonorepoRoot(projectRoot), ".beads", "issues.jsonl");
+  if (!existsSync(issuesPath)) {
+    return null;
+  }
+  let latest = null;
+  for (const issue of readJsonlFile(issuesPath)) {
+    if (!issue || typeof issue !== "object") {
+      continue;
+    }
+    const record = issue;
+    if (record.id === taskId) {
+      latest = record;
+    }
+  }
+  return latest;
+}
+function resolveTaskTitleForAuthorityRun(projectRoot, taskId) {
+  try {
+    const record = readLatestBeadRecord(projectRoot, taskId);
+    const title = record && typeof record.title === "string" ? record.title.trim() : "";
+    if (title) {
+      return title;
+    }
+  } catch {}
+  return null;
+}
+function upsertAgentAuthorityRun(projectRoot, input) {
+  const current = readAuthorityRun(projectRoot, input.runId);
+  const existing = current;
+  const createdAt = existing?.createdAt ?? input.createdAt;
+  const runtimeMode = typeof existing?.runtimeMode === "string" ? existing.runtimeMode : "full-access";
+  const interactionMode = typeof existing?.interactionMode === "string" ? existing.interactionMode : "default";
+  const runMode = typeof existing?.runMode === "string" ? existing.runMode : "autonomous";
+  const runtimeAdapter = normalizeRuntimeAdapter(input.runtimeAdapter ?? existing?.runtimeAdapter ?? "claude-code");
+  const title = resolveTaskTitleForAuthorityRun(projectRoot, input.taskId) ?? input.taskId;
+  const next = {
+    runId: input.runId,
+    projectRoot,
+    workspaceId: existing?.workspaceId ?? RIG_WORKSPACE_ID,
+    taskId: input.taskId,
+    threadId: existing?.threadId ?? null,
+    mode: "local",
+    runtimeAdapter,
+    status: input.status,
+    createdAt,
+    startedAt: input.startedAt ?? existing?.startedAt ?? null,
+    completedAt: input.completedAt ?? existing?.completedAt ?? null,
+    endpointId: existing?.endpointId ?? null,
+    hostId: existing?.hostId ?? null,
+    worktreePath: input.worktreePath ?? existing?.worktreePath ?? null,
+    artifactRoot: input.artifactRoot ?? existing?.artifactRoot ?? null,
+    logRoot: input.logRoot ?? existing?.logRoot ?? null,
+    sessionPath: input.sessionPath ?? existing?.sessionPath ?? null,
+    sessionLogPath: input.sessionLogPath ?? existing?.sessionLogPath ?? null,
+    pid: input.pid ?? existing?.pid ?? null,
+    updatedAt: input.createdAt,
+    title,
+    model: typeof existing?.model === "string" ? existing.model : null,
+    runtimeMode,
+    interactionMode,
+    runMode,
+    initialPrompt: typeof existing?.initialPrompt === "string" ? existing.initialPrompt : null
+  };
+  if (input.errorText !== undefined) {
+    next.errorText = input.errorText;
+  } else if ("errorText" in next) {
+    delete next.errorText;
+  }
+  writeJsonFile(resolve(resolveAuthorityRunDir(projectRoot, input.runId), "run.json"), next);
+  return next;
+}
+
+// packages/cli/src/withMutedConsole.ts
+function isPromise(value) {
+  if (typeof value !== "object" && typeof value !== "function") {
+    return false;
+  }
+  return value !== null && typeof value.then === "function";
+}
+function withMutedConsole(mute, fn) {
+  if (!mute) {
+    return fn();
+  }
+  const originalLog = console.log;
+  const originalWarn = console.warn;
+  const originalInfo = console.info;
+  const restore = () => {
+    console.log = originalLog;
+    console.warn = originalWarn;
+    console.info = originalInfo;
+  };
+  console.log = () => {};
+  console.warn = () => {};
+  console.info = () => {};
+  try {
+    const result = fn();
+    if (isPromise(result)) {
+      return result.finally(restore);
+    }
+    restore();
+    return result;
+  } catch (error) {
+    restore();
+    throw error;
+  } finally {
+    if (console.log === originalLog) {
+      restore();
+    }
+  }
+}
+
+// packages/cli/src/commands/_parsers.ts
+function parseIsolationMode(value, allowOff) {
+  if (!value) {
+    return "worktree";
+  }
+  if (value === "worktree") {
+    return value;
+  }
+  if (allowOff && value === "off") {
+    return value;
+  }
+  throw new CliError2(`Invalid isolation mode: ${value}. Use ${allowOff ? "off|" : ""}worktree.`);
+}
+
+// packages/cli/src/commands/_preflight.ts
+import { ensureProjectMainFreshBeforeRun } from "@rig/runtime/control-plane/project-main-pre-run-sync";
+
+// packages/cli/src/commands/_server-client.ts
+import { ensureLocalRigServerConnection } from "@rig/runtime/local-server";
+
+// packages/cli/src/commands/_preflight.ts
+async function runProjectMainSyncPreflight(context, options) {
+  if (context.dryRun) {
+    if (context.outputMode === "text" && !options.disabled) {
+      console.log("[dry-run] project-rig pre-run sync check");
+    }
+    return;
+  }
+  const result = await ensureProjectMainFreshBeforeRun({
+    projectRoot: context.projectRoot,
+    disabled: options.disabled,
+    runBootstrap: async () => {
+      const bootstrap = await context.runCommand(["bun", "run", "bootstrap"]);
+      if (bootstrap.exitCode !== 0) {
+        throw new CliError2(bootstrap.stderr || bootstrap.stdout || "bun run bootstrap failed during project pre-run sync", bootstrap.exitCode || 1);
+      }
+    }
+  });
+  if (context.outputMode !== "text") {
+    return;
+  }
+  switch (result.status) {
+    case "disabled":
+      console.log("Project pre-run sync skipped (--skip-project-sync).");
+      break;
+    case "skipped_not_main":
+      console.log(`Project pre-run sync skipped (current branch: ${result.branch}).`);
+      break;
+    case "up_to_date":
+      break;
+    case "local_ahead":
+      console.log(`Project pre-run sync skipped (local main ahead by ${result.localAhead} commit(s)).`);
+      break;
+    case "updated":
+      console.log(`Project pre-run sync updated local main from origin/main (+${result.remoteAhead}) and bootstrapped.`);
+      break;
+  }
+}
+
+// packages/cli/src/commands/agent.ts
+function splitAtDoubleDash(args) {
+  const separatorIndex = args.indexOf("--");
+  if (separatorIndex === -1) {
+    return { options: args, commandParts: [] };
+  }
+  return {
+    options: args.slice(0, separatorIndex),
+    commandParts: args.slice(separatorIndex + 1)
+  };
+}
+async function attachEventBusToProvisionedRuntime(context, workspaceDir) {
+  const previousWorkspace = process.env.RIG_TASK_WORKSPACE;
+  process.env.RIG_TASK_WORKSPACE = workspaceDir;
+  try {
+    await context.eventBus.attachRuntimeWorkspace(context.projectRoot);
+  } finally {
+    if (previousWorkspace === undefined) {
+      delete process.env.RIG_TASK_WORKSPACE;
+    } else {
+      process.env.RIG_TASK_WORKSPACE = previousWorkspace;
+    }
+  }
+}
+async function executeAgent(context, args) {
+  const [command = "list", ...rest] = args;
+  switch (command) {
+    case "list": {
+      requireNoExtraArgs(rest, "bun run rig agent list");
+      const runtimes = await listAgentRuntimes(context.projectRoot);
+      if (context.outputMode === "text") {
+        if (runtimes.length === 0) {
+          console.log("No agent runtimes.");
+        } else {
+          for (const runtime of runtimes) {
+            console.log(`${runtime.id} (${runtime.mode}) workspace=${runtime.workspaceDir} created=${runtime.createdAt}`);
+          }
+        }
+      }
+      return { ok: true, group: "agent", command, details: { runtimes } };
+    }
+    case "prepare": {
+      let pending = rest;
+      const idResult = takeOption(pending, "--id");
+      pending = idResult.rest;
+      const modeResult = takeOption(pending, "--mode");
+      pending = modeResult.rest;
+      const taskResult = takeOption(pending, "--task");
+      pending = taskResult.rest;
+      requireNoExtraArgs(pending, "bun run rig agent prepare --task <id> [--id <id>] [--mode worktree]");
+      const mode = parseIsolationMode(modeResult.value, false);
+      const id = idResult.value || agentId("agent");
+      const taskId = taskResult.value?.trim();
+      if (!taskId) {
+        throw new CliError2("Usage: bun run rig agent prepare --task <id> [--id <id>] [--mode worktree]");
+      }
+      const runtime = await withMutedConsole(context.outputMode === "json", () => ensureAgentRuntime({
+        projectRoot: context.projectRoot,
+        id,
+        taskId,
+        mode
+      }));
+      await attachEventBusToProvisionedRuntime(context, runtime.workspaceDir);
+      if (context.outputMode === "text") {
+        console.log(`Prepared runtime ${runtime.id} (${runtime.mode})`);
+        console.log(`Workspace: ${runtime.workspaceDir}`);
+      }
+      return { ok: true, group: "agent", command, details: { runtime } };
+    }
+    case "run": {
+      const { options, commandParts } = splitAtDoubleDash(rest);
+      if (commandParts.length === 0) {
+        throw new CliError2("Usage: bun run rig agent run [--id <id>] [--mode worktree] [--skip-project-sync] -- <command...>");
+      }
+      let pending = options;
+      const idResult = takeOption(pending, "--id");
+      pending = idResult.rest;
+      const modeResult = takeOption(pending, "--mode");
+      pending = modeResult.rest;
+      const taskResult = takeOption(pending, "--task");
+      pending = taskResult.rest;
+      const skipProjectSyncResult = takeFlag(pending, "--skip-project-sync");
+      pending = skipProjectSyncResult.rest;
+      requireNoExtraArgs(pending, "bun run rig agent run --task <id> [--id <id>] [--mode worktree] [--skip-project-sync] -- <command...>");
+      const mode = parseIsolationMode(modeResult.value, false);
+      const id = idResult.value || agentId("agent-run");
+      const taskId = taskResult.value?.trim();
+      if (!taskId) {
+        throw new CliError2("Usage: bun run rig agent run --task <id> [--id <id>] [--mode worktree] [--skip-project-sync] -- <command...>");
+      }
+      await runProjectMainSyncPreflight(context, { disabled: skipProjectSyncResult.value });
+      const createdAt = new Date().toISOString();
+      upsertAgentAuthorityRun(context.projectRoot, {
+        runId: id,
+        taskId,
+        createdAt,
+        runtimeAdapter: process.env.RIG_RUNTIME_ADAPTER || "claude-code",
+        status: "preparing",
+        startedAt: createdAt
+      });
+      try {
+        const runtime = await withMutedConsole(context.outputMode === "json", () => ensureAgentRuntime({
+          projectRoot: context.projectRoot,
+          id,
+          taskId,
+          mode
+        }));
+        await attachEventBusToProvisionedRuntime(context, runtime.workspaceDir);
+        const runningAt = new Date().toISOString();
+        upsertAgentAuthorityRun(context.projectRoot, {
+          runId: runtime.id,
+          taskId,
+          createdAt: runningAt,
+          runtimeAdapter: process.env.RIG_RUNTIME_ADAPTER || "claude-code",
+          status: "running",
+          startedAt: createdAt,
+          worktreePath: runtime.workspaceDir,
+          artifactRoot: resolve2(runtime.workspaceDir, "artifacts", taskId),
+          logRoot: runtime.logsDir,
+          sessionPath: resolve2(runtime.sessionDir, "session.json"),
+          sessionLogPath: resolve2(runtime.logsDir, "agent-stdout.log"),
+          pid: process.pid
+        });
+        const result = await runInAgentRuntime({
+          projectRoot: context.projectRoot,
+          runtime,
+          command: commandParts,
+          inheritStdio: context.outputMode === "text"
+        });
+        if (result.exitCode !== 0) {
+          const failedAt = new Date().toISOString();
+          upsertAgentAuthorityRun(context.projectRoot, {
+            runId: runtime.id,
+            taskId,
+            createdAt: failedAt,
+            runtimeAdapter: process.env.RIG_RUNTIME_ADAPTER || "claude-code",
+            status: "failed",
+            startedAt: createdAt,
+            completedAt: failedAt,
+            worktreePath: runtime.workspaceDir,
+            artifactRoot: resolve2(runtime.workspaceDir, "artifacts", taskId),
+            logRoot: runtime.logsDir,
+            sessionPath: resolve2(runtime.sessionDir, "session.json"),
+            sessionLogPath: resolve2(runtime.logsDir, "agent-stdout.log"),
+            pid: process.pid,
+            errorText: result.stderr ? result.stderr.trim() : `Agent runtime command failed (${result.exitCode})`
+          });
+          throw new CliError2(`Agent runtime command failed (${result.exitCode}) in ${runtime.id}${result.stderr ? `
+${result.stderr.trim()}` : ""}`, result.exitCode);
+        }
+        const completedAt = new Date().toISOString();
+        upsertAgentAuthorityRun(context.projectRoot, {
+          runId: runtime.id,
+          taskId,
+          createdAt: completedAt,
+          runtimeAdapter: process.env.RIG_RUNTIME_ADAPTER || "claude-code",
+          status: "completed",
+          startedAt: createdAt,
+          completedAt,
+          worktreePath: runtime.workspaceDir,
+          artifactRoot: resolve2(runtime.workspaceDir, "artifacts", taskId),
+          logRoot: runtime.logsDir,
+          sessionPath: resolve2(runtime.sessionDir, "session.json"),
+          sessionLogPath: resolve2(runtime.logsDir, "agent-stdout.log"),
+          pid: process.pid
+        });
+        return {
+          ok: true,
+          group: "agent",
+          command,
+          details: {
+            runtimeId: runtime.id,
+            mode: runtime.mode,
+            command: commandParts,
+            exitCode: result.exitCode,
+            sandboxBackend: result.sandboxBackend,
+            sandboxEnabled: result.sandboxEnabled,
+            stdout: result.stdout,
+            stderr: result.stderr
+          }
+        };
+      } catch (error) {
+        const failedAt = new Date().toISOString();
+        upsertAgentAuthorityRun(context.projectRoot, {
+          runId: id,
+          taskId,
+          createdAt: failedAt,
+          runtimeAdapter: process.env.RIG_RUNTIME_ADAPTER || "claude-code",
+          status: "failed",
+          startedAt: createdAt,
+          completedAt: failedAt,
+          errorText: error instanceof Error ? error.message : String(error)
+        });
+        throw error;
+      }
+    }
+    case "cleanup": {
+      let pending = rest;
+      const allResult = takeFlag(pending, "--all");
+      pending = allResult.rest;
+      const idResult = takeOption(pending, "--id");
+      pending = idResult.rest;
+      requireNoExtraArgs(pending, "bun run rig agent cleanup (--id <id> | --all)");
+      if (!allResult.value && !idResult.value) {
+        throw new CliError2("Provide --id <id> or --all.");
+      }
+      const runtimes = await listAgentRuntimes(context.projectRoot);
+      const targets = allResult.value ? runtimes.map((runtime) => runtime.id) : [idResult.value];
+      for (const id of targets) {
+        await cleanupAgentRuntime({
+          projectRoot: context.projectRoot,
+          id
+        });
+      }
+      if (context.outputMode === "text") {
+        console.log(`Cleaned runtimes: ${targets.join(", ")}`);
+      }
+      return {
+        ok: true,
+        group: "agent",
+        command,
+        details: {
+          cleaned: targets,
+          count: targets.length,
+          all: allResult.value
+        }
+      };
+    }
+    default:
+      throw new CliError2(`Unknown agent command: ${command}`);
+  }
+}
+export {
+  executeAgent
+};