@h-rig/cli 0.0.6-alpha.7 → 0.0.6-alpha.70

package/dist/src/commands/_server-client.js

@@ -1,17 +1,23 @@
 // @bun
 // packages/cli/src/commands/_server-client.ts
-import { spawnSync } from "child_process";
 import { existsSync as existsSync2, readFileSync as readFileSync2 } from "fs";
 import { resolve as resolve2 } 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/_server-client.ts
 import { ensureLocalRigServerConnection } from "@rig/runtime/local-server";
@@ -38,9 +44,14 @@ 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) {
+  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;
@@ -81,31 +92,51 @@ 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
   };
 }
+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" } };
+    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 };
+  return { alias: repo.selected, connection, serverProjectRoot: repo.serverProjectRoot };
+}
+function writeRepoServerProjectRoot(projectRoot, serverProjectRoot) {
+  const repo = readRepoConnection(projectRoot);
+  if (!repo)
+    return;
+  writeRepoConnection(projectRoot, { ...repo, serverProjectRoot });
 }
 
 // packages/cli/src/commands/_server-client.ts
-var cachedGitHubBearerToken;
+var scopedGitHubBearerTokens = new Map;
+var serverPhaseListener = null;
+function setServerPhaseListener(listener) {
+  const previous = serverPhaseListener;
+  serverPhaseListener = listener;
+  return previous;
+}
+function reportServerPhase(label) {
+  serverPhaseListener?.(label);
+}
 function cleanToken(value) {
   const trimmed = value?.trim();
   return trimmed ? trimmed : null;
 }
-function setGitHubBearerTokenForCurrentProcess(token) {
-  cachedGitHubBearerToken = cleanToken(token ?? undefined);
+function setGitHubBearerTokenForCurrentProcess(token, projectRoot) {
+  const scopedKey = resolve2(projectRoot ?? process.cwd());
+  scopedGitHubBearerTokens.set(scopedKey, cleanToken(token ?? undefined));
 }
 function readPrivateRemoteSessionToken(projectRoot) {
   const path = resolve2(projectRoot, ".rig", "state", "github-auth.json");
@@ -119,49 +150,80 @@ function readPrivateRemoteSessionToken(projectRoot) {
   }
 }
 function readGitHubBearerTokenForRemote(projectRoot) {
-  if (cachedGitHubBearerToken !== undefined)
-    return cachedGitHubBearerToken;
+  const scopedKey = resolve2(projectRoot);
+  if (scopedGitHubBearerTokens.has(scopedKey))
+    return scopedGitHubBearerTokens.get(scopedKey) ?? null;
   const privateSession = readPrivateRemoteSessionToken(projectRoot);
-  if (privateSession) {
-    cachedGitHubBearerToken = privateSession;
-    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;
+  if (privateSession)
+    return privateSession;
+  return cleanToken(process.env.RIG_SERVER_AUTH_TOKEN) ?? cleanToken(process.env.RIG_REMOTE_AUTH_TOKEN);
+}
+function readStoredGitHubAuthToken(projectRoot) {
+  const path = resolve2(projectRoot, ".rig", "state", "github-auth.json");
+  if (!existsSync2(path))
+    return null;
+  try {
+    const parsed = JSON.parse(readFileSync2(path, "utf8"));
+    return cleanToken(typeof parsed.token === "string" ? parsed.token : undefined);
+  } catch {
+    return null;
   }
-  const result = spawnSync("gh", ["auth", "token"], {
-    encoding: "utf8",
-    timeout: 5000,
-    stdio: ["ignore", "pipe", "ignore"]
-  });
-  cachedGitHubBearerToken = result.status === 0 ? cleanToken(result.stdout) : null;
-  return cachedGitHubBearerToken;
+}
+function readLocalConnectionFallbackToken(projectRoot) {
+  return readGitHubBearerTokenForRemote(projectRoot) ?? cleanToken(process.env.RIG_GITHUB_TOKEN) ?? readStoredGitHubAuthToken(projectRoot);
 }
 async function ensureServerForCli(projectRoot) {
   try {
     const selected = resolveSelectedConnection(projectRoot);
     if (selected?.connection.kind === "remote") {
+      reportServerPhase(`Connecting to ${selected.alias}\u2026`);
+      const authToken = readGitHubBearerTokenForRemote(projectRoot);
+      const serverProjectRoot = selected.serverProjectRoot ?? await backfillRemoteServerProjectRoot(projectRoot, selected.connection.baseUrl, authToken);
       return {
         baseUrl: selected.connection.baseUrl,
-        authToken: readGitHubBearerTokenForRemote(projectRoot),
-        connectionKind: "remote"
+        authToken,
+        connectionKind: "remote",
+        serverProjectRoot
       };
     }
+    reportServerPhase("Starting local Rig server\u2026");
     const connection = await ensureLocalRigServerConnection(projectRoot);
     return {
       baseUrl: connection.baseUrl,
-      authToken: connection.authToken,
-      connectionKind: "local"
+      authToken: connection.authToken ?? readLocalConnectionFallbackToken(projectRoot),
+      connectionKind: "local",
+      serverProjectRoot: resolve2(projectRoot)
     };
   } catch (error) {
     if (error instanceof Error) {
-      throw new CliError2(error.message, 1);
+      throw new CliError(error.message, 1);
     }
     throw error;
   }
 }
+async function backfillRemoteServerProjectRoot(projectRoot, baseUrl, authToken) {
+  const repo = readRepoConnection(projectRoot);
+  const slug = repo?.project?.trim();
+  if (!slug)
+    return null;
+  try {
+    const response = await fetch(`${baseUrl}/api/projects/${encodeURIComponent(slug)}`, {
+      headers: mergeHeaders(undefined, authToken)
+    });
+    if (!response.ok)
+      return null;
+    const payload = await response.json();
+    const project = payload.project && typeof payload.project === "object" && !Array.isArray(payload.project) ? payload.project : null;
+    const checkouts = Array.isArray(project?.checkouts) ? project.checkouts : [];
+    const latestCheckout = [...checkouts].reverse().find((entry) => Boolean(entry && typeof entry === "object" && !Array.isArray(entry) && typeof entry.path === "string"));
+    const path = typeof latestCheckout?.path === "string" && latestCheckout.path.trim() ? latestCheckout.path.trim() : null;
+    if (path)
+      writeRepoServerProjectRoot(projectRoot, path);
+    return path;
+  } catch {
+    return null;
+  }
+}
 function appendTaskFilterParams(url, filters) {
   if (filters.assignee)
     url.searchParams.set("assignee", filters.assignee);
@@ -194,12 +256,65 @@ 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 response = await fetch(`${server.baseUrl}${pathname}`, {
-    ...init,
-    headers: mergeHeaders(init.headers, server.authToken)
-  });
+  const headers = mergeHeaders(init.headers, server.authToken);
+  if (server.serverProjectRoot)
+    headers.set("x-rig-project-root", server.serverProjectRoot);
+  reportServerPhase(`${(init.method ?? "GET").toUpperCase()} ${pathname.split("?")[0]}\u2026`);
+  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 {
@@ -211,7 +326,9 @@ 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;
 }
@@ -220,7 +337,7 @@ async function listWorkspaceTasksViaServer(context, filters = {}) {
   appendTaskFilterParams(url, filters);
   const payload = await requestServerJson(context, `${url.pathname}${url.search}`);
   if (!Array.isArray(payload)) {
-    throw new CliError2("Rig server returned an invalid task list payload.", 1);
+    throw new CliError("Rig server returned an invalid task list payload.", 1, { hint: "Check the selected server with `rig server status`; mixed CLI/server versions can mismatch \u2014 try `rig doctor`." });
   }
   return payload.flatMap((entry) => entry && typeof entry === "object" && !Array.isArray(entry) ? [entry] : []);
 }
@@ -236,7 +353,7 @@ async function selectNextWorkspaceTaskViaServer(context, filters = {}) {
   appendTaskFilterParams(url, filters);
   const payload = await requestServerJson(context, `${url.pathname}${url.search}`);
   if (!payload || typeof payload !== "object" || Array.isArray(payload)) {
-    throw new CliError2("Rig server returned an invalid next-task payload.", 1);
+    throw new CliError("Rig server returned an invalid next-task payload.", 1, { hint: "Check the selected server with `rig server status`; try `rig task list` to see the raw task set." });
   }
   const record = payload;
   const rawTask = record.task;
@@ -275,32 +392,50 @@ async function registerProjectViaServer(context, input) {
 function sleep(ms) {
   return new Promise((resolve3) => setTimeout(resolve3, ms));
 }
+function isRetryableProjectRootSwitchError(error) {
+  if (!(error instanceof Error))
+    return false;
+  const message = error.message.toLowerCase();
+  return message.includes("rig server request failed (401): auth-required") || message.includes("rig server request failed (401): github-token-required") || message.includes("rig server request failed (502)") || message.includes("rig server request failed (503)") || message.includes("bad gateway") || message.includes("fetch failed") || message.includes("econnrefused") || message.includes("connection refused");
+}
 async function switchServerProjectRootViaServer(context, projectRoot, options = {}) {
-  const switched = await requestServerJson(context, "/api/server/project-root", {
-    method: "POST",
-    headers: { "content-type": "application/json" },
-    body: JSON.stringify({ projectRoot })
-  });
   const timeoutMs = options.timeoutMs ?? 30000;
   const pollMs = options.pollMs ?? 1000;
   const deadline = Date.now() + timeoutMs;
   let lastError;
+  let switched = null;
   while (Date.now() < deadline) {
     try {
-      const status = await requestServerJson(context, "/api/server/status");
-      if (status && typeof status === "object" && !Array.isArray(status)) {
-        const record = status;
-        if (record.projectRoot === projectRoot) {
-          return { ok: true, switched, status: record };
-        }
-        lastError = `server projectRoot=${String(record.projectRoot ?? "unknown")}`;
-      }
+      switched = await requestServerJson(context, "/api/server/project-root", {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify({ projectRoot })
+      });
+      break;
     } catch (error) {
       lastError = error;
+      if (!isRetryableProjectRootSwitchError(error))
+        throw error;
+      await sleep(pollMs);
     }
-    await sleep(pollMs);
   }
-  throw new CliError2(`Rig server did not switch to ${projectRoot} before timeout (${lastError instanceof Error ? lastError.message : String(lastError ?? "no status")}).`, 1);
+  if (!switched) {
+    throw new CliError(`Rig server did not accept project-root switch to ${projectRoot} before timeout (${lastError instanceof Error ? lastError.message : String(lastError ?? "no response")}).`, 1);
+  }
+  const record = switched && typeof switched === "object" && !Array.isArray(switched) ? switched : {};
+  if (record.ok === true) {
+    writeRepoServerProjectRoot(context.projectRoot, projectRoot);
+    return { ok: true, switched: record };
+  }
+  throw new CliError(`Rig server rejected project-root scope ${projectRoot}: ${String(record.message ?? record.error ?? "unknown error")}`, 1);
+}
+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)}`);
@@ -315,6 +450,69 @@ async function getRunLogsViaServer(context, runId, options = {}) {
   const payload = await requestServerJson(context, `${url.pathname}${url.search}`);
   return payload && typeof payload === "object" && !Array.isArray(payload) ? payload : { entries: [] };
 }
+async function getRunTimelineViaServer(context, runId, options = {}) {
+  const url = new URL(`http://rig.local/api/runs/${encodeURIComponent(runId)}/timeline`);
+  if (options.limit !== undefined)
+    url.searchParams.set("limit", String(options.limit));
+  if (options.cursor)
+    url.searchParams.set("cursor", options.cursor);
+  const payload = await requestServerJson(context, `${url.pathname}${url.search}`);
+  return payload && typeof payload === "object" && !Array.isArray(payload) ? payload : { entries: [] };
+}
+async function ensureTaskLabelsViaServer(context) {
+  const payload = await requestServerJson(context, "/api/workspace/task-labels", { method: "POST" });
+  return payload && typeof payload === "object" && !Array.isArray(payload) ? payload : {};
+}
+async function listGitHubProjectsViaServer(context, owner) {
+  const url = new URL("http://rig.local/api/github/projects");
+  url.searchParams.set("owner", owner);
+  const payload = await requestServerJson(context, `${url.pathname}${url.search}`);
+  return payload && typeof payload === "object" && !Array.isArray(payload) ? payload : { projects: [] };
+}
+async function getGitHubProjectStatusFieldViaServer(context, projectId) {
+  const payload = await requestServerJson(context, `/api/github/projects/${encodeURIComponent(projectId)}/status-field`);
+  return payload && typeof payload === "object" && !Array.isArray(payload) ? payload : {};
+}
+async function updateWorkspaceTaskViaServer(context, input) {
+  const payload = await requestServerJson(context, "/api/tasks/update", {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify(input)
+  });
+  return payload && typeof payload === "object" && !Array.isArray(payload) ? payload : { ok: true };
+}
+var RESUMABLE_RUN_STATUSES = new Set([
+  "created",
+  "preparing",
+  "running",
+  "validating",
+  "reviewing",
+  "stopped",
+  "failed",
+  "needs-attention",
+  "needs_attention"
+]);
+async function resumeRunViaServer(context, runId, options) {
+  let targetRunId = runId?.trim() || null;
+  if (!targetRunId) {
+    const candidates = (await listRunsViaServer(context)).filter((run) => RESUMABLE_RUN_STATUSES.has(String(run.status ?? ""))).sort((left, right) => String(right.updatedAt ?? "").localeCompare(String(left.updatedAt ?? "")));
+    targetRunId = typeof candidates[0]?.runId === "string" ? candidates[0].runId : null;
+  }
+  if (!targetRunId) {
+    throw new CliError(options.restart ? "No run is available to restart." : "No resumable run is available.", 2, { hint: "List runs with `rig run list`, then pass an explicit id: `rig run resume <run-id>`." });
+  }
+  const payload = await requestServerJson(context, "/api/runs/resume", {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify({ runId: targetRunId, createdAt: new Date().toISOString(), restart: options.restart })
+  });
+  const record = payload && typeof payload === "object" && !Array.isArray(payload) ? payload : {};
+  if (record.ok === false) {
+    const message = typeof record.error === "string" && record.error.trim() ? record.error : "run resume failed";
+    throw new CliError(`${options.restart ? "restart" : "resume"} failed for ${targetRunId}: ${message}`, 1);
+  }
+  return { ok: true, runId: targetRunId, ...record };
+}
 async function stopRunViaServer(context, runId) {
   const payload = await requestServerJson(context, "/api/runs/stop", {
     method: "POST",
@@ -331,6 +529,72 @@ async function steerRunViaServer(context, runId, message) {
   });
   return payload && typeof payload === "object" && !Array.isArray(payload) ? payload : { ok: true };
 }
+async function getRunPiSessionViaServer(context, runId) {
+  const payload = await requestServerJson(context, `/api/runs/${encodeURIComponent(runId)}/pi`);
+  return payload && typeof payload === "object" && !Array.isArray(payload) ? payload : {};
+}
+async function getRunPiMessagesViaServer(context, runId) {
+  const payload = await requestServerJson(context, `/api/runs/${encodeURIComponent(runId)}/pi/messages`);
+  return payload && typeof payload === "object" && !Array.isArray(payload) ? payload : { messages: [] };
+}
+async function getRunPiStatusViaServer(context, runId) {
+  const payload = await requestServerJson(context, `/api/runs/${encodeURIComponent(runId)}/pi/status`);
+  return payload && typeof payload === "object" && !Array.isArray(payload) ? payload : {};
+}
+async function getRunPiCommandsViaServer(context, runId) {
+  const payload = await requestServerJson(context, `/api/runs/${encodeURIComponent(runId)}/pi/commands`);
+  return payload && typeof payload === "object" && !Array.isArray(payload) ? payload : { commands: [] };
+}
+async function getRunPiCapabilitiesViaServer(context, runId) {
+  const payload = await requestServerJson(context, `/api/runs/${encodeURIComponent(runId)}/pi/capabilities`);
+  return payload && typeof payload === "object" && !Array.isArray(payload) ? payload : { capabilities: null };
+}
+async function sendRunPiPromptViaServer(context, runId, text, streamingBehavior) {
+  const payload = await requestServerJson(context, `/api/runs/${encodeURIComponent(runId)}/pi/prompt`, {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify({ text, streamingBehavior })
+  });
+  return payload && typeof payload === "object" && !Array.isArray(payload) ? payload : { accepted: true };
+}
+async function sendRunPiShellViaServer(context, runId, text) {
+  const payload = await requestServerJson(context, `/api/runs/${encodeURIComponent(runId)}/pi/shell`, {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify({ text })
+  });
+  return payload && typeof payload === "object" && !Array.isArray(payload) ? payload : { accepted: true };
+}
+async function runRunPiCommandViaServer(context, runId, text) {
+  const payload = await requestServerJson(context, `/api/runs/${encodeURIComponent(runId)}/pi/commands/run`, {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify({ text })
+  });
+  return payload && typeof payload === "object" && !Array.isArray(payload) ? payload : { type: "done" };
+}
+async function respondRunPiExtensionUiViaServer(context, runId, requestId, valueOrCancel) {
+  const payload = await requestServerJson(context, `/api/runs/${encodeURIComponent(runId)}/pi/extension-ui/respond`, {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify({ requestId, ...valueOrCancel })
+  });
+  return payload && typeof payload === "object" && !Array.isArray(payload) ? payload : { accepted: true };
+}
+async function abortRunPiViaServer(context, runId) {
+  const payload = await requestServerJson(context, `/api/runs/${encodeURIComponent(runId)}/pi/abort`, { method: "POST" });
+  return payload && typeof payload === "object" && !Array.isArray(payload) ? payload : { aborted: true };
+}
+async function buildRunPiEventsWebSocketUrl(context, runId) {
+  const server = await ensureServerForCli(context.projectRoot);
+  const url = new URL(`${server.baseUrl.replace(/\/+$/, "")}/api/runs/${encodeURIComponent(runId)}/pi/events`);
+  url.protocol = url.protocol === "https:" ? "wss:" : "ws:";
+  if (server.authToken)
+    url.searchParams.set("token", server.authToken);
+  if (server.serverProjectRoot)
+    url.searchParams.set("rigProjectRoot", server.serverProjectRoot);
+  return url.toString();
+}
 async function submitTaskRunViaServer(context, input) {
   const isTaskRun = Boolean(input.taskId);
   const endpoint = isTaskRun ? "/api/runs/task" : "/api/runs/adhoc";
@@ -354,29 +618,48 @@ async function submitTaskRunViaServer(context, input) {
     })
   });
   if (!payload || typeof payload !== "object" || Array.isArray(payload)) {
-    throw new CliError2("Rig server returned an invalid run submission payload.", 1);
+    throw new CliError("Rig server returned an invalid run submission payload.", 1, { hint: "Check `rig server status` and retry; `rig run list` shows whether the run was created anyway." });
   }
   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);
+    throw new CliError("Rig server returned no runId for the submitted run.", 1, { hint: "Check `rig run list` \u2014 the run may still have been created; otherwise retry the submission." });
   }
   return { runId };
 }
 export {
+  updateWorkspaceTaskViaServer,
   switchServerProjectRootViaServer,
   submitTaskRunViaServer,
   stopRunViaServer,
   steerRunViaServer,
+  setServerPhaseListener,
   setGitHubBearerTokenForCurrentProcess,
+  sendRunPiShellViaServer,
+  sendRunPiPromptViaServer,
   selectNextWorkspaceTaskViaServer,
+  runRunPiCommandViaServer,
+  resumeRunViaServer,
+  respondRunPiExtensionUiViaServer,
   requestServerJson,
   registerProjectViaServer,
   prepareRemoteCheckoutViaServer,
   postGitHubTokenViaServer,
   listWorkspaceTasksViaServer,
+  listRunsViaServer,
+  listGitHubProjectsViaServer,
   getWorkspaceTaskViaServer,
+  getRunTimelineViaServer,
+  getRunPiStatusViaServer,
+  getRunPiSessionViaServer,
+  getRunPiMessagesViaServer,
+  getRunPiCommandsViaServer,
+  getRunPiCapabilitiesViaServer,
   getRunLogsViaServer,
   getRunDetailsViaServer,
+  getGitHubProjectStatusFieldViaServer,
   getGitHubAuthStatusViaServer,
-  ensureServerForCli
+  ensureTaskLabelsViaServer,
+  ensureServerForCli,
+  buildRunPiEventsWebSocketUrl,
+  abortRunPiViaServer
 };