@h-rig/cli 0.0.6-alpha.64 → 0.0.6-alpha.65

package/dist/src/commands/inbox.js

@@ -1,14 +1,19 @@
 // @bun
-// packages/cli/src/commands/inbox.ts
-import { writeFileSync as writeFileSync2 } from "fs";
-import { resolve as resolve3 } 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 { 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();
+    }
+  }
+}
 function takeOption(args, option) {
   const rest = [];
   let value;
@@ -17,7 +22,7 @@ function takeOption(args, option) {
     if (current === option) {
       const next = args[index + 1];
       if (!next || next.startsWith("-")) {
-        throw new CliError(`Missing value for ${option}`);
+        throw new CliError(`Missing value for ${option}`, 1, { hint: `Provide a value after ${option}, e.g. \`${option} <value>\`.` });
       }
       value = next;
       index += 1;
@@ -36,13 +41,6 @@ Usage: ${usage}`);
   }
 }
 
-// packages/cli/src/commands/inbox.ts
-import {
-  listAuthorityRuns,
-  readJsonlFile,
-  resolveAuthorityRunDir
-} from "@rig/runtime/control-plane/authority-files";
-
 // packages/cli/src/commands/_cli-format.ts
 import { log, note } from "@clack/prompts";
 import pc from "picocolors";
@@ -125,6 +123,11 @@ function formatInboxList(kind, entries) {
 `);
 }
 
+// packages/cli/src/commands/_server-client.ts
+import { existsSync as existsSync2, readFileSync as readFileSync2 } from "fs";
+import { resolve as resolve2 } from "path";
+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";
@@ -147,7 +150,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) {
@@ -211,7 +214,7 @@ function resolveSelectedConnection(projectRoot, options = {}) {
   const global = readGlobalConnections(options);
   const connection = global.connections[repo.selected];
   if (!connection) {
-    throw new CliError2(`Selected Rig server "${repo.selected}" was not found. Run \`rig server list\` or \`rig server 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: repo.serverProjectRoot };
 }
@@ -223,9 +226,6 @@ function writeRepoServerProjectRoot(projectRoot, serverProjectRoot) {
 }
 
 // packages/cli/src/commands/_server-client.ts
-import { existsSync as existsSync2, readFileSync as readFileSync2 } from "fs";
-import { resolve as resolve2 } from "path";
-import { ensureLocalRigServerConnection } from "@rig/runtime/local-server";
 var scopedGitHubBearerTokens = new Map;
 function cleanToken(value) {
   const trimmed = value?.trim();
@@ -287,7 +287,7 @@ async function ensureServerForCli(projectRoot) {
     };
   } catch (error) {
     if (error instanceof Error) {
-      throw new CliError2(error.message, 1);
+      throw new CliError(error.message, 1);
     }
     throw error;
   }
@@ -337,15 +337,64 @@ function diagnosticMessage(payload) {
   });
   return messages.length > 0 ? messages.join("; ") : null;
 }
+var serverReachabilityCache = new Map;
+async function probeServerReachability(baseUrl, authToken) {
+  try {
+    const response = await fetch(`${baseUrl.replace(/\/+$/, "")}/api/server/status`, {
+      headers: mergeHeaders(undefined, authToken),
+      signal: AbortSignal.timeout(1500)
+    });
+    return response.ok;
+  } catch {
+    return false;
+  }
+}
+function cachedServerReachability(projectRoot, baseUrl, authToken) {
+  const key = resolve2(projectRoot);
+  const cached = serverReachabilityCache.get(key);
+  if (cached)
+    return cached;
+  const probe = probeServerReachability(baseUrl, authToken);
+  serverReachabilityCache.set(key, probe);
+  return probe;
+}
+function describeSelectedServer(projectRoot, server) {
+  try {
+    const selected = resolveSelectedConnection(projectRoot);
+    if (selected) {
+      return {
+        alias: selected.alias,
+        target: selected.connection.kind === "remote" ? selected.connection.baseUrl : server.baseUrl
+      };
+    }
+  } catch {}
+  return { alias: server.connectionKind === "remote" ? "remote" : "local", target: server.baseUrl };
+}
+async function buildServerFailureContext(projectRoot, server) {
+  const { alias, target } = describeSelectedServer(projectRoot, server);
+  const reachable = await cachedServerReachability(projectRoot, server.baseUrl, server.authToken);
+  const reachability = reachable ? "server is reachable" : "server is unreachable";
+  return {
+    contextLine: `Currently connected to: ${alias} at ${target} (${reachability}).`,
+    hint: "Check the selected server with `rig server status`, or switch with `rig server use <alias|local>`."
+  };
+}
 async function requestServerJson(context, pathname, init = {}) {
   const server = await ensureServerForCli(context.projectRoot);
   const headers = mergeHeaders(init.headers, server.authToken);
   if (server.serverProjectRoot)
     headers.set("x-rig-project-root", server.serverProjectRoot);
-  const response = await fetch(`${server.baseUrl}${pathname}`, {
-    ...init,
-    headers
-  });
+  let response;
+  try {
+    response = await fetch(`${server.baseUrl}${pathname}`, {
+      ...init,
+      headers
+    });
+  } catch (error) {
+    const failure = await buildServerFailureContext(context.projectRoot, server);
+    throw new CliError(`Rig server request failed: ${error instanceof Error ? error.message : String(error)}
+${failure.contextLine}`, 1, { hint: failure.hint });
+  }
   const text = await response.text();
   const payload = text.trim().length > 0 ? (() => {
     try {
@@ -357,77 +406,106 @@ async function requestServerJson(context, pathname, init = {}) {
   if (!response.ok) {
     const diagnostics = diagnosticMessage(payload);
     const detail = diagnostics ?? (text || response.statusText);
-    throw new CliError2(`Rig server request failed (${response.status}): ${detail}`, 1);
+    const failure = await buildServerFailureContext(context.projectRoot, server);
+    throw new CliError(`Rig server request failed (${response.status}): ${detail}
+${failure.contextLine}`, 1, { hint: failure.hint });
   }
   return payload;
 }
-async function listRunsViaServer(context, options = {}) {
-  const url = new URL("http://rig.local/api/runs");
-  if (options.limit !== undefined)
-    url.searchParams.set("limit", String(options.limit));
-  const payload = await requestServerJson(context, `${url.pathname}${url.search}`);
-  const runs = Array.isArray(payload) ? payload : payload && typeof payload === "object" && !Array.isArray(payload) && Array.isArray(payload.runs) ? payload.runs : [];
-  return runs.filter((entry) => Boolean(entry && typeof entry === "object" && !Array.isArray(entry)));
-}
-async function getRunDetailsViaServer(context, runId) {
-  const payload = await requestServerJson(context, `/api/runs/${encodeURIComponent(runId)}`);
-  return payload && typeof payload === "object" && !Array.isArray(payload) ? payload : {};
-}
 
 // packages/cli/src/commands/inbox.ts
-function isRemoteConnectionSelected(projectRoot) {
-  return resolveSelectedConnection(projectRoot)?.connection.kind === "remote";
-}
-function runMatches(entry, filters) {
-  const runId = typeof entry.runId === "string" ? entry.runId : typeof entry.id === "string" ? entry.id : "";
-  const taskId = typeof entry.taskId === "string" ? entry.taskId : "";
-  return (!filters.run || runId === filters.run) && (!filters.task || taskId === filters.task);
-}
-function normalizeRemoteRunDetails(payload) {
-  const run = payload.run;
-  if (run && typeof run === "object" && !Array.isArray(run)) {
-    return {
-      ...run,
-      ...Array.isArray(payload.timeline) ? { timeline: payload.timeline } : {},
-      ...Array.isArray(payload.approvals) ? { approvals: payload.approvals } : {},
-      ...Array.isArray(payload.userInputs) ? { userInputs: payload.userInputs } : {}
-    };
+async function listInboxRecords(context, kind, filters) {
+  const params = new URLSearchParams;
+  if (filters.run)
+    params.set("runId", filters.run);
+  if (filters.task)
+    params.set("taskId", filters.task);
+  const query = params.size > 0 ? `?${params.toString()}` : "";
+  const payload = await requestServerJson(context, `/api/inbox/${kind}${query}`);
+  const records = Array.isArray(payload) ? payload : [];
+  return filters.pendingOnly ? records.filter((entry) => (entry.status ?? "pending") !== "resolved") : records;
+}
+async function readPendingInboxCounts(context) {
+  try {
+    const [approvals, inputs] = await Promise.all([
+      listInboxRecords(context, "approvals", { pendingOnly: true }),
+      listInboxRecords(context, "inputs", { pendingOnly: true })
+    ]);
+    return { approvals: approvals.length, inputs: inputs.length };
+  } catch {
+    return null;
   }
-  return payload;
 }
-function remoteRecordsFromRun(run, kind) {
-  const key = kind === "approvals" ? "approvals" : "userInputs";
-  const direct = run[key];
-  if (!Array.isArray(direct))
-    return [];
-  const runId = typeof run.runId === "string" ? run.runId : typeof run.id === "string" ? run.id : "";
-  const taskId = typeof run.taskId === "string" ? run.taskId : "";
-  return direct.filter((record) => Boolean(record && typeof record === "object" && !Array.isArray(record))).map((record) => ({ runId, taskId, record }));
-}
-async function listRemoteInboxRecords(context, kind, filters) {
-  const runs = (await listRunsViaServer(context, { limit: 100 })).filter((entry) => runMatches(entry, filters));
-  const records = [];
-  for (const run of runs) {
-    const runId = typeof run.runId === "string" ? run.runId : typeof run.id === "string" ? run.id : "";
-    const detailed = runId ? normalizeRemoteRunDetails(await getRunDetailsViaServer(context, runId).catch(() => run)) : run;
-    records.push(...remoteRecordsFromRun(detailed, kind));
+async function printPendingInboxFooter(context) {
+  if (context.outputMode !== "text")
+    return;
+  const counts = await readPendingInboxCounts(context);
+  if (!counts || counts.approvals === 0 && counts.inputs === 0)
+    return;
+  const parts = [];
+  if (counts.approvals > 0)
+    parts.push(`${counts.approvals} approval${counts.approvals === 1 ? "" : "s"}`);
+  if (counts.inputs > 0)
+    parts.push(`${counts.inputs} input request${counts.inputs === 1 ? "" : "s"}`);
+  console.log(`
+\u26A0 ${parts.join(" and ")} pending \u2014 run \`rig inbox\` to review.`);
+}
+function renderList(context, kind, records) {
+  if (context.outputMode === "text") {
+    printFormattedOutput(formatInboxList(kind, records));
   }
-  return records;
 }
-function listLocalInboxRecords(context, kind, filters) {
-  const fileName = kind === "approvals" ? "approvals.jsonl" : "user-input.jsonl";
-  const runs = listAuthorityRuns(context.projectRoot).filter((entry) => (!filters.run || entry.runId === filters.run) && (!filters.task || entry.taskId === filters.task));
-  return runs.flatMap((entry) => readJsonlFile(resolve3(resolveAuthorityRunDir(context.projectRoot, entry.runId), fileName)).map((record) => ({
-    runId: entry.runId,
-    taskId: entry.taskId ?? undefined,
-    record
-  })));
-}
-async function listInboxRecords(context, kind, filters) {
-  if (isRemoteConnectionSelected(context.projectRoot)) {
-    return listRemoteInboxRecords(context, kind, filters);
+async function watchInbox(context, filters) {
+  const render = async () => {
+    const [approvals, inputs] = await Promise.all([
+      listInboxRecords(context, "approvals", { ...filters, pendingOnly: true }),
+      listInboxRecords(context, "inputs", { ...filters, pendingOnly: true })
+    ]);
+    console.clear();
+    console.log(`rig inbox \u2014 watching (Ctrl-C to stop) \u2014 ${new Date().toLocaleTimeString()}`);
+    renderList(context, "approvals", approvals);
+    renderList(context, "inputs", inputs);
+    if (approvals.length === 0 && inputs.length === 0) {
+      console.log("Nothing pending.");
+    } else {
+      console.log(`
+Resolve with: rig inbox approve --run <id> --request <id> --decision approve|reject`);
+    }
+  };
+  await render();
+  const server = await ensureServerForCli(context.projectRoot);
+  const relevant = /"type":"rig\.(approval|user-input)\./;
+  const fallbackTimer = setInterval(() => {
+    render();
+  }, 30000);
+  fallbackTimer.unref?.();
+  for (;; ) {
+    try {
+      const response = await fetch(`${server.baseUrl}/api/server/events`, {
+        headers: {
+          ...server.authToken ? { authorization: `Bearer ${server.authToken}` } : {},
+          ...server.serverProjectRoot ? { "x-rig-project-root": server.serverProjectRoot } : {},
+          accept: "text/event-stream"
+        }
+      });
+      if (!response.ok || !response.body)
+        throw new Error(`SSE ${response.status}`);
+      const reader = response.body.getReader();
+      const decoder = new TextDecoder;
+      for (;; ) {
+        const { done, value } = await reader.read();
+        if (done)
+          break;
+        const chunk = decoder.decode(value, { stream: true });
+        if (relevant.test(chunk)) {
+          await render();
+        }
+      }
+    } catch {
+      await render();
+      await new Promise((resolveSleep) => setTimeout(resolveSleep, 2000));
+    }
   }
-  return listLocalInboxRecords(context, kind, filters);
 }
 async function executeInbox(context, args) {
   const [command = "approvals", ...rest] = args;
@@ -440,11 +518,20 @@ async function executeInbox(context, args) {
       pending = task.rest;
       requireNoExtraArgs(pending, "rig inbox approvals [--run <id>] [--task <id>]");
       const approvals = await listInboxRecords(context, "approvals", { run: run.value, task: task.value });
-      if (context.outputMode === "text") {
-        printFormattedOutput(formatInboxList("approvals", approvals));
-      }
+      renderList(context, "approvals", approvals);
       return { ok: true, group: "inbox", command, details: { approvals } };
     }
+    case "inputs": {
+      let pending = rest;
+      const run = takeOption(pending, "--run");
+      pending = run.rest;
+      const task = takeOption(pending, "--task");
+      pending = task.rest;
+      requireNoExtraArgs(pending, "rig inbox inputs [--run <id>] [--task <id>]");
+      const requests = await listInboxRecords(context, "inputs", { run: run.value, task: task.value });
+      renderList(context, "inputs", requests);
+      return { ok: true, group: "inbox", command, details: { requests } };
+    }
     case "approve": {
       let pending = rest;
       const run = takeOption(pending, "--run");
@@ -457,35 +544,22 @@ async function executeInbox(context, args) {
       pending = note2.rest;
       requireNoExtraArgs(pending, "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.");
+        throw new CliError("approve requires --run, --request, and --decision. List pending requests with `rig inbox approvals`.");
       }
       if (decision.value !== "approve" && decision.value !== "reject") {
-        throw new CliError2("decision must be approve or reject.");
-      }
-      if (isRemoteConnectionSelected(context.projectRoot)) {
-        throw new CliError2("Remote approval resolution is not available from this CLI yet; use the server UI/API or switch to local state for direct JSONL edits.", 2);
+        throw new CliError("decision must be approve or reject.", 1, { hint: "Re-run as `rig inbox approve --run <id> --request <id> --decision approve|reject`." });
       }
-      const approvalsPath = resolve3(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: note2.value ?? null, resolvedAt } : entry);
-      writeFileSync2(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, "rig inbox inputs [--run <id>] [--task <id>]");
-      const requests = await listInboxRecords(context, "inputs", { run: run.value, task: task.value });
-      if (context.outputMode === "text") {
-        printFormattedOutput(formatInboxList("inputs", requests));
-      }
-      return { ok: true, group: "inbox", command, details: { requests } };
+      const result = await requestServerJson(context, "/api/inbox/approvals/resolve", {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify({
+          runId: run.value,
+          requestId: request.value,
+          decision: decision.value,
+          note: note2.value ?? null
+        })
+      });
+      return { ok: true, group: "inbox", command, details: { result } };
     }
     case "respond": {
       let pending = rest;
@@ -498,11 +572,11 @@ async function executeInbox(context, args) {
       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");
+          const next = pending[index + 1];
+          if (!next || next.startsWith("-")) {
+            throw new CliError("Missing value for --answer", 1, { hint: "Pass key=value pairs, e.g. `rig inbox respond --run <id> --request <id> --answer key=value`." });
           }
-          answers.push(next2);
+          answers.push(next);
           index += 1;
           continue;
         }
@@ -512,28 +586,38 @@ async function executeInbox(context, args) {
       }
       requireNoExtraArgs(remaining, "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.");
-      }
-      if (isRemoteConnectionSelected(context.projectRoot)) {
-        throw new CliError2("Remote input responses are not available from this CLI yet; use the server UI/API or switch to local state for direct JSONL edits.", 2);
+        throw new CliError("respond requires --run, --request, and at least one --answer. List pending requests with `rig inbox inputs`.");
       }
       const parsedAnswers = Object.fromEntries(answers.map((entry) => {
         const [key, ...restValue] = entry.split("=");
         return [key, restValue.join("=")];
       }));
-      const requestsPath = resolve3(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);
-      writeFileSync2(requestsPath, `${next.map((entry) => JSON.stringify(entry)).join(`
-`)}
-`, "utf8");
-      return { ok: true, group: "inbox", command, details: { runId: run.value, requestId: request.value, answers: parsedAnswers } };
+      const result = await requestServerJson(context, "/api/inbox/inputs/respond", {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify({
+          runId: run.value,
+          requestId: request.value,
+          answers: parsedAnswers
+        })
+      });
+      return { ok: true, group: "inbox", command, details: { result } };
+    }
+    case "watch": {
+      let pending = rest;
+      const run = takeOption(pending, "--run");
+      pending = run.rest;
+      const task = takeOption(pending, "--task");
+      pending = task.rest;
+      requireNoExtraArgs(pending, "rig inbox watch [--run <id>] [--task <id>]");
+      return await watchInbox(context, { run: run.value, task: task.value });
     }
     default:
-      throw new CliError2(`Unknown inbox command: ${command}`);
+      throw new CliError(`Unknown inbox command: ${command}. Use approvals|inputs|approve|respond|watch.`);
   }
 }
 export {
+  readPendingInboxCounts,
+  printPendingInboxFooter,
   executeInbox
 };