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

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,181 @@
+// @bun
+// packages/cli/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,
+  resolveRegistryBaseUrl,
+  resolveRegistrySecret,
+  resolveRelayUrl
+} from "@rig/runtime/control-plane/remote";
+
+// packages/cli/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/src/commands/_cli-format.ts
+import pc from "picocolors";
+var dim = pc.dim;
+var faintBar = pc.dim("\u2502");
+var accent = pc.cyan;
+function printFormattedOutput(message) {
+  console.log(message);
+}
+
+// packages/cli/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.registrySecret": { env: "RIG_REGISTRY_SHARED_SECRET", effective: (r) => resolveRegistrySecret(r), def: "(built-in default)" },
+  "runtime.server.sshTarget": { env: "RIG_SSH_TARGET", effective: () => process.env.RIG_SSH_TARGET?.trim() ?? "(none \u2014 local placement)", def: "(none)" }
+};
+var ALIASES = {
+  relayUrl: "runtime.server.relayUrl",
+  registryUrl: "runtime.server.registryUrl",
+  registrySecret: "runtime.server.registrySecret",
+  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 = 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>;

package/dist/src/commands/dist.js

@@ -17,12 +17,19 @@ 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 { CliError as RuntimeCliError } 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";
+
+class CliError extends RuntimeCliError {
+  hint;
+  constructor(message, exitCode = 1, options = {}) {
+    super(message, exitCode);
+    if (options.hint?.trim()) {
+      this.hint = options.hint.trim();
+    }
+  }
+}
 function takeOption(args, option) {
   const rest = [];
   let value;
@@ -31,7 +38,7 @@ function takeOption(args, option) {
     if (current === option) {
       const next = args[index + 1];
       if (!next || next.startsWith("-")) {
-        throw new CliError(`Missing value for ${option}`);
+        throw new CliError(`Missing value for ${option}`, 1, { hint: `Provide a value after ${option}, e.g. \`${option} <value>\`.` });
       }
       value = next;
       index += 1;
@@ -51,11 +58,11 @@ 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";
+import { buildBinary as buildBinary2 } from "@rig/runtime/control-plane/runtime/isolation";
 
 // packages/cli/src/commands/_parsers.ts
 import { homedir } from "os";
@@ -67,7 +74,7 @@ function parseInstallScope(value) {
   if (value === "system") {
     return "system";
   }
-  throw new CliError2(`Invalid --scope value: ${value}. Use user|system.`);
+  throw new CliError(`Invalid --scope value: ${value}. Use user|system.`);
 }
 function resolveInstallDir(scope, explicitPath) {
   if (explicitPath) {
@@ -81,7 +88,7 @@ function resolveInstallDir(scope, explicitPath) {
 
 // packages/cli/src/commands/_paths.ts
 import { resolve as resolve2 } from "path";
-import { resolveMonorepoRoot } from "@rig/runtime/control-plane/native/utils";
+import { resolveMonorepoRoot } from "@rig/runtime/layout";
 function resolveControlPlaneMonorepoRoot(projectRoot) {
   return resolveMonorepoRoot(projectRoot);
 }
@@ -117,8 +124,9 @@ function collectRigValidatorBuildTargets(input) {
   if (!existsSync(validatorsRoot))
     return [];
   const targets = [];
-  const categories = readdirSync(validatorsRoot, { withFileTypes: true }).filter((entry) => entry.isDirectory());
-  for (const category of categories) {
+  for (const category of readdirSync(validatorsRoot, { withFileTypes: true })) {
+    if (!category.isDirectory())
+      continue;
     const categoryDir = resolve3(validatorsRoot, category.name);
     for (const entry of readdirSync(categoryDir, { withFileTypes: true })) {
       if (!entry.isFile() || !entry.name.endsWith(".ts"))
@@ -126,9 +134,10 @@ function collectRigValidatorBuildTargets(input) {
       const check = entry.name.replace(/\.ts$/, "");
       if (!check || check === "index" || check === "shared")
         continue;
+      const validatorName = `${category.name}-${check}`;
       targets.push({
         source: `packages/runtime/src/control-plane/validators/${category.name}/${entry.name}`,
-        dest: resolve3(input.imageDir, `bin/validators/${category.name}-${check}`),
+        dest: resolve3(input.imageDir, `bin/validators/${validatorName}`),
         cwd: input.hostProjectRoot
       });
     }
@@ -140,15 +149,22 @@ async function findLatestDistBinary(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;
-    }
+  const candidates = [];
+  for (const entry of readdirSync(distRoot, { withFileTypes: true })) {
+    if (!entry.name.startsWith("rig-") && entry.name !== "rig")
+      continue;
+    const entryPath = resolve3(distRoot, entry.name);
+    const binary = entry.isDirectory() ? resolve3(entryPath, "bin", "rig") : entryPath;
+    try {
+      const stat = statSync(binary);
+      if (stat.isFile())
+        candidates.push({ path: binary, mtimeMs: stat.mtimeMs });
+    } catch {}
+  }
+  candidates.sort((a, b) => b.mtimeMs - a.mtimeMs);
+  for (const { path } of candidates) {
+    if (await isRunnableRigBinary(path, projectRoot))
+      return path;
   }
   return null;
 }
@@ -185,11 +201,10 @@ async function executeDist(context, args) {
   switch (command) {
     case "build": {
       const { value: outputDir, rest: pending } = takeOption(rest, "--output-dir");
-      requireNoExtraArgs(pending, "bun run rig dist build [--output-dir <dir>]");
+      requireNoExtraArgs(pending, "rig dist build [--output-dir <dir>]");
       const commandParts = ["bun", "run", "packages/cli/bin/build-rig-binaries.ts"];
-      if (outputDir) {
+      if (outputDir)
         commandParts.push("--output-dir", outputDir);
-      }
       await context.runCommand(commandParts);
       return { ok: true, group: "dist", command, details: { outputDir: outputDir || null } };
     }
@@ -197,9 +212,9 @@ async function executeDist(context, args) {
       let pending = rest;
       const scopeResult = takeOption(pending, "--scope");
       pending = scopeResult.rest;
-      const pathResult = takeOption(pending, "--path");
+      const pathResult = takeOption(pending, "--dir");
       pending = pathResult.rest;
-      requireNoExtraArgs(pending, "bun run rig dist install [--scope user|system] [--path <dir>]");
+      requireNoExtraArgs(pending, "rig dist install [--scope user|system] [--dir <dir>]");
       const scope = parseInstallScope(scopeResult.value);
       const installDir = resolveInstallDir(scope, pathResult.value);
       mkdirSync(installDir, { recursive: true });
@@ -211,7 +226,7 @@ async function executeDist(context, args) {
         source = resolve3(buildDir, "bin", "rig");
       }
       if (!existsSync(source)) {
-        throw new CliError2(`Unable to locate rig binary at ${source}.`, 2);
+        throw new CliError(`Unable to locate rig binary at ${source}.`, 2, { hint: "Build it first with `rig dist build`, then re-run `rig dist install`." });
       }
       const installedPath = resolve3(installDir, "rig");
       if (existsSync(installedPath)) {
@@ -242,7 +257,7 @@ async function executeDist(context, args) {
       };
     }
     case "doctor": {
-      requireNoExtraArgs(rest, "bun run rig dist doctor");
+      requireNoExtraArgs(rest, "rig dist doctor");
       const details = await runDistDoctor(context.projectRoot);
       if (context.outputMode === "text") {
         console.log(`bun: ${details.bun.available ? `ok (${details.bun.version})` : "missing"}`);
@@ -253,7 +268,7 @@ async function executeDist(context, args) {
       return { ok: true, group: "dist", command, details };
     }
     case "rebuild-agent": {
-      requireNoExtraArgs(rest, "bun run rig dist rebuild-agent");
+      requireNoExtraArgs(rest, "rig dist rebuild-agent");
       const fp = await computeRuntimeImageFingerprint(context.projectRoot);
       const currentId = computeRuntimeImageId(fp);
       const imagesDir = resolve3(resolveControlPlaneMonorepoRuntimeDir(context.projectRoot), "images");
@@ -393,7 +408,7 @@ async function executeDist(context, args) {
       return { ok: true, group: "dist", command, details: { imageId: currentId, count: targets.length } };
     }
     default:
-      throw new CliError2(`Unknown dist command: ${command}`);
+      throw new CliError(`Unknown dist command: ${command}`, 1, { hint: "Run `rig dist --help` \u2014 commands are build|install|doctor|rebuild-agent." });
   }
 }
 export {

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

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