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

package/dist/src/app-opentui/types.d.ts

@@ -0,0 +1,188 @@
+import type { StyledText } from "@opentui/core";
+import type { RunnerContext } from "../runner";
+import type { StageLayout } from "./layout";
+export type AppSceneId = "main" | "fleet" | "tasks" | "inbox" | "server" | "init" | "doctor" | "run-detail" | "handoff" | "help" | "error";
+export type AppActionKind = "none" | "refresh" | "navigate" | "task-run-next" | "task-run-id" | "run-stop" | "run-attach" | "run-steer" | "inbox-approve" | "inbox-reject" | "inbox-answer" | "init-start" | "doctor-run";
+export type AppIntent = {
+    readonly scene: AppSceneId;
+    readonly argv: readonly string[];
+    readonly raw?: string;
+    readonly action: {
+        readonly kind: AppActionKind;
+        readonly label?: string;
+        readonly payload?: Record<string, unknown>;
+    };
+};
+export type AppStatus = "idle" | "loading" | "action" | "success" | "error";
+export type AppFooterState = {
+    readonly project?: string;
+    readonly server?: string;
+    readonly auth?: string;
+    readonly run?: string;
+    readonly message?: string;
+    readonly [key: string]: string | undefined;
+};
+export type AppTypeBarState = {
+    readonly value: string;
+    readonly placeholder: string;
+    readonly message?: string;
+};
+export type AppErrorState = {
+    readonly message: string;
+    readonly hint?: string;
+    readonly cause?: unknown;
+};
+export type AppSelectionState = {
+    readonly index: number;
+    readonly count: number;
+};
+export type AppState = {
+    readonly projectRoot: string;
+    readonly scene: AppSceneId;
+    readonly status: AppStatus;
+    readonly tick: number;
+    readonly argv: readonly string[];
+    readonly intent: AppIntent;
+    readonly typeBar: AppTypeBarState;
+    readonly footer: AppFooterState;
+    readonly selection: AppSelectionState;
+    readonly data: Record<string, unknown>;
+    readonly runtimeReady: boolean;
+    readonly actionLabel?: string;
+    readonly error?: AppErrorState;
+};
+export type AppStatePatch = Omit<Partial<AppState>, "typeBar" | "footer" | "selection" | "data"> & {
+    readonly typeBar?: Partial<AppTypeBarState>;
+    readonly footer?: Partial<AppFooterState>;
+    readonly selection?: Partial<AppSelectionState>;
+    readonly data?: Record<string, unknown>;
+};
+export type AppEvent = {
+    readonly type: "scene.change";
+    readonly scene: AppSceneId;
+    readonly intent?: AppIntent;
+} | {
+    readonly type: "action.started";
+    readonly label: string;
+    readonly optimistic?: Record<string, unknown>;
+} | {
+    readonly type: "action.progress";
+    readonly label: string;
+    readonly detail?: string;
+    readonly data?: Record<string, unknown>;
+} | {
+    readonly type: "action.completed";
+    readonly label: string;
+    readonly data?: Record<string, unknown>;
+} | {
+    readonly type: "action.failed";
+    readonly label: string;
+    readonly message: string;
+    readonly hint?: string;
+    readonly cause?: unknown;
+} | {
+    readonly type: "data.patch";
+    readonly data: Record<string, unknown>;
+} | {
+    readonly type: "footer.patch";
+    readonly footer: Partial<AppFooterState>;
+} | {
+    readonly type: "typebar.patch";
+    readonly typeBar: Partial<AppTypeBarState>;
+} | {
+    readonly type: "runtime.ready";
+    readonly runner: RunnerContext;
+} | {
+    readonly type: "runtime.failed";
+    readonly message: string;
+    readonly hint?: string;
+    readonly cause?: unknown;
+};
+export type AppStore = {
+    getState(): AppState;
+    setState(next: AppState): void;
+    patch(patch: AppStatePatch): void;
+    subscribe(listener: (state: AppState) => void): () => void;
+};
+export type AppEventBus = {
+    emit(event: AppEvent): void;
+    subscribe(listener: (event: AppEvent) => void): () => void;
+};
+export type AppSceneLine = {
+    readonly text: string;
+    readonly styledText?: StyledText;
+    readonly fg?: string;
+    readonly bold?: boolean;
+    readonly dim?: boolean;
+    readonly align?: "left" | "center" | "right";
+    /** Zero-based selectable item index for keyboard/mouse navigation. */
+    readonly selectableIndex?: number;
+    /** Activate on single click instead of only selecting/double-clicking. */
+    readonly activateOnClick?: boolean;
+};
+export type AppScenePanel = {
+    readonly id: string;
+    readonly top: number;
+    readonly left?: number;
+    readonly width?: number;
+    readonly height: number;
+    readonly lines: readonly AppSceneLine[];
+    readonly backgroundColor?: string;
+    readonly backgroundAlpha?: number;
+    readonly border?: boolean;
+    readonly borderColor?: string;
+    readonly borderAlpha?: number;
+    readonly opacity?: number;
+    readonly zIndex?: number;
+    readonly stickyScroll?: boolean;
+    readonly stickyStart?: "bottom" | "top" | "left" | "right";
+    readonly chrome?: "ad-terminal" | "none";
+    readonly headerText?: string;
+    readonly headerHeight?: number;
+    readonly paddingX?: number;
+    readonly paddingY?: number;
+};
+export type AppSceneFrame = {
+    readonly scene: AppSceneId;
+    readonly title?: string;
+    readonly lines: readonly AppSceneLine[];
+    readonly panels?: readonly AppScenePanel[];
+    readonly footer?: Partial<AppFooterState>;
+    readonly typeBarPlaceholder?: string;
+    readonly live?: boolean;
+    /** Use the full terminal canvas instead of the centered app layout. */
+    readonly fullScreen?: boolean;
+    /** Hide and blur the command typebar while another terminal app owns input. */
+    readonly hideTypeBar?: boolean;
+    /** Raw keypresses should be forwarded to the embedded terminal host. */
+    readonly terminalActive?: boolean;
+};
+export type AppSceneRenderer = (state: AppState, layout?: StageLayout) => AppSceneFrame;
+export type AppRuntime = {
+    getState(): AppState;
+    patchState(patch: AppStatePatch): void;
+    emit(event: AppEvent): void;
+    setScene(scene: AppSceneId, intent?: AppIntent): void;
+    runIntent(intent: AppIntent): Promise<void>;
+    getRunnerContext(): Promise<RunnerContext>;
+    suspend(): void;
+    resume(): void;
+    destroy(): void;
+};
+export type AppAdapter = {
+    readonly id: string;
+    start?(runtime: AppRuntime): void | Promise<void>;
+    handleIntent?(runtime: AppRuntime, intent: AppIntent): boolean | void | Promise<boolean | void>;
+};
+export type AppLaunchOptions = {
+    readonly projectRoot: string;
+    readonly argv: readonly string[];
+    readonly dryRun?: boolean;
+    readonly runId?: string;
+    readonly policyMode?: "off" | "observe" | "enforce";
+    readonly projectConfigured?: boolean;
+    readonly initialFooter?: AppFooterState;
+    readonly initializeRuntime?: () => Promise<RunnerContext>;
+    readonly adapters?: readonly AppAdapter[];
+    readonly sceneRenderers?: Partial<Record<AppSceneId, AppSceneRenderer>>;
+};

package/dist/src/app-opentui/types.js

@@ -0,0 +1 @@
+// @bun

package/dist/src/commands/_async-ui.d.ts

@@ -0,0 +1,13 @@
+import type { OutputMode } from "@rig/runtime/control-plane/runtime/types";
+export type SpinnerOutput = Pick<NodeJS.WriteStream, "write"> & {
+    readonly isTTY?: boolean;
+};
+export type WithSpinnerOptions = {
+    /** Final line left behind on success. Default: the spinner line is erased. */
+    readonly doneLabel?: string;
+    /** Pass context.outputMode; "json" suppresses all spinner output. */
+    readonly outputMode?: OutputMode;
+    /** Stream override for tests. Defaults to process.stderr. */
+    readonly output?: SpinnerOutput;
+};
+export declare function withSpinner<T>(label: string, work: (update: (label: string) => void) => Promise<T>, options?: WithSpinnerOptions): Promise<T>;

package/dist/src/commands/_async-ui.js

@@ -0,0 +1,223 @@
+// @bun
+// packages/cli/src/commands/_async-ui.ts
+import pc from "picocolors";
+
+// packages/cli/src/commands/_spinner.ts
+var SPINNER_FRAMES = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
+function createTtySpinner(input) {
+  const output = input.output ?? process.stdout;
+  const isTty = output.isTTY === true;
+  const frames = input.frames && input.frames.length > 0 ? input.frames : SPINNER_FRAMES;
+  let label = input.label;
+  let frame = 0;
+  let paused = false;
+  let stopped = false;
+  let lastPrintedLabel = "";
+  const render = () => {
+    if (stopped || paused)
+      return;
+    if (!isTty) {
+      if (label !== lastPrintedLabel) {
+        output.write(`${label}
+`);
+        lastPrintedLabel = label;
+      }
+      return;
+    }
+    frame = (frame + 1) % frames.length;
+    const glyph = frames[frame] ?? frames[0] ?? "";
+    output.write(`\r\x1B[2K${input.styleFrame ? input.styleFrame(glyph) : glyph} ${label}`);
+  };
+  const clearLine = () => {
+    if (isTty)
+      output.write("\r\x1B[2K");
+  };
+  render();
+  const timer = isTty ? setInterval(render, input.intervalMs ?? 16) : null;
+  return {
+    setLabel(next) {
+      label = next;
+      render();
+    },
+    pause() {
+      paused = true;
+      clearLine();
+    },
+    resume() {
+      if (stopped)
+        return;
+      paused = false;
+      render();
+    },
+    stop(finalLine) {
+      if (stopped)
+        return;
+      stopped = true;
+      if (timer)
+        clearInterval(timer);
+      clearLine();
+      if (finalLine)
+        output.write(`${finalLine}
+`);
+    }
+  };
+}
+
+// packages/cli/src/runner.ts
+import { EventBus } from "@rig/runtime/control-plane/runtime/events";
+import { CliError as RuntimeCliError } from "@rig/runtime/control-plane/errors";
+import { evaluate, loadPolicy, resolveAction } from "@rig/runtime/control-plane/runtime/guard";
+import { buildBinary } from "@rig/runtime/control-plane/runtime/isolation";
+
+// packages/cli/src/commands/_server-client.ts
+import { ensureLocalRigServerConnection } from "@rig/runtime/local-server";
+var scopedGitHubBearerTokens = new Map;
+var serverPhaseListener = null;
+function setServerPhaseListener(listener) {
+  const previous = serverPhaseListener;
+  serverPhaseListener = listener;
+  return previous;
+}
+var serverReachabilityCache = new Map;
+var RESUMABLE_RUN_STATUSES = new Set([
+  "created",
+  "preparing",
+  "running",
+  "validating",
+  "reviewing",
+  "stopped",
+  "failed",
+  "needs-attention",
+  "needs_attention"
+]);
+
+// packages/cli/src/app/theme.ts
+var RIG_PALETTE = {
+  ink: "#f2f3f6",
+  ink2: "#aeb0ba",
+  ink3: "#6c6e79",
+  ink4: "#44464f",
+  accent: "#ccff4d",
+  accentDim: "#a9d63f",
+  cyan: "#56d8ff",
+  red: "#ff5d5d",
+  yellow: "#ffd24d"
+};
+function hexToRgb(hex) {
+  const value = hex.replace("#", "");
+  return [
+    Number.parseInt(value.slice(0, 2), 16),
+    Number.parseInt(value.slice(2, 4), 16),
+    Number.parseInt(value.slice(4, 6), 16)
+  ];
+}
+function fg(hex) {
+  const [r, g, b] = hexToRgb(hex);
+  return (text) => `\x1B[38;2;${r};${g};${b}m${text}\x1B[39m`;
+}
+var ink = fg(RIG_PALETTE.ink);
+var ink2 = fg(RIG_PALETTE.ink2);
+var ink3 = fg(RIG_PALETTE.ink3);
+var ink4 = fg(RIG_PALETTE.ink4);
+var accent = fg(RIG_PALETTE.accent);
+var accentDim = fg(RIG_PALETTE.accentDim);
+var cyan = fg(RIG_PALETTE.cyan);
+var red = fg(RIG_PALETTE.red);
+var yellow = fg(RIG_PALETTE.yellow);
+function bold(text) {
+  return `\x1B[1m${text}\x1B[22m`;
+}
+var DRONE_ART = [
+  "  .-=-.                   .-=-.   ",
+  " ( !!! )                 ( !!! )  ",
+  "  '-=-'._               _.'-=-'   ",
+  "        '._           _.'         ",
+  "           '=$$$$$$$=.'           ",
+  "          =$$$$$$$$$$$=           ",
+  "         $$$@@@@@@@@@@$$$         ",
+  "        $$$@@        @@$$$        ",
+  "        $$@    ?     @$$$         ",
+  "        $$$@   '-'   @$$$         ",
+  "        $$$@@        @@$$$        ",
+  "         $$$@@@@@@@@@@$$$         ",
+  "          =$$$$$$$$$$$=           ",
+  "           '=$$$$$$$=.'           ",
+  "        _.'           '._         ",
+  "  .-=-.'                 '.-=-.   ",
+  " ( !!! )                 ( !!! )  ",
+  "  '-=-'                   '-=-'   "
+];
+var EYE_FRAMES = ["@", "o", "."];
+var DRONE_WIDTH = DRONE_ART[0].length;
+var DRONE_HEIGHT = DRONE_ART.length;
+var MICRO_BLADES = ["---", "\\\\\\", "|||", "///"];
+function microDroneFrame(tick) {
+  const blade = MICRO_BLADES[tick % MICRO_BLADES.length];
+  const eye = EYE_FRAMES[Math.floor(tick / 2) % EYE_FRAMES.length];
+  return `(${blade})${eye}(${blade})`;
+}
+var MICRO_DRONE_FRAMES = Array.from({ length: 12 }, (_, index) => microDroneFrame(index));
+function renderMicroDroneFrame(tick) {
+  const blade = MICRO_BLADES[tick % MICRO_BLADES.length];
+  const eye = EYE_FRAMES[Math.floor(tick / 2) % EYE_FRAMES.length];
+  return `${ink4("(")}${cyan(blade)}${ink4(")")}${bold(accent(eye))}${ink4("(")}${cyan(blade)}${ink4(")")}`;
+}
+
+// packages/cli/src/commands/_async-ui.ts
+var DONE_SYMBOL = pc.green("\u25C7");
+var FAIL_SYMBOL = pc.red("\u25A0");
+var activeUpdate = null;
+async function withSpinner(label, work, options = {}) {
+  if (options.outputMode === "json") {
+    return work(() => {});
+  }
+  if (activeUpdate) {
+    const outer = activeUpdate;
+    outer(label);
+    return work(outer);
+  }
+  const output = options.output ?? process.stderr;
+  const isTty = output.isTTY === true;
+  let lastLabel = label;
+  if (!isTty) {
+    output.write(`${label}
+`);
+    const update2 = (next) => {
+      lastLabel = next;
+    };
+    activeUpdate = update2;
+    const previousListener2 = setServerPhaseListener(update2);
+    try {
+      return await work(update2);
+    } finally {
+      activeUpdate = null;
+      setServerPhaseListener(previousListener2);
+    }
+  }
+  const spinner = createTtySpinner({
+    label,
+    output,
+    frames: MICRO_DRONE_FRAMES,
+    styleFrame: (frame) => renderMicroDroneFrame(Math.max(0, MICRO_DRONE_FRAMES.indexOf(frame)))
+  });
+  const update = (next) => {
+    lastLabel = next;
+    spinner.setLabel(next);
+  };
+  activeUpdate = update;
+  const previousListener = setServerPhaseListener(update);
+  try {
+    const result = await work(update);
+    spinner.stop(options.doneLabel ? `${DONE_SYMBOL} ${options.doneLabel}` : undefined);
+    return result;
+  } catch (error) {
+    spinner.stop(`${FAIL_SYMBOL} ${lastLabel}`);
+    throw error;
+  } finally {
+    activeUpdate = null;
+    setServerPhaseListener(previousListener);
+  }
+}
+export {
+  withSpinner
+};

package/dist/src/commands/_authority-runs.d.ts

@@ -0,0 +1,22 @@
+import { type AuthorityRunRecord } from "@rig/runtime/control-plane/authority-files";
+import type { RunStatus } from "@rig/contracts";
+export declare const RIG_WORKSPACE_ID = "rig-local-workspace";
+export type RuntimeAdapter = "claude-code" | "codex" | "pi";
+export declare function normalizeRuntimeAdapter(value: string | undefined): RuntimeAdapter;
+export declare function readLatestBeadRecord(projectRoot: string, taskId: string): Record<string, unknown> | null;
+export declare function upsertAgentAuthorityRun(projectRoot: string, input: {
+    runId: string;
+    taskId: string;
+    createdAt: string;
+    runtimeAdapter?: string;
+    status: RunStatus;
+    startedAt?: string | null;
+    completedAt?: string | null;
+    worktreePath?: string | null;
+    artifactRoot?: string | null;
+    logRoot?: string | null;
+    sessionPath?: string | null;
+    sessionLogPath?: string | null;
+    pid?: number | null;
+    errorText?: string | null;
+}): AuthorityRunRecord & Record<string, unknown>;

package/dist/src/commands/_authority-runs.js

@@ -5,8 +5,7 @@ import { resolve } from "path";
 import {
   readAuthorityRun,
   readJsonlFile,
-  resolveAuthorityRunDir,
-  writeJsonFile
+  writeAuthorityRunRecord
 } from "@rig/runtime/control-plane/authority-files";
 
 // packages/cli/src/commands/_paths.ts
@@ -100,7 +99,7 @@ function upsertAgentAuthorityRun(projectRoot, input) {
   } else if ("errorText" in next) {
     delete next.errorText;
   }
-  writeJsonFile(resolve(resolveAuthorityRunDir(projectRoot, input.runId), "run.json"), next);
+  writeAuthorityRunRecord(projectRoot, input.runId, next);
   return next;
 }
 export {

package/dist/src/commands/_cli-format.d.ts

@@ -0,0 +1,49 @@
+export type CliTaskLike = Record<string, unknown>;
+export type CliRunLike = Record<string, unknown>;
+export declare function printFormattedOutput(message: string, options?: {
+    title?: string;
+}): void;
+export declare function formatStatusPill(status: string): string;
+export declare function formatSection(title: string, subtitle?: string): string;
+export declare function formatSuccessCard(title: string, rows?: Array<[string, string | number | null | undefined]>): string;
+export declare function formatNextSteps(steps: readonly string[]): string[];
+export declare function formatTaskList(tasks: readonly CliTaskLike[], options?: {
+    raw?: boolean;
+}): string;
+export declare function formatTaskCard(task: CliTaskLike, options?: {
+    title?: string;
+    selected?: boolean;
+}): string;
+export declare function formatTaskDetails(task: CliTaskLike): string;
+export declare function formatRunList(runs: readonly CliRunLike[], options?: {
+    source?: "local" | "server";
+}): string;
+export declare function formatSubmittedRun(input: {
+    runId: string;
+    task?: CliTaskLike | null;
+    runtimeAdapter?: string | null;
+    runtimeMode?: string | null;
+    interactionMode?: string | null;
+    detached?: boolean;
+}): 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;
+export declare function formatConnectionList(connections: Record<string, {
+    kind: string;
+    baseUrl?: string;
+    mode?: string;
+}>): string;
+export declare function formatConnectionStatus(selected: string, connections: Record<string, {
+    kind: string;
+    baseUrl?: string;
+    mode?: string;
+}>): string;