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

package/dist/src/host-session.js

@@ -0,0 +1,355 @@
+// @bun
+// 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.";
+var RIG_RUN_SCOPE_LIMITATION = "Legacy rig-host selected-run remote join is retired for the product path. Selected-run discovery now belongs to OMP collab; use the default Rig OMP extension/collab session flow instead.";
+async function createRigOmpWritableJoinLink(_options) {
+  throw new Error(RIG_GENERIC_OMP_JOIN_LIMITATION);
+}
+async function createRigOmpJoinRoute(options) {
+  const runId = options.runId?.trim() ? options.runId : null;
+  throw new Error(runId ? RIG_RUN_SCOPE_LIMITATION : RIG_GENERIC_OMP_JOIN_LIMITATION);
+}
+async function joinRigOmpRelayLink(_options) {
+  throw new Error(RIG_GENERIC_OMP_JOIN_LIMITATION);
+}
+async function runRigJoinSelectedRun(_options) {
+  throw new Error(RIG_RUN_SCOPE_LIMITATION);
+}
+function rigGenericOmpJoinLimitation() {
+  return RIG_GENERIC_OMP_JOIN_LIMITATION;
+}
+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 });
+    }
+  };
+}
+export {
+  startRigHostSession,
+  runRigJoinSelectedRun,
+  rigGenericOmpJoinLimitation,
+  joinRigOmpRelayLink,
+  createRigOmpWritableJoinLink,
+  createRigOmpJoinRoute
+};

package/dist/src/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./host-session";
+export * from "./protocol";
+export * from "./cli-entry";
+export * from "./local-omp-runner";
+export * from "./pty-spawn";