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

package/dist/src/commands/_cli-format.js

@@ -0,0 +1,319 @@
+// @bun
+// 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 numberField(record, key) {
+  const value = record[key];
+  return typeof value === "number" && Number.isFinite(value) ? value : null;
+}
+function arrayField(record, key) {
+  const value = record[key];
+  return Array.isArray(value) ? value.filter((entry) => typeof entry === "string" && entry.trim().length > 0) : [];
+}
+function rawObject(record) {
+  const value = record.raw;
+  return value && typeof value === "object" && !Array.isArray(value) ? value : record;
+}
+function truncate(value, width) {
+  return value.length <= width ? value : `${value.slice(0, Math.max(0, width - 1))}\u2026`;
+}
+function pad(value, width) {
+  return value.length >= width ? value : `${value}${" ".repeat(width - value.length)}`;
+}
+function statusColor(status) {
+  const normalized = status.trim().toLowerCase();
+  if (["done", "completed", "ready", "healthy", "open", "approved"].includes(normalized))
+    return pc.green;
+  if (["failed", "error", "blocked", "rejected", "stopped"].includes(normalized))
+    return pc.red;
+  if (["running", "in_progress", "in-progress", "active", "booting"].includes(normalized))
+    return pc.cyan;
+  if (["pending", "queued", "created", "local"].includes(normalized))
+    return pc.yellow;
+  return pc.dim;
+}
+function compactDate(value) {
+  const parsed = Date.parse(value);
+  if (!Number.isFinite(parsed))
+    return value;
+  return new Date(parsed).toISOString().replace("T", " ").replace(/\.\d{3}Z$/, "Z");
+}
+function compactValue(value) {
+  if (value === null || value === undefined)
+    return "\u2014";
+  if (typeof value === "string")
+    return value;
+  if (typeof value === "number" || typeof value === "boolean")
+    return String(value);
+  return JSON.stringify(value);
+}
+function firstString(record, keys, fallback = "") {
+  for (const key of keys) {
+    const value = record[key];
+    if (typeof value === "string" && value.trim())
+      return value;
+  }
+  return fallback;
+}
+function runIdOf(run) {
+  return firstString(run, ["runId", "id"], "(unknown-run)");
+}
+function taskIdOf(run) {
+  return firstString(run, ["taskId", "task", "task_id"]);
+}
+function runTitleOf(run) {
+  return firstString(run, ["title", "summary", "name"], taskIdOf(run) || "(untitled)");
+}
+function requestIdOf(entry) {
+  return firstString(entry, ["requestId", "id", "approvalId", "inputId"], "(unknown-request)");
+}
+function printFormattedOutput(message) {
+  console.log(message);
+}
+function formatStatusPill(status) {
+  const label = status || "unknown";
+  return statusColor(label)(`\u25CF ${label}`);
+}
+function formatSection(title, subtitle) {
+  return `${pc.bold(accent("\u25C6"))} ${pc.bold(title)}${subtitle ? dim(` \u2014 ${subtitle}`) : ""}`;
+}
+function formatSuccessCard(title, rows = []) {
+  const body = rows.filter(([, value]) => value !== undefined && value !== null && String(value).length > 0).map(([key, value]) => `${faintBar} ${dim(key.padEnd(12))} ${value}`);
+  return [formatSection(title), ...body].join(`
+`);
+}
+function formatNextSteps(steps) {
+  if (steps.length === 0)
+    return [];
+  return [pc.bold("Next"), ...steps.map((step) => `${accent("\u203A")} ${step}`)];
+}
+function formatLegacyAutomationSurface() {
+  return [];
+}
+function formatTaskList(tasks, options = {}) {
+  if (tasks.length === 0) {
+    return [formatSection("Tasks", "empty"), dim("No tasks available."), "", ...formatNextSteps(["Refresh: `rig task list`", "Pick next: `rig task next`"])].join(`
+`);
+  }
+  if (options.raw) {
+    return JSON.stringify(tasks, null, 2);
+  }
+  const rows = tasks.map((task) => summarizeTaskRow(task));
+  const idWidth = Math.max(2, ...rows.map((row) => row.id.length));
+  const statusWidth = Math.max(6, ...rows.map((row) => row.status.length));
+  const body = rows.map((row) => {
+    const labels = row.labels.length > 0 ? dim(`  ${row.labels.slice(0, 4).map((label) => `#${label}`).join(" ")}`) : "";
+    const source = row.source ? dim(`  ${row.source}`) : "";
+    return [
+      pc.bold(pad(truncate(row.id, idWidth), idWidth)),
+      statusColor(row.status)(pad(truncate(row.status, statusWidth), statusWidth)),
+      `${row.title}${labels}${source}`
+    ].join("  ");
+  });
+  return [formatSection("Tasks", `${tasks.length}`), ...body].join(`
+`);
+}
+function summarizeTaskRow(task) {
+  const raw = rawObject(task);
+  return {
+    id: firstString(task, ["id", "taskId"], "(unknown-task)"),
+    title: firstString(task, ["title", "summary", "name"], "(untitled)"),
+    status: firstString(task, ["status"], "unknown"),
+    labels: arrayField(task, "labels").length > 0 ? arrayField(task, "labels") : arrayField(raw, "labels"),
+    source: firstString(task, ["source"], "")
+  };
+}
+function formatTaskCard(task, options = {}) {
+  const raw = rawObject(task);
+  const lines = [formatSection(options.title ?? (options.selected ? "Selected task" : "Task"))];
+  for (const [label, value] of [
+    ["id", firstString(task, ["id", "taskId"], "(unknown-task)")],
+    ["title", firstString(task, ["title", "summary", "name"], "(untitled)")],
+    ["status", firstString(task, ["status"], "unknown")],
+    ["source", firstString(task, ["source"], "")],
+    ["url", firstString(raw, ["url"], "")]
+  ]) {
+    if (value)
+      lines.push(`${faintBar} ${dim(label.padEnd(12))} ${value}`);
+  }
+  const labels = arrayField(task, "labels");
+  if (labels.length > 0)
+    lines.push(`${faintBar} ${dim("labels".padEnd(12))} ${labels.map((label) => `#${label}`).join(" ")}`);
+  return lines.join(`
+`);
+}
+function formatTaskDetails(task) {
+  return formatTaskCard(task, { title: "Task details" });
+}
+function formatRunList(runs, options = {}) {
+  if (runs.length === 0) {
+    return [
+      formatSection("Runs", "none recorded"),
+      options.source === "server" ? dim("No runs recorded on the selected server.") : dim("No runs recorded in local state."),
+      "",
+      ...formatLegacyAutomationSurface()
+    ].join(`
+`);
+  }
+  const body = runs.map((run) => {
+    const row = run;
+    const runId = runIdOf(row);
+    const status = firstString(row, ["status"], "unknown");
+    const runtime = firstString(row, ["runtime", "runtimeAdapter"], "");
+    return [
+      pc.bold(runId),
+      statusColor(status)(pad(truncate(status, 12), 12)),
+      `${runTitleOf(row)}${runtime ? dim(`  ${runtime}`) : ""}`
+    ].join("  ");
+  });
+  return [formatSection("Runs", options.source === "server" ? "selected server" : "local state"), ...body, "", ...formatLegacyAutomationSurface()].join(`
+`);
+}
+function formatSubmittedRun(input) {
+  return formatSuccessCard("Run submitted", [
+    ["run", input.runId],
+    ["task", input.taskId ?? undefined],
+    ["title", input.title ?? undefined],
+    ["queue", input.queuePosition ?? undefined]
+  ]);
+}
+function formatRunCard(run, options = {}) {
+  const record = run;
+  const lines = [formatSection(options.title ?? "Run")];
+  for (const [label, value] of [
+    ["run", runIdOf(record)],
+    ["task", taskIdOf(record)],
+    ["title", runTitleOf(record)],
+    ["status", firstString(record, ["status"], "unknown")],
+    ["runtime", firstString(record, ["runtime", "runtimeAdapter"], "")],
+    ["created", firstString(record, ["createdAt"], "")],
+    ["updated", firstString(record, ["updatedAt"], "")]
+  ]) {
+    if (value)
+      lines.push(`${faintBar} ${dim(label.padEnd(12))} ${label === "created" || label === "updated" ? compactDate(value) : value}`);
+  }
+  const errorSummary = firstString(record, ["errorSummary"]);
+  if (errorSummary)
+    lines.push(`${faintBar} Error: ${errorSummary}`);
+  return lines.join(`
+`);
+}
+function formatRunStatus(summary, options = {}) {
+  const activeRuns = summary.activeRuns ?? [];
+  const recentRuns = summary.recentRuns ?? [];
+  const lines = [formatSection("Run status", options.source === "server" ? "selected server" : "local state")];
+  lines.push(`Active runs (${activeRuns.length})`);
+  if (activeRuns.length === 0)
+    lines.push(dim("No active runs."));
+  else
+    for (const run of activeRuns)
+      lines.push(formatRunSummaryLine(run));
+  lines.push("", `Recent runs (${recentRuns.length})`);
+  if (recentRuns.length === 0)
+    lines.push(dim("No recent terminal runs."));
+  else
+    for (const run of recentRuns.slice(0, 10))
+      lines.push(formatRunSummaryLine(run));
+  lines.push("", ...formatLegacyAutomationSurface());
+  return lines.join(`
+`);
+}
+function formatRunSummaryLine(run) {
+  const record = run;
+  const runId = runIdOf(record);
+  const taskId = taskIdOf(record);
+  const title = runTitleOf(record);
+  const status = firstString(record, ["status"], "unknown");
+  const runtime = firstString(record, ["runtime", "runtimeAdapter"], "");
+  const descriptor = [taskId, title].filter(Boolean).join(" \xB7 ");
+  return `${faintBar} ${pc.bold(runId)} ${formatStatusPill(status)} ${descriptor}${runtime ? dim(`  ${runtime}`) : ""}`;
+}
+function formatInboxList(kind, entries) {
+  const title = kind === "approvals" ? "Pending approvals" : "Pending user input";
+  if (entries.length === 0) {
+    return [
+      formatSection(title, "empty"),
+      dim(kind === "approvals" ? "No pending approvals." : "No pending user-input requests."),
+      "",
+      ...formatLegacyAutomationSurface()
+    ].join(`
+`);
+  }
+  const lines = [formatSection(title, `${entries.length}`)];
+  for (const record of entries) {
+    const runId = firstString(record, ["runId"], "(unknown-run)");
+    const taskId = firstString(record, ["taskId"], "");
+    const status = firstString(record, ["status"], "pending");
+    const prompt = firstString(record, ["prompt", "message", "reason", "title", "summary"], kind === "approvals" ? "Approval requested" : "Input requested");
+    lines.push(`${faintBar} ${pc.bold(requestIdOf(record))} ${formatStatusPill(status)} ${prompt}`);
+    lines.push(`${faintBar} ${dim("run".padEnd(12))} ${runId}${taskId ? dim(`  task ${taskId}`) : ""}`);
+  }
+  lines.push("", ...formatLegacyAutomationSurface(), ...formatNextSteps(kind === "approvals" ? ["Resolve: `rig inbox approve --run <run-id> --request <request-id> --decision approve|reject`"] : ["Reply: `rig inbox answer --run <run-id> --request <request-id> --text ...`"]));
+  return lines.join(`
+`);
+}
+function formatConnectionList(connections) {
+  const names = Object.keys(connections).sort();
+  if (names.length === 0) {
+    return [formatSection("Rig servers", "empty"), dim("No saved server connections.")].join(`
+`);
+  }
+  return [formatSection("Rig servers", `${names.length}`), ...names.map((name) => {
+    const connection = connections[name];
+    const target = connection.kind === "remote" ? connection.baseUrl ?? "(missing url)" : connection.mode ?? "local";
+    return `${faintBar} ${pc.bold(name)} ${dim(connection.kind)} ${target}`;
+  })].join(`
+`);
+}
+function formatConnectionStatus(selected, connections, repo, remoteProjectLink) {
+  const selectedConnection = connections[selected];
+  const lines = [formatSection("Rig server", "selected for this repo")];
+  lines.push(`${faintBar} ${dim("selected".padEnd(12))} ${pc.bold(selected)}`);
+  if (selectedConnection) {
+    lines.push(`${faintBar} ${dim("kind".padEnd(12))} ${selectedConnection.kind}`);
+    if (selectedConnection.baseUrl)
+      lines.push(`${faintBar} ${dim("base url".padEnd(12))} ${selectedConnection.baseUrl}`);
+    if (selectedConnection.mode)
+      lines.push(`${faintBar} ${dim("mode".padEnd(12))} ${selectedConnection.mode}`);
+  }
+  if (repo?.project)
+    lines.push(`${faintBar} ${dim("project".padEnd(12))} ${repo.project}`);
+  if (repo?.serverProjectRoot)
+    lines.push(`${faintBar} ${dim("server root".padEnd(12))} ${repo.serverProjectRoot}`);
+  if (remoteProjectLink?.status)
+    lines.push(`${faintBar} ${dim("link".padEnd(12))} ${remoteProjectLink.status}`);
+  if (remoteProjectLink?.message)
+    lines.push(`${faintBar} ${dim("message".padEnd(12))} ${remoteProjectLink.message}`);
+  if (remoteProjectLink?.hint)
+    lines.push(`${faintBar} ${dim("hint".padEnd(12))} ${remoteProjectLink.hint}`);
+  return lines.join(`
+`);
+}
+function formatStatsTable(rows) {
+  return rows.map(([label, value]) => `${faintBar} ${dim(label.padEnd(20))} ${compactValue(value)}`).join(`
+`);
+}
+function readOptionalCount(record, key) {
+  return numberField(record, key);
+}
+export {
+  readOptionalCount,
+  printFormattedOutput,
+  formatTaskList,
+  formatTaskDetails,
+  formatTaskCard,
+  formatSuccessCard,
+  formatSubmittedRun,
+  formatStatusPill,
+  formatStatsTable,
+  formatSection,
+  formatRunStatus,
+  formatRunList,
+  formatRunCard,
+  formatNextSteps,
+  formatInboxList,
+  formatConnectionStatus,
+  formatConnectionList
+};

package/dist/src/commands/_config-env.d.ts

@@ -0,0 +1,18 @@
+import type { RigConfig } from "@rig/contracts";
+/**
+ * Bridge `rig.config.ts` → `process.env`, FILL-IF-UNSET, establishing the global
+ * resolution order for every env-driven / computed value:
+ *
+ *   ambient process env at run time   (top winner — `RIG_X=… rig …`)
+ *   → rig.config.ts (typed sections, then the generic `env` map)
+ *   → computed default / derived value (under the hood, in the resolvers)
+ *
+ * Because we only set a key when it is currently absent, an ambient env var always
+ * wins; the config only fills gaps; the resolvers' own defaults fill what neither
+ * set. Typed sections are applied before the generic `env` map so a specific
+ * `runtime.server.relayUrl` beats a generic `env: { RIG_COLLAB_RELAY }`.
+ *
+ * Call this ONCE at CLI startup, before any resolver runs and before launching OMP
+ * or spawning run subprocesses (which inherit the populated env).
+ */
+export declare function applyRigConfigEnv(config: Pick<RigConfig, "env" | "runtime">, env?: NodeJS.ProcessEnv): void;

package/dist/src/commands/_config-env.js

@@ -0,0 +1,22 @@
+// @bun
+// packages/cli/src/commands/_config-env.ts
+function applyRigConfigEnv(config, env = process.env) {
+  const fill = (key, value) => {
+    if (value && !env[key])
+      env[key] = value;
+  };
+  const server = config.runtime?.server;
+  if (server) {
+    const host = server.host?.trim();
+    fill("RIG_COLLAB_RELAY", server.relayUrl ?? (host ? `wss://${host}` : undefined));
+    fill("RIG_REGISTRY_URL", server.registryUrl ?? (host ? `https://${host}/registry` : undefined));
+    fill("RIG_REGISTRY_SHARED_SECRET", server.registrySecret);
+    fill("RIG_SSH_TARGET", server.sshTarget);
+    fill("RIG_REMOTE_CHECKOUT", server.checkout);
+  }
+  for (const [key, value] of Object.entries(config.env ?? {}))
+    fill(key, value);
+}
+export {
+  applyRigConfigEnv
+};

package/dist/src/commands/_connection-state.d.ts

@@ -0,0 +1,54 @@
+export type RigConnection = {
+    kind: "local";
+    mode: "auto";
+} | {
+    kind: "remote";
+    baseUrl: string;
+};
+export type GlobalConnectionState = {
+    connections: Record<string, RigConnection>;
+};
+export type RepoConnectionState = {
+    selected: string;
+    project?: string;
+    linkedAt?: string;
+    /**
+     * The server-host project root this repo scopes to (multi-root serving).
+     * Sent as the x-rig-project-root header on every remote request.
+     */
+    serverProjectRoot?: string;
+    /** The selected alias that produced serverProjectRoot. Prevents cross-alias reuse. */
+    serverProjectRootAlias?: string;
+    /** The remote base URL that produced serverProjectRoot. Prevents same-alias retarget leaks. */
+    serverProjectRootBaseUrl?: string;
+};
+export declare function resolveGlobalConnectionsPath(env?: NodeJS.ProcessEnv): string;
+export declare function resolveRepoConnectionPath(projectRoot: string): string;
+export declare function readGlobalConnections(options?: {
+    env?: NodeJS.ProcessEnv;
+}): GlobalConnectionState;
+export declare function writeGlobalConnections(state: GlobalConnectionState, options?: {
+    env?: NodeJS.ProcessEnv;
+}): void;
+export declare function upsertGlobalConnection(alias: string, connection: RigConnection, options?: {
+    env?: NodeJS.ProcessEnv;
+}): GlobalConnectionState;
+export declare function readRepoConnection(projectRoot: string): RepoConnectionState | null;
+export declare function writeRepoConnection(projectRoot: string, state: RepoConnectionState): void;
+export declare function resolveSelectedConnection(projectRoot: string, options?: {
+    env?: NodeJS.ProcessEnv;
+}): {
+    alias: string;
+    connection: RigConnection;
+    serverProjectRoot?: string;
+} | null;
+/** Persist the server-host project root this repo scopes to (multi-root serving). */
+export declare function writeRepoServerProjectRoot(projectRoot: string, serverProjectRoot: string, metadata?: {
+    alias?: string;
+    baseUrl?: string;
+    project?: string;
+}): void;
+/** Remove a stale server-host root while preserving selected server/repo state. */
+export declare function clearRepoServerProjectRoot(projectRoot: string): void;
+/** Whether this repo's selected connection targets a remote Rig server. */
+export declare function isRemoteConnectionSelected(projectRoot: string): boolean;

package/dist/src/commands/_connection-state.js

@@ -6,12 +6,19 @@ import { dirname, resolve } 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();
+    }
+  }
+}
 
 // packages/cli/src/commands/_connection-state.ts
 function resolveGlobalConnectionsPath(env = process.env) {
@@ -32,7 +39,7 @@ function readJsonFile(path) {
   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);
+    throw new CliError(`Invalid Rig connection state at ${path}: ${error instanceof Error ? error.message : String(error)}`, 1, { hint: "Fix or delete that file, then re-select a server with `rig server use <alias|local>`." });
   }
 }
 function writeJsonFile(path, value) {
@@ -75,7 +82,7 @@ function writeGlobalConnections(state, options = {}) {
 function upsertGlobalConnection(alias, connection, options = {}) {
   const cleanAlias = alias.trim();
   if (!cleanAlias)
-    throw new CliError2("Connection alias is required.", 1);
+    throw new CliError("Connection alias is required.", 1, { hint: "Save a server with `rig server add <alias> <url>`." });
   const state = readGlobalConnections(options);
   state.connections[cleanAlias] = connection;
   writeGlobalConnections(state, options);
@@ -92,26 +99,81 @@ function readRepoConnection(projectRoot) {
   return {
     selected,
     project: typeof record.project === "string" ? record.project : undefined,
-    linkedAt: typeof record.linkedAt === "string" ? record.linkedAt : undefined
+    linkedAt: typeof record.linkedAt === "string" ? record.linkedAt : undefined,
+    serverProjectRoot: typeof record.serverProjectRoot === "string" && record.serverProjectRoot.trim() ? record.serverProjectRoot.trim() : undefined,
+    serverProjectRootAlias: typeof record.serverProjectRootAlias === "string" && record.serverProjectRootAlias.trim() ? record.serverProjectRootAlias.trim() : undefined,
+    serverProjectRootBaseUrl: typeof record.serverProjectRootBaseUrl === "string" && record.serverProjectRootBaseUrl.trim() ? record.serverProjectRootBaseUrl.trim().replace(/\/+$/, "") : undefined
   };
 }
 function writeRepoConnection(projectRoot, state) {
   writeJsonFile(resolveRepoConnectionPath(projectRoot), state);
 }
+function rootAllowedForSelection(repo, connection) {
+  const root = repo.serverProjectRoot?.trim();
+  if (!root)
+    return;
+  if (connection.kind === "remote") {
+    if (repo.serverProjectRootAlias !== repo.selected)
+      return;
+    if (repo.serverProjectRootBaseUrl !== connection.baseUrl)
+      return;
+  } else if (repo.serverProjectRootAlias && repo.serverProjectRootAlias !== repo.selected) {
+    return;
+  }
+  return root;
+}
 function resolveSelectedConnection(projectRoot, options = {}) {
   const repo = readRepoConnection(projectRoot);
   if (!repo)
     return null;
   if (repo.selected === "local")
-    return { alias: "local", connection: { kind: "local", mode: "auto" } };
+    return { alias: "local", connection: { kind: "local", mode: "auto" }, serverProjectRoot: repo.serverProjectRoot };
   const global = readGlobalConnections(options);
   const connection = global.connections[repo.selected];
   if (!connection) {
-    throw new CliError2(`Selected Rig connection "${repo.selected}" was not found. Run \`rig connect list\` or \`rig connect use local\`.`, 1);
+    throw new CliError(`Selected Rig server "${repo.selected}" was not found. Run \`rig server list\` or \`rig server use local\`.`, 1);
+  }
+  return { alias: repo.selected, connection, serverProjectRoot: rootAllowedForSelection(repo, connection) };
+}
+function writeRepoServerProjectRoot(projectRoot, serverProjectRoot, metadata = {}) {
+  const repo = readRepoConnection(projectRoot);
+  if (!repo)
+    return;
+  let inferred = metadata;
+  if (!inferred.alias || !inferred.baseUrl) {
+    try {
+      const selected = resolveSelectedConnection(projectRoot);
+      if (selected?.connection.kind === "remote") {
+        inferred = {
+          alias: inferred.alias ?? selected.alias,
+          baseUrl: inferred.baseUrl ?? selected.connection.baseUrl
+        };
+      }
+    } catch {}
   }
-  return { alias: repo.selected, connection };
+  writeRepoConnection(projectRoot, {
+    ...repo,
+    ...metadata.project ? { project: metadata.project } : {},
+    serverProjectRoot,
+    ...inferred.alias ? { serverProjectRootAlias: inferred.alias } : {},
+    ...inferred.baseUrl ? { serverProjectRootBaseUrl: inferred.baseUrl.replace(/\/+$/, "") } : {}
+  });
+}
+function clearRepoServerProjectRoot(projectRoot) {
+  const repo = readRepoConnection(projectRoot);
+  if (!repo)
+    return;
+  writeRepoConnection(projectRoot, {
+    selected: repo.selected,
+    ...repo.project ? { project: repo.project } : {},
+    ...repo.linkedAt ? { linkedAt: repo.linkedAt } : {}
+  });
+}
+function isRemoteConnectionSelected(projectRoot) {
+  return resolveSelectedConnection(projectRoot)?.connection.kind === "remote";
 }
 export {
+  writeRepoServerProjectRoot,
   writeRepoConnection,
   writeGlobalConnections,
   upsertGlobalConnection,
@@ -119,5 +181,7 @@ export {
   resolveRepoConnectionPath,
   resolveGlobalConnectionsPath,
   readRepoConnection,
-  readGlobalConnections
+  readGlobalConnections,
+  isRemoteConnectionSelected,
+  clearRepoServerProjectRoot
 };

package/dist/src/commands/_doctor-checks.d.ts

@@ -0,0 +1,46 @@
+type DoctorConfig = {
+    readonly project?: Record<string, unknown>;
+    readonly taskSource?: {
+        readonly kind?: string;
+        readonly owner?: string;
+        readonly repo?: string;
+    };
+    readonly github?: {
+        readonly projects?: {
+            readonly enabled?: boolean;
+            readonly projectId?: string;
+            readonly statusFieldId?: string;
+        };
+    };
+    readonly pr?: {
+        readonly mode?: string;
+    };
+    readonly merge?: {
+        readonly mode?: string;
+        readonly method?: string;
+    };
+};
+import { type PiInstallCheck } from "./_pi-install";
+export type DoctorStatus = "pass" | "warn" | "fail";
+export type RigDoctorCheck = {
+    readonly id: string;
+    readonly label: string;
+    readonly status: DoctorStatus;
+    readonly detail?: string;
+    readonly remediation?: string;
+};
+export type RunRigDoctorChecksOptions = {
+    readonly projectRoot: string;
+    readonly requestJson?: (pathname: string, init?: RequestInit) => Promise<unknown>;
+    readonly piChecks?: () => Promise<readonly PiInstallCheck[]>;
+    readonly which?: (binary: string) => string | null;
+    readonly bunVersion?: string;
+    readonly loadConfig?: (projectRoot: string) => Promise<DoctorConfig | null>;
+    /** Per-check status narration ("Checking GitHub auth…") for wait spinners. */
+    readonly onProgress?: (label: string) => void;
+};
+export declare function runRigDoctorChecks(options: RunRigDoctorChecksOptions): Promise<RigDoctorCheck[]>;
+export declare function formatDoctorChecks(checks: readonly RigDoctorCheck[]): string;
+export declare function countDoctorFailures(checks: readonly RigDoctorCheck[]): number;
+export declare function throwIfDoctorFailed(checks: readonly RigDoctorCheck[]): void;
+export {};