@h-rig/cli 0.0.6-alpha.100 → 0.0.6-alpha.102

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

@@ -1 +0,0 @@
-export {};

package/dist/src/operator-entry.js

@@ -1,3 +0,0 @@
-// @bun
-// packages/cli/src/operator-entry.ts
-throw new Error("@rig/cli/operator-entry is a retired legacy AuthorityRunRecord operator surface. Run the `rig` CLI instead; it launches upstream OMP with the bundled Rig extension.");

package/dist/src/runner.d.ts

@@ -1,47 +0,0 @@
-import { CliError as RuntimeCliError } from "@rig/runtime/control-plane/errors";
-import type { PolicyMode } from "@rig/runtime/control-plane/runtime/guard-types";
-import type { RunnerContext } from "@rig/runtime/control-plane/runtime/runner-context";
-import { buildBinary } from "@rig/runtime/control-plane/runtime/isolation";
-import type { CommandExecutionResult, OutputMode } from "@rig/runtime/control-plane/runtime/types";
-export type { RunnerContext } from "@rig/runtime/control-plane/runtime/runner-context";
-/**
- * CLI-side error with an optional remediation hint. The hint is rendered on
- * its own line as `Next: <hint>` (and carried in the --json error payload),
- * so every failure names the next command to run. Extends the runtime
- * CliError so `instanceof` checks against either class keep working.
- */
-export declare class CliError extends RuntimeCliError {
-    readonly hint?: string;
-    constructor(message: string, exitCode?: number, options?: {
-        readonly hint?: string;
-    });
-}
-export declare function withProjectRoot(projectRoot: string): void;
-export declare function formatCommand(parts: string[]): string;
-type AgentShellBuild = typeof buildBinary;
-type AgentShellMaterializationOptions = {
-    readonly env?: Record<string, string | undefined>;
-    readonly cwd?: string;
-    readonly moduleDir?: string;
-    readonly build?: AgentShellBuild;
-};
-export declare function resolveAgentMaterializationSourceRoot(projectRoot: string, options?: AgentShellMaterializationOptions): string;
-export declare function ensureAgentShellBinary(projectRoot: string, options?: AgentShellMaterializationOptions): Promise<string>;
-export declare function initializeRuntime(options: {
-    projectRoot: string;
-    dryRun: boolean;
-    outputMode: OutputMode;
-    runId?: string;
-    policyMode?: PolicyMode;
-}): Promise<RunnerContext>;
-export declare function runCommand(context: RunnerContext, parts: string[]): Promise<CommandExecutionResult>;
-export declare function takeFlag(args: string[], flag: string): {
-    value: boolean;
-    rest: string[];
-};
-export declare function takeOption(args: string[], option: string): {
-    value: string | undefined;
-    rest: string[];
-};
-export declare function requireNoExtraArgs(args: string[], usage: string): void;
-export declare function requireTask(taskId: string | undefined, usage: string): string;

package/dist/src/runner.js

@@ -1,267 +0,0 @@
-// @bun
-// packages/cli/src/runner.ts
-var {$ } = globalThis.Bun;
-import { existsSync, mkdirSync } from "fs";
-import { resolve } from "path";
-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 withProjectRoot(projectRoot) {
-  $.cwd(projectRoot);
-}
-function formatCommand(parts) {
-  return parts.map((part) => /[^a-zA-Z0-9_./:-]/.test(part) ? JSON.stringify(part) : part).join(" ");
-}
-var AGENT_DISPATCH_SOURCE = "packages/runtime/bin/rig-agent-dispatch.ts";
-function hasAgentDispatchSource(root) {
-  return existsSync(resolve(root, AGENT_DISPATCH_SOURCE));
-}
-function resolveAgentMaterializationSourceRoot(projectRoot, options = {}) {
-  const env = options.env ?? process.env;
-  const candidates = [
-    env.RIG_HOST_PROJECT_ROOT?.trim(),
-    env.PROJECT_RIG_ROOT?.trim(),
-    options.cwd ?? process.cwd(),
-    resolve(options.moduleDir ?? import.meta.dir, "../../.."),
-    projectRoot
-  ].filter((value) => Boolean(value));
-  for (const candidate of candidates) {
-    const root = resolve(candidate);
-    if (hasAgentDispatchSource(root)) {
-      return root;
-    }
-  }
-  return resolve(projectRoot);
-}
-async function ensureAgentShellBinary(projectRoot, options = {}) {
-  const agentBinary = resolve(projectRoot, ".rig", "bin", "rig-agent");
-  if (existsSync(agentBinary)) {
-    return agentBinary;
-  }
-  const sourceRoot = resolveAgentMaterializationSourceRoot(projectRoot, options);
-  if (!hasAgentDispatchSource(sourceRoot)) {
-    throw new CliError(`Missing compiled agent dispatch binary at ${agentBinary}, and no Rig source checkout with ${AGENT_DISPATCH_SOURCE} was found to materialize it automatically.`, 2);
-  }
-  mkdirSync(resolve(agentBinary, ".."), { recursive: true });
-  try {
-    await (options.build ?? buildBinary)(AGENT_DISPATCH_SOURCE, agentBinary, sourceRoot, {
-      AGENT_PROJECT_ROOT: projectRoot
-    });
-  } catch (error) {
-    throw new CliError(`Missing compiled agent dispatch binary at ${agentBinary}, and automatic materialization from ${sourceRoot} failed: ${error instanceof Error ? error.message : String(error)}`, 2);
-  }
-  if (!existsSync(agentBinary)) {
-    throw new CliError(`Automatic agent dispatch materialization from ${sourceRoot} did not create ${agentBinary}.`, 2);
-  }
-  return agentBinary;
-}
-async function initializeRuntime(options) {
-  const eventBus = new EventBus({ projectRoot: options.projectRoot, runId: options.runId });
-  const context = {
-    projectRoot: options.projectRoot,
-    dryRun: options.dryRun,
-    outputMode: options.outputMode,
-    runId: eventBus.getRunId(),
-    policyMode: options.policyMode,
-    eventBus,
-    emitEvent: async (type, payload) => {
-      await eventBus.emit(type, payload);
-    }
-  };
-  context.runCommand = async (parts) => runCommand(context, parts);
-  await context.emitEvent("runtime.init", {
-    runId: context.runId,
-    outputMode: context.outputMode,
-    dryRun: context.dryRun,
-    policyMode: context.policyMode ?? loadPolicy(options.projectRoot).mode,
-    policyFile: resolve(options.projectRoot, "rig/policy/policy.json")
-  });
-  return context;
-}
-async function runCommand(context, parts) {
-  if (parts.length === 0) {
-    throw new CliError("Cannot execute an empty command.");
-  }
-  const envMode = process.env.RIG_BASH_MODE;
-  const effectiveMode = context.policyMode || (envMode === "off" || envMode === "observe" || envMode === "enforce" ? envMode : loadPolicy(context.projectRoot).mode);
-  const controlledPath = `${resolve(context.projectRoot, ".rig", "bin")}:${context.projectRoot}/rig/tools:${process.env.PATH ?? ""}`;
-  const usesInfrastructureBinary = parts[0] === "rig-server";
-  const controlledBash = usesInfrastructureBinary ? null : await ensureAgentShellBinary(context.projectRoot);
-  const commandEnv = [
-    "env",
-    `PATH=${controlledPath}`,
-    `PROJECT_RIG_ROOT=${context.projectRoot}`,
-    ...controlledBash ? [`BASH=${controlledBash}`] : [],
-    `RIG_BASH_MODE=${effectiveMode}`,
-    `RIG_POLICY_FILE=${resolve(context.projectRoot, "rig/policy/policy.json")}`,
-    ...context.eventBus.getEventsFile() ? [`RIG_EVENTS_FILE=${context.eventBus.getEventsFile()}`] : []
-  ];
-  const commandWithEnv = [...commandEnv, ...parts];
-  const formatted = formatCommand(commandWithEnv);
-  await context.emitEvent("command.received", {
-    command: commandWithEnv,
-    formattedCommand: formatted
-  });
-  const guardDecision = evaluate({
-    projectRoot: context.projectRoot,
-    evaluation: { type: "command", command: formatted }
-  });
-  const guardAction = resolveAction(effectiveMode, guardDecision.matchedRules);
-  await context.emitEvent("policy.decision", {
-    target: "command",
-    command: formatted,
-    mode: effectiveMode,
-    allowed: guardAction !== "block",
-    matchedRuleIds: guardDecision.matchedRules.map((r) => r.id),
-    reasons: guardDecision.matchedRules.map((r) => r.reason)
-  });
-  if (guardAction === "block") {
-    await context.emitEvent("command.failed", {
-      command: commandWithEnv,
-      formattedCommand: formatted,
-      reason: "Policy denied command",
-      matchedRuleIds: guardDecision.matchedRules.map((r) => r.id),
-      mode: effectiveMode
-    });
-    throw new CliError(`Policy blocked command: ${formatted}`, 126, { hint: "Review rig/policy/policy.json, or re-run with `--policy-mode observe` to log instead of block." });
-  }
-  const startedAt = new Date;
-  await context.emitEvent("command.started", {
-    command: commandWithEnv,
-    formattedCommand: formatted,
-    startedAt: startedAt.toISOString(),
-    dryRun: context.dryRun
-  });
-  if (context.dryRun) {
-    const dryResult = {
-      command: commandWithEnv,
-      formattedCommand: formatted,
-      exitCode: 0,
-      durationMs: 0,
-      startedAt: startedAt.toISOString(),
-      finishedAt: startedAt.toISOString()
-    };
-    if (context.outputMode === "text") {
-      console.log(`$ ${formatted}`);
-    }
-    await context.emitEvent("command.finished", {
-      ...dryResult,
-      dryRun: true
-    });
-    return dryResult;
-  }
-  let exitCode = 0;
-  let stdout = "";
-  let stderr = "";
-  if (context.outputMode === "json") {
-    const child = Bun.spawn(commandWithEnv, {
-      cwd: context.projectRoot,
-      stdin: "inherit",
-      stdout: "pipe",
-      stderr: "pipe"
-    });
-    exitCode = await child.exited;
-    stdout = await new Response(child.stdout).text();
-    stderr = await new Response(child.stderr).text();
-  } else {
-    const child = Bun.spawn(commandWithEnv, {
-      cwd: context.projectRoot,
-      stdin: "inherit",
-      stdout: "inherit",
-      stderr: "inherit"
-    });
-    exitCode = await child.exited;
-  }
-  const finishedAt = new Date;
-  const result = {
-    command: commandWithEnv,
-    formattedCommand: formatted,
-    exitCode,
-    durationMs: finishedAt.getTime() - startedAt.getTime(),
-    startedAt: startedAt.toISOString(),
-    finishedAt: finishedAt.toISOString(),
-    stdout: context.outputMode === "json" ? stdout : undefined,
-    stderr: context.outputMode === "json" ? stderr : undefined
-  };
-  if (exitCode !== 0) {
-    await context.emitEvent("command.failed", {
-      ...result
-    });
-    const errorSuffix = context.outputMode === "json" && stderr ? `
-${stderr.trim()}` : "";
-    throw new CliError(`Command failed (${exitCode}): ${formatted}${errorSuffix}`, exitCode);
-  }
-  await context.emitEvent("command.finished", {
-    ...result
-  });
-  return result;
-}
-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}`);
-  }
-}
-function requireTask(taskId, usage) {
-  if (!taskId) {
-    throw new CliError(`Missing --task option.
-Usage: ${usage}`);
-  }
-  return taskId;
-}
-export {
-  withProjectRoot,
-  takeOption,
-  takeFlag,
-  runCommand,
-  resolveAgentMaterializationSourceRoot,
-  requireTask,
-  requireNoExtraArgs,
-  initializeRuntime,
-  formatCommand,
-  ensureAgentShellBinary,
-  CliError
-};

package/dist/src/withMutedConsole.d.ts

@@ -1,2 +0,0 @@
-export declare function withMutedConsole<T>(mute: boolean, fn: () => Promise<T>): Promise<T>;
-export declare function withMutedConsole<T>(mute: boolean, fn: () => T): T;

package/dist/src/withMutedConsole.js

@@ -1,42 +0,0 @@
-// @bun
-// 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();
-    }
-  }
-}
-export {
-  withMutedConsole
-};