@h-rig/run-plugin 0.0.6-alpha.186

package/dist/src/read-model/reconcile.d.ts

@@ -0,0 +1,23 @@
+import { type IdentityRegistryFilter, type RunReadModelReconcileInput, type RunReadModelReconcileResult, type RunSessionJournalWriterService } from "@rig/contracts";
+export type CollabSessionProjectionLike = {
+    readonly runId?: string;
+    readonly source?: string;
+    readonly customEntries: unknown;
+    readonly session: {
+        readonly path: string;
+        readonly id?: string;
+    };
+    readonly collab?: {
+        readonly sessionId?: string;
+        readonly stale?: boolean;
+        readonly pid?: number;
+        readonly sessionPath?: string;
+    };
+};
+type ReconcileDeps = {
+    readonly listCollabSessionProjections?: (filter: IdentityRegistryFilter) => Promise<readonly CollabSessionProjectionLike[]>;
+    readonly journalWriter?: RunSessionJournalWriterService;
+    readonly processExists?: (pid: number) => boolean;
+};
+export declare function reconcileActiveRuns(input: RunReadModelReconcileInput, deps?: ReconcileDeps): Promise<RunReadModelReconcileResult>;
+export {};

package/dist/src/read-model/reconcile.js

@@ -0,0 +1,306 @@
+// @bun
+var __require = import.meta.require;
+
+// packages/run-plugin/src/read-model/reconcile.ts
+import { defineCapability } from "@rig/core/capability";
+import { loadCapabilityForRoot } from "@rig/core/capability-loaders";
+import {
+  RUN_SESSION_JOURNAL_WRITER
+} from "@rig/contracts";
+
+// packages/run-plugin/src/read-model/session-journal.ts
+import { Schema } from "effect";
+import {
+  CUSTOM_TYPE_FOR,
+  RIG_CONTROL_SENTINEL_END,
+  RIG_INBOX_RESOLUTION_SENTINEL,
+  RIG_PAUSE_SENTINEL,
+  RIG_RESUME_SENTINEL,
+  RIG_STOP_SENTINEL,
+  RIG_STOP_SENTINEL_END,
+  RunJournalEvent,
+  TYPE_FOR_CUSTOM
+} from "@rig/contracts";
+var decodeRunJournalEvent = (value) => Schema.decodeUnknownSync(RunJournalEvent)(value);
+var RUN_STATUS_TRANSITIONS = {
+  created: ["queued", "preparing", "running", "failed", "stopped"],
+  queued: ["preparing", "running", "failed", "stopped"],
+  preparing: ["queued", "running", "needs-attention", "failed", "stopped"],
+  running: [
+    "queued",
+    "waiting-approval",
+    "waiting-user-input",
+    "paused",
+    "validating",
+    "reviewing",
+    "closing-out",
+    "needs-attention",
+    "completed",
+    "failed",
+    "stopped"
+  ],
+  "waiting-approval": ["running", "needs-attention", "failed", "stopped"],
+  "waiting-user-input": ["running", "needs-attention", "failed", "stopped"],
+  paused: ["running", "failed", "stopped"],
+  validating: ["running", "reviewing", "closing-out", "needs-attention", "completed", "failed", "stopped"],
+  reviewing: ["running", "validating", "closing-out", "needs-attention", "completed", "failed", "stopped"],
+  "closing-out": ["running", "needs-attention", "completed", "failed", "stopped"],
+  "needs-attention": ["queued", "preparing", "running", "closing-out", "completed", "failed", "stopped"],
+  completed: [],
+  failed: ["queued", "preparing", "running", "closing-out"],
+  stopped: ["queued", "preparing", "running", "closing-out"]
+};
+var TERMINAL_RUN_STATUSES = ["completed", "failed", "stopped"];
+function isTerminalRunStatus(status) {
+  return TERMINAL_RUN_STATUSES.includes(status);
+}
+function canTransitionRunStatus(from, to) {
+  if (from === null)
+    return true;
+  if (from === to)
+    return true;
+  return RUN_STATUS_TRANSITIONS[from].includes(to);
+}
+function reduceRunJournal(events, runId = null) {
+  let record = {};
+  let status = null;
+  const statusHistory = [];
+  const pendingApprovals = new Map;
+  const resolvedApprovals = [];
+  const pendingUserInputs = new Map;
+  const resolvedUserInputs = [];
+  const closeoutPhases = [];
+  let resolvedPipeline = null;
+  const stageOutcomes = [];
+  const anomalies = [];
+  let steeringCount = 0;
+  let stallCount = 0;
+  let lastSeq = 0;
+  let lastEventAt = null;
+  const projectedRunId = runId ?? events[0]?.runId ?? null;
+  for (const event of events) {
+    lastSeq = event.seq;
+    lastEventAt = event.at;
+    switch (event.type) {
+      case "status-changed": {
+        if (!canTransitionRunStatus(status, event.to)) {
+          anomalies.push({ seq: event.seq, kind: "illegal-transition", detail: `${status ?? "(none)"} -> ${event.to}` });
+        }
+        statusHistory.push({ seq: event.seq, at: event.at, from: status, to: event.to, reason: event.reason ?? null });
+        const wasTerminal = status !== null && isTerminalRunStatus(status);
+        status = event.to;
+        record = { ...record, updatedAt: event.at };
+        if (isTerminalRunStatus(event.to) && !record.completedAt)
+          record = { ...record, completedAt: event.at };
+        if (!isTerminalRunStatus(event.to) && wasTerminal)
+          record = { ...record, completedAt: null };
+        if (event.to === "running" && !record.startedAt)
+          record = { ...record, startedAt: event.at };
+        break;
+      }
+      case "record-patch": {
+        const next = { ...record };
+        for (const [key, value] of Object.entries(event.patch)) {
+          if (value !== undefined)
+            next[key] = value;
+        }
+        next.updatedAt = event.patch.updatedAt ?? event.at;
+        record = next;
+        break;
+      }
+      case "approval-requested": {
+        pendingApprovals.set(event.requestId, {
+          requestId: event.requestId,
+          requestKind: event.requestKind,
+          actionId: event.actionId ?? null,
+          payload: event.payload,
+          requestedAt: event.at
+        });
+        break;
+      }
+      case "approval-resolved": {
+        const pending = pendingApprovals.get(event.requestId);
+        if (!pending) {
+          const alreadyResolved = resolvedApprovals.some((entry) => entry.requestId === event.requestId);
+          anomalies.push({ seq: event.seq, kind: alreadyResolved ? "duplicate-resolution" : "unknown-request", detail: `approval ${event.requestId}` });
+          break;
+        }
+        pendingApprovals.delete(event.requestId);
+        resolvedApprovals.push({ ...pending, decision: event.decision, note: event.note ?? null, actor: event.actor, resolvedAt: event.at });
+        break;
+      }
+      case "input-requested": {
+        pendingUserInputs.set(event.requestId, {
+          requestId: event.requestId,
+          requestKind: "user-input",
+          actionId: null,
+          payload: event.payload,
+          requestedAt: event.at
+        });
+        break;
+      }
+      case "input-resolved": {
+        const pending = pendingUserInputs.get(event.requestId);
+        if (!pending) {
+          const alreadyResolved = resolvedUserInputs.some((entry) => entry.requestId === event.requestId);
+          anomalies.push({ seq: event.seq, kind: alreadyResolved ? "duplicate-resolution" : "unknown-request", detail: `user-input ${event.requestId}` });
+          break;
+        }
+        pendingUserInputs.delete(event.requestId);
+        resolvedUserInputs.push({ ...pending, answers: event.answers, actor: event.actor, resolvedAt: event.at });
+        break;
+      }
+      case "steering":
+        steeringCount += 1;
+        break;
+      case "adopted":
+        record = { ...record, pid: event.pid, updatedAt: event.at };
+        break;
+      case "stall-detected":
+        stallCount += 1;
+        break;
+      case "closeout-phase":
+        closeoutPhases.push({ seq: event.seq, at: event.at, phase: event.phase, outcome: event.outcome, detail: event.detail ?? null });
+        break;
+      case "pipeline-resolved":
+        resolvedPipeline = event.pipeline;
+        break;
+      case "stage-outcome":
+        stageOutcomes.push({ seq: event.seq, at: event.at, outcome: event.outcome });
+        break;
+      case "timeline-entry":
+      case "log-entry":
+        break;
+    }
+  }
+  return {
+    runId: projectedRunId,
+    record,
+    status,
+    statusHistory,
+    pendingApprovals: [...pendingApprovals.values()],
+    resolvedApprovals,
+    pendingUserInputs: [...pendingUserInputs.values()],
+    resolvedUserInputs,
+    steeringCount,
+    stallCount,
+    closeoutPhases,
+    resolvedPipeline,
+    stageOutcomes,
+    lastSeq,
+    lastEventAt,
+    anomalies
+  };
+}
+function isRunSessionCustomType(customType) {
+  return customType !== undefined && Object.hasOwn(TYPE_FOR_CUSTOM, customType);
+}
+function foldRunSessionEntries(entries, runId) {
+  const events = [];
+  entries.forEach((entry, index) => {
+    if (entry.type !== "custom" || !isRunSessionCustomType(entry.customType))
+      return;
+    const data = entry.data !== null && typeof entry.data === "object" ? entry.data : {};
+    const stamped = {
+      v: 1,
+      seq: index + 1,
+      at: typeof data.at === "string" ? data.at : new Date(0).toISOString(),
+      runId,
+      ...data,
+      type: TYPE_FOR_CUSTOM[entry.customType]
+    };
+    try {
+      events.push(decodeRunJournalEvent(stamped));
+    } catch {}
+  });
+  return reduceRunJournal(events, runId);
+}
+function projectRunFromSession(source, runId) {
+  const entries = "getEntries" in source ? source.getEntries() : source;
+  return foldRunSessionEntries(entries, runId);
+}
+
+// packages/run-plugin/src/read-model/reconcile.ts
+var RunSessionJournalWriterCap = defineCapability(RUN_SESSION_JOURNAL_WRITER);
+var collabApiPromise = null;
+async function loadCollabApi() {
+  collabApiPromise ??= import("@oh-my-pi/pi-coding-agent/collab-api").then((api) => api).catch(() => null);
+  return collabApiPromise;
+}
+var ACTIVE_LOCAL_RUN_STATUSES = new Set([
+  "created",
+  "preparing",
+  "running",
+  "validating",
+  "reviewing",
+  "closing-out"
+]);
+function pidExists(pid) {
+  if (!Number.isInteger(pid) || pid <= 0)
+    return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function projectionRunId(item) {
+  if (item.runId?.trim())
+    return item.runId.trim();
+  if (item.collab?.sessionId?.trim())
+    return item.collab.sessionId.trim();
+  if (item.session.id?.trim())
+    return item.session.id.trim();
+  return null;
+}
+function isLocallyDiscovered(item) {
+  return item.source === "session-list";
+}
+function isActiveStatus(status) {
+  if (status === null)
+    return false;
+  return !isTerminalRunStatus(status);
+}
+function shouldFlip(item, status, exists) {
+  if (!isActiveStatus(status))
+    return false;
+  if (item.collab?.stale === true)
+    return true;
+  const pid = item.collab?.pid;
+  return isLocallyDiscovered(item) && pid !== undefined && ACTIVE_LOCAL_RUN_STATUSES.has(status) && !exists(pid);
+}
+async function reconcileActiveRuns(input, deps = {}) {
+  const collabApi = deps.listCollabSessionProjections ? null : await loadCollabApi();
+  const listProjections = deps.listCollabSessionProjections ?? collabApi?.listCollabSessionProjections;
+  const journalWriter = deps.journalWriter ?? await loadCapabilityForRoot(input.workspaceRoot, RunSessionJournalWriterCap);
+  if (!journalWriter)
+    return { flipped: [], resumable: [] };
+  const exists = deps.processExists ?? pidExists;
+  if (!listProjections)
+    return { flipped: [], resumable: [] };
+  const projections = await listProjections(input.identityFilter);
+  const flipped = [];
+  for (const item of projections) {
+    const runId = projectionRunId(item);
+    const sessionPath = item.session.path || item.collab?.sessionPath || "";
+    if (!runId || !sessionPath)
+      continue;
+    const projection = projectRunFromSession(item.customEntries, runId);
+    const status = projection.status;
+    if (status === null || !shouldFlip(item, status, exists))
+      continue;
+    const result = await journalWriter.reconcileDeadPid({
+      projectRoot: input.workspaceRoot,
+      runId,
+      sessionPath,
+      reason: "lazy-reconcile:dead-pid"
+    });
+    if (result.updated)
+      flipped.push({ runId, sessionPath, reason: "lazy-reconcile:dead-pid" });
+  }
+  return { flipped, resumable: flipped };
+}
+export {
+  reconcileActiveRuns
+};

package/dist/src/read-model/run-format.d.ts

@@ -0,0 +1,23 @@
+import type { RunPresentationRecord, RunReadModelStatusRole } from "@rig/contracts";
+export type CliRunLike = RunPresentationRecord;
+export declare function formatStatusPill(status: string, role: RunReadModelStatusRole | null): string;
+export declare function formatRunList(runs: readonly CliRunLike[], options?: {
+    source?: "local" | "server";
+}): string;
+export declare function formatSubmittedRun(input: {
+    runId: string;
+    taskId?: string | null;
+    title?: string | null;
+    queuePosition?: number | null;
+}): string;
+export declare function formatRunCard(run: CliRunLike, options?: {
+    title?: string;
+}): string;
+export declare function formatRunStatus(summary: {
+    activeRuns?: CliRunLike[];
+    recentRuns?: CliRunLike[];
+    runs?: CliRunLike[];
+}, options?: {
+    source?: "local" | "server";
+}): string;
+export declare function formatInboxList(kind: "approvals" | "inputs", entries: readonly Record<string, unknown>[]): string;

package/dist/src/read-model/run-format.js

@@ -0,0 +1,202 @@
+// @bun
+// packages/run-plugin/src/read-model/run-format.ts
+import pc from "picocolors";
+import { formatSection, formatSuccessCard, formatNextSteps } from "@rig/std-shared/cli-format";
+var dim = pc.dim;
+var faintBar = pc.dim("\u2502");
+var accent = pc.cyan;
+var STATUS_ROLES = new Set([
+  "success",
+  "action-yellow",
+  "active-cyan",
+  "failure",
+  "muted",
+  "neutral"
+]);
+function projectedStatusRole(value) {
+  return typeof value === "string" && STATUS_ROLES.has(value) ? value : null;
+}
+function truncate(value, width) {
+  return value.length <= width ? value : `${value.slice(0, Math.max(0, width - 1))}\u2026`;
+}
+function pad(value, width) {
+  return value.length >= width ? value : `${value}${" ".repeat(width - value.length)}`;
+}
+function colorForRole(role) {
+  switch (role) {
+    case "success":
+      return pc.green;
+    case "action-yellow":
+      return pc.yellow;
+    case "active-cyan":
+      return pc.cyan;
+    case "failure":
+      return pc.red;
+    case "muted":
+    case "neutral":
+      return pc.dim;
+  }
+}
+function inboxStatusRole(record) {
+  const projected = projectedStatusRole(record.statusRole);
+  if (projected)
+    return projected;
+  return record.status === "pending" ? "active-cyan" : "neutral";
+}
+function compactDate(value) {
+  const parsed = Date.parse(value);
+  if (!Number.isFinite(parsed))
+    return value;
+  return new Date(parsed).toISOString().replace("T", " ").replace(/\.\d{3}Z$/, "Z");
+}
+function firstString(record, keys, fallback = "") {
+  for (const key of keys) {
+    const value = record[key];
+    if (typeof value === "string" && value.trim())
+      return value;
+  }
+  return fallback;
+}
+function runIdOf(run) {
+  return firstString(run, ["runId", "id"], "(unknown-run)");
+}
+function taskIdOf(run) {
+  return firstString(run, ["taskId", "task", "task_id"]);
+}
+function runTitleOf(run) {
+  return firstString(run, ["title", "summary", "name"], taskIdOf(run) || "(untitled)");
+}
+function requestIdOf(entry) {
+  return firstString(entry, ["requestId", "id", "approvalId", "inputId"], "(unknown-request)");
+}
+function runLikeStatusText(run) {
+  const record = run;
+  const status = typeof record.status === "string" ? record.status.trim() : "";
+  return status || "unclassified";
+}
+function runLikeStatusColor(run) {
+  const record = run;
+  return colorForRole(projectedStatusRole(record.statusRole) ?? "neutral");
+}
+function formatStatusPill(status, role) {
+  const label = status || "unclassified";
+  return colorForRole(role ?? "neutral")(`\u25CF ${label}`);
+}
+function formatLegacyAutomationSurface() {
+  return [];
+}
+function formatRunList(runs, options = {}) {
+  if (runs.length === 0) {
+    return [
+      formatSection("Runs", "none recorded"),
+      options.source === "server" ? dim("No runs recorded on the selected server.") : dim("No runs recorded in local state."),
+      "",
+      ...formatLegacyAutomationSurface()
+    ].join(`
+`);
+  }
+  const body = runs.map((run) => {
+    const row = run;
+    const runId = runIdOf(row);
+    const status = runLikeStatusText(run);
+    const runtime = firstString(row, ["runtime", "runtimeAdapter"], "");
+    return [
+      pc.bold(runId),
+      runLikeStatusColor(run)(pad(truncate(status, 12), 12)),
+      `${runTitleOf(row)}${runtime ? dim(`  ${runtime}`) : ""}`
+    ].join("  ");
+  });
+  return [formatSection("Runs", options.source === "server" ? "selected server" : "local state"), ...body, "", ...formatLegacyAutomationSurface()].join(`
+`);
+}
+function formatSubmittedRun(input) {
+  return formatSuccessCard("Run submitted", [
+    ["run", input.runId],
+    ["task", input.taskId ?? undefined],
+    ["title", input.title ?? undefined],
+    ["queue", input.queuePosition ?? undefined]
+  ]);
+}
+function formatRunCard(run, options = {}) {
+  const record = run;
+  const lines = [formatSection(options.title ?? "Run")];
+  for (const [label, value] of [
+    ["run", runIdOf(record)],
+    ["task", taskIdOf(record)],
+    ["title", runTitleOf(record)],
+    ["status", runLikeStatusText(run)],
+    ["runtime", firstString(record, ["runtime", "runtimeAdapter"], "")],
+    ["created", firstString(record, ["createdAt"], "")],
+    ["updated", firstString(record, ["updatedAt"], "")]
+  ]) {
+    if (value)
+      lines.push(`${faintBar} ${dim(label.padEnd(12))} ${label === "status" ? runLikeStatusColor(run)(value) : label === "created" || label === "updated" ? compactDate(value) : value}`);
+  }
+  const errorSummary = firstString(record, ["errorSummary"]);
+  if (errorSummary)
+    lines.push(`${faintBar} Error: ${errorSummary}`);
+  return lines.join(`
+`);
+}
+function formatRunStatus(summary, options = {}) {
+  const activeRuns = summary.activeRuns ?? [];
+  const recentRuns = summary.recentRuns ?? [];
+  const lines = [formatSection("Run status", options.source === "server" ? "selected server" : "local state")];
+  lines.push(`Active runs (${activeRuns.length})`);
+  if (activeRuns.length === 0)
+    lines.push(dim("No active runs."));
+  else
+    for (const run of activeRuns)
+      lines.push(formatRunSummaryLine(run));
+  lines.push("", `Recent runs (${recentRuns.length})`);
+  if (recentRuns.length === 0)
+    lines.push(dim("No recent terminal runs."));
+  else
+    for (const run of recentRuns.slice(0, 10))
+      lines.push(formatRunSummaryLine(run));
+  lines.push("", ...formatLegacyAutomationSurface());
+  return lines.join(`
+`);
+}
+function formatRunSummaryLine(run) {
+  const record = run;
+  const runId = runIdOf(record);
+  const taskId = taskIdOf(record);
+  const title = runTitleOf(record);
+  const status = runLikeStatusText(run);
+  const runtime = firstString(record, ["runtime", "runtimeAdapter"], "");
+  const descriptor = [taskId, title].filter(Boolean).join(" \xB7 ");
+  return `${faintBar} ${pc.bold(runId)} ${runLikeStatusColor(run)(`\u25CF ${status}`)} ${descriptor}${runtime ? dim(`  ${runtime}`) : ""}`;
+}
+function formatInboxList(kind, entries) {
+  const title = kind === "approvals" ? "Pending approvals" : "Pending user input";
+  if (entries.length === 0) {
+    return [
+      formatSection(title, "empty"),
+      dim(kind === "approvals" ? "No pending approvals." : "No pending user-input requests."),
+      "",
+      ...formatLegacyAutomationSurface()
+    ].join(`
+`);
+  }
+  const lines = [formatSection(title, `${entries.length}`)];
+  for (const record of entries) {
+    const runId = firstString(record, ["runId"], "(unknown-run)");
+    const taskId = firstString(record, ["taskId"], "");
+    const status = firstString(record, ["status"], "pending");
+    const prompt = firstString(record, ["prompt", "message", "reason", "title", "summary"], kind === "approvals" ? "Approval requested" : "Input requested");
+    lines.push(`${faintBar} ${pc.bold(requestIdOf(record))} ${formatStatusPill(status, inboxStatusRole(record))} ${prompt}`);
+    lines.push(`${faintBar} ${dim("run".padEnd(12))} ${runId}${taskId ? dim(`  task ${taskId}`) : ""}`);
+  }
+  lines.push("", ...formatLegacyAutomationSurface(), ...formatNextSteps(kind === "approvals" ? ["Resolve: `rig inbox approve --run <run-id> --request <request-id> --decision approve|reject`"] : ["Reply: `rig inbox answer --run <run-id> --request <request-id> --text ...`"]));
+  return lines.join(`
+`);
+}
+export {
+  formatSubmittedRun,
+  formatStatusPill,
+  formatRunStatus,
+  formatRunList,
+  formatRunCard,
+  formatInboxList
+};

package/dist/src/read-model/runs-screen.d.ts

@@ -0,0 +1,14 @@
+import type { CockpitBoardView, CockpitBoardViewHost } from "@rig/contracts";
+/**
+ * Width-truncation is injected: the real implementation is pi-tui's native
+ * `truncateToWidth` (ANSI/wide-char aware), whose `@oh-my-pi/pi-natives` loader
+ * is Bun-only (`import.meta.dir`) and unimportable under vitest. The panel's
+ * `createView` passes the real one; tests pass a plain slicer.
+ */
+export type WidthTruncate = (text: string, width: number) => string;
+/** pi-tui key matcher (handles the terminal escape encodings); injected for the same reason. */
+export type KeyMatcher = (data: string, key: "up" | "down" | "enter" | "return" | "escape") => boolean;
+export declare function createRunsBoardView(host: CockpitBoardViewHost, deps: {
+    truncateToWidth: WidthTruncate;
+    matchesKey: KeyMatcher;
+}): CockpitBoardView;