@h-rig/cli 0.0.6-alpha.0

package/dist/src/commands/server.js

@@ -0,0 +1,368 @@
+// @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 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/_authority-runs.ts
+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";
+
+// packages/cli/src/commands/_authority-runs.ts
+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";
+}
+
+// packages/cli/src/commands/_server-client.ts
+import { spawnSync } from "child_process";
+import { ensureLocalRigServerConnection } from "@rig/runtime/local-server";
+
+// 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 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 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 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 };
+}
+
+// packages/cli/src/commands/_server-client.ts
+var cachedGitHubBearerToken;
+function cleanToken(value) {
+  const trimmed = value?.trim();
+  return trimmed ? trimmed : null;
+}
+function readGitHubBearerTokenForRemote() {
+  if (cachedGitHubBearerToken !== undefined)
+    return cachedGitHubBearerToken;
+  const envToken = cleanToken(process.env.RIG_GITHUB_TOKEN) ?? cleanToken(process.env.GITHUB_TOKEN) ?? cleanToken(process.env.GH_TOKEN);
+  if (envToken) {
+    cachedGitHubBearerToken = envToken;
+    return cachedGitHubBearerToken;
+  }
+  const result = spawnSync("gh", ["auth", "token"], {
+    encoding: "utf8",
+    timeout: 5000,
+    stdio: ["ignore", "pipe", "ignore"]
+  });
+  cachedGitHubBearerToken = result.status === 0 ? cleanToken(result.stdout) : null;
+  return cachedGitHubBearerToken;
+}
+async function ensureServerForCli(projectRoot) {
+  try {
+    const selected = resolveSelectedConnection(projectRoot);
+    if (selected?.connection.kind === "remote") {
+      return {
+        baseUrl: selected.connection.baseUrl,
+        authToken: readGitHubBearerTokenForRemote(),
+        connectionKind: "remote"
+      };
+    }
+    const connection = await ensureLocalRigServerConnection(projectRoot);
+    return {
+      baseUrl: connection.baseUrl,
+      authToken: connection.authToken,
+      connectionKind: "local"
+    };
+  } catch (error) {
+    if (error instanceof Error) {
+      throw new CliError2(error.message, 1);
+    }
+    throw error;
+  }
+}
+function mergeHeaders(headers, authToken) {
+  const merged = new Headers(headers);
+  if (authToken) {
+    merged.set("authorization", `Bearer ${authToken}`);
+  }
+  return merged;
+}
+function diagnosticMessage(payload) {
+  if (!payload || typeof payload !== "object" || Array.isArray(payload))
+    return null;
+  const record = payload;
+  const diagnostics = Array.isArray(record.diagnostics) ? record.diagnostics : [];
+  const messages = diagnostics.flatMap((entry) => {
+    if (!entry || typeof entry !== "object" || Array.isArray(entry))
+      return [];
+    const diagnostic = entry;
+    const kind = typeof diagnostic.kind === "string" ? diagnostic.kind : "task-source";
+    const message = typeof diagnostic.message === "string" ? diagnostic.message : null;
+    return message ? [`${kind}: ${message}`] : [];
+  });
+  return messages.length > 0 ? messages.join("; ") : null;
+}
+async function requestServerJson(context, pathname, init = {}) {
+  const server = await ensureServerForCli(context.projectRoot);
+  const response = await fetch(`${server.baseUrl}${pathname}`, {
+    ...init,
+    headers: mergeHeaders(init.headers, server.authToken)
+  });
+  const text = await response.text();
+  const payload = text.trim().length > 0 ? (() => {
+    try {
+      return JSON.parse(text);
+    } catch {
+      return null;
+    }
+  })() : null;
+  if (!response.ok) {
+    const diagnostics = diagnosticMessage(payload);
+    const detail = diagnostics ?? (text || response.statusText);
+    throw new CliError2(`Rig server request failed (${response.status}): ${detail}`, 1);
+  }
+  return payload;
+}
+async function submitTaskRunViaServer(context, input) {
+  const isTaskRun = Boolean(input.taskId);
+  const endpoint = isTaskRun ? "/api/runs/task" : "/api/runs/adhoc";
+  const payload = await requestServerJson(context, endpoint, {
+    method: "POST",
+    headers: {
+      "content-type": "application/json"
+    },
+    body: JSON.stringify({
+      runId: input.runId,
+      taskId: input.taskId,
+      title: input.title,
+      runtimeAdapter: input.runtimeAdapter,
+      model: input.model,
+      runtimeMode: input.runtimeMode,
+      interactionMode: input.interactionMode,
+      initialPrompt: input.initialPrompt,
+      baselineMode: input.baselineMode,
+      prMode: input.prMode,
+      executionTarget: "local"
+    })
+  });
+  if (!payload || typeof payload !== "object" || Array.isArray(payload)) {
+    throw new CliError2("Rig server returned an invalid run submission payload.", 1);
+  }
+  const runId = payload.runId;
+  if (typeof runId !== "string" || runId.trim().length === 0) {
+    throw new CliError2("Rig server returned no runId for the submitted run.", 1);
+  }
+  return { runId };
+}
+
+// packages/cli/src/commands/server.ts
+async function executeServer(context, args, options) {
+  const [command = "start", ...rest] = args;
+  switch (command) {
+    case "start": {
+      let pending = rest;
+      const hostResult = takeOption(pending, "--host");
+      pending = hostResult.rest;
+      const portResult = takeOption(pending, "--port");
+      pending = portResult.rest;
+      const pollResult = takeOption(pending, "--poll-ms");
+      pending = pollResult.rest;
+      const authTokenResult = takeOption(pending, "--auth-token");
+      pending = authTokenResult.rest;
+      requireNoExtraArgs(pending, "bun run rig server start [--host <host>] [--port <n>] [--poll-ms <n>] [--auth-token <token>]");
+      const commandParts = ["bun", "run", "packages/server/src/server.ts", "start"];
+      if (hostResult.value) {
+        commandParts.push("--host", hostResult.value);
+      }
+      if (portResult.value) {
+        commandParts.push("--port", portResult.value);
+      }
+      if (pollResult.value) {
+        commandParts.push("--poll-ms", pollResult.value);
+      }
+      if (authTokenResult.value) {
+        commandParts.push("--auth-token", authTokenResult.value);
+      }
+      await context.runCommand(commandParts);
+      return { ok: true, group: "server", command };
+    }
+    case "events":
+      throw new CliError2("server events is not supported by the CLI wrapper. Use `rig inspector stream` for bounded event streaming, or start the server with `rig server start`.", 2);
+    case "notify-test": {
+      let pending = rest;
+      const eventResult = takeOption(pending, "--event");
+      pending = eventResult.rest;
+      requireNoExtraArgs(pending, "bun run rig server notify-test [--event <type>]");
+      const commandParts = ["bun", "run", "packages/server/src/server.ts", "notify-test"];
+      if (eventResult.value) {
+        commandParts.push("--event", eventResult.value);
+      }
+      await context.runCommand(commandParts);
+      return { ok: true, group: "server", command, details: { event: eventResult.value || "manual.test" } };
+    }
+    case "task-run": {
+      let pending = rest;
+      const taskResult = takeOption(pending, "--task");
+      pending = taskResult.rest;
+      const titleResult = takeOption(pending, "--title");
+      pending = titleResult.rest;
+      const runtimeAdapterResult = takeOption(pending, "--runtime-adapter");
+      pending = runtimeAdapterResult.rest;
+      const modelResult = takeOption(pending, "--model");
+      pending = modelResult.rest;
+      const runtimeModeResult = takeOption(pending, "--runtime-mode");
+      pending = runtimeModeResult.rest;
+      const interactionModeResult = takeOption(pending, "--interaction-mode");
+      pending = interactionModeResult.rest;
+      const initialPromptResult = takeOption(pending, "--initial-prompt");
+      pending = initialPromptResult.rest;
+      const dirtyBaselineResult = takeOption(pending, "--dirty-baseline");
+      pending = dirtyBaselineResult.rest;
+      const prResult = takeOption(pending, "--pr");
+      pending = prResult.rest;
+      requireNoExtraArgs(pending, "bun run rig --run-id <run-id> server task-run [--task <id>] [--title <text>] [--runtime-adapter claude-code|codex|pi] [--model <model>] [--runtime-mode <mode>] [--interaction-mode <mode>] [--initial-prompt <text>] [--dirty-baseline head|dirty-snapshot] [--pr auto|ask|off]");
+      if (!taskResult.value && !initialPromptResult.value && !titleResult.value) {
+        throw new CliError2("server task-run requires either --task <id> or --initial-prompt/--title for an ad hoc run.", 2);
+      }
+      const input = {
+        runId: context.runId,
+        taskId: taskResult.value ?? undefined,
+        title: titleResult.value ?? undefined,
+        runtimeAdapter: normalizeRuntimeAdapter(runtimeAdapterResult.value),
+        model: modelResult.value ?? undefined,
+        runtimeMode: runtimeModeResult.value || "full-access",
+        interactionMode: interactionModeResult.value || "default",
+        initialPrompt: initialPromptResult.value ?? undefined,
+        baselineMode: dirtyBaselineResult.value === "dirty-snapshot" ? "dirty-snapshot" : "head",
+        prMode: prResult.value === "auto" || prResult.value === "ask" || prResult.value === "off" ? prResult.value : undefined
+      };
+      if (process.env.RIG_SERVER_INTERNAL_EXEC === "1") {
+        await options.executeRigOwnedTaskRun(context, input);
+      } else {
+        await submitTaskRunViaServer(context, input);
+      }
+      return {
+        ok: true,
+        group: "server",
+        command,
+        details: { runId: context.runId, taskId: taskResult.value ?? null, title: titleResult.value ?? null }
+      };
+    }
+    default:
+      throw new CliError2(`Unknown server command: ${command}`);
+  }
+}
+export {
+  executeServer
+};