@h-rig/cli 0.0.6-alpha.24 → 0.0.6-alpha.240

package/dist/src/commands/connect.js

@@ -1,180 +0,0 @@
-// @bun
-// 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 requireNoExtraArgs(args, usage) {
-  if (args.length > 0) {
-    throw new CliError(`Unexpected arguments: ${args.join(" ")}
-Usage: ${usage}`);
-  }
-}
-
-// packages/cli/src/commands/_connection-state.ts
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
-import { homedir } from "os";
-import { dirname, resolve } from "path";
-function resolveGlobalConnectionsPath(env = process.env) {
-  const explicit = env.RIG_CONNECTIONS_FILE?.trim();
-  if (explicit)
-    return resolve(explicit);
-  const stateDir = env.RIG_GLOBAL_STATE_DIR?.trim();
-  if (stateDir)
-    return resolve(stateDir, "connections.json");
-  return resolve(homedir(), ".rig", "connections.json");
-}
-function resolveRepoConnectionPath(projectRoot) {
-  return resolve(projectRoot, ".rig", "state", "connection.json");
-}
-function readJsonFile(path) {
-  if (!existsSync(path))
-    return null;
-  try {
-    return JSON.parse(readFileSync(path, "utf8"));
-  } catch (error) {
-    throw new CliError2(`Invalid Rig connection state at ${path}: ${error instanceof Error ? error.message : String(error)}`, 1);
-  }
-}
-function writeJsonFile(path, value) {
-  mkdirSync(dirname(path), { recursive: true });
-  writeFileSync(path, `${JSON.stringify(value, null, 2)}
-`, "utf8");
-}
-function normalizeConnection(value) {
-  if (!value || typeof value !== "object" || Array.isArray(value))
-    return null;
-  const record = value;
-  if (record.kind === "local")
-    return { kind: "local", mode: "auto" };
-  if (record.kind === "remote" && typeof record.baseUrl === "string" && record.baseUrl.trim()) {
-    const baseUrl = record.baseUrl.trim().replace(/\/+$/, "");
-    return { kind: "remote", baseUrl };
-  }
-  return null;
-}
-function readGlobalConnections(options = {}) {
-  const path = resolveGlobalConnectionsPath(options.env ?? process.env);
-  const payload = readJsonFile(path);
-  if (!payload || typeof payload !== "object" || Array.isArray(payload)) {
-    return { connections: {} };
-  }
-  const rawConnections = payload.connections;
-  const connections = {};
-  if (rawConnections && typeof rawConnections === "object" && !Array.isArray(rawConnections)) {
-    for (const [alias, raw] of Object.entries(rawConnections)) {
-      const connection = normalizeConnection(raw);
-      if (connection)
-        connections[alias] = connection;
-    }
-  }
-  return { connections };
-}
-function writeGlobalConnections(state, options = {}) {
-  writeJsonFile(resolveGlobalConnectionsPath(options.env ?? process.env), state);
-}
-function upsertGlobalConnection(alias, connection, options = {}) {
-  const cleanAlias = alias.trim();
-  if (!cleanAlias)
-    throw new CliError2("Connection alias is required.", 1);
-  const state = readGlobalConnections(options);
-  state.connections[cleanAlias] = connection;
-  writeGlobalConnections(state, options);
-  return state;
-}
-function readRepoConnection(projectRoot) {
-  const payload = readJsonFile(resolveRepoConnectionPath(projectRoot));
-  if (!payload || typeof payload !== "object" || Array.isArray(payload))
-    return null;
-  const record = payload;
-  const selected = typeof record.selected === "string" ? record.selected.trim() : "";
-  if (!selected)
-    return null;
-  return {
-    selected,
-    project: typeof record.project === "string" ? record.project : undefined,
-    linkedAt: typeof record.linkedAt === "string" ? record.linkedAt : undefined
-  };
-}
-function writeRepoConnection(projectRoot, state) {
-  writeJsonFile(resolveRepoConnectionPath(projectRoot), state);
-}
-
-// packages/cli/src/commands/connect.ts
-function parseConnection(alias, value) {
-  if (alias === "local" && !value)
-    return { kind: "local", mode: "auto" };
-  if (!value)
-    throw new CliError2("Missing remote server URL. Usage: rig connect add <alias> <url>", 1);
-  let parsed;
-  try {
-    parsed = new URL(value);
-  } catch {
-    throw new CliError2(`Invalid Rig server URL: ${value}`, 1);
-  }
-  if (parsed.protocol !== "https:" && parsed.protocol !== "http:") {
-    throw new CliError2("Rig remote server URL must be http(s).", 1);
-  }
-  return { kind: "remote", baseUrl: parsed.toString().replace(/\/+$/, "") };
-}
-function printJsonOrText(context, payload, text) {
-  if (context.outputMode === "json") {
-    console.log(JSON.stringify(payload, null, 2));
-  } else {
-    console.log(text);
-  }
-}
-async function executeConnect(context, args) {
-  const [command, ...rest] = args;
-  switch (command ?? "status") {
-    case "list": {
-      requireNoExtraArgs(rest, "rig connect list");
-      const state = readGlobalConnections();
-      printJsonOrText(context, state, Object.entries(state.connections).map(([alias, connection]) => `${alias}	${connection.kind === "remote" ? connection.baseUrl : "local"}`).join(`
-`) || "No Rig connections configured.");
-      return { ok: true, group: "connect", command: "list", details: state };
-    }
-    case "add": {
-      const [alias, url, ...extra] = rest;
-      if (!alias)
-        throw new CliError2("Missing alias. Usage: rig connect add <alias> <url>", 1);
-      requireNoExtraArgs(extra, "rig connect add <alias> <url>");
-      const connection = parseConnection(alias, url);
-      const state = upsertGlobalConnection(alias, connection);
-      printJsonOrText(context, { alias, connection }, `Added Rig connection ${alias}.`);
-      return { ok: true, group: "connect", command: "add", details: { alias, connection, count: Object.keys(state.connections).length } };
-    }
-    case "use": {
-      const [alias, ...extra] = rest;
-      if (!alias)
-        throw new CliError2("Missing alias. Usage: rig connect use <alias|local>", 1);
-      requireNoExtraArgs(extra, "rig connect use <alias|local>");
-      if (alias !== "local") {
-        const state = readGlobalConnections();
-        if (!state.connections[alias])
-          throw new CliError2(`Unknown Rig connection: ${alias}`, 1);
-      }
-      const repoState = { selected: alias, linkedAt: new Date().toISOString() };
-      writeRepoConnection(context.projectRoot, repoState);
-      printJsonOrText(context, repoState, `Selected Rig connection ${alias} for this repo.`);
-      return { ok: true, group: "connect", command: "use", details: repoState };
-    }
-    case "status": {
-      requireNoExtraArgs(rest, "rig connect status");
-      const repo = readRepoConnection(context.projectRoot);
-      const global = readGlobalConnections();
-      const details = { selected: repo?.selected ?? "local", repo, connections: global.connections };
-      printJsonOrText(context, details, `Selected Rig connection: ${details.selected}`);
-      return { ok: true, group: "connect", command: "status", details };
-    }
-    default:
-      throw new CliError2(`Unknown connect command: ${String(command)}
-Usage: rig connect <list|add|use|status>`, 1);
-  }
-}
-export {
-  executeConnect
-};

package/dist/src/commands/dist.js

@@ -1,402 +0,0 @@
-// @bun
-// packages/cli/src/commands/dist.ts
-import {
-  chmodSync,
-  copyFileSync,
-  existsSync,
-  mkdirSync,
-  readdirSync,
-  readlinkSync,
-  rmSync,
-  statSync,
-  symlinkSync,
-  unlinkSync
-} from "fs";
-import { homedir as homedir2 } from "os";
-import { resolve as resolve3 } 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 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/dist.ts
-import { buildBinary as buildBinary2 } from "@rig/runtime/control-plane/runtime/isolation";
-import {
-  computeRuntimeImageFingerprint,
-  computeRuntimeImageId
-} from "@rig/runtime/control-plane/runtime/image/index";
-
-// packages/cli/src/commands/_parsers.ts
-import { homedir } from "os";
-import { resolve } from "path";
-function parseInstallScope(value) {
-  if (!value || value === "user") {
-    return "user";
-  }
-  if (value === "system") {
-    return "system";
-  }
-  throw new CliError2(`Invalid --scope value: ${value}. Use user|system.`);
-}
-function resolveInstallDir(scope, explicitPath) {
-  if (explicitPath) {
-    return resolve(explicitPath);
-  }
-  if (scope === "system") {
-    return "/usr/local/bin";
-  }
-  return resolve(homedir(), ".local/bin");
-}
-
-// packages/cli/src/commands/_paths.ts
-import { resolve as resolve2 } from "path";
-import { resolveMonorepoRoot } from "@rig/runtime/control-plane/native/utils";
-function resolveControlPlaneMonorepoRoot(projectRoot) {
-  return resolveMonorepoRoot(projectRoot);
-}
-function resolveControlPlaneHostStateRoot(projectRoot) {
-  return resolve2(projectRoot, ".rig");
-}
-function resolveControlPlaneHostBinDir(projectRoot) {
-  return resolve2(resolveControlPlaneHostStateRoot(projectRoot), "bin");
-}
-function resolveControlPlaneHostDistDir(projectRoot) {
-  return resolve2(resolveControlPlaneHostStateRoot(projectRoot), "dist");
-}
-function resolveControlPlaneMonorepoStateRoot(projectRoot) {
-  return resolve2(resolveControlPlaneMonorepoRoot(projectRoot), ".rig");
-}
-function resolveControlPlaneMonorepoRuntimeDir(projectRoot) {
-  return resolve2(resolveControlPlaneMonorepoStateRoot(projectRoot), "runtime");
-}
-
-// packages/cli/src/commands/_probes.ts
-async function runQuietBinaryProbe(binaryPath, args, cwd) {
-  try {
-    const run = await Bun.$`${binaryPath} ${args}`.cwd(cwd).quiet().nothrow();
-    return run.exitCode === 0;
-  } catch {
-    return false;
-  }
-}
-
-// packages/cli/src/commands/dist.ts
-function collectRigValidatorBuildTargets(input) {
-  const validatorsRoot = resolve3(input.hostProjectRoot, "packages/runtime/src/control-plane/validators");
-  if (!existsSync(validatorsRoot))
-    return [];
-  const targets = [];
-  const categories = readdirSync(validatorsRoot, { withFileTypes: true }).filter((entry) => entry.isDirectory());
-  for (const category of categories) {
-    const categoryDir = resolve3(validatorsRoot, category.name);
-    for (const entry of readdirSync(categoryDir, { withFileTypes: true })) {
-      if (!entry.isFile() || !entry.name.endsWith(".ts"))
-        continue;
-      const check = entry.name.replace(/\.ts$/, "");
-      if (!check || check === "index" || check === "shared")
-        continue;
-      targets.push({
-        source: `packages/runtime/src/control-plane/validators/${category.name}/${entry.name}`,
-        dest: resolve3(input.imageDir, `bin/validators/${category.name}-${check}`),
-        cwd: input.hostProjectRoot
-      });
-    }
-  }
-  return targets;
-}
-async function findLatestDistBinary(projectRoot) {
-  const distRoot = resolveControlPlaneHostDistDir(projectRoot);
-  if (!existsSync(distRoot)) {
-    return null;
-  }
-  const entries = readdirSync(distRoot, { withFileTypes: true }).filter((entry) => entry.isDirectory() && entry.name.startsWith("rig-")).map((entry) => ({
-    name: entry.name,
-    mtimeMs: statSync(resolve3(distRoot, entry.name)).mtimeMs
-  })).sort((a, b) => b.mtimeMs - a.mtimeMs || b.name.localeCompare(a.name));
-  for (const { name } of entries) {
-    const candidate = resolve3(distRoot, name, "bin", "rig");
-    if (existsSync(candidate) && await isRunnableRigBinary(candidate, projectRoot)) {
-      return candidate;
-    }
-  }
-  return null;
-}
-async function isRunnableRigBinary(binaryPath, projectRoot) {
-  return runQuietBinaryProbe(binaryPath, ["help"], projectRoot);
-}
-async function runDistDoctor(projectRoot) {
-  const bunPath = Bun.which("bun");
-  const rigPath = Bun.which("rig");
-  const userBinDir = resolve3(homedir2(), ".local/bin");
-  const userBinInPath = (process.env.PATH || "").split(":").filter(Boolean).includes(userBinDir);
-  let rigRunnable = false;
-  if (rigPath) {
-    rigRunnable = await runQuietBinaryProbe(rigPath, ["help"], projectRoot);
-  }
-  return {
-    bun: {
-      available: Boolean(bunPath),
-      path: bunPath || null,
-      version: Bun.version
-    },
-    rig: {
-      onPath: Boolean(rigPath),
-      path: rigPath || null,
-      runnable: rigRunnable
-    },
-    userBinDir,
-    userBinInPath,
-    latestDistBinary: await findLatestDistBinary(projectRoot)
-  };
-}
-async function executeDist(context, args) {
-  const [command = "build", ...rest] = args;
-  switch (command) {
-    case "build": {
-      const { value: outputDir, rest: pending } = takeOption(rest, "--output-dir");
-      requireNoExtraArgs(pending, "bun run rig dist build [--output-dir <dir>]");
-      const commandParts = ["bun", "run", "packages/cli/bin/build-rig-binaries.ts"];
-      if (outputDir) {
-        commandParts.push("--output-dir", outputDir);
-      }
-      await context.runCommand(commandParts);
-      return { ok: true, group: "dist", command, details: { outputDir: outputDir || null } };
-    }
-    case "install": {
-      let pending = rest;
-      const scopeResult = takeOption(pending, "--scope");
-      pending = scopeResult.rest;
-      const pathResult = takeOption(pending, "--path");
-      pending = pathResult.rest;
-      requireNoExtraArgs(pending, "bun run rig dist install [--scope user|system] [--path <dir>]");
-      const scope = parseInstallScope(scopeResult.value);
-      const installDir = resolveInstallDir(scope, pathResult.value);
-      mkdirSync(installDir, { recursive: true });
-      let source = await findLatestDistBinary(context.projectRoot);
-      let buildDir = null;
-      if (!source) {
-        buildDir = resolve3(resolveControlPlaneHostDistDir(context.projectRoot), `rig-install-${Date.now()}`);
-        await context.runCommand(["bun", "run", "packages/cli/bin/build-rig-binaries.ts", "--output-dir", buildDir]);
-        source = resolve3(buildDir, "bin", "rig");
-      }
-      if (!existsSync(source)) {
-        throw new CliError2(`Unable to locate rig binary at ${source}.`, 2);
-      }
-      const installedPath = resolve3(installDir, "rig");
-      if (existsSync(installedPath)) {
-        unlinkSync(installedPath);
-      }
-      copyFileSync(source, installedPath);
-      chmodSync(installedPath, 493);
-      const pathEntries = (process.env.PATH || "").split(":").filter(Boolean);
-      const inPath = pathEntries.includes(installDir);
-      if (context.outputMode === "text") {
-        console.log(`Installed: ${installedPath}`);
-        if (!inPath) {
-          console.log(`PATH note: add ${installDir} to PATH to run 'rig' directly.`);
-        }
-      }
-      return {
-        ok: true,
-        group: "dist",
-        command,
-        details: {
-          scope,
-          installDir,
-          installedPath,
-          sourcePath: source,
-          builtNow: Boolean(buildDir),
-          inPath
-        }
-      };
-    }
-    case "doctor": {
-      requireNoExtraArgs(rest, "bun run rig dist doctor");
-      const details = await runDistDoctor(context.projectRoot);
-      if (context.outputMode === "text") {
-        console.log(`bun: ${details.bun.available ? `ok (${details.bun.version})` : "missing"}`);
-        console.log(`rig on PATH: ${details.rig.onPath ? details.rig.path : "missing"}`);
-        console.log(`user bin dir: ${details.userBinDir} (${details.userBinInPath ? "in PATH" : "not in PATH"})`);
-        console.log(`latest dist binary: ${details.latestDistBinary || "none"}`);
-      }
-      return { ok: true, group: "dist", command, details };
-    }
-    case "rebuild-agent": {
-      requireNoExtraArgs(rest, "bun run rig dist rebuild-agent");
-      const fp = await computeRuntimeImageFingerprint(context.projectRoot);
-      const currentId = computeRuntimeImageId(fp);
-      const imagesDir = resolve3(resolveControlPlaneMonorepoRuntimeDir(context.projectRoot), "images");
-      mkdirSync(imagesDir, { recursive: true });
-      let pruned = 0;
-      for (const entry of readdirSync(imagesDir, { withFileTypes: true })) {
-        if (entry.isDirectory() && entry.name !== currentId) {
-          rmSync(resolve3(imagesDir, entry.name), { recursive: true, force: true });
-          pruned++;
-        }
-      }
-      if (pruned > 0 && context.outputMode === "text") {
-        console.log(`Pruned ${pruned} stale image(s).`);
-      }
-      const imageDir = resolve3(imagesDir, currentId);
-      mkdirSync(resolve3(imageDir, "bin/hooks"), { recursive: true });
-      mkdirSync(resolve3(imageDir, "bin/plugins"), { recursive: true });
-      mkdirSync(resolve3(imageDir, "bin/validators"), { recursive: true });
-      const hookNames = [
-        "scope-guard",
-        "import-guard",
-        "safety-guard",
-        "test-integrity-guard",
-        "audit-trail",
-        "post-edit-lint",
-        "completion-verification",
-        "inject-context",
-        "task-runtime-start"
-      ];
-      const targets = [];
-      const hostProjectRoot = process.env.RIG_HOST_PROJECT_ROOT?.trim() || context.projectRoot;
-      targets.push({ source: "packages/runtime/bin/rig-agent.ts", dest: resolve3(imageDir, "bin/rig-agent"), cwd: hostProjectRoot });
-      targets.push({ source: "packages/runtime/bin/rig-agent-dispatch.ts", dest: resolve3(resolveControlPlaneHostBinDir(context.projectRoot), "rig-agent"), cwd: hostProjectRoot });
-      for (const hookName of hookNames) {
-        const src = `packages/runtime/src/control-plane/hooks/${hookName}.ts`;
-        targets.push({ source: src, dest: resolve3(imageDir, `bin/hooks/${hookName}`), cwd: hostProjectRoot });
-        targets.push({ source: src, dest: resolve3(resolveControlPlaneHostBinDir(context.projectRoot), `hooks/${hookName}`), cwd: hostProjectRoot });
-      }
-      const pluginsDir = resolve3(context.projectRoot, "rig/plugins");
-      const binPluginsDir = resolve3(resolveControlPlaneHostBinDir(context.projectRoot), "plugins");
-      const validatorsRoot = resolve3(hostProjectRoot, "packages/runtime/src/control-plane/validators");
-      const binValidatorsDir = resolve3(resolveControlPlaneHostBinDir(context.projectRoot), "validators");
-      mkdirSync(binPluginsDir, { recursive: true });
-      mkdirSync(binValidatorsDir, { recursive: true });
-      if (existsSync(pluginsDir)) {
-        for (const entry of readdirSync(pluginsDir, { withFileTypes: true })) {
-          const m = entry.name.match(/^(.+)\.plugin\.(ts|js|mjs|cjs)$/);
-          if (!m)
-            continue;
-          targets.push({ source: `rig/plugins/${entry.name}`, dest: resolve3(imageDir, `bin/plugins/${m[1]}`), cwd: context.projectRoot });
-        }
-      }
-      targets.push(...collectRigValidatorBuildTargets({ contextProjectRoot: context.projectRoot, hostProjectRoot, imageDir }));
-      for (const { source, dest, cwd } of targets) {
-        if (context.outputMode === "text") {
-          console.log(`Building: ${dest}`);
-        }
-        const isValidator = dest.includes("/bin/validators/");
-        await buildBinary2(source, dest, cwd, isValidator ? { AGENT_BUN_PATH: Bun.which("bun") || "bun" } : { AGENT_PROJECT_ROOT: context.projectRoot });
-      }
-      if (existsSync(pluginsDir)) {
-        for (const entry of readdirSync(pluginsDir, { withFileTypes: true })) {
-          const m = entry.name.match(/^(.+)\.plugin\.(ts|js|mjs|cjs)$/);
-          if (!m)
-            continue;
-          const pluginName = m[1];
-          const imageBin = resolve3(imageDir, `bin/plugins/${pluginName}`);
-          if (!pluginName)
-            continue;
-          const symlinkPath = resolve3(binPluginsDir, pluginName);
-          if (existsSync(imageBin)) {
-            try {
-              unlinkSync(symlinkPath);
-            } catch {}
-            symlinkSync(imageBin, symlinkPath);
-          }
-        }
-      }
-      if (existsSync(validatorsRoot)) {
-        const categories = readdirSync(validatorsRoot, { withFileTypes: true }).filter((entry) => entry.isDirectory());
-        for (const category of categories) {
-          const categoryDir = resolve3(validatorsRoot, category.name);
-          for (const entry of readdirSync(categoryDir, { withFileTypes: true })) {
-            if (!entry.isFile() || !entry.name.endsWith(".ts"))
-              continue;
-            const check = entry.name.replace(/\.ts$/, "");
-            if (!check || check === "index" || check === "shared")
-              continue;
-            const validatorName = `${category.name}-${check}`;
-            const imageBin = resolve3(imageDir, `bin/validators/${validatorName}`);
-            const symlinkPath = resolve3(binValidatorsDir, validatorName);
-            if (existsSync(imageBin)) {
-              try {
-                unlinkSync(symlinkPath);
-              } catch {}
-              symlinkSync(imageBin, symlinkPath);
-            }
-          }
-        }
-      }
-      const agentsDir = resolve3(resolveControlPlaneMonorepoRuntimeDir(context.projectRoot), "agents");
-      if (existsSync(agentsDir)) {
-        let relinkCount = 0;
-        for (const agentEntry of readdirSync(agentsDir, { withFileTypes: true })) {
-          if (!agentEntry.isDirectory())
-            continue;
-          const agentBinDir = resolve3(agentsDir, agentEntry.name, "worktree", ".rig", "bin");
-          if (!existsSync(agentBinDir))
-            continue;
-          const walkDir = (dir) => {
-            for (const entry of readdirSync(dir, { withFileTypes: true })) {
-              const fullPath = resolve3(dir, entry.name);
-              if (entry.isDirectory()) {
-                walkDir(fullPath);
-              } else if (entry.isSymbolicLink()) {
-                const target = readlinkSync(fullPath);
-                if (target.includes("/.rig/runtime/images/") && !target.includes(`/${currentId}/`)) {
-                  const newTarget = target.replace(/\/\.rig\/runtime\/images\/[^/]+\//, `/.rig/runtime/images/${currentId}/`);
-                  try {
-                    unlinkSync(fullPath);
-                    symlinkSync(newTarget, fullPath);
-                    relinkCount++;
-                  } catch {}
-                }
-              }
-            }
-          };
-          walkDir(agentBinDir);
-        }
-        if (relinkCount > 0 && context.outputMode === "text") {
-          console.log(`Re-linked ${relinkCount} worktree symlink(s) to image ${currentId}.`);
-        }
-      }
-      if (context.outputMode === "text") {
-        console.log(`Rebuilt ${targets.length} binaries into image ${currentId}.`);
-      }
-      return { ok: true, group: "dist", command, details: { imageId: currentId, count: targets.length } };
-    }
-    default:
-      throw new CliError2(`Unknown dist command: ${command}`);
-  }
-}
-export {
-  executeDist,
-  collectRigValidatorBuildTargets
-};