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

package/dist/src/rig-config-package-deps.d.ts

@@ -0,0 +1,10 @@
+export declare function hasRigConfig(projectRoot: string): boolean;
+export declare function resolveRigConfigPackageVersion(): string;
+export declare function rigConfigDevDependencies(): Record<string, string>;
+export type RigConfigDependencyPreflightResult = {
+    readonly rewroteManifest: boolean;
+    readonly ranInstall: boolean;
+    readonly command: string | null;
+    readonly version: string;
+};
+export declare function ensureRigConfigDependenciesInstalled(projectRoot: string): RigConfigDependencyPreflightResult;

package/dist/src/rig-config-package-deps.js

@@ -0,0 +1,272 @@
+// @bun
+// packages/cli-surface-plugin/src/rig-config-package-deps.ts
+import { spawnSync } from "child_process";
+import { existsSync as existsSync2, readFileSync as readFileSync2, writeFileSync } from "fs";
+import { basename, join, resolve as resolve2 } from "path";
+
+// packages/cli-surface-plugin/src/version.ts
+import { existsSync, readFileSync } from "fs";
+import { dirname, resolve } from "path";
+import { fileURLToPath } from "url";
+import { readBuildConfig } from "@rig/runtime/build-time-config";
+var SOURCE_CLI_VERSION = "0.0.0-alpha.1";
+var DEV_CLI_VERSION = "0.0.0-dev";
+function resolveInstalledCliVersion() {
+  const buildConfig = readBuildConfig();
+  const envVersion = process.env.RIG_CLI_VERSION?.trim();
+  const buildVersion = buildConfig.RIG_CLI_VERSION?.trim();
+  let version = envVersion || buildVersion || "";
+  if (!version) {
+    try {
+      const execPath = process.execPath || "";
+      const moduleDir = dirname(fileURLToPath(import.meta.url));
+      const candidates = [
+        execPath ? resolve(dirname(execPath), "..", "manifest.json") : "",
+        resolve(moduleDir, "..", "package.json"),
+        resolve(moduleDir, "..", "..", "package.json"),
+        resolve(process.cwd(), "packages/cli/package.json")
+      ].filter(Boolean);
+      for (const candidate of candidates) {
+        if (!existsSync(candidate))
+          continue;
+        const parsed = JSON.parse(readFileSync(candidate, "utf-8"));
+        const candidateVersion = parsed.version?.trim();
+        if (candidateVersion) {
+          version = candidateVersion;
+          break;
+        }
+      }
+    } catch {}
+  }
+  return version || DEV_CLI_VERSION;
+}
+function isPublishedCliVersion(version) {
+  const normalized = version.trim();
+  return normalized.length > 0 && normalized !== SOURCE_CLI_VERSION && normalized !== DEV_CLI_VERSION;
+}
+
+// packages/cli-surface-plugin/src/rig-config-package-deps.ts
+var REQUIRED_RIG_CONFIG_PACKAGE_NAMES = ["core", "standard-plugin"];
+var RIG_CONFIG_FILENAMES = ["rig.config.ts", "rig.config.mts", "rig.config.json"];
+var DEPENDENCY_SECTION_NAMES = ["dependencies", "devDependencies", "optionalDependencies", "peerDependencies"];
+var INSTALL_CHECK_SECTION_NAMES = ["dependencies", "devDependencies", "optionalDependencies"];
+function hasRigConfig(projectRoot) {
+  const root = resolve2(projectRoot);
+  return RIG_CONFIG_FILENAMES.some((name) => existsSync2(join(root, name)));
+}
+function resolveRigConfigPackageVersion() {
+  const explicit = process.env.RIG_CONFIG_PACKAGE_VERSION?.trim();
+  if (explicit)
+    return explicit;
+  const installed = resolveInstalledCliVersion();
+  return isPublishedCliVersion(installed) ? installed : "latest";
+}
+function rigConfigDevDependencies() {
+  const version = resolveRigConfigPackageVersion();
+  return Object.fromEntries(REQUIRED_RIG_CONFIG_PACKAGE_NAMES.map((name) => [`@rig/${name}`, rigPackageSpec(name, version)]));
+}
+function readPackageManifest(path) {
+  if (!existsSync2(path))
+    return null;
+  return JSON.parse(readFileSync2(path, "utf8"));
+}
+function mutableDeps(manifest, key) {
+  const source = manifest[key];
+  return source && typeof source === "object" && !Array.isArray(source) ? { ...source } : {};
+}
+function rigPackageName(name) {
+  const match = name.match(/^@rig\/([^/]+)$/);
+  return match?.[1] ?? null;
+}
+function rigPackageNameFromSpecifier(specifier) {
+  const match = specifier.match(/^@rig\/([^/]+)/);
+  return match?.[1] ?? null;
+}
+function rigPackageSpec(packageName, version = resolveRigConfigPackageVersion()) {
+  return `npm:@h-rig/${packageName}@${version}`;
+}
+function mutableDependencySections(manifest) {
+  return Object.fromEntries(DEPENDENCY_SECTION_NAMES.map((section) => [section, mutableDeps(manifest, section)]));
+}
+function discoveredConfigRigSpecs(sections, packageNames) {
+  const version = resolveRigConfigPackageVersion();
+  const expected = {};
+  for (const section of DEPENDENCY_SECTION_NAMES) {
+    for (const name of Object.keys(sections[section])) {
+      const packageName = rigPackageName(name);
+      if (packageName && packageNames.has(packageName))
+        expected[name] = rigPackageSpec(packageName, version);
+    }
+  }
+  return expected;
+}
+function installedConfigDependencySpecs(sections, packageNames) {
+  const expected = {};
+  for (const section of INSTALL_CHECK_SECTION_NAMES) {
+    for (const [name, spec] of Object.entries(sections[section])) {
+      const packageName = rigPackageName(name);
+      if (packageName && packageNames.has(packageName) && typeof spec === "string")
+        expected[name] = spec;
+    }
+  }
+  return expected;
+}
+function hasFirstPartyRigDependency(manifest) {
+  const sections = mutableDependencySections(manifest);
+  return DEPENDENCY_SECTION_NAMES.some((section) => Object.keys(sections[section]).some((name) => rigPackageName(name) !== null));
+}
+function rigConfigImportPackageNames(projectRoot) {
+  const names = new Set;
+  for (const filename of RIG_CONFIG_FILENAMES) {
+    const path = join(projectRoot, filename);
+    if (!existsSync2(path))
+      continue;
+    const source = readFileSync2(path, "utf8");
+    const importPattern = /(?:from\s*|import\s*\(\s*|import\s*)["'](@rig\/[^"']+)["']/g;
+    for (const match of source.matchAll(importPattern)) {
+      const packageName = rigPackageNameFromSpecifier(match[1] ?? "");
+      if (packageName)
+        names.add(packageName);
+    }
+  }
+  return [...names];
+}
+function withRigConfigDeps(projectRoot, manifest, options) {
+  const configPackageNames = new Set(options.requiredConfigPackageNames);
+  const sections = mutableDependencySections(manifest);
+  let changed = false;
+  for (const [name, spec] of Object.entries(discoveredConfigRigSpecs(sections, configPackageNames))) {
+    for (const section of DEPENDENCY_SECTION_NAMES) {
+      if (!Object.prototype.hasOwnProperty.call(sections[section], name))
+        continue;
+      if (sections[section][name] !== spec) {
+        sections[section][name] = spec;
+        changed = true;
+      }
+    }
+  }
+  for (const packageName of options.requiredConfigPackageNames) {
+    const name = `@rig/${packageName}`;
+    const existsInInstallableSection = INSTALL_CHECK_SECTION_NAMES.some((section) => Object.prototype.hasOwnProperty.call(sections[section], name));
+    if (existsInInstallableSection)
+      continue;
+    sections.devDependencies[name] = rigPackageSpec(packageName);
+    changed = true;
+  }
+  const next = {
+    ...Object.keys(manifest).length > 0 ? manifest : { name: basename(projectRoot) || "rig-project", private: true }
+  };
+  for (const section of DEPENDENCY_SECTION_NAMES) {
+    if (Object.keys(sections[section]).length > 0)
+      next[section] = sections[section];
+  }
+  return { next, changed, expectedInstalled: installedConfigDependencySpecs(sections, configPackageNames) };
+}
+function expectedPublishedVersion(spec) {
+  const match = spec.match(/^npm:@h-rig\/[^@]+@(.+)$/);
+  if (!match)
+    return null;
+  return match[1] === "latest" ? null : match[1] ?? null;
+}
+function installedRigPackageHealthy(projectRoot, packageName, expectedSpec) {
+  const rigName = rigPackageName(packageName);
+  if (!rigName)
+    return true;
+  const manifest = readPackageManifest(join(projectRoot, "node_modules", "@rig", rigName, "package.json"));
+  if (!manifest)
+    return false;
+  const installedVersion = typeof manifest.version === "string" ? manifest.version.trim() : "";
+  const expectedVersion = expectedPublishedVersion(expectedSpec);
+  if (expectedVersion && installedVersion !== expectedVersion)
+    return false;
+  if (!installedVersion)
+    return false;
+  if (rigName === "core" || rigName === "standard-plugin") {
+    const exportsField = manifest.exports;
+    if (!exportsField || typeof exportsField !== "object" || Array.isArray(exportsField))
+      return false;
+    const exportsRecord = exportsField;
+    if (rigName === "core" && !("./config" in exportsRecord))
+      return false;
+    if (rigName === "standard-plugin" && !("./bundle" in exportsRecord))
+      return false;
+  }
+  return true;
+}
+function resolvePackageManagerBinary(manager) {
+  if (manager !== "bun")
+    return manager;
+  const candidates = [
+    Bun.which("bun") ?? "",
+    process.env.RIG_BUN_PATH?.trim() ?? "",
+    process.env.HOME ? join(process.env.HOME, ".bun", "bin", "bun") : "",
+    "/opt/homebrew/bin/bun",
+    "/usr/local/bin/bun",
+    "/usr/bin/bun"
+  ];
+  for (const candidate of candidates) {
+    if (candidate && existsSync2(candidate))
+      return candidate;
+  }
+  return "bun";
+}
+function installCommandFor(manifest) {
+  const packageManager = typeof manifest.packageManager === "string" ? manifest.packageManager.trim() : "";
+  const manager = packageManager.split("@")[0] || "bun";
+  switch (manager) {
+    case "npm":
+      return ["npm", "install", "--ignore-scripts"];
+    case "pnpm":
+      return ["pnpm", "install", "--ignore-scripts"];
+    case "yarn":
+      return ["yarn", "install", "--ignore-scripts"];
+    default:
+      return [resolvePackageManagerBinary("bun"), "install", "--ignore-scripts"];
+  }
+}
+function ensureRigConfigDependenciesInstalled(projectRoot) {
+  const root = resolve2(projectRoot);
+  const version = resolveRigConfigPackageVersion();
+  const manifestPath = join(root, "package.json");
+  const current = readPackageManifest(manifestPath);
+  const hasConfig = hasRigConfig(root);
+  if (!hasConfig && (!current || !hasFirstPartyRigDependency(current))) {
+    return { rewroteManifest: false, ranInstall: false, command: null, version };
+  }
+  const requiredConfigPackageNames = hasConfig ? [...new Set([...REQUIRED_RIG_CONFIG_PACKAGE_NAMES, ...rigConfigImportPackageNames(root)])] : [];
+  const { next, changed, expectedInstalled } = withRigConfigDeps(root, current ?? {}, { requiredConfigPackageNames });
+  const installNeeded = changed || Object.entries(expectedInstalled).some(([name, spec]) => !installedRigPackageHealthy(root, name, spec));
+  if (changed) {
+    writeFileSync(manifestPath, `${JSON.stringify(next, null, 2)}
+`, "utf8");
+  }
+  if (!installNeeded) {
+    return { rewroteManifest: changed, ranInstall: false, command: null, version };
+  }
+  const command = installCommandFor(next);
+  const executable = command[0];
+  if (!executable)
+    throw new Error("Rig dependency preflight could not determine a package manager command.");
+  const result = spawnSync(executable, command.slice(1), {
+    cwd: root,
+    encoding: "utf8",
+    env: process.env
+  });
+  if (result.status !== 0) {
+    const detail = [
+      result.error ? String(result.error) : "",
+      `${result.stdout ?? ""}${result.stderr ?? ""}`.trim()
+    ].filter(Boolean).join(`
+`);
+    throw new Error(`Rig dependency preflight failed in ${root}: ${command.join(" ")}${detail ? `
+${detail}` : ""}
+Rig does not delete node_modules or lockfiles automatically; fix the repo/package-manager state explicitly if install recovery is needed.`.trim());
+  }
+  return { rewroteManifest: changed, ranInstall: true, command: command.join(" "), version };
+}
+export {
+  rigConfigDevDependencies,
+  resolveRigConfigPackageVersion,
+  hasRigConfig,
+  ensureRigConfigDependenciesInstalled
+};

package/dist/src/runner.d.ts

@@ -0,0 +1,47 @@
+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

@@ -0,0 +1,267 @@
+// @bun
+// packages/cli-surface-plugin/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/version.d.ts

@@ -0,0 +1,8 @@
+export declare const SOURCE_CLI_VERSION = "0.0.0-alpha.1";
+export declare const DEV_CLI_VERSION = "0.0.0-dev";
+/**
+ * Resolve the CLI version no matter how the command was launched:
+ * compiled binary, dist artifact, npm JS bin, or source checkout.
+ */
+export declare function resolveInstalledCliVersion(): string;
+export declare function isPublishedCliVersion(version: string): boolean;

package/dist/src/version.js

@@ -0,0 +1,47 @@
+// @bun
+// packages/cli-surface-plugin/src/version.ts
+import { existsSync, readFileSync } from "fs";
+import { dirname, resolve } from "path";
+import { fileURLToPath } from "url";
+import { readBuildConfig } from "@rig/runtime/build-time-config";
+var SOURCE_CLI_VERSION = "0.0.0-alpha.1";
+var DEV_CLI_VERSION = "0.0.0-dev";
+function resolveInstalledCliVersion() {
+  const buildConfig = readBuildConfig();
+  const envVersion = process.env.RIG_CLI_VERSION?.trim();
+  const buildVersion = buildConfig.RIG_CLI_VERSION?.trim();
+  let version = envVersion || buildVersion || "";
+  if (!version) {
+    try {
+      const execPath = process.execPath || "";
+      const moduleDir = dirname(fileURLToPath(import.meta.url));
+      const candidates = [
+        execPath ? resolve(dirname(execPath), "..", "manifest.json") : "",
+        resolve(moduleDir, "..", "package.json"),
+        resolve(moduleDir, "..", "..", "package.json"),
+        resolve(process.cwd(), "packages/cli/package.json")
+      ].filter(Boolean);
+      for (const candidate of candidates) {
+        if (!existsSync(candidate))
+          continue;
+        const parsed = JSON.parse(readFileSync(candidate, "utf-8"));
+        const candidateVersion = parsed.version?.trim();
+        if (candidateVersion) {
+          version = candidateVersion;
+          break;
+        }
+      }
+    } catch {}
+  }
+  return version || DEV_CLI_VERSION;
+}
+function isPublishedCliVersion(version) {
+  const normalized = version.trim();
+  return normalized.length > 0 && normalized !== SOURCE_CLI_VERSION && normalized !== DEV_CLI_VERSION;
+}
+export {
+  resolveInstalledCliVersion,
+  isPublishedCliVersion,
+  SOURCE_CLI_VERSION,
+  DEV_CLI_VERSION
+};

package/dist/src/withMutedConsole.d.ts

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