@h-rig/cli 0.0.6-alpha.0

package/dist/src/launcher.js

@@ -0,0 +1,131 @@
+// @bun
+// packages/cli/src/launcher.ts
+import { existsSync } from "fs";
+import { resolve } from "path";
+import { loadDotEnvSecrets } from "@rig/runtime/baked-secrets";
+import { RIG_DEFINITION_DIRNAME, RIG_STATE_DIRNAME, resolveNearestRigProjectRoot } from "@rig/runtime/layout";
+function parsePolicyMode(value) {
+  if (!value) {
+    return;
+  }
+  if (value === "off" || value === "observe" || value === "enforce") {
+    return value;
+  }
+  throw new Error(`Invalid --policy-mode value: ${value}. Use off|observe|enforce.`);
+}
+function hasRigProjectMarker(candidate) {
+  return existsSync(resolve(candidate, RIG_DEFINITION_DIRNAME)) || existsSync(resolve(candidate, RIG_STATE_DIRNAME)) || existsSync(resolve(candidate, "rig.config.ts")) || existsSync(resolve(candidate, "rig.config.json"));
+}
+function resolveProjectRoot({
+  envProjectRoot,
+  execPath = process.execPath,
+  importDir,
+  cwd = process.cwd()
+}) {
+  if (envProjectRoot) {
+    return resolve(cwd, envProjectRoot);
+  }
+  const fallbackImportDir = importDir ?? cwd;
+  const candidates = [cwd, resolve(execPath, "..", ".."), resolve(fallbackImportDir, "..")];
+  for (const candidate of candidates) {
+    const nearest = resolveNearestRigProjectRoot(candidate);
+    if (hasRigProjectMarker(nearest)) {
+      return nearest;
+    }
+  }
+  return resolve(cwd);
+}
+function normalizeCliErrorCode(message, isCliError) {
+  if (message.startsWith("Invalid --policy-mode value:")) {
+    return "INVALID_POLICY_MODE";
+  }
+  if (message.startsWith("Missing value for --")) {
+    return "MISSING_OPTION_VALUE";
+  }
+  return isCliError ? "CLI_ERROR" : "UNEXPECTED_ERROR";
+}
+function normalizeCliErrorPayload(error, CliErrorClass, options = {}) {
+  const isCliError = error instanceof CliErrorClass;
+  const message = error instanceof Error ? error.message : String(error);
+  const exitCode = isCliError ? error.exitCode : 1;
+  const payload = {
+    ok: false,
+    code: normalizeCliErrorCode(message, isCliError),
+    message,
+    exitCode
+  };
+  if (options.debug && error instanceof Error && error.stack) {
+    return { ...payload, stack: error.stack };
+  }
+  return payload;
+}
+async function runRigCli(module, options = {}) {
+  const io = options.io ?? {
+    log: (message) => console.log(message),
+    error: (message) => console.error(message)
+  };
+  const args = [...options.argv ?? process.argv.slice(2)];
+  const debugErrors = process.env.RIG_DEBUG === "1" || process.env.RIG_CLI_DEBUG === "1";
+  let jsonOutput = args.includes("--json");
+  try {
+    const dryRunResult = module.takeFlag(args, "--dry-run");
+    const jsonResult = module.takeFlag(dryRunResult.rest, "--json");
+    jsonOutput = jsonResult.value;
+    const projectResult = module.takeOption(jsonResult.rest, "--project");
+    const cwd = options.cwd ?? process.cwd();
+    const projectRoot = resolveProjectRoot(Object.fromEntries(Object.entries({
+      envProjectRoot: projectResult.value ?? options.envProjectRoot ?? process.env.PROJECT_RIG_ROOT,
+      execPath: options.execPath ?? process.execPath,
+      importDir: options.importDir,
+      cwd
+    }).filter(([, value]) => value !== undefined)));
+    hydrateProcessEnvFromDotEnv(projectRoot);
+    module.withProjectRoot(projectRoot);
+    const policyModeResult = module.takeOption(projectResult.rest, "--policy-mode");
+    const runIdResult = module.takeOption(policyModeResult.rest, "--run-id");
+    const policyMode = parsePolicyMode(policyModeResult.value);
+    const outputMode = jsonResult.value ? "json" : "text";
+    const runtimeOptions = {
+      projectRoot,
+      dryRun: dryRunResult.value,
+      outputMode,
+      runId: runIdResult.value,
+      policyMode
+    };
+    const context = await module.initializeRuntime(runtimeOptions);
+    const outcome = await module.execute(context, runIdResult.rest);
+    if (outputMode === "json") {
+      io.log(JSON.stringify({
+        ok: true,
+        runId: context.runId,
+        outcome,
+        eventsFile: context.eventBus.getEventsFile(),
+        policyFile: resolve(projectRoot, "rig", "policy", "policy.json"),
+        policyMode: context.policyMode ?? policyMode ?? module.loadPolicy(projectRoot).mode
+      }, null, 2));
+    }
+  } catch (error) {
+    const payload = normalizeCliErrorPayload(error, module.CliError, { debug: debugErrors });
+    if (jsonOutput) {
+      io.error(JSON.stringify(payload, null, 2));
+    } else {
+      io.error(debugErrors && payload.stack ? payload.stack : payload.message);
+    }
+    process.exit(payload.exitCode);
+  }
+}
+function hydrateProcessEnvFromDotEnv(projectRoot) {
+  const secrets = loadDotEnvSecrets(projectRoot, process.env);
+  for (const [key, value] of Object.entries(secrets)) {
+    if (value && !process.env[key]) {
+      process.env[key] = value;
+    }
+  }
+}
+export {
+  runRigCli,
+  resolveProjectRoot,
+  parsePolicyMode,
+  normalizeCliErrorPayload,
+  hydrateProcessEnvFromDotEnv
+};

package/dist/src/report-bug.js

@@ -0,0 +1,260 @@
+// @bun
+// packages/cli/src/report-bug.ts
+import { copyFileSync, existsSync, mkdirSync, rmSync, writeFileSync } from "fs";
+import { basename, extname, join, resolve } from "path";
+function slugifyBugTitle(value) {
+  const slug = value.trim().toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 80).replace(/-+$/g, "");
+  return slug || "bug-report";
+}
+function defaultBrowserBugProfile(title) {
+  return `hp-next-${slugifyBugTitle(title)}`;
+}
+function defaultBrowserBugOptions(environment) {
+  if (environment === "shared-dev") {
+    return {
+      preset: "hp-next-shared",
+      attachUrl: "http://127.0.0.1:9341",
+      stateDir: ".tmp/rig-browser/hp-next-shared"
+    };
+  }
+  return {
+    preset: "hp-next-local",
+    attachUrl: "http://127.0.0.1:9333",
+    stateDir: ".tmp/rig-browser/hp-next"
+  };
+}
+function createBugReportFiles(input) {
+  const slug = slugifyBugTitle(input.slug || input.title);
+  const outputDir = resolve(input.projectRoot, input.outputRoot);
+  const reportDir = resolve(outputDir, slug);
+  const assetDir = join(reportDir, "assets");
+  const screenshotDir = join(reportDir, "screenshots");
+  const taskPath = join(reportDir, "task.md");
+  const browserRequired = input.browserRequired ?? true;
+  const browserPath = browserRequired ? join(reportDir, "browser.json") : null;
+  const manifestPath = join(reportDir, "manifest.json");
+  if (existsSync(reportDir)) {
+    if (!input.overwrite) {
+      throw new Error(`Bug report directory already exists: ${reportDir}`);
+    }
+    rmSync(reportDir, { recursive: true, force: true });
+  }
+  mkdirSync(assetDir, { recursive: true });
+  mkdirSync(screenshotDir, { recursive: true });
+  const copiedScreenshots = copyEvidenceFiles(input.projectRoot, screenshotDir, input.screenshots ?? [], "screenshot");
+  const copiedAssets = copyEvidenceFiles(input.projectRoot, assetDir, input.assets ?? [], "asset");
+  const manifestAssets = [
+    ...copiedScreenshots.map((name) => ({
+      path: `screenshots/${name}`,
+      type: mediaTypeForFileName(name)
+    })),
+    ...copiedAssets.map((name) => ({
+      path: `assets/${name}`,
+      type: mediaTypeForFileName(name)
+    }))
+  ];
+  const browser = browserRequired ? buildBrowserBlock(input) : null;
+  const manifest = {
+    schema_version: 1,
+    slug,
+    issue_id: input.issueId ?? null,
+    title: input.title,
+    environment: input.environment,
+    url: input.url,
+    viewport: input.viewport,
+    task_file: "task.md",
+    browser_file: browserRequired ? "browser.json" : null,
+    screenshots: copiedScreenshots.map((name) => `screenshots/${name}`),
+    assets: manifestAssets,
+    created_at: new Date().toISOString(),
+    platform: process.platform,
+    arch: process.arch
+  };
+  writeFileSync(join(assetDir, "README.md"), buildAssetReadme(input.title), "utf8");
+  writeFileSync(join(screenshotDir, "README.md"), buildScreenshotReadme(input.title), "utf8");
+  if (browserPath && browser) {
+    writeFileSync(browserPath, `${JSON.stringify(browser, null, 2)}
+`, "utf8");
+  }
+  writeFileSync(manifestPath, `${JSON.stringify(manifest, null, 2)}
+`, "utf8");
+  writeFileSync(taskPath, buildBugReportMarkdown(input, browser, copiedScreenshots, copiedAssets), "utf8");
+  return {
+    slug,
+    reportDir,
+    taskPath,
+    browserPath,
+    manifestPath,
+    assetDir,
+    screenshotDir,
+    copiedAssets,
+    copiedScreenshots
+  };
+}
+function buildBrowserBlock(input) {
+  return {
+    browser: {
+      required: true,
+      preset: input.preset,
+      profile: input.profile,
+      attach_url: input.attachUrl,
+      state_dir: input.stateDir,
+      dev_command: "bun run app:dev:browser:hp-next",
+      launch_command: "bun run app:start:browser:hp-next",
+      check_command: "bun run app:check:browser:hp-next",
+      e2e_command: "bun run app:e2e:browser:hp-next",
+      mode: input.mode
+    }
+  };
+}
+function buildBugReportMarkdown(input, browser, screenshots, assets) {
+  const browserRequired = input.browserRequired ?? true;
+  const assetEntries = [
+    ...screenshots.map((name) => ({ name, path: `screenshots/${name}` })),
+    ...assets.map((name) => ({ name, path: `assets/${name}` }))
+  ];
+  const assetLines = assetEntries.length > 0 ? assetEntries.map(({ name, path }) => formatAssetMarkdown(name, path)) : ["- No assets attached yet. Drag screenshots or videos into `assets/` and link them here."];
+  const evidenceLines = input.evidence.length > 0 ? input.evidence.map((item) => `- ${item}`) : ["- Console errors: not captured yet.", "- Failed network requests: not captured yet."];
+  return [
+    `# ${input.title}`,
+    "",
+    ...input.issueId ? ["## Task", "", `Task ID: \`${input.issueId}\``, ""] : [],
+    "## Summary",
+    "",
+    input.summary || "TODO: describe the user-visible bug.",
+    "",
+    ...browser ? [
+      "## Browser Block",
+      "",
+      "```json",
+      JSON.stringify(browser, null, 2),
+      "```",
+      ""
+    ] : [],
+    "## Environment",
+    "",
+    `- URL: \`${input.url}\``,
+    `- Environment: \`${input.environment}\``,
+    ...browserRequired ? [
+      `- Preset: \`${input.preset}\``,
+      `- Profile: \`${input.profile}\``,
+      `- Viewport: \`${input.viewport}\``
+    ] : ["- Browser: not required for this report."],
+    "",
+    "## Reproduction",
+    "",
+    ...numberedLines(input.steps.length > 0 ? input.steps : ["TODO: add reproduction step."]),
+    "",
+    "## Expected",
+    "",
+    input.expected || "TODO: expected behavior.",
+    "",
+    "## Actual",
+    "",
+    input.actual || "TODO: actual behavior.",
+    "",
+    "## Assets",
+    "",
+    ...assetLines,
+    "",
+    "## Evidence",
+    "",
+    ...evidenceLines,
+    "",
+    "## Agent Handoff",
+    "",
+    ...input.issueId ? [
+      `- Canonical task assets live under \`artifacts/${input.issueId}/bug-report/\`.`,
+      `- Start with \`artifacts/${input.issueId}/bug-report/task.md\` and the files in \`artifacts/${input.issueId}/bug-report/assets/\`.`,
+      browserRequired ? `- Run \`bun run rig task info --task ${input.issueId}\` to confirm browser wiring before debugging.` : `- Run \`bun run rig task info --task ${input.issueId}\` to confirm scope and artifact links before debugging.`
+    ] : [
+      "- Draft-only report: convert this into a beads task before assigning it to an agent run."
+    ],
+    "",
+    "## Validation",
+    "",
+    "```bash",
+    ...input.issueId ? [`bun run rig task validate --task ${input.issueId}`] : [],
+    ...browserRequired ? [
+      "bun run app:check:browser:hp-next",
+      "bun run app:e2e:browser:hp-next"
+    ] : [],
+    "```",
+    ""
+  ].join(`
+`);
+}
+function numberedLines(items) {
+  return items.map((item, index) => `${index + 1}. ${item}`);
+}
+function buildAssetReadme(title) {
+  return [
+    `# Evidence Assets For ${title}`,
+    "",
+    "Drag and drop screenshots or videos for this bug report into this directory.",
+    "Use stable, descriptive file names such as `login-loading.png`, `chunk-404-network.png`, or `otp-flow.webm`.",
+    "Reference images from `../task.md` with Markdown image links and videos with normal file links.",
+    ""
+  ].join(`
+`);
+}
+function buildScreenshotReadme(title) {
+  return [
+    `# Screenshots For ${title}`,
+    "",
+    "Drop legacy screenshot files for this bug report into this directory.",
+    "Use `assets/` for new screenshot, video, and mixed evidence attachments.",
+    "Reference screenshots from `../task.md` with Markdown image links.",
+    ""
+  ].join(`
+`);
+}
+function copyEvidenceFiles(projectRoot, targetDir, paths, label) {
+  const copied = [];
+  const used = new Set;
+  for (const rawPath of paths.map((path) => path.trim()).filter(Boolean)) {
+    const source = resolve(projectRoot, rawPath);
+    if (!existsSync(source)) {
+      throw new Error(`${label} does not exist: ${source}`);
+    }
+    const targetName = uniqueEvidenceName(rawPath, used, label);
+    copyFileSync(source, join(targetDir, targetName));
+    copied.push(targetName);
+  }
+  return copied;
+}
+function uniqueEvidenceName(path, used, fallback) {
+  const original = sanitizeFileName(basename(path)) || fallback;
+  const extension = extname(original);
+  const stem = extension ? original.slice(0, -extension.length) : original;
+  let candidate = original;
+  let index = 2;
+  while (used.has(candidate)) {
+    candidate = `${stem}-${index}${extension}`;
+    index += 1;
+  }
+  used.add(candidate);
+  return candidate;
+}
+function sanitizeFileName(value) {
+  return value.trim().replace(/[^a-zA-Z0-9._-]+/g, "-").replace(/^-+|-+$/g, "");
+}
+function mediaTypeForFileName(fileName) {
+  const extension = extname(fileName).toLowerCase();
+  if ([".png", ".jpg", ".jpeg", ".gif", ".webp", ".svg"].includes(extension)) {
+    return "image";
+  }
+  if ([".mp4", ".mov", ".m4v", ".webm", ".avi", ".mkv"].includes(extension)) {
+    return "video";
+  }
+  return "file";
+}
+function formatAssetMarkdown(name, path) {
+  return mediaTypeForFileName(name) === "image" ? `- ![${name}](${path})` : `- [${name}](${path})`;
+}
+export {
+  slugifyBugTitle,
+  defaultBrowserBugProfile,
+  defaultBrowserBugOptions,
+  createBugReportFiles
+};

package/dist/src/runner.js

@@ -0,0 +1,272 @@
+// @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 } 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 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 runtimeContext = loadRuntimeContextFromEnv() ?? undefined;
+  const plugins = await PluginManager.load({
+    projectRoot: options.projectRoot,
+    runId: eventBus.getRunId(),
+    eventBus,
+    runtimeContext
+  });
+  const context = {
+    projectRoot: options.projectRoot,
+    dryRun: options.dryRun,
+    outputMode: options.outputMode,
+    runId: eventBus.getRunId(),
+    policyMode: options.policyMode,
+    eventBus,
+    plugins,
+    emitEvent: async (type, payload) => {
+      const event = await eventBus.emit(type, payload);
+      await plugins.onEvent(event);
+    }
+  };
+  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"),
+    plugins: context.plugins.list()
+  });
+  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 controlledBash = await ensureAgentShellBinary(context.projectRoot);
+  const commandEnv = [
+    "env",
+    `PATH=${controlledPath}`,
+    `PROJECT_RIG_ROOT=${context.projectRoot}`,
+    `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);
+  }
+  await context.plugins.beforeCommand({ command: commandWithEnv, formattedCommand: formatted });
+  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.plugins.afterCommand(dryResult);
+    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
+  };
+  await context.plugins.afterCommand(result);
+  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}`);
+      }
+      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,
+  CliError2 as CliError
+};

package/dist/src/withMutedConsole.js

@@ -0,0 +1,42 @@
+// @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
+};