@h-rig/cli-surface-plugin 0.0.6-alpha.146

package/dist/src/commands/agent.js

@@ -0,0 +1,322 @@
+// @bun
+// packages/cli-surface-plugin/src/runner.ts
+import { EventBus } from "@rig/runtime/control-plane/runtime/events";
+import { CliError as RuntimeCliError } from "@rig/runtime/control-plane/errors";
+import { evaluate, loadPolicy, resolveAction } from "@rig/runtime/control-plane/runtime/guard";
+import { buildBinary } from "@rig/runtime/control-plane/runtime/isolation";
+
+class CliError extends RuntimeCliError {
+  hint;
+  constructor(message, exitCode = 1, options = {}) {
+    super(message, exitCode);
+    if (options.hint?.trim()) {
+      this.hint = options.hint.trim();
+    }
+  }
+}
+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}`, 1, { hint: `Provide a value after ${option}, e.g. \`${option} <value>\`.` });
+      }
+      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-surface-plugin/src/commands/agent.ts
+import {
+  agentId,
+  cleanupAgentRuntime,
+  ensureAgentRuntime,
+  listAgentRuntimes,
+  runInAgentRuntime
+} from "@rig/runtime/control-plane/runtime/isolation";
+
+// packages/cli-surface-plugin/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-surface-plugin/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 CliError(`Invalid isolation mode: ${value}. Use ${allowOff ? "off|" : ""}worktree.`);
+}
+
+// packages/cli-surface-plugin/src/commands/agent.ts
+import { ensureProjectMainFreshBeforeRun } from "@rig/runtime/control-plane/project-main-pre-run-sync";
+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 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 CliError(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;
+  }
+}
+async function executeAgent(context, args) {
+  const [command = "list", ...rest] = args;
+  switch (command) {
+    case "list": {
+      requireNoExtraArgs(rest, "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, "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 CliError("Usage: 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 CliError("Usage: 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, "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 CliError("Usage: rig agent run --task <id> [--id <id>] [--mode worktree] [--skip-project-sync] -- <command...>");
+      }
+      await runProjectMainSyncPreflight(context, { disabled: skipProjectSyncResult.value });
+      try {
+        const runtime = await withMutedConsole(context.outputMode === "json", () => ensureAgentRuntime({
+          projectRoot: context.projectRoot,
+          id,
+          taskId,
+          mode
+        }));
+        await attachEventBusToProvisionedRuntime(context, runtime.workspaceDir);
+        const result = await runInAgentRuntime({
+          projectRoot: context.projectRoot,
+          runtime,
+          command: commandParts,
+          inheritStdio: context.outputMode === "text"
+        });
+        if (result.exitCode !== 0) {
+          throw new CliError(`Agent runtime command failed (${result.exitCode}) in ${runtime.id}${result.stderr ? `
+${result.stderr.trim()}` : ""}`, result.exitCode);
+        }
+        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) {
+        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, "rig agent cleanup (--id <id> | --all)");
+      if (!allResult.value && !idResult.value) {
+        throw new CliError("Provide --id <id> or --all.", 1, { hint: "Run `rig agent list` to find agent ids." });
+      }
+      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 CliError(`Unknown agent command: ${command}`, 1, { hint: "Run `rig agent --help` to list agent commands." });
+  }
+}
+export {
+  executeAgent
+};

package/dist/src/commands/config.d.ts

@@ -0,0 +1,3 @@
+import type { CommandOutcome } from "@rig/runtime";
+import { type RunnerContext } from "../runner";
+export declare function executeConfig(context: RunnerContext, args: string[]): Promise<CommandOutcome>;

package/dist/src/commands/config.js

@@ -0,0 +1,193 @@
+// @bun
+// packages/cli-surface-plugin/src/commands/config.ts
+import { existsSync, readFileSync, writeFileSync } from "fs";
+import { resolve } from "path";
+import { loadConfig } from "@rig/core/load-config";
+import {
+  DEFAULT_RIG_RELAY_URL,
+  DEFAULT_RIG_REGISTRY_URL,
+  resolveDispatchTransportPlacement,
+  resolveRegistryBaseUrl,
+  resolveRelayUrl
+} from "@rig/runtime/control-plane/remote-config";
+
+// packages/cli-surface-plugin/src/runner.ts
+import { EventBus } from "@rig/runtime/control-plane/runtime/events";
+import { CliError as RuntimeCliError } from "@rig/runtime/control-plane/errors";
+import { evaluate, loadPolicy, resolveAction } from "@rig/runtime/control-plane/runtime/guard";
+import { buildBinary } from "@rig/runtime/control-plane/runtime/isolation";
+
+class CliError extends RuntimeCliError {
+  hint;
+  constructor(message, exitCode = 1, options = {}) {
+    super(message, exitCode);
+    if (options.hint?.trim()) {
+      this.hint = options.hint.trim();
+    }
+  }
+}
+function requireNoExtraArgs(args, usage) {
+  if (args.length > 0) {
+    throw new CliError(`Unexpected arguments: ${args.join(" ")}
+Usage: ${usage}`);
+  }
+}
+
+// packages/cli-surface-plugin/src/commands/_cli-format.ts
+import pc from "picocolors";
+import { runStatusColorRole, runStatusText, statusColorRole } from "@rig/client";
+var dim = pc.dim;
+var faintBar = pc.dim("\u2502");
+var accent = pc.cyan;
+function printFormattedOutput(message) {
+  console.log(message);
+}
+
+// packages/cli-surface-plugin/src/commands/config.ts
+var KNOBS = {
+  "runtime.server.relayUrl": { env: "RIG_COLLAB_RELAY", effective: () => resolveRelayUrl(), def: DEFAULT_RIG_RELAY_URL },
+  "runtime.server.registryUrl": { env: "RIG_REGISTRY_URL", effective: (r) => resolveRegistryBaseUrl(r), def: DEFAULT_RIG_REGISTRY_URL },
+  "runtime.server.sshTarget": {
+    env: "RIG_SSH_TARGET",
+    effective: (r) => {
+      const placement = resolveDispatchTransportPlacement(r);
+      return placement.kind === "remote" ? placement.sshTarget : "(none \u2014 local placement)";
+    },
+    def: "(none)",
+    source: (r) => {
+      if (process.env.RIG_SSH_TARGET?.trim())
+        return null;
+      const placement = resolveDispatchTransportPlacement(r);
+      return placement.kind === "remote" && placement.selected ? `rig server use ${placement.selected.alias}` : null;
+    }
+  }
+};
+var ALIASES = {
+  relayUrl: "runtime.server.relayUrl",
+  registryUrl: "runtime.server.registryUrl",
+  sshTarget: "runtime.server.sshTarget"
+};
+function canonicalKey(key) {
+  return ALIASES[key] ?? key;
+}
+async function loadProjectConfig(root) {
+  try {
+    return await loadConfig(root);
+  } catch {
+    return null;
+  }
+}
+function configHasKnob(config, canonical, envKey) {
+  if (!config)
+    return false;
+  const server = config.runtime?.server;
+  const field = canonical.replace("runtime.server.", "");
+  if (server && server[field] !== undefined)
+    return true;
+  if (server && server.host !== undefined && (field === "relayUrl" || field === "registryUrl"))
+    return true;
+  const envMap = config.env;
+  return Boolean(envMap && envMap[envKey] !== undefined);
+}
+function describe(root, config, canonical) {
+  const knob = KNOBS[canonical];
+  if (!knob) {
+    const val = process.env[canonical];
+    const fromConfig = Boolean(config?.env?.[canonical]);
+    return `${canonical} = ${val ?? "(unset)"}  [${val === undefined ? "default" : fromConfig ? "rig.config.ts" : "env"}]`;
+  }
+  const value = knob.effective(root);
+  const inConfig = configHasKnob(config, canonical, knob.env);
+  const ambient = Boolean(process.env[knob.env]);
+  const source = knob.source?.(root) ?? (inConfig ? "rig.config.ts" : ambient ? "env" : "default");
+  return `${canonical} = ${value}  [${source}]`;
+}
+async function configGet(context, args) {
+  const root = context.projectRoot;
+  const config = await loadProjectConfig(root);
+  const text = context.outputMode === "text";
+  if (args[0]) {
+    const canonical = canonicalKey(args[0]);
+    requireNoExtraArgs(args.slice(1), "rig config get [<key>]");
+    if (text)
+      printFormattedOutput(describe(root, config, canonical));
+    return { ok: true, group: "config", command: "get", details: { key: canonical } };
+  }
+  const lines = ["\u25C6 Rig config \u2014 effective values (ambient env \u2192 rig.config.ts \u2192 default)"];
+  for (const canonical of Object.keys(KNOBS))
+    lines.push(`  ${describe(root, config, canonical)}`);
+  const envMap = config?.env ?? {};
+  const envKeys = Object.keys(envMap);
+  lines.push(envKeys.length ? `  env overrides: ${envKeys.join(", ")}` : "  env overrides: (none)");
+  if (text)
+    printFormattedOutput(lines.join(`
+`));
+  return { ok: true, group: "config", command: "get", details: {} };
+}
+function writeEnvOverride(source, envKey, value) {
+  const entry = `    ${JSON.stringify(envKey)}: ${JSON.stringify(value)},`;
+  const envBlock = /env\s*:\s*\{([\s\S]*?)\}/m;
+  const m = envBlock.exec(source);
+  if (m) {
+    const body = m[1] ?? "";
+    const keyRe = new RegExp(`(^|\\n)\\s*${envKey.replace(/[.*+?^${}()|[\\]\\\\]/g, "\\$&")}\\s*:\\s*[^,\\n]*,?`, "m");
+    const quotedRe = new RegExp(`(^|\\n)\\s*["']${envKey}["']\\s*:\\s*[^,\\n]*,?`, "m");
+    if (keyRe.test(body) || quotedRe.test(body)) {
+      const newBody = body.replace(quotedRe, `
+${entry}`).replace(keyRe, `
+${entry}`);
+      return source.replace(envBlock, `env: {${newBody}
+  }`);
+    }
+    return source.replace(envBlock, `env: {
+${entry}${body}}`);
+  }
+  const defRe = /defineConfig\s*\(\s*\{/m;
+  if (!defRe.test(source)) {
+    throw new CliError("Could not find `defineConfig({` in rig.config.ts to insert an env override.", 2, {
+      hint: `Add manually: env: { ${JSON.stringify(envKey)}: ${JSON.stringify(value)} }`
+    });
+  }
+  return source.replace(defRe, (match) => `${match}
+  env: {
+${entry}
+  },`);
+}
+async function configSet(context, args) {
+  const [rawKey, ...valueParts] = args;
+  if (!rawKey || valueParts.length === 0) {
+    throw new CliError("Usage: rig config set <key> <value>", 2, {
+      hint: `Keys: ${Object.keys(ALIASES).join(", ")}, or any RIG_* env var.`
+    });
+  }
+  const value = valueParts.join(" ");
+  const canonical = canonicalKey(rawKey);
+  const envKey = KNOBS[canonical]?.env ?? canonical;
+  const configPath = resolve(context.projectRoot, "rig.config.ts");
+  if (!existsSync(configPath)) {
+    throw new CliError(`No rig.config.ts at ${context.projectRoot}.`, 2, { hint: "Run `rig init` first." });
+  }
+  const source = readFileSync(configPath, "utf8");
+  const updated = writeEnvOverride(source, envKey, value);
+  writeFileSync(configPath, updated);
+  if (context.outputMode === "text") {
+    printFormattedOutput(`Set ${canonical} (env ${envKey}) = ${value} in rig.config.ts`);
+  }
+  return { ok: true, group: "config", command: "set", details: { key: canonical, env: envKey, value } };
+}
+async function executeConfig(context, args) {
+  const [sub, ...rest] = args;
+  switch (sub) {
+    case "get":
+      return configGet(context, rest);
+    case "set":
+      return configSet(context, rest);
+    default:
+      throw new CliError("Usage: rig config <get|set>", 2, {
+        hint: "rig config get [<key>] \u2014 effective value + source; rig config set <key> <value> \u2014 write to rig.config.ts"
+      });
+  }
+}
+export {
+  executeConfig
+};

package/dist/src/commands/dist.d.ts

@@ -0,0 +1,28 @@
+import { type RunnerContext } from "../runner";
+import type { CommandOutcome } from "@rig/runtime";
+export type DistDoctorDetails = {
+    bun: {
+        available: boolean;
+        path: string | null;
+        version: string;
+    };
+    rig: {
+        onPath: boolean;
+        path: string | null;
+        runnable: boolean;
+    };
+    userBinDir: string;
+    userBinInPath: boolean;
+    latestDistBinary: string | null;
+};
+export type BuildTarget = {
+    source: string;
+    dest: string;
+    cwd: string;
+};
+export declare function collectRigValidatorBuildTargets(input: {
+    contextProjectRoot: string;
+    hostProjectRoot: string;
+    imageDir: string;
+}): BuildTarget[];
+export declare function executeDist(context: RunnerContext, args: string[]): Promise<CommandOutcome>;