@h-rig/cli 0.0.6-alpha.80 → 0.0.6-alpha.81

package/dist/src/app/board.js

@@ -50,6 +50,7 @@ function statusColor(status) {
     case "validating":
     case "reviewing":
     case "closing-out":
+    case "stopping":
       return cyan;
     case "needs-attention":
     case "needs_attention":
@@ -951,7 +952,7 @@ async function loadTaskRunProjectDefaults(projectRoot) {
 
 // packages/cli/src/app/board.ts
 var BOARD_REFRESH_MS = 5000;
-var BOARD_TICK_MS = 250;
+var BOARD_TICK_MS = 16;
 var BOARD_TASK_PAGE = 20;
 function oneLine(message) {
   return message.split(`
@@ -974,6 +975,7 @@ function statusRank(status) {
     case "pending":
     case "preparing":
     case "adopted":
+    case "stopping":
       return 2;
     case "completed":
     case "merged":
@@ -1013,6 +1015,10 @@ class RunsList {
   selectedRun() {
     return this.visibleRuns()[this.selected] ?? null;
   }
+  patchRun(runId, patch) {
+    this.runs = this.runs.map((run) => run.runId === runId ? { ...run, ...patch } : run);
+    this.clampSelection();
+  }
   cycleSort() {
     this.sortMode = this.sortMode === "active" ? "recent" : this.sortMode === "recent" ? "status" : "active";
     this.clampSelection();
@@ -1235,6 +1241,14 @@ class InboxView {
   selectedItem() {
     return this.items[this.selected] ?? null;
   }
+  patchItem(requestId, summary) {
+    this.items = this.items.map((item) => item.requestId === requestId ? { ...item, summary } : item);
+  }
+  removeItem(requestId) {
+    const previousIndex = this.selected;
+    this.items = this.items.filter((item) => item.requestId !== requestId);
+    this.selected = Math.max(0, Math.min(previousIndex, Math.max(0, this.items.length - 1)));
+  }
   invalidate() {}
   render(width) {
     return this.renderLines(width).map((line) => truncateToWidth(line, Math.max(10, width - 1)));
@@ -1456,9 +1470,14 @@ async function runOperatorBoard(context, options = {}) {
     tui.stop();
   };
   let refreshInFlight = false;
-  const refresh = async () => {
+  const refresh = async (options2 = {}) => {
     if (refreshInFlight)
       return;
+    if (!options2.quiet) {
+      notice = "refreshing fleet\u2026";
+      renderFooter();
+      tui.requestRender();
+    }
     if (!hasRigProject(context.projectRoot)) {
       list.loading = false;
       list.noProject = true;
@@ -1541,6 +1560,7 @@ async function runOperatorBoard(context, options = {}) {
   };
   const resolveApproval = async (item, decision) => {
     notice = `${decision === "approve" ? "approving" : "rejecting"} ${item.requestId.slice(0, 12)}\u2026`;
+    inboxView.patchItem(item.requestId, `${decision === "approve" ? "approving" : "rejecting"}\u2026 ${item.summary}`);
     renderFooter();
     tui.requestRender();
     try {
@@ -1549,8 +1569,10 @@ async function runOperatorBoard(context, options = {}) {
         headers: { "content-type": "application/json" },
         body: JSON.stringify({ runId: item.runId, requestId: item.requestId, decision, note: null })
       });
+      inboxView.removeItem(item.requestId);
       notice = `${decision === "approve" ? "approved" : "rejected"} \u2014 drone resumes`;
     } catch (error) {
+      inboxView.patchItem(item.requestId, item.summary);
       notice = `resolve failed: ${oneLine(error instanceof Error ? error.message : String(error))}`;
     }
     renderFooter();
@@ -1559,6 +1581,7 @@ async function runOperatorBoard(context, options = {}) {
   };
   const answerInput = async (item, text) => {
     notice = `answering ${item.requestId.slice(0, 12)}\u2026`;
+    inboxView.patchItem(item.requestId, `answering\u2026 ${item.summary}`);
     renderFooter();
     tui.requestRender();
     try {
@@ -1571,8 +1594,10 @@ async function runOperatorBoard(context, options = {}) {
           answers: { [item.questionId ?? "response"]: text }
         })
       });
+      inboxView.removeItem(item.requestId);
       notice = "answer sent \u2014 drone resumes";
     } catch (error) {
+      inboxView.patchItem(item.requestId, item.summary);
       notice = `answer failed: ${oneLine(error instanceof Error ? error.message : String(error))}`;
     }
     renderFooter();
@@ -1721,6 +1746,7 @@ async function runOperatorBoard(context, options = {}) {
       const run = list.selectedRun();
       if (run) {
         notice = `stop requested for ${run.runId.slice(0, 8)}\u2026`;
+        list.patchRun(run.runId, { status: "stopping" });
         renderFooter();
         tui.requestRender();
         stopRunViaServer(context, run.runId).then(() => refresh()).catch(() => refresh());
@@ -1728,6 +1754,9 @@ async function runOperatorBoard(context, options = {}) {
       return { consume: true };
     }
     if (data === "r") {
+      notice = "refreshing fleet\u2026";
+      renderFooter();
+      tui.requestRender();
       refresh();
       return { consume: true };
     }
@@ -1757,7 +1786,7 @@ async function runOperatorBoard(context, options = {}) {
     refresh();
   }, BOARD_REFRESH_MS);
   tui.start();
-  refresh();
+  refresh({ quiet: true });
   await new Promise((resolve3) => {
     const poll = setInterval(() => {
       if (stopped) {

package/dist/src/app/drone-ui.js

@@ -105,7 +105,7 @@ function createTtySpinner(input) {
       output.write("\r\x1B[2K");
   };
   render();
-  const timer = isTty ? setInterval(render, input.intervalMs ?? 120) : null;
+  const timer = isTty ? setInterval(render, input.intervalMs ?? 16) : null;
   return {
     setLabel(next) {
       label = next;

package/dist/src/app/theme.js

@@ -44,6 +44,7 @@ function statusColor(status) {
     case "validating":
     case "reviewing":
     case "closing-out":
+    case "stopping":
       return cyan;
     case "needs-attention":
     case "needs_attention":

package/dist/src/app-opentui/adapters/common.d.ts

@@ -0,0 +1,53 @@
+import type { RunnerContext } from "../../runner";
+import type { AppEvent, AppIntent, AppRuntime, AppSceneId } from "../types";
+export type AppStateLike = {
+    readonly projectRoot?: string;
+    readonly scene?: AppSceneId;
+    readonly status?: string;
+    readonly tick?: number;
+    readonly argv?: readonly string[];
+    readonly data?: Record<string, unknown>;
+    readonly footer?: Record<string, unknown>;
+    readonly [key: string]: unknown;
+};
+export type AppAdapterEvent = AppEvent;
+export type AppRendererHandoff = {
+    readonly suspend?: () => void | Promise<void>;
+    readonly resume?: () => void | Promise<void>;
+    readonly destroy?: () => void | Promise<void>;
+};
+export type AppAdapterContext = {
+    readonly projectRoot?: string;
+    readonly rig?: Pick<RunnerContext, "projectRoot" | "runId" | "outputMode">;
+    readonly renderer?: AppRendererHandoff;
+    readonly ensureRuntime?: () => Promise<RunnerContext>;
+    emit(event: AppAdapterEvent): void;
+    getState(): AppStateLike;
+};
+export declare function adapterContextFromRuntime(runtime: AppRuntime, renderer?: AppRendererHandoff): AppAdapterContext;
+export type NormalizedAppError = {
+    readonly message: string;
+    readonly hint?: string;
+};
+export type CapturedConsole = {
+    readonly result: unknown;
+    readonly output: readonly string[];
+};
+export declare function projectRootOf(ctx: AppAdapterContext): string;
+export declare function runtimeOf(ctx: AppAdapterContext): Promise<RunnerContext>;
+export declare function normalizeAppError(error: unknown): NormalizedAppError;
+export declare function emitStarted(ctx: AppAdapterContext, label: string, optimistic?: Record<string, unknown>): void;
+export declare function emitProgress(ctx: AppAdapterContext, label: string, detail?: string, data?: Record<string, unknown>): void;
+export declare function emitCompleted(ctx: AppAdapterContext, label: string, data?: Record<string, unknown>): void;
+export declare function emitFailed(ctx: AppAdapterContext, label: string, error: unknown, data?: Record<string, unknown>): void;
+export declare function patchData(ctx: AppAdapterContext, data: Record<string, unknown>): void;
+export declare function patchFooter(ctx: AppAdapterContext, footer: Record<string, unknown>): void;
+export declare function captureConsole<T>(fn: () => Promise<T> | T): Promise<{
+    result: T;
+    output: readonly string[];
+}>;
+export declare function releaseRendererForExternalTui(ctx: AppAdapterContext): Promise<void>;
+export declare function arrayFromPayload(value: unknown): Record<string, unknown>[];
+export declare function stringField(record: Record<string, unknown>, keys: readonly string[], fallback?: string): string;
+export declare function compactRecord(record: Record<string, unknown>, keys: readonly string[]): Record<string, unknown>;
+export declare function payloadString(intent: AppIntent, key: string): string | undefined;

package/dist/src/app-opentui/adapters/common.js

@@ -0,0 +1,149 @@
+// @bun
+// packages/cli/src/app-opentui/adapters/common.ts
+function adapterContextFromRuntime(runtime, renderer) {
+  return {
+    projectRoot: runtime.getState().projectRoot,
+    renderer,
+    ensureRuntime: () => runtime.getRunnerContext(),
+    emit: (event) => runtime.emit(event),
+    getState: () => runtime.getState()
+  };
+}
+function projectRootOf(ctx) {
+  const root = ctx.rig?.projectRoot ?? ctx.projectRoot ?? ctx.getState().projectRoot;
+  if (typeof root === "string" && root.trim())
+    return root;
+  throw new Error("Rig app adapter requires a projectRoot.");
+}
+async function runtimeOf(ctx) {
+  if (ctx.rig && "runId" in ctx.rig && ctx.ensureRuntime === undefined) {
+    return ctx.rig;
+  }
+  if (ctx.ensureRuntime)
+    return ctx.ensureRuntime();
+  throw new Error("Rig app adapter requires ensureRuntime() before this action can run.");
+}
+function normalizeAppError(error) {
+  const message = error instanceof Error ? error.message : String(error);
+  const rawHint = error instanceof Error ? error.hint : undefined;
+  return {
+    message,
+    ...typeof rawHint === "string" && rawHint.trim() ? { hint: rawHint.trim() } : {}
+  };
+}
+function emitStarted(ctx, label, optimistic) {
+  ctx.emit({ type: "action.started", label, ...optimistic ? { optimistic } : {} });
+}
+function emitProgress(ctx, label, detail, data) {
+  ctx.emit({ type: "action.progress", label, ...detail ? { detail } : {}, ...data ? { data } : {} });
+}
+function emitCompleted(ctx, label, data) {
+  ctx.emit({ type: "action.completed", label, ...data ? { data } : {} });
+}
+function emitFailed(ctx, label, error, data) {
+  if (data)
+    patchData(ctx, data);
+  const normalized = normalizeAppError(error);
+  ctx.emit({
+    type: "action.failed",
+    label,
+    message: normalized.message,
+    ...normalized.hint ? { hint: normalized.hint } : {},
+    cause: error
+  });
+}
+function patchData(ctx, data) {
+  ctx.emit({ type: "data.patch", data });
+}
+function patchFooter(ctx, footer) {
+  ctx.emit({ type: "footer.patch", footer });
+}
+async function captureConsole(fn) {
+  const output = [];
+  const original = {
+    log: console.log,
+    info: console.info,
+    warn: console.warn,
+    error: console.error
+  };
+  const capture = (...parts) => {
+    output.push(parts.map((part) => typeof part === "string" ? part : JSON.stringify(part)).join(" "));
+  };
+  console.log = capture;
+  console.info = capture;
+  console.warn = capture;
+  console.error = capture;
+  try {
+    const result = await fn();
+    return { result, output };
+  } finally {
+    console.log = original.log;
+    console.info = original.info;
+    console.warn = original.warn;
+    console.error = original.error;
+  }
+}
+async function releaseRendererForExternalTui(ctx) {
+  const renderer = ctx.renderer;
+  if (!renderer)
+    return;
+  if (renderer.suspend) {
+    await renderer.suspend();
+    return;
+  }
+  if (renderer.destroy) {
+    await renderer.destroy();
+  }
+}
+function arrayFromPayload(value) {
+  if (Array.isArray(value)) {
+    return value.filter((entry) => Boolean(entry && typeof entry === "object" && !Array.isArray(entry)));
+  }
+  if (value && typeof value === "object" && !Array.isArray(value)) {
+    const entries = value.entries;
+    if (Array.isArray(entries))
+      return arrayFromPayload(entries);
+  }
+  return [];
+}
+function stringField(record, keys, fallback = "") {
+  for (const key of keys) {
+    const value = record[key];
+    if (typeof value === "string" && value.trim())
+      return value.trim();
+    if (typeof value === "number" && Number.isFinite(value))
+      return String(value);
+  }
+  return fallback;
+}
+function compactRecord(record, keys) {
+  const out = {};
+  for (const key of keys) {
+    const value = record[key];
+    if (value !== undefined && value !== null && value !== "")
+      out[key] = value;
+  }
+  return out;
+}
+function payloadString(intent, key) {
+  const value = intent.action.payload?.[key];
+  return typeof value === "string" && value.trim() ? value.trim() : undefined;
+}
+export {
+  stringField,
+  runtimeOf,
+  releaseRendererForExternalTui,
+  projectRootOf,
+  payloadString,
+  patchFooter,
+  patchData,
+  normalizeAppError,
+  emitStarted,
+  emitProgress,
+  emitFailed,
+  emitCompleted,
+  compactRecord,
+  captureConsole,
+  arrayFromPayload,
+  adapterContextFromRuntime
+};

package/dist/src/app-opentui/adapters/doctor.d.ts

@@ -0,0 +1,11 @@
+import type { AppAdapter } from "../types";
+import { type AppAdapterContext } from "./common";
+export declare function createDoctorAdapter(): AppAdapter;
+export type AppDoctorCheck = {
+    readonly id: string;
+    readonly label: string;
+    readonly status: "pass" | "warn" | "fail";
+    readonly detail?: string;
+    readonly remediation?: string;
+};
+export declare function runDoctorChecksForApp(ctx: AppAdapterContext): Promise<AppDoctorCheck[]>;