@h-rig/cli 0.0.6-alpha.90 → 0.0.6-alpha.91

package/dist/src/commands/_run-bridge.js

@@ -0,0 +1,387 @@
+// @bun
+var __require = import.meta.require;
+
+// packages/cli/src/commands/_run-bridge.ts
+import { randomUUID } from "crypto";
+import { spawn as nodeSpawn } from "child_process";
+import { existsSync, readdirSync, readFileSync } from "fs";
+import { dirname, resolve } from "path";
+import { fileURLToPath } from "url";
+import { CUSTOM_TYPE_FOR, sessionIdFromSessionFile } from "@rig/contracts";
+import { createPluginHost } from "@rig/core";
+import { loadConfig } from "@rig/core/load-config";
+import { resolveOwnerNamespaceKey, resolveRegistryBaseUrl, resolveRegistrySecret, resolveSelectedRemote } from "@rig/runtime/control-plane/remote";
+import { listAgentRuntimes } from "@rig/runtime/control-plane/runtime/isolation";
+import { createRegistryClient } from "@rig/relay-registry";
+import {
+  listActiveCollabSessions as ompListActiveCollabSessions
+} from "@oh-my-pi/pi-coding-agent/collab/api";
+var DEFAULT_ATTACH_TIMEOUT_MS = 15000;
+var DEFAULT_ATTACH_POLL_INTERVAL_MS = 250;
+function stringField(value) {
+  return typeof value === "string" && value.trim().length > 0 ? value.trim() : undefined;
+}
+function githubUserId(value) {
+  if (typeof value === "number" && Number.isInteger(value))
+    return String(value);
+  return stringField(value);
+}
+function readJsonRecord(path) {
+  if (!existsSync(path))
+    return null;
+  try {
+    const parsed = JSON.parse(readFileSync(path, "utf8"));
+    return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+function publicIdentityEnv(projectRoot) {
+  const auth = readJsonRecord(resolve(projectRoot, ".rig", "state", "github-auth.json"));
+  const connection = readJsonRecord(resolve(projectRoot, ".rig", "state", "connection.json"));
+  const values = {};
+  const selectedRepo = stringField(auth?.selectedRepo) ?? stringField(connection?.project);
+  const userId = githubUserId(auth?.userId);
+  const login = stringField(auth?.login);
+  const namespaceKey = stringField(auth?.userNamespaceKey) ?? resolveOwnerNamespaceKey(projectRoot);
+  if (selectedRepo)
+    values.RIG_SELECTED_REPO = selectedRepo;
+  if (userId)
+    values.RIG_GITHUB_USER_ID = userId;
+  if (login)
+    values.RIG_GITHUB_LOGIN = login;
+  if (namespaceKey)
+    values.RIG_GITHUB_NAMESPACE_KEY = namespaceKey;
+  return values;
+}
+function taskText(value) {
+  return typeof value === "string" && value.trim().length > 0 ? value.trim() : null;
+}
+function taskUrl(record) {
+  const metadata = record;
+  return taskText(metadata.url) ?? taskText(metadata.html_url) ?? taskText(metadata.webUrl);
+}
+function taskBody(record) {
+  const metadata = record;
+  return taskText(metadata.body) ?? taskText(metadata.description);
+}
+function taskTitle(record) {
+  const metadata = record;
+  return taskText(metadata.title) ?? taskText(metadata.name) ?? record.id;
+}
+function toExtensionTask(record, sourceKind) {
+  return {
+    id: record.id,
+    title: taskTitle(record),
+    status: typeof record.status === "string" ? record.status : null,
+    source: sourceKind,
+    url: taskUrl(record),
+    body: taskBody(record)
+  };
+}
+async function loadConfiguredTaskSource(projectRoot) {
+  const normalizedRoot = resolve(projectRoot);
+  const config = await loadConfig(normalizedRoot);
+  const pluginHost = createPluginHost(config.plugins);
+  const taskSourceFactory = pluginHost.resolveTaskSourceFactoryByKind(config.taskSource.kind);
+  if (!taskSourceFactory) {
+    const kinds = pluginHost.listExecutableTaskSources().map((entry) => entry.kind).join(", ") || "none";
+    throw new Error(`No task source factory registered for kind "${config.taskSource.kind}". Registered kinds: ${kinds}.`);
+  }
+  return {
+    kind: config.taskSource.kind,
+    source: taskSourceFactory.factory(config.taskSource, { projectRoot: normalizedRoot })
+  };
+}
+async function listTasksFromSource(projectRoot, deps = {}) {
+  const { kind, source } = await (deps.loadTaskSource ?? loadConfiguredTaskSource)(projectRoot);
+  return (await source.list()).map((task) => toExtensionTask(task, kind));
+}
+async function getTaskFromSource(projectRoot, taskId, deps = {}) {
+  const tasks = await listTasksFromSource(projectRoot, deps);
+  return tasks.find((task) => task.id === taskId) ?? null;
+}
+async function readSelectedTarget(projectRoot, env = process.env) {
+  const config = await loadConfig(resolve(projectRoot));
+  const selected = resolveSelectedRemote(projectRoot, env);
+  return {
+    alias: selected?.alias ?? "local",
+    kind: selected ? "remote" : "local",
+    projectRoot,
+    status: "ready",
+    taskSource: config.taskSource.kind
+  };
+}
+function runningFromCompiledBinary() {
+  return import.meta.url.includes("$bunfs");
+}
+function resolveRigRunBin() {
+  if (runningFromCompiledBinary())
+    return resolve(dirname(process.execPath), "rig-run");
+  return resolve(dirname(fileURLToPath(import.meta.url)), "../../../rig-host/bin/rig-run.ts");
+}
+async function defaultRunRunProcess(input) {
+  const { runRunProcess } = await import("@rig/rig-host");
+  return await runRunProcess(input);
+}
+function shellQuote(value) {
+  return `'${value.replace(/'/g, "'\\''")}'`;
+}
+function readProjectSlug(projectRoot) {
+  const connection = readJsonRecord(resolve(projectRoot, ".rig", "state", "connection.json"));
+  return stringField(connection?.project) ?? null;
+}
+function resolveProjectOriginUrl(projectRoot) {
+  const slug = readProjectSlug(projectRoot);
+  return slug && /^[^/]+\/[^/]+$/.test(slug) ? `https://github.com/${slug}.git` : null;
+}
+async function spawnRunProcess(input, deps = {}) {
+  const runId = (deps.uuid ?? randomUUID)();
+  const env = deps.env ?? process.env;
+  const identityEnv = publicIdentityEnv(input.projectRoot);
+  const selected = resolveSelectedRemote(input.projectRoot, env);
+  const sshTarget = selected?.sshTarget ?? env.RIG_REMOTE_ALIAS?.trim();
+  if (sshTarget) {
+    const namespaceKey = identityEnv.RIG_GITHUB_NAMESPACE_KEY ?? resolveOwnerNamespaceKey(input.projectRoot, env) ?? "";
+    const sh = shellQuote;
+    const originUrl = resolveProjectOriginUrl(input.projectRoot);
+    const repoName = (readProjectSlug(input.projectRoot)?.split("/").pop() ?? "project").replace(/[^A-Za-z0-9._-]/g, "-");
+    const checkoutExpr = selected?.checkout ? sh(selected.checkout) : `"$HOME/.rig/checkouts/${repoName}"`;
+    const identityAssignments = Object.entries(identityEnv).map(([k, v]) => `${k}=${sh(v)}`);
+    if (namespaceKey && !identityEnv.RIG_GITHUB_NAMESPACE_KEY)
+      identityAssignments.push(`RIG_GITHUB_NAMESPACE_KEY=${sh(namespaceKey)}`);
+    const runInvocation = [
+      `RIG_RUN_ID=${sh(runId)}`,
+      `RIG_TASK_ID=${sh(input.taskId)}`,
+      ...identityAssignments,
+      selected?.registryBaseUrl ? `RIG_REGISTRY_URL=${sh(selected.registryBaseUrl)}` : "",
+      `rig run start --task ${sh(input.taskId)}`
+    ].filter(Boolean).join(" ");
+    const provisionAndRun = [
+      "set -e",
+      `CHECKOUT=${checkoutExpr}`,
+      originUrl ? `[ -d "$CHECKOUT/.git" ] || git clone ${sh(originUrl)} "$CHECKOUT"` : `[ -d "$CHECKOUT/.git" ] || { echo "rig: remote checkout $CHECKOUT missing and no origin to clone" >&2; exit 1; }`,
+      `cd "$CHECKOUT"`,
+      "git fetch origin --prune --quiet || true",
+      runInvocation
+    ].join("; ");
+    const child = (deps.spawn ?? nodeSpawn)("ssh", [sshTarget, `bash -lc ${sh(provisionAndRun)}`], {
+      cwd: input.projectRoot,
+      env: { ...env, ...identityEnv },
+      detached: true,
+      stdio: "ignore"
+    });
+    child.unref();
+    return { runId };
+  }
+  await (deps.runRunProcess ?? defaultRunRunProcess)({
+    projectRoot: input.projectRoot,
+    taskId: input.taskId,
+    runId,
+    title: input.title,
+    rigRunBin: (deps.resolveRigRunBin ?? resolveRigRunBin)()
+  });
+  return { runId };
+}
+function buildRemoteControlCommand(runId, control, ctx) {
+  const verb = control.kind === "stop" ? `rig run stop ${shellQuote(runId)}${control.reason.trim() ? ` --reason ${shellQuote(control.reason)}` : ""}` : `rig run steer ${shellQuote(runId)} --message ${shellQuote(control.message)}`;
+  return [
+    ctx.checkout ? `cd ${shellQuote(ctx.checkout)} &&` : "",
+    ctx.namespaceKey ? `RIG_GITHUB_NAMESPACE_KEY=${shellQuote(ctx.namespaceKey)}` : "",
+    ctx.registryBaseUrl ? `RIG_REGISTRY_URL=${shellQuote(ctx.registryBaseUrl)}` : "",
+    verb
+  ].filter(Boolean).join(" ");
+}
+async function deliverRemoteRunControl(projectRoot, runId, control, deps = {}) {
+  const env = deps.env ?? process.env;
+  const selected = resolveSelectedRemote(projectRoot, env);
+  const sshTarget = selected?.sshTarget ?? env.RIG_REMOTE_ALIAS?.trim();
+  if (!sshTarget) {
+    throw new Error(`Run ${runId} is remote but no SSH target is configured (set one with \`rig server use <alias>\`).`);
+  }
+  const identityEnv = publicIdentityEnv(projectRoot);
+  const namespaceKey = identityEnv.RIG_GITHUB_NAMESPACE_KEY ?? resolveOwnerNamespaceKey(projectRoot, env) ?? "";
+  const remoteCommand = buildRemoteControlCommand(runId, control, {
+    checkout: selected?.checkout ?? null,
+    registryBaseUrl: selected?.registryBaseUrl ?? null,
+    namespaceKey
+  });
+  await new Promise((resolveDone, rejectDone) => {
+    const child = (deps.spawn ?? nodeSpawn)("ssh", [sshTarget, `bash -lc ${shellQuote(remoteCommand)}`], {
+      cwd: projectRoot,
+      env: { ...env, ...identityEnv },
+      stdio: ["ignore", "ignore", "pipe"]
+    });
+    let stderr = "";
+    child.stderr?.on("data", (chunk) => {
+      stderr += String(chunk);
+    });
+    child.on("error", rejectDone);
+    child.on("close", (code) => {
+      if (code === 0) {
+        resolveDone();
+        return;
+      }
+      const detail = stderr.trim();
+      rejectDone(new Error(`remote \`rig run ${control.kind}\` exited ${code ?? "null"}${detail ? `: ${detail}` : ""}`));
+    });
+  });
+}
+function registrySecret(env = process.env) {
+  return resolveRegistrySecret(process.cwd(), env) ?? null;
+}
+function registryBaseUrl(env = process.env) {
+  return resolveRegistryBaseUrl(process.cwd(), env);
+}
+function collabFromRegistryEntry(entry) {
+  return {
+    sessionId: entry.roomId,
+    sessionPath: "",
+    cwd: "",
+    title: entry.title,
+    joinLink: entry.joinLink,
+    webLink: entry.webLink,
+    relayUrl: entry.relayUrl,
+    owner: entry.owner,
+    selectedRepo: entry.repo,
+    startedAt: entry.startedAt,
+    updatedAt: entry.heartbeatAt,
+    ...entry.pid === undefined ? {} : { pid: entry.pid },
+    stale: entry.stale
+  };
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+function readLocalRunCollab(runtime) {
+  if (!runtime.sessionDir || !existsSync(runtime.sessionDir))
+    return null;
+  let files;
+  try {
+    files = readdirSync(runtime.sessionDir).filter((f) => f.endsWith(".jsonl")).sort().reverse();
+  } catch {
+    return null;
+  }
+  for (const file of files) {
+    let lines;
+    try {
+      lines = readFileSync(resolve(runtime.sessionDir, file), "utf8").split(`
+`);
+    } catch {
+      continue;
+    }
+    let host = null;
+    for (const line of lines) {
+      if (!line.includes("collab-host-started"))
+        continue;
+      let entry;
+      try {
+        entry = JSON.parse(line);
+      } catch {
+        continue;
+      }
+      if (!isRecord(entry) || entry.customType !== CUSTOM_TYPE_FOR["timeline-entry"] || !isRecord(entry.data))
+        continue;
+      const payload = isRecord(entry.data.payload) ? entry.data.payload : entry.data;
+      if (payload.type !== "collab-host-started")
+        continue;
+      host = {
+        roomId: typeof payload.roomId === "string" ? payload.roomId : undefined,
+        joinLink: typeof payload.joinLink === "string" ? payload.joinLink : undefined,
+        webLink: typeof payload.webLink === "string" ? payload.webLink : undefined,
+        relayUrl: typeof payload.relayUrl === "string" ? payload.relayUrl : undefined,
+        at: typeof entry.data.at === "string" ? entry.data.at : undefined
+      };
+    }
+    if (!host?.joinLink)
+      continue;
+    const at = host.at ?? "";
+    const sessionId = host.roomId ?? sessionIdFromSessionFile(resolve(runtime.sessionDir, file)) ?? runtime.id;
+    return {
+      sessionId,
+      sessionPath: resolve(runtime.sessionDir, file),
+      cwd: runtime.workspaceDir,
+      joinLink: host.joinLink,
+      webLink: host.webLink ?? "",
+      relayUrl: host.relayUrl ?? "",
+      title: runtime.taskId ? `[${runtime.taskId}] Rig run ${sessionId}` : `Rig run ${sessionId}`,
+      startedAt: at,
+      updatedAt: at,
+      stale: false
+    };
+  }
+  return null;
+}
+async function listLocalRunCollabSessions(projectRoot) {
+  let runtimes;
+  try {
+    runtimes = await listAgentRuntimes(projectRoot);
+  } catch {
+    return [];
+  }
+  const out = [];
+  for (const runtime of runtimes) {
+    const collab = readLocalRunCollab(runtime);
+    if (collab)
+      out.push(collab);
+  }
+  return out;
+}
+async function listActiveRunCollab(filter) {
+  return defaultListActiveCollabSessions(filter);
+}
+async function defaultListActiveCollabSessions(filter) {
+  const projectRoot = process.cwd();
+  const local = await listLocalRunCollabSessions(projectRoot);
+  const namespaceKey = filter.namespaceKey ?? resolveOwnerNamespaceKey(projectRoot);
+  const secret = registrySecret();
+  const remote = namespaceKey && secret ? (await createRegistryClient({ baseUrl: registryBaseUrl(), namespaceKey, secret }).listRoomsByOwner(filter)).map(collabFromRegistryEntry) : await ompListActiveCollabSessions(filter);
+  const seen = new Set(local.map((c) => c.sessionId));
+  return [...local, ...remote.filter((c) => !seen.has(c.sessionId))];
+}
+function sleep(ms) {
+  const { promise, resolve: resolveSleep } = Promise.withResolvers();
+  setTimeout(resolveSleep, ms);
+  return promise;
+}
+function matchesRun(collab, runId, taskId) {
+  if (collab.sessionId === runId)
+    return true;
+  if (runId && collab.title?.includes(runId))
+    return true;
+  return Boolean(taskId && collab.title?.includes(taskId));
+}
+async function attachViaRelay(input, deps = {}) {
+  const timeoutMs = input.timeoutMs ?? DEFAULT_ATTACH_TIMEOUT_MS;
+  const pollIntervalMs = input.pollIntervalMs ?? DEFAULT_ATTACH_POLL_INTERVAL_MS;
+  const listActive = deps.listActiveCollabSessions ?? defaultListActiveCollabSessions;
+  const now = deps.now ?? Date.now;
+  const pause = deps.sleep ?? sleep;
+  const deadline = now() + timeoutMs;
+  do {
+    const live = await listActive(input.identityFilter);
+    const match = live.find((collab) => matchesRun(collab, input.runId, input.taskId) && !collab.stale);
+    if (match) {
+      return {
+        sessionPath: match.sessionPath || null,
+        joinLink: match.joinLink || null,
+        collabSessionId: match.sessionId
+      };
+    }
+    if (now() >= deadline)
+      break;
+    await pause(pollIntervalMs);
+  } while (now() <= deadline);
+  return null;
+}
+export {
+  spawnRunProcess,
+  resolveRigRunBin,
+  readSelectedTarget,
+  listTasksFromSource,
+  listActiveRunCollab,
+  getTaskFromSource,
+  deliverRemoteRunControl,
+  buildRemoteControlCommand,
+  attachViaRelay
+};

package/dist/src/commands/_run-diagnostics.d.ts

@@ -0,0 +1,9 @@
+import type { RunJournalProjection } from "@rig/contracts";
+/**
+ * Extract the most useful human-facing failure diagnostic from the folded run journal.
+ *
+ * The live projection deliberately does not retain log/timeline lines, so this mirrors the
+ * deleted server-side categorization using only fields that survive folding: record fields,
+ * status reasons, closeout details, and reducer anomalies.
+ */
+export declare function summarizeUsefulRunError(projection: RunJournalProjection): string | null;

package/dist/src/commands/_run-diagnostics.js

@@ -0,0 +1,51 @@
+// @bun
+// packages/cli/src/commands/_run-diagnostics.ts
+function normalizeString(value) {
+  if (typeof value !== "string")
+    return null;
+  const normalized = value.replace(/\s+/g, " ").trim();
+  return normalized.length > 0 ? normalized : null;
+}
+function isGenericRunFailure(value) {
+  const text = normalizeString(value);
+  return Boolean(text && /^Task run failed \([^)]*\)$/i.test(text));
+}
+function appendCandidate(candidates, value) {
+  const text = normalizeString(value);
+  if (text && !candidates.includes(text))
+    candidates.push(text);
+}
+function categorizeUsefulRunError(lines) {
+  const taskSourceFailure = lines.find((line) => /failed to update task source/i.test(line));
+  if (taskSourceFailure)
+    return `Task source update failed: ${taskSourceFailure}`;
+  const moduleFailure = lines.find((line) => /cannot find module/i.test(line));
+  if (moduleFailure)
+    return `Runtime module resolution failed: ${moduleFailure}`;
+  const providerFailure = lines.find((line) => /no api key found|unauthorized|authentication failed|invalid api key/i.test(line));
+  if (providerFailure)
+    return `Provider authentication failed: ${providerFailure}`;
+  return null;
+}
+function summarizeUsefulRunError(projection) {
+  if (projection.status !== "failed")
+    return null;
+  const candidates = [];
+  for (const anomaly of projection.anomalies) {
+    appendCandidate(candidates, `Journal anomaly (${anomaly.kind}): ${anomaly.detail}`);
+  }
+  for (const phase of projection.closeoutPhases) {
+    if (phase.outcome === "failed")
+      appendCandidate(candidates, phase.detail);
+  }
+  for (const entry of projection.statusHistory) {
+    appendCandidate(candidates, entry.reason);
+  }
+  appendCandidate(candidates, projection.record.statusDetail);
+  appendCandidate(candidates, projection.record.errorText);
+  const nonGeneric = candidates.filter((candidate) => !isGenericRunFailure(candidate));
+  return categorizeUsefulRunError(nonGeneric) ?? nonGeneric.at(-1) ?? normalizeString(projection.record.errorText);
+}
+export {
+  summarizeUsefulRunError
+};

package/dist/src/commands/_run-driver-helpers.d.ts

@@ -1,5 +1,3 @@
-import { type AuthorityRunPatch, type AuthorityRunRecord } from "@rig/runtime/control-plane/authority-files";
-import type { RunStatus } from "@rig/contracts";
 export type SourceTaskContract = {
     id: string;
     title?: string | null;
@@ -11,89 +9,18 @@ export type SourceTaskContract = {
     status?: string | null;
     issueType?: string | null;
     role?: string | null;
-    externalRef?: string | null;
-    scope?: readonly string[];
-    validation?: readonly string[];
-    validators?: readonly string[];
-    labels?: readonly string[];
+    validation?: string[];
+    validators?: string[];
+    labels?: string[];
+    scope?: string[];
 };
-export declare function patchAuthorityRun(projectRoot: string, runId: string, patch: AuthorityRunPatch): AuthorityRunRecord;
-/**
- * THE status mutation on the CLI driver side: transition-checked and
- * journaled as a status-changed event (see @rig/contracts run-journal).
- */
-export declare function setRunStatusOrFail(projectRoot: string, runId: string, to: RunStatus, options?: {
-    reason?: string | null;
-    errorText?: string | null;
-}): AuthorityRunRecord;
-export declare function touchAuthorityRun(projectRoot: string, runId: string): void;
-export declare function appendRunTimeline(projectRoot: string, runId: string, value: Record<string, unknown>): void;
-export declare function appendRunLog(projectRoot: string, runId: string, value: Record<string, unknown>): void;
-type RunActionInput = {
-    id: string;
-    actionType: string;
-    title: string;
-    detail?: string | null;
-    state: "running" | "completed" | "failed";
-    startedAt: string;
-    completedAt?: string | null;
-    payload?: Record<string, unknown>;
-};
-export declare function appendRunAction(projectRoot: string, runId: string, value: RunActionInput): void;
-export type RunActionHandle = {
-    startedAt: string;
-    complete: (detail?: string | null, payload?: Record<string, unknown>) => void;
-    fail: (detail: string, payload?: Record<string, unknown>) => void;
-};
-export declare function startRunAction(projectRoot: string, runId: string, input: {
-    actionId: string;
-    actionType: string;
-    title: string;
-    detail?: string | null;
-    payload?: Record<string, unknown>;
-}): RunActionHandle;
-export type RunEvent = {
-    type: "status";
-    runId: string;
-    status: string;
-    detail?: string | null;
-    sessionId?: string | null;
-} | {
-    type: "timeline";
-    runId: string;
-} | {
-    type: "log";
-    runId: string;
-    title?: string;
-} | {
-    type: "completed";
-    runId: string;
-} | {
-    type: "failed";
-    runId: string;
-    error: string;
-};
-/**
- * Route emitServerRunEvent through the run.jsonl lifecycle log + doorbell in
- * addition to stdout. Called once at the start of executeRigOwnedTaskRun.
- */
-export declare function configureRunEventSink(projectRoot: string): void;
-/**
- * Print a parseable status line to stdout that the server's spawn-and-watch
- * path reads to update its own state. Format: `__RIG_RUN_EVENT__<json>`.
- *
- * When `configureRunEventSink` has run, the same event is also appended to
- * the run's `run.jsonl` lifecycle log and the server doorbell is rung.
- */
-export declare function emitServerRunEvent(event: RunEvent): void;
 export declare function buildRunPrompt(input: {
     projectRoot: string;
-    taskId?: string;
-    fallbackTitle?: string | null;
-    fallbackDescription?: string | null;
-    fallbackAcceptanceCriteria?: string | null;
+    taskId?: string | undefined;
+    fallbackTitle?: string | undefined;
+    fallbackDescription?: string | undefined;
+    fallbackAcceptanceCriteria?: string | undefined;
     sourceTask?: SourceTaskContract | null;
     initialPrompt?: string;
     runtimeAdapter: "claude-code" | "codex" | "pi";
 }): string;
-export {};