@h-rig/cli 0.0.6-alpha.0

package/dist/src/commands/github.js

@@ -0,0 +1,276 @@
+// @bun
+// packages/cli/src/commands/github.ts
+import { spawnSync as spawnSync2 } from "child_process";
+
+// 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 };
+}
+
+// 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 getGitHubAuthStatusViaServer(context) {
+  const payload = await requestServerJson(context, "/api/github/auth/status");
+  return payload && typeof payload === "object" && !Array.isArray(payload) ? payload : {};
+}
+async function postGitHubTokenViaServer(context, token, options = {}) {
+  const payload = await requestServerJson(context, "/api/github/auth/token", {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify({ token, selectedRepo: options.selectedRepo })
+  });
+  return payload && typeof payload === "object" && !Array.isArray(payload) ? payload : {};
+}
+
+// packages/cli/src/commands/github.ts
+function printPayload(context, payload, fallback) {
+  if (context.outputMode === "json")
+    console.log(JSON.stringify(payload, null, 2));
+  else
+    console.log(fallback);
+}
+function readGhToken() {
+  const result = spawnSync2("gh", ["auth", "token"], { encoding: "utf8" });
+  if (result.status !== 0) {
+    const detail = result.stderr?.trim() || result.stdout?.trim() || "gh auth token failed";
+    throw new CliError2(`Could not import GitHub token from gh: ${detail}`, 1);
+  }
+  const token = result.stdout.trim();
+  if (!token)
+    throw new CliError2("gh auth token returned an empty token.", 1);
+  return token;
+}
+async function executeGithub(context, args) {
+  const [group, command, ...rest] = args;
+  if (group !== "auth") {
+    throw new CliError2("Usage: rig github auth <status|import-gh|token>", 1);
+  }
+  switch (command) {
+    case "status": {
+      if (rest.length > 0)
+        throw new CliError2("Usage: rig github auth status", 1);
+      const status = await getGitHubAuthStatusViaServer(context);
+      printPayload(context, status, `GitHub auth: ${status.authenticated ? "authenticated" : "unauthenticated"}`);
+      return { ok: true, group: "github", command: "auth status", details: status };
+    }
+    case "token": {
+      const parsed = takeOption(rest, "--token");
+      if (parsed.rest.length > 0)
+        throw new CliError2("Usage: rig github auth token --token <token>", 1);
+      const token = parsed.value?.trim();
+      if (!token)
+        throw new CliError2("Missing --token value.", 1);
+      const result = await postGitHubTokenViaServer(context, token);
+      printPayload(context, result, "GitHub token stored on the selected Rig server.");
+      return { ok: true, group: "github", command: "auth token", details: result };
+    }
+    case "import-gh": {
+      if (rest.length > 0)
+        throw new CliError2("Usage: rig github auth import-gh", 1);
+      const result = await postGitHubTokenViaServer(context, readGhToken());
+      printPayload(context, result, "GitHub token imported from gh and stored on the selected Rig server.");
+      return { ok: true, group: "github", command: "auth import-gh", details: result };
+    }
+    default:
+      throw new CliError2("Usage: rig github auth <status|import-gh|token>", 1);
+  }
+}
+export {
+  executeGithub
+};

package/dist/src/commands/inbox.js

@@ -0,0 +1,160 @@
+// @bun
+// packages/cli/src/commands/inbox.ts
+import { writeFileSync } from "fs";
+import { 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";
+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/inbox.ts
+import {
+  listAuthorityRuns,
+  readJsonlFile,
+  resolveAuthorityRunDir
+} from "@rig/runtime/control-plane/authority-files";
+async function executeInbox(context, args) {
+  const [command = "approvals", ...rest] = args;
+  switch (command) {
+    case "approvals": {
+      let pending = rest;
+      const run = takeOption(pending, "--run");
+      pending = run.rest;
+      const task = takeOption(pending, "--task");
+      pending = task.rest;
+      requireNoExtraArgs(pending, "bun run rig inbox approvals [--run <id>] [--task <id>]");
+      const runs = listAuthorityRuns(context.projectRoot).filter((entry) => (!run.value || entry.runId === run.value) && (!task.value || entry.taskId === task.value));
+      const approvals = runs.flatMap((entry) => readJsonlFile(resolve(resolveAuthorityRunDir(context.projectRoot, entry.runId), "approvals.jsonl")).map((record) => ({
+        runId: entry.runId,
+        record
+      })));
+      if (context.outputMode === "text") {
+        for (const approval of approvals) {
+          console.log(JSON.stringify(approval));
+        }
+      }
+      return { ok: true, group: "inbox", command, details: { approvals } };
+    }
+    case "approve": {
+      let pending = rest;
+      const run = takeOption(pending, "--run");
+      pending = run.rest;
+      const request = takeOption(pending, "--request");
+      pending = request.rest;
+      const decision = takeOption(pending, "--decision");
+      pending = decision.rest;
+      const note = takeOption(pending, "--note");
+      pending = note.rest;
+      requireNoExtraArgs(pending, "bun run rig inbox approve --run <id> --request <id> --decision approve|reject [--note <text>]");
+      if (!run.value || !request.value || !decision.value) {
+        throw new CliError2("approve requires --run, --request, and --decision.");
+      }
+      if (decision.value !== "approve" && decision.value !== "reject") {
+        throw new CliError2("decision must be approve or reject.");
+      }
+      const approvalsPath = resolve(resolveAuthorityRunDir(context.projectRoot, run.value), "approvals.jsonl");
+      const approvals = readJsonlFile(approvalsPath);
+      const resolvedAt = new Date().toISOString();
+      const next = approvals.map((entry) => entry.requestId === request.value || entry.id === request.value ? { ...entry, status: "resolved", decision: decision.value, note: note.value ?? null, resolvedAt } : entry);
+      writeFileSync(approvalsPath, `${next.map((entry) => JSON.stringify(entry)).join(`
+`)}
+`, "utf8");
+      return { ok: true, group: "inbox", command, details: { runId: run.value, requestId: request.value, decision: decision.value } };
+    }
+    case "inputs": {
+      let pending = rest;
+      const run = takeOption(pending, "--run");
+      pending = run.rest;
+      const task = takeOption(pending, "--task");
+      pending = task.rest;
+      requireNoExtraArgs(pending, "bun run rig inbox inputs [--run <id>] [--task <id>]");
+      const runs = listAuthorityRuns(context.projectRoot).filter((entry) => (!run.value || entry.runId === run.value) && (!task.value || entry.taskId === task.value));
+      const requests = runs.flatMap((entry) => readJsonlFile(resolve(resolveAuthorityRunDir(context.projectRoot, entry.runId), "user-input.jsonl")).map((record) => ({
+        runId: entry.runId,
+        record
+      })));
+      if (context.outputMode === "text") {
+        for (const request of requests) {
+          console.log(JSON.stringify(request));
+        }
+      }
+      return { ok: true, group: "inbox", command, details: { requests } };
+    }
+    case "respond": {
+      let pending = rest;
+      const run = takeOption(pending, "--run");
+      pending = run.rest;
+      const request = takeOption(pending, "--request");
+      pending = request.rest;
+      const answers = [];
+      const remaining = [];
+      for (let index = 0;index < pending.length; index += 1) {
+        const current = pending[index];
+        if (current === "--answer") {
+          const next2 = pending[index + 1];
+          if (!next2 || next2.startsWith("-")) {
+            throw new CliError2("Missing value for --answer");
+          }
+          answers.push(next2);
+          index += 1;
+          continue;
+        }
+        if (current !== undefined) {
+          remaining.push(current);
+        }
+      }
+      requireNoExtraArgs(remaining, "bun run rig inbox respond --run <id> --request <id> --answer key=value [--answer key=value]");
+      if (!run.value || !request.value || answers.length === 0) {
+        throw new CliError2("respond requires --run, --request, and at least one --answer.");
+      }
+      const parsedAnswers = Object.fromEntries(answers.map((entry) => {
+        const [key, ...restValue] = entry.split("=");
+        return [key, restValue.join("=")];
+      }));
+      const requestsPath = resolve(resolveAuthorityRunDir(context.projectRoot, run.value), "user-input.jsonl");
+      const requests = readJsonlFile(requestsPath);
+      const resolvedAt = new Date().toISOString();
+      const next = requests.map((entry) => entry.requestId === request.value || entry.id === request.value ? { ...entry, status: "resolved", answers: parsedAnswers, respondedAt: resolvedAt, resolvedAt } : entry);
+      writeFileSync(requestsPath, `${next.map((entry) => JSON.stringify(entry)).join(`
+`)}
+`, "utf8");
+      return { ok: true, group: "inbox", command, details: { runId: run.value, requestId: request.value, answers: parsedAnswers } };
+    }
+    default:
+      throw new CliError2(`Unknown inbox command: ${command}`);
+  }
+}
+export {
+  executeInbox
+};