@h-rig/cli 0.0.6-alpha.0

package/dist/src/commands/_authority-runs.js

@@ -0,0 +1,110 @@
+// @bun
+// packages/cli/src/commands/_authority-runs.ts
+import { existsSync } from "fs";
+import { resolve } from "path";
+import {
+  readAuthorityRun,
+  readJsonlFile,
+  resolveAuthorityRunDir,
+  writeJsonFile
+} from "@rig/runtime/control-plane/authority-files";
+
+// packages/cli/src/commands/_paths.ts
+import { resolveMonorepoRoot } from "@rig/runtime/control-plane/native/utils";
+function resolveControlPlaneMonorepoRoot(projectRoot) {
+  return resolveMonorepoRoot(projectRoot);
+}
+
+// packages/cli/src/commands/_authority-runs.ts
+var RIG_WORKSPACE_ID = "rig-local-workspace";
+function normalizeRuntimeAdapter(value) {
+  const normalized = value?.trim().toLowerCase();
+  if (!normalized) {
+    return "pi";
+  }
+  if (normalized === "codex" || normalized === "codex-cli" || normalized === "codex-app-server" || normalized === "gpt-codex") {
+    return "codex";
+  }
+  if (normalized === "pi" || normalized === "rig-pi" || normalized === "@rig/pi") {
+    return "pi";
+  }
+  return "claude-code";
+}
+function readLatestBeadRecord(projectRoot, taskId) {
+  const issuesPath = resolve(resolveControlPlaneMonorepoRoot(projectRoot), ".beads", "issues.jsonl");
+  if (!existsSync(issuesPath)) {
+    return null;
+  }
+  let latest = null;
+  for (const issue of readJsonlFile(issuesPath)) {
+    if (!issue || typeof issue !== "object") {
+      continue;
+    }
+    const record = issue;
+    if (record.id === taskId) {
+      latest = record;
+    }
+  }
+  return latest;
+}
+function resolveTaskTitleForAuthorityRun(projectRoot, taskId) {
+  try {
+    const record = readLatestBeadRecord(projectRoot, taskId);
+    const title = record && typeof record.title === "string" ? record.title.trim() : "";
+    if (title) {
+      return title;
+    }
+  } catch {}
+  return null;
+}
+function upsertAgentAuthorityRun(projectRoot, input) {
+  const current = readAuthorityRun(projectRoot, input.runId);
+  const existing = current;
+  const createdAt = existing?.createdAt ?? input.createdAt;
+  const runtimeMode = typeof existing?.runtimeMode === "string" ? existing.runtimeMode : "full-access";
+  const interactionMode = typeof existing?.interactionMode === "string" ? existing.interactionMode : "default";
+  const runMode = typeof existing?.runMode === "string" ? existing.runMode : "autonomous";
+  const runtimeAdapter = normalizeRuntimeAdapter(input.runtimeAdapter ?? existing?.runtimeAdapter ?? "claude-code");
+  const title = resolveTaskTitleForAuthorityRun(projectRoot, input.taskId) ?? input.taskId;
+  const next = {
+    runId: input.runId,
+    projectRoot,
+    workspaceId: existing?.workspaceId ?? RIG_WORKSPACE_ID,
+    taskId: input.taskId,
+    threadId: existing?.threadId ?? null,
+    mode: "local",
+    runtimeAdapter,
+    status: input.status,
+    createdAt,
+    startedAt: input.startedAt ?? existing?.startedAt ?? null,
+    completedAt: input.completedAt ?? existing?.completedAt ?? null,
+    endpointId: existing?.endpointId ?? null,
+    hostId: existing?.hostId ?? null,
+    worktreePath: input.worktreePath ?? existing?.worktreePath ?? null,
+    artifactRoot: input.artifactRoot ?? existing?.artifactRoot ?? null,
+    logRoot: input.logRoot ?? existing?.logRoot ?? null,
+    sessionPath: input.sessionPath ?? existing?.sessionPath ?? null,
+    sessionLogPath: input.sessionLogPath ?? existing?.sessionLogPath ?? null,
+    pid: input.pid ?? existing?.pid ?? null,
+    updatedAt: input.createdAt,
+    title,
+    model: typeof existing?.model === "string" ? existing.model : null,
+    runtimeMode,
+    interactionMode,
+    runMode,
+    initialPrompt: typeof existing?.initialPrompt === "string" ? existing.initialPrompt : null
+  };
+  if (input.errorText !== undefined) {
+    next.errorText = input.errorText;
+  } else if ("errorText" in next) {
+    delete next.errorText;
+  }
+  writeJsonFile(resolve(resolveAuthorityRunDir(projectRoot, input.runId), "run.json"), next);
+  return next;
+}
+export {
+  upsertAgentAuthorityRun,
+  readLatestBeadRecord,
+  normalizeRuntimeAdapter,
+  RIG_WORKSPACE_ID
+};

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

@@ -0,0 +1,123 @@
+// @bun
+// packages/cli/src/commands/_connection-state.ts
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { homedir } from "os";
+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 { 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";
+
+// packages/cli/src/commands/_connection-state.ts
+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);
+}
+function resolveSelectedConnection(projectRoot, options = {}) {
+  const repo = readRepoConnection(projectRoot);
+  if (!repo)
+    return null;
+  if (repo.selected === "local")
+    return { alias: "local", connection: { kind: "local", mode: "auto" } };
+  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);
+  }
+  return { alias: repo.selected, connection };
+}
+export {
+  writeRepoConnection,
+  writeGlobalConnections,
+  upsertGlobalConnection,
+  resolveSelectedConnection,
+  resolveRepoConnectionPath,
+  resolveGlobalConnectionsPath,
+  readRepoConnection,
+  readGlobalConnections
+};