@h-rig/cli 0.0.6-alpha.0

package/dist/src/commands/_run-driver-helpers.js

@@ -0,0 +1,289 @@
+// @bun
+// packages/cli/src/commands/_run-driver-helpers.ts
+import { readFileSync } 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 { 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/_run-driver-helpers.ts
+import {
+  appendJsonlRecord,
+  readAuthorityRun as readAuthorityRun2,
+  resolveAuthorityRunDir as resolveAuthorityRunDir2,
+  writeJsonFile as writeJsonFile2
+} from "@rig/runtime/control-plane/authority-files";
+import { taskLookup } from "@rig/runtime/control-plane/native/task-ops";
+import { buildProviderTaskRunInstructionLines } from "@rig/runtime/control-plane/provider/runtime-instructions";
+import { loadRigTaskRunSkillBody } from "@rig/runtime/control-plane/provider/rig-task-run-skill";
+
+// packages/cli/src/commands/_authority-runs.ts
+import { existsSync } from "fs";
+import { resolve as resolve2 } from "path";
+import {
+  readAuthorityRun,
+  readJsonlFile,
+  resolveAuthorityRunDir,
+  writeJsonFile
+} from "@rig/runtime/control-plane/authority-files";
+
+// packages/cli/src/commands/_paths.ts
+import { resolve } from "path";
+import { resolveMonorepoRoot } from "@rig/runtime/control-plane/native/utils";
+function resolveControlPlaneMonorepoRoot(projectRoot) {
+  return resolveMonorepoRoot(projectRoot);
+}
+function resolveControlPlaneTaskConfigPath(projectRoot) {
+  return resolve(resolveControlPlaneMonorepoRoot(projectRoot), ".rig", "task-config.json");
+}
+
+// packages/cli/src/commands/_authority-runs.ts
+function readLatestBeadRecord(projectRoot, taskId) {
+  const issuesPath = resolve2(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;
+}
+
+// packages/cli/src/commands/_run-driver-helpers.ts
+function patchAuthorityRun(projectRoot, runId, patch) {
+  const current = readAuthorityRun2(projectRoot, runId);
+  if (!current) {
+    throw new CliError2(`Run not found: ${runId}`, 2);
+  }
+  const next = {
+    ...current,
+    ...patch,
+    updatedAt: new Date().toISOString()
+  };
+  writeJsonFile2(resolve3(resolveAuthorityRunDir2(projectRoot, runId), "run.json"), next);
+  return next;
+}
+function touchAuthorityRun(projectRoot, runId) {
+  const current = readAuthorityRun2(projectRoot, runId);
+  if (!current) {
+    return;
+  }
+  writeJsonFile2(resolve3(resolveAuthorityRunDir2(projectRoot, runId), "run.json"), {
+    ...current,
+    updatedAt: new Date().toISOString()
+  });
+}
+function appendRunTimeline(projectRoot, runId, value) {
+  appendJsonlRecord(resolve3(resolveAuthorityRunDir2(projectRoot, runId), "timeline.jsonl"), value);
+  touchAuthorityRun(projectRoot, runId);
+}
+function appendRunLog(projectRoot, runId, value) {
+  appendJsonlRecord(resolve3(resolveAuthorityRunDir2(projectRoot, runId), "logs.jsonl"), value);
+  touchAuthorityRun(projectRoot, runId);
+}
+function appendRunAction(projectRoot, runId, value) {
+  appendJsonlRecord(resolve3(resolveAuthorityRunDir2(projectRoot, runId), "timeline.jsonl"), {
+    id: value.id,
+    type: "action",
+    actionType: value.actionType,
+    title: value.title,
+    detail: value.detail ?? null,
+    state: value.state,
+    createdAt: value.startedAt,
+    completedAt: value.completedAt ?? null,
+    payload: value.payload ?? {}
+  });
+}
+function startRunAction(projectRoot, runId, input) {
+  const startedAt = new Date().toISOString();
+  appendRunAction(projectRoot, runId, {
+    id: input.actionId,
+    actionType: input.actionType,
+    title: input.title,
+    detail: input.detail,
+    state: "running",
+    startedAt,
+    payload: input.payload
+  });
+  emitServerRunEvent({ type: "timeline", runId });
+  return {
+    startedAt,
+    complete: (detail, payload) => {
+      appendRunAction(projectRoot, runId, {
+        id: input.actionId,
+        actionType: input.actionType,
+        title: input.title,
+        detail: detail ?? input.detail ?? null,
+        state: "completed",
+        startedAt,
+        completedAt: new Date().toISOString(),
+        payload: payload ?? input.payload
+      });
+      emitServerRunEvent({ type: "timeline", runId });
+    },
+    fail: (detail, payload) => {
+      appendRunAction(projectRoot, runId, {
+        id: input.actionId,
+        actionType: input.actionType,
+        title: input.title,
+        detail,
+        state: "failed",
+        startedAt,
+        completedAt: new Date().toISOString(),
+        payload: payload ?? input.payload
+      });
+      emitServerRunEvent({ type: "timeline", runId });
+    }
+  };
+}
+function emitServerRunEvent(event) {
+  console.log(`__RIG_RUN_EVENT__${JSON.stringify({ ...event, at: new Date().toISOString() })}`);
+}
+function buildRunPrompt(input) {
+  const initialPrompt = input.initialPrompt?.trim() || null;
+  if (!input.taskId) {
+    return initialPrompt ?? input.fallbackTitle?.trim() ?? "Continue the requested Rig run and complete the work.";
+  }
+  const issues = (() => {
+    try {
+      return taskLookup(input.projectRoot, input.taskId);
+    } catch {
+      return "";
+    }
+  })();
+  const scopeText = (() => {
+    try {
+      const parsed = JSON.parse(readFileSync(resolveControlPlaneTaskConfigPath(input.projectRoot), "utf8"));
+      const entry = parsed[input.taskId] ?? {};
+      const scope = Array.isArray(entry.scope) ? entry.scope.filter((item) => typeof item === "string") : [];
+      const validation = Array.isArray(entry.validation) ? entry.validation.filter((item) => typeof item === "string") : [];
+      const lines = [];
+      if (scope.length > 0)
+        lines.push(`Scope:
+- ${scope.join(`
+- `)}`);
+      if (validation.length > 0)
+        lines.push(`Validation:
+- ${validation.join(`
+- `)}`);
+      return lines.join(`
+
+`);
+    } catch {
+      return "";
+    }
+  })();
+  const bead = readLatestBeadRecord(input.projectRoot, input.taskId);
+  const sourceTask = input.sourceTask ?? null;
+  const sourceDescription = firstPromptString(sourceTask?.description, sourceTask?.body);
+  const sourceAcceptance = firstPromptString(sourceTask?.acceptanceCriteria, sourceTask?.acceptance_criteria);
+  const sourceValidation = uniqueStrings([...sourceTask?.validation ?? [], ...sourceTask?.validators ?? []]);
+  const title = (bead && typeof bead === "object" && typeof bead.title === "string" ? bead.title : null) ?? firstPromptString(sourceTask?.title) ?? input.fallbackTitle ?? issues ?? input.taskId;
+  const description = (bead && typeof bead === "object" && typeof bead.description === "string" ? bead.description : null) ?? sourceDescription ?? input.fallbackDescription ?? "";
+  const acceptance = bead && typeof bead === "object" && typeof bead.acceptance_criteria === "string" ? bead.acceptance_criteria : sourceAcceptance ?? input.fallbackAcceptanceCriteria ?? "";
+  const sourceContractLines = renderSourceTaskContract(sourceTask, sourceValidation);
+  const providerLines = buildProviderTaskRunInstructionLines(input.runtimeAdapter);
+  const skillBody = loadRigTaskRunSkillBody();
+  return [
+    `You are working on task ${input.taskId}: ${title}.`,
+    description ? `Description:
+${description}` : null,
+    acceptance ? `Acceptance criteria:
+${acceptance}` : null,
+    sourceContractLines.length > 0 ? `Source task contract:
+${sourceContractLines.join(`
+`)}` : null,
+    scopeText || renderSourceScopeValidation(sourceTask, sourceValidation) || null,
+    initialPrompt ? `Additional operator guidance:
+${initialPrompt}` : null,
+    providerLines.length > 0 ? `Provider-specific runtime tooling:
+${providerLines.join(" ")}` : null,
+    skillBody || null
+  ].filter((value) => Boolean(value)).join(`
+
+`);
+}
+function firstPromptString(...values) {
+  for (const value of values) {
+    const trimmed = typeof value === "string" ? value.trim() : "";
+    if (trimmed.length > 0) {
+      return trimmed;
+    }
+  }
+  return null;
+}
+function uniqueStrings(values) {
+  return Array.from(new Set(values.map((value) => value.trim()).filter(Boolean)));
+}
+function renderSourceTaskContract(task, validation) {
+  if (!task) {
+    return [];
+  }
+  const lines = [];
+  const sourceIssueId = firstPromptString(task.sourceIssueId);
+  if (sourceIssueId)
+    lines.push(`Source issue: ${sourceIssueId}`);
+  const status = firstPromptString(task.status);
+  if (status)
+    lines.push(`Source status: ${status}`);
+  const issueType = firstPromptString(task.issueType);
+  if (issueType)
+    lines.push(`Issue type: ${issueType}`);
+  const role = firstPromptString(task.role);
+  if (role)
+    lines.push(`Role: ${role}`);
+  const externalRef = firstPromptString(task.externalRef);
+  if (externalRef)
+    lines.push(`External ref: ${externalRef}`);
+  const labels = uniqueStrings(task.labels ?? []);
+  if (labels.length > 0)
+    lines.push(`Labels:
+- ${labels.join(`
+- `)}`);
+  if (validation.length > 0)
+    lines.push(`Validators:
+- ${validation.join(`
+- `)}`);
+  return lines;
+}
+function renderSourceScopeValidation(task, validation) {
+  if (!task) {
+    return "";
+  }
+  const lines = [];
+  const scope = uniqueStrings(task.scope ?? []);
+  if (scope.length > 0)
+    lines.push(`Scope:
+- ${scope.join(`
+- `)}`);
+  if (validation.length > 0)
+    lines.push(`Validation:
+- ${validation.join(`
+- `)}`);
+  return lines.join(`
+
+`);
+}
+export {
+  touchAuthorityRun,
+  startRunAction,
+  patchAuthorityRun,
+  emitServerRunEvent,
+  buildRunPrompt,
+  appendRunTimeline,
+  appendRunLog,
+  appendRunAction
+};

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

@@ -0,0 +1,364 @@
+// @bun
+// packages/cli/src/commands/_server-client.ts
+import { spawnSync } 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";
+
+// packages/cli/src/commands/_server-client.ts
+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 setGitHubBearerTokenForCurrentProcess(token) {
+  cachedGitHubBearerToken = cleanToken(token ?? undefined);
+}
+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 appendTaskFilterParams(url, filters) {
+  if (filters.assignee)
+    url.searchParams.set("assignee", filters.assignee);
+  if (filters.state)
+    url.searchParams.set("state", filters.state);
+  if (filters.status)
+    url.searchParams.set("status", filters.status);
+  if (filters.limit !== undefined)
+    url.searchParams.set("limit", String(filters.limit));
+}
+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 listWorkspaceTasksViaServer(context, filters = {}) {
+  const url = new URL("http://rig.local/api/workspace/tasks");
+  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);
+  }
+  return payload.flatMap((entry) => entry && typeof entry === "object" && !Array.isArray(entry) ? [entry] : []);
+}
+async function getWorkspaceTaskViaServer(context, taskId) {
+  const payload = await requestServerJson(context, `/api/workspace/tasks/${encodeURIComponent(taskId)}`);
+  if (!payload || typeof payload !== "object" || Array.isArray(payload))
+    return null;
+  const task = payload.task;
+  return task && typeof task === "object" && !Array.isArray(task) ? task : null;
+}
+async function selectNextWorkspaceTaskViaServer(context, filters = {}) {
+  const url = new URL("http://rig.local/api/workspace/tasks/next");
+  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);
+  }
+  const record = payload;
+  const rawTask = record.task;
+  const task = rawTask && typeof rawTask === "object" && !Array.isArray(rawTask) ? rawTask : null;
+  const count = typeof record.count === "number" && Number.isFinite(record.count) ? record.count : task ? 1 : 0;
+  return { task, count };
+}
+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 : {};
+}
+async function prepareRemoteCheckoutViaServer(context, input) {
+  const payload = await requestServerJson(context, `/api/projects/${encodeURIComponent(input.repoSlug)}/prepare-checkout`, {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify({ checkout: input.checkout, repoUrl: input.repoUrl, baseDir: input.baseDir })
+  });
+  return payload && typeof payload === "object" && !Array.isArray(payload) ? payload : {};
+}
+async function registerProjectViaServer(context, input) {
+  const payload = await requestServerJson(context, "/api/projects", {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify(input)
+  });
+  return payload && typeof payload === "object" && !Array.isArray(payload) ? payload : {};
+}
+function sleep(ms) {
+  return new Promise((resolve2) => setTimeout(resolve2, ms));
+}
+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;
+  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")}`;
+      }
+    } catch (error) {
+      lastError = error;
+    }
+    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);
+}
+async function getRunDetailsViaServer(context, runId) {
+  const payload = await requestServerJson(context, `/api/runs/${encodeURIComponent(runId)}`);
+  return payload && typeof payload === "object" && !Array.isArray(payload) ? payload : {};
+}
+async function getRunLogsViaServer(context, runId, options = {}) {
+  const url = new URL(`http://rig.local/api/runs/${encodeURIComponent(runId)}/logs`);
+  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 stopRunViaServer(context, runId) {
+  const payload = await requestServerJson(context, "/api/runs/stop", {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify({ runId })
+  });
+  return payload && typeof payload === "object" && !Array.isArray(payload) ? payload : { ok: true, runId };
+}
+async function steerRunViaServer(context, runId, message) {
+  const payload = await requestServerJson(context, `/api/runs/${encodeURIComponent(runId)}/steer`, {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify({ message })
+  });
+  return payload && typeof payload === "object" && !Array.isArray(payload) ? payload : { ok: true };
+}
+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 };
+}
+export {
+  switchServerProjectRootViaServer,
+  submitTaskRunViaServer,
+  stopRunViaServer,
+  steerRunViaServer,
+  setGitHubBearerTokenForCurrentProcess,
+  selectNextWorkspaceTaskViaServer,
+  requestServerJson,
+  registerProjectViaServer,
+  prepareRemoteCheckoutViaServer,
+  postGitHubTokenViaServer,
+  listWorkspaceTasksViaServer,
+  getWorkspaceTaskViaServer,
+  getRunLogsViaServer,
+  getRunDetailsViaServer,
+  getGitHubAuthStatusViaServer,
+  ensureServerForCli
+};