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

package/README.md

@@ -4,27 +4,26 @@
 
 ## Purpose
 
-- route operator commands into the runtime control plane
-- provide setup, server, task, review, queue, and profile entry points
+- launch upstream OMP with the Rig extension cockpit loaded
+- keep the public root UX centered on bare `rig`, `rig --workspace <path>`, and
+  OMP collab joins
+- fence legacy control-plane subcommands so retained automation paths are not
+  advertised as the current product flow
 
-## Common command
+## Common commands
 
-- `bun run rig -- <subcommand>`
-- `bun run rig report-bug`
-- `bun run rig report-bug --no-prompt --browser --title "OTP submit fails" --url "https://dev.rig.hptestingsite.com/login?next=%2F" --environment shared-dev --asset ./path/to/screenshot.png --video ./path/to/recording.webm`
-- `bun run rig report-bug --no-prompt --no-browser --title "OTP API fails" --url "https://dev.rig.hptestingsite.com/api/auth/email/otp/verify" --asset ./path/to/api-response.txt`
-- `bun run rig browser --help`
-- `bun run rig browser explain`
-- `bun run rig browser hp-next dev`
+- `bun run rig` — open OMP with the Rig cockpit for the current workspace
+- `bun run rig -- --workspace /path/to/repo` — open the cockpit scoped to a
+  specific workspace
+- `bun run rig -- join <collab-link>` — join an encrypted OMP collab session
+- `bun run rig -- --help` — show the root OMP/cockpit help
 
 ## Notes
 
-- CLI behavior should stay thin and delegate business logic into `@rig/runtime`.
-- `report-bug` uses `@clack/prompts` for its interactive wizard and asks whether Rig Browser is required.
-- `report-bug` creates a runnable beads `task` by default, writes committable evidence under `artifacts/<task-id>/bug-report/` (relative to the resolved monorepo root), and upserts task-config wiring.
-- `report-bug --no-beads` keeps the old draft-only behavior under `docs/bug-reports/`.
-- `report-bug --no-browser` skips `browser.json`, the `browser-required` label, browser validation, and browser helper commands while preserving task assets.
-- `report-bug` accepts drag-and-drop asset values through `--asset` and `--video`; copied files are stored under `bug-report/assets/` and indexed in `manifest.json`.
-- Browser bug-report evidence must be tracked by git before validation/handoff; untracked assets fail `integration:browser-bug-report-task`.
-- Key `report-bug` flags: `--browser`, `--no-browser`, `--summary`, `--steps`, `--expected`, `--actual`, `--evidence`, `--asset`, `--video`, `--screenshot`, `--priority`, `--labels`, `--parent`, `--assignee`, `--owner`, `--preset`, `--profile`, `--attach-url`, `--state-dir`, `--mode`, `--viewport`, `--output-dir`, `--slug`, and `--overwrite`.
-- `rig browser` is the operator-friendly command family for Rig Browser help, hp-next launch/check/e2e/reset, and package-level CDP/profile diagnostics.
+- Root command routing lives in `bin/rig.ts`; it forwards OMP launch/join/acp
+  arguments with `@rig/rig-extension` injected.
+- Legacy groups such as `init`, `task`, `doctor`, `run`, `inspect`, `stats`,
+  and `inbox` must stay rejected or clearly compatibility-routed at the public
+  root.
+- CLI behavior should stay thin and delegate product behavior to OMP extension
+  surfaces or narrow compatibility modules.

package/dist/bin/build-rig-binaries.js

@@ -5,7 +5,7 @@
 import { cpSync, existsSync, mkdirSync, readFileSync } from "fs";
 import { resolve } from "path";
 import { runCapture } from "@rig/runtime/control-plane/native/utils";
-import { buildRuntimeBinary } from "@rig/runtime/binary-run";
+import { buildRuntimeBinary, runtimeRigCliBinaryExternals } from "@rig/runtime/binary-run";
 function readCliVersion(rootDir) {
   try {
     const pkg = JSON.parse(readFileSync(resolve(rootDir, "packages/cli/package.json"), "utf-8"));
@@ -21,14 +21,17 @@ async function main() {
   const stamp = timestamp();
   const outputDir = args.outputDir || resolve(rootDir, ".rig/dist", `rig-${stamp}`);
   const binDir = resolve(outputDir, "bin");
+  const configDir = resolve(outputDir, "config");
   const runtimeDir = resolve(outputDir, "runtime", "rig");
   mkdirSync(binDir, { recursive: true });
+  mkdirSync(configDir, { recursive: true });
   mkdirSync(runtimeDir, { recursive: true });
   const cliVersion = readCliVersion(rootDir);
   await buildBinary("packages/cli/bin/rig.ts", resolve(binDir, "rig"), rootDir, {
     "process.env.RIG_CLI_VERSION": JSON.stringify(cliVersion)
-  });
+  }, runtimeRigCliBinaryExternals);
   await buildBinary("packages/runtime/bin/rig-agent-dispatch.ts", resolve(binDir, "rig-agent"), rootDir);
+  cpSync(resolve(rootDir, "packages/cli/config/rig-default-config.yml"), resolve(configDir, "rig-default-config.yml"));
   for (const entry of [
     "hooks",
     "lib",
@@ -57,17 +60,21 @@ async function main() {
   };
   await Bun.write(resolve(outputDir, "manifest.json"), `${JSON.stringify(manifest, null, 2)}
 `);
-  const archive = `${outputDir}.tar.gz`;
-  const tar = await Bun.$`tar -czf ${archive} -C ${outputDir} .`.cwd(rootDir).quiet().nothrow();
-  if (tar.exitCode !== 0) {
-    throw new Error(`Failed to create archive: ${tar.stderr.toString() || tar.stdout.toString()}`);
+  let archive = null;
+  if (args.archive) {
+    archive = `${outputDir}.tar.gz`;
+    const tar = await Bun.$`tar -czf ${archive} -C ${outputDir} .`.cwd(rootDir).quiet().nothrow();
+    if (tar.exitCode !== 0) {
+      throw new Error(`Failed to create archive: ${tar.stderr.toString() || tar.stdout.toString()}`);
+    }
   }
   console.log("Build complete");
   console.log(`- directory: ${outputDir}`);
-  console.log(`- archive: ${archive}`);
+  if (archive)
+    console.log(`- archive: ${archive}`);
 }
 function parseArgs(argv) {
-  const args = {};
+  const args = { archive: true };
   for (let i = 0;i < argv.length; i += 1) {
     const current = argv[i];
     if (current === "--output-dir") {
@@ -79,16 +86,21 @@ function parseArgs(argv) {
       i += 1;
       continue;
     }
+    if (current === "--no-archive") {
+      args.archive = false;
+      continue;
+    }
     throw new Error(`Unknown option: ${current}`);
   }
   return args;
 }
-async function buildBinary(source, output, cwd, define) {
+async function buildBinary(source, output, cwd, define, external) {
   await buildRuntimeBinary({
     sourcePath: source,
     outputPath: output,
     cwd,
-    ...define ? { define } : {}
+    ...define ? { define } : {},
+    ...external ? { external } : {}
   });
 }
 function timestamp() {

package/dist/bin/rig.d.ts

@@ -1,2 +1,72 @@
-#!/usr/bin/env bun
+export declare function resolveRigServerEntrypointArgv(argv: readonly string[]): string[] | null;
+export declare function stripRigServerEntrypointArg(argv: readonly string[]): string[];
+export declare function runRigServerEntrypoint(argv?: readonly string[]): Promise<boolean>;
+export type RigRootRoute = {
+    readonly kind: "omp";
+    readonly argv: readonly string[];
+    readonly workspaceRoot?: string;
+} | {
+    readonly kind: "run";
+    readonly taskRef: string;
+    readonly title?: string;
+    readonly model?: string;
+    readonly prompt?: string;
+    readonly workspaceRoot?: string;
+} | {
+    readonly kind: "help";
+    readonly argv: readonly string[];
+} | {
+    readonly kind: "version";
+} | {
+    readonly kind: "operator";
+    readonly argv: readonly string[];
+    readonly workspaceRoot?: string;
+} | {
+    readonly kind: "unsupported";
+    readonly argv: readonly string[];
+    readonly message: string;
+};
+export declare function resolveRigDefaultConfigPath(): string;
+export declare function resolveRigRootRoute(argv: readonly string[]): RigRootRoute;
+type RigExtensionTask = {
+    readonly id: string;
+    readonly title?: string | null;
+    readonly status?: string | null;
+    readonly source?: string | null;
+    readonly url?: string | null;
+    readonly body?: string | null;
+};
+type RigExtensionServerState = {
+    readonly alias: string;
+    readonly kind: "local" | "remote";
+    readonly baseUrl?: string | null;
+    readonly projectRoot?: string | null;
+    readonly status?: string | null;
+    readonly taskSource?: string | null;
+};
+type RigExtensionAttachResult = {
+    readonly sessionPath?: string | null;
+    readonly joinLink?: string | null;
+    readonly collabSessionId?: string | null;
+};
+type RigExtensionServerBridge = {
+    readonly selectedServer: {
+        readServerState(): Promise<RigExtensionServerState>;
+        listTasks(): Promise<readonly RigExtensionTask[]>;
+        getTask(taskId: string): Promise<RigExtensionTask | null>;
+        dispatchTask(input: {
+            readonly taskId: string;
+            readonly title?: string | null;
+        }): Promise<{
+            runId: string;
+        }>;
+        attachRun(input: {
+            readonly runId: string;
+            readonly taskId?: string;
+        }): Promise<RigExtensionAttachResult | null>;
+    };
+};
+export declare function createRigExtensionBridge(projectRoot: string): RigExtensionServerBridge;
+export declare function installRigExtensionBridge(projectRoot: string, bridge?: RigExtensionServerBridge): RigExtensionServerBridge;
+export declare function runRigRootCli(argv?: readonly string[]): Promise<void>;
 export {};