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

package/dist/src/commands/server.js

@@ -0,0 +1,155 @@
+// @bun
+// packages/cli-surface-plugin/src/commands/server.ts
+import { addPlacement, listPlacements, readPlacement, removePlacement, selectPlacement } from "@rig/client";
+
+// packages/cli-surface-plugin/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 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}`);
+  }
+}
+
+// packages/cli-surface-plugin/src/commands/_cli-format.ts
+import pc from "picocolors";
+import { runStatusColorRole, runStatusText, statusColorRole } from "@rig/client";
+var dim = pc.dim;
+var faintBar = pc.dim("\u2502");
+var accent = pc.cyan;
+function printFormattedOutput(message) {
+  console.log(message);
+}
+
+// packages/cli-surface-plugin/src/commands/server.ts
+var DEFAULT_REMOTE_PORT = 22;
+async function executeServer(context, args) {
+  const [command = "status", ...rest] = args;
+  const text = context.outputMode === "text";
+  const projectRoot = context.projectRoot;
+  switch (command) {
+    case "status": {
+      requireNoExtraArgs(rest, "rig server status");
+      const target = await readPlacement(projectRoot);
+      if (text) {
+        printFormattedOutput(target.kind === "local" ? "Placement: local (runs execute on this machine)." : `Placement: remote \u2192 ${target.alias}${target.host ? ` (${target.host}:${target.port ?? DEFAULT_REMOTE_PORT})` : ""}`);
+        printFormattedOutput(`Task source: ${target.taskSource}`);
+      }
+      return { ok: true, group: "server", command, details: { placement: target.kind, alias: target.alias, taskSource: target.taskSource, ...target.host ? { host: target.host, port: target.port } : {} } };
+    }
+    case "list": {
+      requireNoExtraArgs(rest, "rig server list");
+      const placements = listPlacements(projectRoot);
+      const selected = placements.find((placement) => placement.status === "selected")?.alias ?? "local";
+      if (text) {
+        for (const placement of placements) {
+          const marker = selected === placement.alias ? "* " : "  ";
+          if (placement.alias === "local")
+            printFormattedOutput(`${marker}local \u2014 runs execute on this machine`);
+          else if (placement.alias === "remote")
+            printFormattedOutput(`${marker}remote \u2014 runs execute on the shared host (${placement.host})`);
+          else
+            printFormattedOutput(`${marker}${placement.alias} \u2014 ${placement.host}:${placement.port}`);
+        }
+      }
+      return { ok: true, group: "server", command, details: { selected, builtins: ["local", "remote"], endpoints: placements.filter((placement) => placement.alias !== "local" && placement.alias !== "remote").map((placement) => ({ alias: placement.alias, host: placement.host, port: placement.port })) } };
+    }
+    case "use": {
+      const [aliasArg, ...extra] = rest;
+      requireNoExtraArgs(extra, "rig server use <local|alias>");
+      const alias = (aliasArg ?? "").trim();
+      if (!alias)
+        throw new CliError("rig server use requires a target.", 2, { hint: "rig server use local  |  rig server use <alias>" });
+      let selected;
+      try {
+        selected = selectPlacement(projectRoot, alias, { dryRun: context.dryRun });
+      } catch (error) {
+        throw new CliError(error instanceof Error ? error.message : String(error), 2, { hint: "Run `rig server list`, or add it with `rig server add --alias <a> --host <h>`." });
+      }
+      if (context.dryRun)
+        return { ok: true, group: "server", command, details: { selected: alias, dryRun: true } };
+      if (text)
+        printFormattedOutput(selected.alias === "local" ? "Placement set to local." : `Placement set to remote \u2192 ${selected.alias}.`);
+      return { ok: true, group: "server", command, details: { selected: selected.alias } };
+    }
+    case "add": {
+      const aliasOpt = takeOption(rest, "--alias");
+      const hostOpt = takeOption(aliasOpt.rest, "--host");
+      const portOpt = takeOption(hostOpt.rest, "--port");
+      const tokenOpt = takeOption(portOpt.rest, "--token");
+      const positional = tokenOpt.rest.filter((arg) => !arg.startsWith("-"));
+      const alias = (aliasOpt.value ?? positional[0] ?? "").trim();
+      const host = (hostOpt.value ?? positional[1] ?? "").trim();
+      const portRaw = portOpt.value ?? positional[2];
+      if (!alias || !host)
+        throw new CliError("rig server add requires --alias <a> and --host <h>.", 2, { hint: "rig server add --alias prod --host prod.example.com --port 22" });
+      const port = portRaw ? Number(portRaw) : DEFAULT_REMOTE_PORT;
+      if (!Number.isFinite(port))
+        throw new CliError(`Invalid --port: ${portRaw}`, 2);
+      const saved = addPlacement(projectRoot, { alias, host, port, ...tokenOpt.value ? { token: tokenOpt.value } : {} }, { dryRun: context.dryRun });
+      if (context.dryRun)
+        return { ok: true, group: "server", command, details: { alias, host, port, dryRun: true } };
+      if (text)
+        printFormattedOutput(`Saved remote endpoint ${saved.alias} \u2192 ${saved.host}:${saved.port}. Select it with \`rig server use ${saved.alias}\`.`);
+      return { ok: true, group: "server", command, details: { alias: saved.alias, host: saved.host, port: saved.port } };
+    }
+    case "remove": {
+      const [aliasArg, ...extra] = rest;
+      requireNoExtraArgs(extra, "rig server remove <alias>");
+      const alias = (aliasArg ?? "").trim();
+      if (!alias)
+        throw new CliError("rig server remove requires an alias.", 2);
+      const removed = removePlacement(projectRoot, alias, { dryRun: context.dryRun });
+      if (context.dryRun)
+        return { ok: true, group: "server", command, details: { alias, dryRun: true } };
+      if (!removed.removed) {
+        throw new CliError(`No remote endpoint named ${alias}.`, 1, { hint: "Run `rig server list` to see configured endpoints." });
+      }
+      if (text)
+        printFormattedOutput(`Removed remote endpoint ${alias}.`);
+      return { ok: true, group: "server", command, details: { alias, removed: true } };
+    }
+    case "start":
+      throw new CliError("rig server start is retired: there is no standalone Rig server process after the OMP migration.", 2, { hint: "Runs execute locally (tmux) or on a selected remote \u2014 pick one with `rig server use local|<alias>`." });
+    case "repair-link":
+      throw new CliError("rig server repair-link is retired with the standalone server.", 2, { hint: "Select placement with `rig server use local|<alias>`." });
+    default:
+      throw new CliError(`Unknown server command: ${command}`, 1, { hint: "Run `rig server --help` \u2014 commands are status|list|use|add|remove." });
+  }
+}
+export {
+  executeServer
+};

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

@@ -0,0 +1,16 @@
+import type { TaskSourceConfig } from "@rig/contracts";
+import type { CommandOutcome } from "@rig/runtime";
+import { type RigPluginWithRuntime } from "@rig/core";
+import { type RunnerContext } from "../runner";
+type SetupCheck = {
+    ok: boolean;
+    label: string;
+    hint?: string;
+};
+type SetupRigConfig = {
+    plugins?: readonly RigPluginWithRuntime[];
+    taskSource?: TaskSourceConfig;
+};
+export declare function buildTaskSourceKindSetupCheck(config: SetupRigConfig): SetupCheck | null;
+export declare function executeSetup(context: RunnerContext, args: string[]): Promise<CommandOutcome>;
+export {};

package/dist/src/commands/setup.js

@@ -0,0 +1,356 @@
+// @bun
+// packages/cli-surface-plugin/src/commands/setup.ts
+import { createPluginHost } from "@rig/core";
+import { detectStartupStatus, ensureGitHubAuth, parseRepoSlug, runSetup, validateGitHubAuth } from "@rig/client";
+
+// packages/cli-surface-plugin/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 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}`);
+  }
+}
+
+// packages/cli-surface-plugin/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();
+    }
+  }
+}
+
+// packages/cli-surface-plugin/src/commands/_doctor-checks.ts
+import { countDoctorFailures, runDoctorChecks } from "@rig/client";
+var runRigDoctorChecks = runDoctorChecks;
+function formatDoctorChecks(checks) {
+  return checks.map((entry) => {
+    const status = String(entry.status ?? entry.level ?? "warn");
+    const marker = status === "pass" || status === "ok" ? "OK" : status === "warn" ? "WARN" : "FAIL";
+    return `${marker}: ${entry.label}${entry.detail ? ` \u2014 ${entry.detail}` : ""}${entry.remediation ? `
+  fix: ${entry.remediation}` : ""}`;
+  }).join(`
+`);
+}
+
+// packages/cli-surface-plugin/src/commands/_async-ui.ts
+import pc from "picocolors";
+
+// packages/cli-surface-plugin/src/commands/_spinner.ts
+var SPINNER_FRAMES = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
+function createTtySpinner(input) {
+  const output = input.output ?? process.stdout;
+  const isTty = output.isTTY === true;
+  const frames = input.frames && input.frames.length > 0 ? input.frames : SPINNER_FRAMES;
+  let label = input.label;
+  let frame = 0;
+  let paused = false;
+  let stopped = false;
+  let lastPrintedLabel = "";
+  const render = () => {
+    if (stopped || paused)
+      return;
+    if (!isTty) {
+      if (label !== lastPrintedLabel) {
+        output.write(`${label}
+`);
+        lastPrintedLabel = label;
+      }
+      return;
+    }
+    frame = (frame + 1) % frames.length;
+    const glyph = frames[frame] ?? frames[0] ?? "";
+    output.write(`\r\x1B[2K${input.styleFrame ? input.styleFrame(glyph) : glyph} ${label}`);
+  };
+  const clearLine = () => {
+    if (isTty)
+      output.write("\r\x1B[2K");
+  };
+  render();
+  const timer = isTty ? setInterval(render, input.intervalMs ?? 16) : null;
+  return {
+    setLabel(next) {
+      label = next;
+      render();
+    },
+    pause() {
+      paused = true;
+      clearLine();
+    },
+    resume() {
+      if (stopped)
+        return;
+      paused = false;
+      render();
+    },
+    stop(finalLine) {
+      if (stopped)
+        return;
+      stopped = true;
+      if (timer)
+        clearInterval(timer);
+      clearLine();
+      if (finalLine)
+        output.write(`${finalLine}
+`);
+    }
+  };
+}
+
+// packages/cli-surface-plugin/src/commands/_async-ui.ts
+var FRAMES = ["\u25D0", "\u25D3", "\u25D1", "\u25D2"];
+var DONE_SYMBOL = pc.green("\u25C7");
+var FAIL_SYMBOL = pc.red("\u25A0");
+var activeUpdate = null;
+async function withSpinner(label, work, options = {}) {
+  if (options.outputMode === "json") {
+    return work(() => {
+      return;
+    });
+  }
+  if (activeUpdate) {
+    activeUpdate(label);
+    return work(activeUpdate);
+  }
+  const output = options.output ?? process.stderr;
+  const isTty = output.isTTY === true;
+  let lastLabel = label;
+  if (!isTty) {
+    output.write(`${label}
+`);
+    const update2 = (next) => {
+      lastLabel = next;
+    };
+    activeUpdate = update2;
+    try {
+      return await work(update2);
+    } finally {
+      activeUpdate = null;
+    }
+  }
+  const spinner = createTtySpinner({
+    label,
+    output,
+    frames: FRAMES,
+    styleFrame: (frame) => pc.cyan(frame)
+  });
+  const update = (next) => {
+    lastLabel = next;
+    spinner.setLabel(next);
+  };
+  activeUpdate = update;
+  try {
+    const result = await work(update);
+    spinner.stop(options.doneLabel ? `${DONE_SYMBOL} ${options.doneLabel}` : undefined);
+    return result;
+  } catch (error) {
+    spinner.stop(`${FAIL_SYMBOL} ${lastLabel}`);
+    throw error;
+  } finally {
+    activeUpdate = null;
+  }
+}
+
+// packages/cli-surface-plugin/src/commands/setup.ts
+function formatTaskSourceKinds(kinds) {
+  return kinds.length > 0 ? kinds.join(", ") : "none";
+}
+function buildTaskSourceKindSetupCheck(config) {
+  if (!config.taskSource)
+    return null;
+  const kind = config.taskSource.kind;
+  const pluginHost = createPluginHost(config.plugins ?? []);
+  const registeredKinds = pluginHost.listExecutableTaskSources().map((source) => source.kind);
+  const isRegistered = Boolean(pluginHost.resolveTaskSourceFactoryByKind(kind));
+  return {
+    ok: isRegistered,
+    label: `task source kind "${kind}" registered`,
+    hint: isRegistered ? undefined : `registered kinds: ${formatTaskSourceKinds(registeredKinds)}; load a plugin that contributes an executable task source factory for "${kind}"`
+  };
+}
+async function executeSetup(context, args) {
+  const [command = "check", ...rest] = args;
+  switch (command) {
+    case "bootstrap":
+      requireNoExtraArgs(rest, "rig setup bootstrap");
+      await runBootstrap(context.projectRoot);
+      return { ok: true, group: "setup", command };
+    case "check":
+      requireNoExtraArgs(rest, `rig setup ${command}`);
+      return withMutedConsole(context.outputMode === "json", async () => {
+        const checks = await runSetupCheck(context.projectRoot, context.outputMode);
+        return { ok: true, group: "setup", command, details: { checks, failures: countDoctorFailures(checks) } };
+      });
+    case "setup":
+      return withMutedConsole(context.outputMode === "json", () => runSetupCommand(context, rest));
+    case "preflight":
+      requireNoExtraArgs(rest, "rig setup preflight");
+      await withMutedConsole(context.outputMode === "json", () => runSetupPreflight(context.projectRoot, context.outputMode));
+      return { ok: true, group: "setup", command };
+    default:
+      throw new CliError(`Unknown setup command: ${command}`, 1, { hint: "Run `rig setup --help` \u2014 commands are bootstrap|check|setup|preflight." });
+  }
+}
+async function runBootstrap(projectRoot) {
+  const hostBash = Bun.which("bash") || "/bin/bash";
+  const env = { ...process.env };
+  delete env.BASH;
+  delete env.RIG_BASH_MODE;
+  delete env.RIG_TASK_ID;
+  delete env.RIG_TASK_RUNTIME_ID;
+  delete env.RIG_TASK_WORKSPACE;
+  const proc = Bun.spawn([hostBash, "./bootstrap.sh"], { cwd: projectRoot, env, stdin: "inherit", stdout: "inherit", stderr: "inherit" });
+  const exitCode = await proc.exited;
+  if (exitCode !== 0)
+    throw new CliError(`Command failed (${exitCode}): ${hostBash} ./bootstrap.sh`, exitCode);
+}
+async function runSetupCheck(projectRoot, outputMode = "text") {
+  const status = await detectStartupStatus({ projectRoot });
+  await validateGitHubAuth(projectRoot, status.slug);
+  const doctorChecks = await withSpinner("Running setup checks\u2026", (update) => runRigDoctorChecks({ projectRoot, onProgress: update }), { outputMode });
+  console.log(formatDoctorChecks(doctorChecks));
+  const failures = countDoctorFailures(doctorChecks);
+  if (failures > 0)
+    throw new CliError(`Setup check failed (${failures} failing doctor check${failures === 1 ? "" : "s"}).`, 1, { hint: "Run bare `rig` and open Cockpit \u2192 Doctor for remediation details." });
+  return doctorChecks;
+}
+async function runSetupCommand(context, args) {
+  let pending = args;
+  const repoResult = takeOption(pending, "--repo");
+  pending = repoResult.rest;
+  const slugResult = takeOption(pending, "--slug");
+  pending = slugResult.rest;
+  const placementResult = takeOption(pending, "--placement");
+  pending = placementResult.rest;
+  const hostResult = takeOption(pending, "--host");
+  pending = hostResult.rest;
+  const portResult = takeOption(pending, "--port");
+  pending = portResult.rest;
+  const tokenResult = takeOption(pending, "--token");
+  pending = tokenResult.rest;
+  const githubTokenResult = takeOption(pending, "--github-token");
+  pending = githubTokenResult.rest;
+  const importGhToken = takeFlag(pending, "--import-gh-token");
+  pending = importGhToken.rest;
+  const noPi = takeFlag(pending, "--no-pi");
+  pending = noPi.rest;
+  const noLabels = takeFlag(pending, "--no-labels");
+  pending = noLabels.rest;
+  const noConfig = takeFlag(pending, "--no-config");
+  pending = noConfig.rest;
+  requireNoExtraArgs(pending, "rig setup setup --repo <owner/repo> [--placement local|<alias>] [--host <ssh-host>] [--port <n>] [--token <t>] [--github-token <t>|--import-gh-token] [--no-pi] [--no-labels] [--no-config]");
+  const startup = await detectStartupStatus({ projectRoot: context.projectRoot });
+  const slug = repoResult.value ?? slugResult.value ?? startup.slug;
+  if (!slug)
+    throw new CliError("rig setup setup requires --repo <owner/repo> when no GitHub origin/config is detectable.", 2);
+  const repo = parseRepoSlug(slug);
+  await ensureGitHubAuth({ projectRoot: context.projectRoot, slug: repo.slug, token: githubTokenResult.value, importGhToken: importGhToken.value });
+  const placement = setupPlacement(placementResult.value, hostResult.value, portResult.value, tokenResult.value);
+  const result = await runSetup({
+    projectRoot: context.projectRoot,
+    slug: repo.slug,
+    placement,
+    rewriteConfig: !noConfig.value,
+    ensurePi: !noPi.value,
+    ensureLabels: !noLabels.value,
+    githubToken: githubTokenResult.value,
+    importGhToken: importGhToken.value
+  });
+  if (context.outputMode === "text")
+    console.log(`Rig setup complete for ${result.repoSlug} (${result.placement}).`);
+  return { ok: true, group: "setup", command: "setup", details: result };
+}
+function setupPlacement(aliasValue, host, portValue, token) {
+  const alias = aliasValue?.trim() || (host?.trim() ? "remote" : "local");
+  const port = portValue ? Number(portValue) : undefined;
+  if (portValue && !Number.isFinite(port))
+    throw new CliError(`Invalid --port: ${portValue}`, 2);
+  return { alias, kind: host?.trim() ? "remote" : "local", ...host?.trim() ? { host: host.trim() } : {}, ...port ? { port } : {}, ...token ? { token } : {} };
+}
+async function runSetupPreflight(projectRoot, outputMode = "text") {
+  await runSetupCheck(projectRoot, outputMode);
+  const startup = await detectStartupStatus({ projectRoot });
+  if (!startup.configured)
+    throw new CliError(`Rig startup is not configured: ${startup.reasons.join("; ")}`, 1);
+  console.log("OK: rig startup status configured");
+}
+export {
+  executeSetup,
+  buildTaskSourceKindSetupCheck
+};

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

@@ -0,0 +1,11 @@
+import type { RigStatsData } from "@rig/contracts";
+import type { CommandOutcome } from "@rig/runtime";
+import type { RunRecord } from "@rig/client";
+import { type RunnerContext } from "../runner";
+type StatsCommandDeps = {
+    listRuns?: (projectRoot: string) => Promise<RunRecord[]>;
+};
+export declare function parseSinceOption(value: string | undefined, now?: Date): Date | null;
+export declare function formatStatsRows(stats: RigStatsData): Array<[string, unknown]>;
+export declare function executeStats(context: RunnerContext, args: string[], deps?: StatsCommandDeps): Promise<CommandOutcome>;
+export {};