@h-rig/rig-host 0.0.6-alpha.91

package/dist/src/cli-entry.js

@@ -0,0 +1,476 @@
+// @bun
+// packages/rig-host/src/cli-entry.ts
+import { existsSync, readFileSync } from "fs";
+import { dirname, resolve as resolve4 } from "path";
+
+// packages/rig-host/src/host-session.ts
+import { resolve as resolve3 } from "path";
+
+// packages/rig-host/src/domain/run.ts
+import { basename, resolve as resolve2 } from "path";
+
+// packages/rig-host/src/domain/task.ts
+import { resolve } from "path";
+import { createPluginHost } from "@rig/core";
+import { loadConfig } from "@rig/core/load-config";
+function stringList(value) {
+  if (!Array.isArray(value))
+    return [];
+  return value.filter((entry) => typeof entry === "string").map((entry) => entry.trim()).filter((entry) => entry.length > 0);
+}
+function stringOrNull(value) {
+  if (typeof value !== "string")
+    return null;
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : null;
+}
+function titleFor(record) {
+  return stringOrNull(record.title) ?? stringOrNull(record.name) ?? record.id;
+}
+function descriptionFor(record) {
+  return stringOrNull(record.description) ?? stringOrNull(record.body) ?? "";
+}
+function scopeFor(record) {
+  const direct = stringList(record.scope);
+  if (direct.length > 0)
+    return direct;
+  return stringList(record.labels).filter((label) => label.startsWith("scope:")).map((label) => label.slice("scope:".length).trim()).filter((label) => label.length > 0);
+}
+function validationKeysFor(record) {
+  const direct = stringList(record.validationKeys);
+  if (direct.length > 0)
+    return direct;
+  const validation = stringList(record.validation);
+  if (validation.length > 0)
+    return validation;
+  return stringList(record.labels).filter((label) => label.startsWith("validator:")).map((label) => label.slice("validator:".length).trim()).filter((label) => label.length > 0);
+}
+function createdAtFor(record, fallback) {
+  return stringOrNull(record.createdAt) ?? fallback;
+}
+function updatedAtFor(record, fallback) {
+  return stringOrNull(record.updatedAt) ?? createdAtFor(record, fallback) ?? fallback;
+}
+function mapTaskRecordToSummary(record, workspaceId, fallbackTimestamp) {
+  const metadata = record;
+  const createdAt = createdAtFor(record, fallbackTimestamp);
+  const updatedAt = updatedAtFor(record, fallbackTimestamp);
+  return {
+    id: record.id,
+    workspaceId,
+    graphId: null,
+    externalId: stringOrNull(metadata.externalId) ?? stringOrNull(metadata.externalRef),
+    title: titleFor(record),
+    description: descriptionFor(record),
+    status: record.status,
+    priority: typeof metadata.priority === "number" && Number.isInteger(metadata.priority) && metadata.priority > 0 ? metadata.priority : null,
+    role: stringOrNull(metadata.role),
+    scope: scopeFor(record),
+    validationKeys: validationKeysFor(record),
+    sourceIssueId: stringOrNull(metadata.sourceIssueId),
+    dependencies: [...record.deps],
+    parentChildDeps: [],
+    metadata,
+    createdAt,
+    updatedAt
+  };
+}
+async function loadRigIdeaTasks(workspaceRoot) {
+  const normalizedRoot = resolve(workspaceRoot);
+  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}.`);
+  }
+  const source = taskSourceFactory.factory(config.taskSource, { projectRoot: normalizedRoot });
+  const fallbackTimestamp = new Date().toISOString();
+  const workspaceId = normalizedRoot;
+  const tasks = await source.list();
+  return tasks.map((task) => mapTaskRecordToSummary(task, workspaceId, fallbackTimestamp));
+}
+
+// packages/rig-host/src/domain/run.ts
+var LEGACY_AUTHORITY_RUN_CREATION_RETIRED_MESSAGE = "Legacy rig-host run-record creation is retired for the product path. Use the default Rig OMP extension/collab session flow instead.";
+var LEGACY_AUTHORITY_RUN_CONTROL_RETIRED_MESSAGE = "Legacy rig-host run-record control, inspection, and active-run state are retired for the product path. Use the default Rig OMP extension/collab session flow instead.";
+function legacyAuthorityRunUnsupportedMessage() {
+  return LEGACY_AUTHORITY_RUN_CREATION_RETIRED_MESSAGE;
+}
+function legacyAuthorityRunControlUnsupportedMessage() {
+  return LEGACY_AUTHORITY_RUN_CONTROL_RETIRED_MESSAGE;
+}
+function legacyAuthorityRunControlUnsupportedError() {
+  return new Error(legacyAuthorityRunControlUnsupportedMessage());
+}
+function projectRetiredLegacyRigIdeaWorkspace(workspaceRoot, tasks) {
+  const normalizedRoot = resolve2(workspaceRoot);
+  const updatedAt = new Date().toISOString();
+  const title = basename(normalizedRoot) || normalizedRoot;
+  return {
+    workspaceRoot: normalizedRoot,
+    activeRunId: null,
+    sequence: 0,
+    workspaces: [{
+      id: normalizedRoot,
+      title,
+      rootPath: normalizedRoot,
+      sourceKind: "native",
+      defaultModel: null,
+      createdAt: updatedAt,
+      updatedAt
+    }],
+    graphs: [],
+    tasks: [...tasks],
+    runs: [],
+    runtimes: [],
+    conversations: [],
+    messages: [],
+    actions: [],
+    logs: [],
+    approvals: [],
+    userInputs: [],
+    validations: [],
+    reviews: [],
+    artifacts: [],
+    policyDecisions: [],
+    queue: [],
+    worktrees: [],
+    remoteEndpoints: [],
+    remoteConnections: [],
+    remoteOrchestrations: [],
+    updatedAt
+  };
+}
+async function createRigIdeaHarness(workspaceRoot) {
+  const normalizedRoot = resolve2(workspaceRoot);
+  const tasks = await loadRigIdeaTasks(normalizedRoot).catch(() => []);
+  return {
+    snapshot() {
+      return projectRetiredLegacyRigIdeaWorkspace(normalizedRoot, tasks);
+    },
+    async stopRun(_runId) {
+      throw legacyAuthorityRunControlUnsupportedError();
+    },
+    async resolveApproval(_runId, _requestId, _decision) {
+      throw legacyAuthorityRunControlUnsupportedError();
+    },
+    async resolveUserInput(_runId, _requestId, _answers) {
+      throw legacyAuthorityRunControlUnsupportedError();
+    }
+  };
+}
+
+// packages/rig-host/src/replication/broadcast.ts
+function createRigHostBroadcaster(listener, collab) {
+  const backlog = [];
+  const welcomedPeers = new Set;
+  const hasWelcomedRelayPeer = () => {
+    for (const peer of welcomedPeers) {
+      if (peer !== 0)
+        return true;
+    }
+    return false;
+  };
+  const emit = (frame, targetPeer = 0) => {
+    listener?.(frame);
+    collab?.send(frame, targetPeer);
+  };
+  const flush = (targetPeer) => {
+    let write = 0;
+    for (let read = 0;read < backlog.length; read += 1) {
+      const next = backlog[read];
+      if (next.targetPeer === targetPeer) {
+        emit(next.frame, next.targetPeer);
+      } else {
+        backlog[write] = next;
+        write += 1;
+      }
+    }
+    backlog.length = write;
+  };
+  return {
+    publish(frame, targetPeer = 0) {
+      if (frame.t === "welcome") {
+        welcomedPeers.add(targetPeer);
+        emit(frame, targetPeer);
+        flush(targetPeer);
+        return;
+      }
+      if (!welcomedPeers.has(targetPeer) && frame.t !== "bye" && frame.t !== "error") {
+        if (targetPeer === 0) {
+          if (hasWelcomedRelayPeer())
+            emit(frame, targetPeer);
+          return;
+        }
+        backlog.push({ frame, targetPeer });
+        return;
+      }
+      emit(frame, targetPeer);
+    },
+    publishWelcome(snapshot, readOnly, targetPeer) {
+      this.publish({ t: "welcome", snapshot, readOnly }, targetPeer);
+    },
+    rejectReadOnly(action, targetPeer) {
+      this.publish({
+        t: "error",
+        code: "READ_ONLY",
+        message: `${action} is disabled on a read-only link`
+      }, targetPeer);
+    }
+  };
+}
+
+// packages/rig-host/src/host-session.ts
+var LOCAL_PEER_ID = 0;
+var RIG_GENERIC_OMP_JOIN_LIMITATION = "Legacy rig-host remote join and attachment are retired for the product path. Use the default Rig OMP extension/collab session flow instead.";
+async function startRigHostSession(options) {
+  if (options.relayUrl) {
+    throw new Error(RIG_GENERIC_OMP_JOIN_LIMITATION);
+  }
+  const workspaceRoot = resolve3(options.workspaceRoot);
+  let stopped = false;
+  let harness = await createRigIdeaHarness(workspaceRoot);
+  let snapshot = harness.snapshot();
+  let hostSequence = snapshot.sequence;
+  const guests = new Map;
+  const broadcast = createRigHostBroadcaster(options.onFrame);
+  function publishState(nextSnapshot) {
+    hostSequence = Math.max(hostSequence, nextSnapshot.sequence) + 1;
+    snapshot = { ...nextSnapshot, sequence: hostSequence };
+    broadcast.publish({ t: "state", snapshot });
+    return snapshot;
+  }
+  async function refreshWorkspaceState() {
+    harness = await createRigIdeaHarness(workspaceRoot);
+    publishState(harness.snapshot());
+  }
+  function publishLegacyRunError(message, fromPeer) {
+    broadcast.publish({
+      t: "error",
+      code: "LEGACY_AUTHORITY_RUN_UNSUPPORTED",
+      message
+    }, fromPeer);
+  }
+  async function handleCommand(frame, fromPeer) {
+    switch (frame.command.kind) {
+      case "workspace.refresh":
+        await refreshWorkspaceState();
+        return;
+      case "run.createAdhoc":
+      case "task.run":
+        publishLegacyRunError(legacyAuthorityRunUnsupportedMessage(), fromPeer);
+        return;
+      case "run.stop":
+      case "run.resume":
+      case "run.interrupt":
+      case "run.submitMessage":
+      case "approval.resolve":
+      case "input.resolve":
+        publishLegacyRunError(legacyAuthorityRunControlUnsupportedMessage(), fromPeer);
+        return;
+    }
+  }
+  async function handleGuestFrame(frame, fromPeer = LOCAL_PEER_ID) {
+    if (stopped)
+      return;
+    switch (frame.t) {
+      case "hello": {
+        const guest = {
+          sessionName: frame.sessionName.trim().slice(0, 64) || `guest-${fromPeer}`,
+          readOnly: frame.readOnly === true
+        };
+        guests.set(fromPeer, guest);
+        broadcast.publishWelcome(snapshot, guest.readOnly, fromPeer);
+        return;
+      }
+      case "command": {
+        if (guests.get(fromPeer)?.readOnly !== false) {
+          broadcast.rejectReadOnly("command", fromPeer);
+          return;
+        }
+        try {
+          await handleCommand(frame, fromPeer);
+        } catch (error) {
+          broadcast.publish({
+            t: "error",
+            code: "COMMAND_FAILED",
+            message: error instanceof Error ? error.message : String(error)
+          }, fromPeer);
+        }
+        return;
+      }
+      case "abort": {
+        if (guests.get(fromPeer)?.readOnly !== false) {
+          broadcast.rejectReadOnly("abort", fromPeer);
+          return;
+        }
+        publishLegacyRunError(legacyAuthorityRunControlUnsupportedMessage(), fromPeer);
+        return;
+      }
+      case "fetch-transcript": {
+        publishLegacyRunError(legacyAuthorityRunControlUnsupportedMessage(), fromPeer);
+        return;
+      }
+    }
+  }
+  return {
+    snapshot() {
+      return snapshot;
+    },
+    async createShareLink(_readOnly = false) {
+      throw new Error(RIG_GENERIC_OMP_JOIN_LIMITATION);
+    },
+    handleGuestFrame(frame) {
+      return handleGuestFrame(frame);
+    },
+    async stop(reason) {
+      if (stopped)
+        return;
+      stopped = true;
+      broadcast.publish({ t: "bye", reason });
+    }
+  };
+}
+
+// packages/rig-host/src/cli-entry.ts
+function packageVersionFrom(startDir) {
+  let current = resolve4(startDir);
+  while (true) {
+    const pkgPath = resolve4(current, "package.json");
+    if (existsSync(pkgPath)) {
+      try {
+        const pkg = JSON.parse(readFileSync(pkgPath, "utf8"));
+        if ((pkg.name === "rig" || pkg.name === "@rig/cli" || pkg.name === "@h-rig/cli") && pkg.version)
+          return pkg.version;
+      } catch {}
+    }
+    const parent = dirname(current);
+    if (parent === current)
+      return null;
+    current = parent;
+  }
+}
+function usageText() {
+  return [
+    "Usage: rig [host|share] [--workspace <path>] [--json]",
+    "",
+    "Commands:",
+    "  host   Boot the host-authoritative runtime and print the current workspace summary.",
+    "  share  Boot the host-authoritative runtime and print a read-only share link.",
+    "",
+    "Flags:",
+    "  --workspace <path>  Override the workspace root (defaults to the current working directory).",
+    "  --json              Emit JSON instead of the text summary.",
+    "  --write             For share, emit a writable collaboration link instead of read-only.",
+    "  --help, -h          Show this help text.",
+    "  --version, -V       Show the rig CLI version."
+  ].join(`
+`);
+}
+function parseRigHostCli(args) {
+  let command = "host";
+  let help = false;
+  let json = false;
+  let readOnly = true;
+  let version = false;
+  let workspaceRoot = process.cwd();
+  for (let index = 0;index < args.length; index += 1) {
+    const arg = args[index];
+    if (arg === undefined)
+      continue;
+    if (arg === "--help" || arg === "-h" || arg === "help") {
+      help = true;
+      continue;
+    }
+    if (arg === "--version" || arg === "-V" || arg === "version") {
+      version = true;
+      continue;
+    }
+    if (arg === "--json") {
+      json = true;
+      continue;
+    }
+    if (arg === "--write") {
+      readOnly = false;
+      continue;
+    }
+    if (arg === "--workspace") {
+      const next = args[index + 1];
+      if (!next)
+        throw new Error("Missing value for --workspace");
+      workspaceRoot = next;
+      index += 1;
+      continue;
+    }
+    if (arg === "host" || arg === "share") {
+      command = arg;
+      continue;
+    }
+    return null;
+  }
+  return {
+    command,
+    help,
+    json,
+    readOnly,
+    version,
+    workspaceRoot: resolve4(workspaceRoot)
+  };
+}
+function writeLine(text) {
+  process.stdout.write(`${text}
+`);
+}
+function renderHostSummary(workspaceRoot, snapshot) {
+  const pendingApprovals = snapshot.approvals.filter((item) => item.status === "pending").length;
+  const pendingInputs = (snapshot.userInputs ?? []).filter((item) => item.status === "pending").length;
+  return [
+    `Workspace: ${workspaceRoot}`,
+    `Tasks: ${snapshot.tasks.length}`,
+    `Runs: ${snapshot.runs.length}`,
+    `Approvals: ${pendingApprovals}`,
+    `Inputs: ${pendingInputs}`
+  ];
+}
+async function runRigHostCli(args) {
+  const options = parseRigHostCli(args);
+  if (!options) {
+    throw new Error("__RIG_HOST_CLI_FALLBACK__");
+  }
+  if (options.version) {
+    writeLine(`rig ${process.env.RIG_CLI_VERSION?.trim() || packageVersionFrom(import.meta.dir) || "0.0.0-dev"}`);
+    return;
+  }
+  if (options.help) {
+    writeLine(usageText());
+    return;
+  }
+  const host = await startRigHostSession({ workspaceRoot: options.workspaceRoot });
+  try {
+    if (options.command === "share") {
+      const link = await host.createShareLink(options.readOnly);
+      if (options.json) {
+        writeLine(JSON.stringify({ link, readOnly: options.readOnly, workspaceRoot: options.workspaceRoot }, null, 2));
+        return;
+      }
+      writeLine(`Share link (${options.readOnly ? "read-only" : "write"}): ${link}`);
+      return;
+    }
+    const snapshot = host.snapshot();
+    if (options.json) {
+      writeLine(JSON.stringify({
+        connection: "connected",
+        snapshot
+      }, null, 2));
+      return;
+    }
+    for (const line of renderHostSummary(options.workspaceRoot, snapshot))
+      writeLine(line);
+  } finally {
+    await host.stop("rig host cli complete");
+  }
+}
+export {
+  runRigHostCli
+};

package/dist/src/domain/approval.d.ts

@@ -0,0 +1 @@
+export declare function resolveApproval(_workspaceRoot: string, runId: string, requestId: string, decision: "approve" | "reject"): Promise<void>;

package/dist/src/domain/approval.js

@@ -0,0 +1,9 @@
+// @bun
+// packages/rig-host/src/domain/approval.ts
+var OMP_COLLAB_APPROVAL_RETIRED_MESSAGE = "Approval resolution through rig-host file append is retired. Resolve approvals through the OMP collab inbox/run detail flow.";
+async function resolveApproval(_workspaceRoot, runId, requestId, decision) {
+  throw new Error(`${OMP_COLLAB_APPROVAL_RETIRED_MESSAGE} Refusing to ${decision} approval ${requestId} for run ${runId}.`);
+}
+export {
+  resolveApproval
+};

package/dist/src/domain/input.d.ts

@@ -0,0 +1 @@
+export declare function resolveUserInput(_workspaceRoot: string, runId: string, requestId: string, _answers: Record<string, string>): Promise<void>;

package/dist/src/domain/input.js

@@ -0,0 +1,9 @@
+// @bun
+// packages/rig-host/src/domain/input.ts
+var OMP_COLLAB_INPUT_RETIRED_MESSAGE = "User input resolution through rig-host file append is retired. Resolve user input requests through the OMP collab inbox/run detail flow.";
+async function resolveUserInput(_workspaceRoot, runId, requestId, _answers) {
+  throw new Error(`${OMP_COLLAB_INPUT_RETIRED_MESSAGE} Refusing to resolve user input ${requestId} for run ${runId}.`);
+}
+export {
+  resolveUserInput
+};

package/dist/src/domain/run.d.ts

@@ -0,0 +1,28 @@
+import type { TaskSummary } from "@rig/contracts";
+import type { RigIdeaSnapshot } from "../protocol";
+export type LegacyAuthorityRunStartOptions = {
+    readonly runtimeAdapter?: string | null;
+    readonly model?: string | null;
+    readonly runtimeMode?: string | null;
+    readonly interactionMode?: string | null;
+    readonly initialPrompt?: string | null;
+    readonly baselineMode?: string | null;
+    readonly prMode?: "auto" | "ask" | "off" | null;
+};
+export type RigIdeaHarness = {
+    snapshot(): RigIdeaSnapshot;
+    stopRun(runId: string): Promise<void>;
+    resolveApproval(runId: string, requestId: string, decision: "approve" | "reject"): Promise<void>;
+    resolveUserInput(runId: string, requestId: string, answers: Record<string, string>): Promise<void>;
+};
+export declare function legacyAuthorityRunUnsupportedMessage(): string;
+export declare function legacyAuthorityRunControlUnsupportedMessage(): string;
+export declare function projectRetiredLegacyRigIdeaWorkspace(workspaceRoot: string, tasks: readonly TaskSummary[]): RigIdeaSnapshot;
+export declare function startLegacyRigIdeaAdhocAuthorityRun(_workspaceRoot: string, _prompt: string, _options?: LegacyAuthorityRunStartOptions): Promise<{
+    runId: string;
+}>;
+export declare function startLegacyRigIdeaTaskAuthorityRun(_workspaceRoot: string, _task: RigIdeaSnapshot["tasks"][number], _options?: LegacyAuthorityRunStartOptions): Promise<{
+    runId: string;
+}>;
+export declare function stopRigIdeaRun(_workspaceRoot: string, _runId: string): never;
+export declare function createRigIdeaHarness(workspaceRoot: string): Promise<RigIdeaHarness>;