@h-rig/transport-plugin 0.0.6-alpha.158

package/dist/src/discovery.js

@@ -0,0 +1,308 @@
+// @bun
+// packages/transport-plugin/src/discovery.ts
+import { Effect as Effect2, Option, Stream as Stream2, Duration } from "effect";
+
+// packages/transport-plugin/relay-registry/src/client.ts
+import { Effect, Queue, Stream } from "effect";
+function registryUrl(baseUrl, pathname) {
+  const base = baseUrl.endsWith("/") ? baseUrl : `${baseUrl}/`;
+  return new URL(pathname.replace(/^\/+/, ""), base);
+}
+function registryWsUrl(baseUrl, pathname) {
+  const url = registryUrl(baseUrl, pathname);
+  url.protocol = url.protocol === "https:" ? "wss:" : "ws:";
+  return url;
+}
+async function parseResponseJson(response) {
+  const text = await response.text();
+  const data = text ? JSON.parse(text) : null;
+  if (!response.ok) {
+    const message = data && typeof data === "object" && "error" in data ? String(data.error) : response.statusText;
+    throw new Error(`registry request failed (${response.status}): ${message}`);
+  }
+  return data;
+}
+function subscribeDiscovery(namespaceKey, repo, options) {
+  return Stream.callback((queue) => Effect.sync(() => {
+    const WebSocketCtor = options.WebSocket ?? WebSocket;
+    const url = registryWsUrl(options.baseUrl, "ws");
+    url.searchParams.set("namespaceKey", namespaceKey);
+    if (repo)
+      url.searchParams.set("repo", repo);
+    const ws = new WebSocketCtor(url);
+    const entries = new Map;
+    const snapshot = (sentAt) => ({
+      type: "registry.snapshot",
+      namespaceKey,
+      sentAt,
+      entries: Array.from(entries.values())
+    });
+    ws.addEventListener("message", (event) => {
+      try {
+        const text = typeof event.data === "string" ? event.data : String(event.data);
+        const frame = JSON.parse(text);
+        if (frame?.type === "registry.snapshot") {
+          entries.clear();
+          for (const entry of frame.entries)
+            entries.set(entry.roomId, entry);
+          Queue.offerUnsafe(queue, frame);
+          return;
+        }
+        if (frame?.type !== "registry.delta")
+          return;
+        if (frame.action === "remove") {
+          entries.delete(frame.roomId);
+        } else if (frame.entry) {
+          entries.set(frame.entry.roomId, frame.entry);
+        }
+        Queue.offerUnsafe(queue, snapshot(frame.sentAt));
+      } catch {}
+    });
+    ws.addEventListener("error", () => {});
+    return ws;
+  }).pipe(Effect.flatMap((ws) => Effect.addFinalizer(() => Effect.sync(() => ws.close())))), { bufferSize: 1, strategy: "sliding" });
+}
+function createRegistryClient(options) {
+  const requestFetch = options.fetch ?? fetch;
+  const headers = { "content-type": "application/json" };
+  async function post(pathname, body) {
+    const response = await requestFetch(registryUrl(options.baseUrl, pathname), {
+      method: "POST",
+      headers,
+      body: JSON.stringify(body)
+    });
+    return parseResponseJson(response);
+  }
+  return {
+    async registerRoom(room) {
+      const response = await post("register", room);
+      return response.entry;
+    },
+    async heartbeatRoom(roomId, status, projection) {
+      const body = projection === undefined ? { roomId, namespaceKey: options.namespaceKey, status } : { roomId, namespaceKey: options.namespaceKey, status, projection };
+      const response = await post("heartbeat", body);
+      return response.entry;
+    },
+    async ingestProjection(input) {
+      const response = await post("projection", {
+        ...input,
+        namespaceKey: input.namespaceKey ?? options.namespaceKey
+      });
+      return response.entry;
+    },
+    async listRoomsByOwner(filter) {
+      const namespaceKey = filter.namespaceKey ?? options.namespaceKey;
+      const url = registryUrl(options.baseUrl, "list");
+      url.searchParams.set("namespaceKey", namespaceKey);
+      if (filter.selectedRepo)
+        url.searchParams.set("repo", filter.selectedRepo);
+      const response = await requestFetch(url);
+      return (await parseResponseJson(response)).entries;
+    },
+    async removeRoom(roomId) {
+      const response = await post("remove", { roomId, namespaceKey: options.namespaceKey });
+      return response.removed;
+    }
+  };
+}
+// packages/transport-plugin/relay-registry/src/schema.ts
+import { RunStatus as ContractRunStatus, Schema } from "@rig/contracts";
+var RegistryOwner = Schema.Struct({
+  githubUserId: Schema.String,
+  login: Schema.String,
+  namespaceKey: Schema.String
+});
+var REGISTRY_STATUS_ALIASES = ["starting", "waiting-input"];
+var REGISTRY_STATUS_VALUES = [
+  ...ContractRunStatus.members.map((member) => member.literal),
+  ...REGISTRY_STATUS_ALIASES
+];
+var RegistryStatus = Schema.Literals(REGISTRY_STATUS_VALUES);
+var REGISTRY_STATUS_SET = new Set(REGISTRY_STATUS_VALUES);
+var RegistryEntry = Schema.Struct({
+  roomId: Schema.String,
+  owner: RegistryOwner,
+  repo: Schema.String,
+  title: Schema.String,
+  status: RegistryStatus,
+  joinLink: Schema.String,
+  webLink: Schema.String,
+  relayUrl: Schema.String,
+  startedAt: Schema.String,
+  cwd: Schema.optional(Schema.String),
+  sessionPath: Schema.optional(Schema.String),
+  heartbeatAt: Schema.String,
+  pid: Schema.optional(Schema.Number),
+  projection: Schema.optional(Schema.Unknown)
+});
+var RegisterRequest = Schema.Struct({
+  roomId: Schema.String,
+  owner: RegistryOwner,
+  repo: Schema.String,
+  title: Schema.String,
+  status: RegistryStatus,
+  joinLink: Schema.String,
+  webLink: Schema.String,
+  relayUrl: Schema.String,
+  startedAt: Schema.String,
+  cwd: Schema.optional(Schema.String),
+  sessionPath: Schema.optional(Schema.String),
+  pid: Schema.optional(Schema.Number),
+  projection: Schema.optional(Schema.Unknown)
+});
+var HeartbeatRequest = Schema.Struct({
+  roomId: Schema.String,
+  namespaceKey: Schema.String,
+  status: RegistryStatus,
+  projection: Schema.optional(Schema.Unknown)
+});
+var ProjectionIngestRequest = Schema.Struct({
+  namespaceKey: Schema.String,
+  roomId: Schema.optional(Schema.String),
+  owner: Schema.optional(RegistryOwner),
+  repo: Schema.optional(Schema.String),
+  projection: Schema.Unknown
+});
+var RemoveRequest = Schema.Struct({
+  namespaceKey: Schema.String,
+  roomId: Schema.String
+});
+var ListedRegistryEntry = Schema.Struct({
+  roomId: Schema.String,
+  owner: RegistryOwner,
+  repo: Schema.String,
+  title: Schema.String,
+  status: RegistryStatus,
+  joinLink: Schema.String,
+  webLink: Schema.String,
+  relayUrl: Schema.String,
+  startedAt: Schema.String,
+  heartbeatAt: Schema.String,
+  cwd: Schema.optional(Schema.String),
+  sessionPath: Schema.optional(Schema.String),
+  pid: Schema.optional(Schema.Number),
+  projection: Schema.optional(Schema.Unknown),
+  stale: Schema.Boolean
+});
+var ListResponse = Schema.Struct({
+  entries: Schema.Array(ListedRegistryEntry)
+});
+var RegisterResponse = Schema.Struct({
+  entry: RegistryEntry
+});
+var HeartbeatResponse = Schema.Struct({
+  entry: RegistryEntry
+});
+var ProjectionIngestResponse = Schema.Struct({
+  entry: RegistryEntry
+});
+var RemoveResponse = Schema.Struct({
+  removed: Schema.Boolean
+});
+var RegistrySnapshotFrame = Schema.Struct({
+  type: Schema.Literal("registry.snapshot"),
+  namespaceKey: Schema.String,
+  sentAt: Schema.String,
+  entries: Schema.Array(ListedRegistryEntry)
+});
+var RegistryDeltaFrame = Schema.Struct({
+  type: Schema.Literal("registry.delta"),
+  namespaceKey: Schema.String,
+  sentAt: Schema.String,
+  action: Schema.Literals(["upsert", "remove"]),
+  roomId: Schema.String,
+  entry: Schema.optional(ListedRegistryEntry)
+});
+var WorkerProjectionFrame = Schema.Struct({
+  type: Schema.Literal("projection"),
+  projection: Schema.Unknown
+});
+// packages/transport-plugin/src/discovery.ts
+import { resolveOwnerNamespaceKey, resolveRegistryBaseUrl } from "@rig/core/remote-config";
+function registryBaseUrl(projectRoot = process.cwd(), env = process.env) {
+  return resolveRegistryBaseUrl(projectRoot, env);
+}
+function collabFromRegistryEntry(entry) {
+  return {
+    sessionId: entry.roomId,
+    title: entry.title,
+    sessionPath: entry.sessionPath ?? (entry.projection && typeof entry.projection === "object" && "sessionPath" in entry.projection && typeof entry.projection.sessionPath === "string" ? entry.projection.sessionPath : ""),
+    cwd: entry.cwd ?? (entry.projection && typeof entry.projection === "object" && "worktreePath" in entry.projection && typeof entry.projection.worktreePath === "string" ? entry.projection.worktreePath : ""),
+    joinLink: entry.joinLink ?? "",
+    webLink: entry.webLink ?? "",
+    relayUrl: entry.relayUrl ?? "",
+    owner: entry.owner,
+    selectedRepo: entry.repo,
+    startedAt: entry.startedAt,
+    updatedAt: entry.heartbeatAt,
+    ...entry.pid === undefined ? {} : { pid: entry.pid },
+    stale: entry.stale,
+    registryStatus: entry.status,
+    registryProjection: entry.projection
+  };
+}
+function namespaceKeyFor(projectRoot, filter = {}) {
+  return filter.namespaceKey ?? resolveOwnerNamespaceKey(projectRoot) ?? "anonymous";
+}
+async function listActiveRunCollab(projectRoot, filter) {
+  return defaultListActiveCollabSessions(projectRoot, filter);
+}
+async function defaultListActiveCollabSessions(projectRoot, filter) {
+  const namespaceKey = namespaceKeyFor(projectRoot, filter);
+  if (!namespaceKey)
+    return [];
+  try {
+    const client = createRegistryClient({ baseUrl: registryBaseUrl(projectRoot), namespaceKey });
+    return (await client.listRoomsByOwner({ ...filter, namespaceKey })).map(collabFromRegistryEntry);
+  } catch {
+    return [];
+  }
+}
+function matchesRun(collab, runId, taskId) {
+  if (collab.sessionId === runId)
+    return true;
+  return Boolean(taskId && collab.title?.includes(taskId));
+}
+function runDiscoveryStream(projectRoot) {
+  const namespaceKey = namespaceKeyFor(projectRoot);
+  if (!namespaceKey)
+    return Stream2.never;
+  return subscribeDiscovery(namespaceKey, null, { baseUrl: registryBaseUrl(projectRoot) }).pipe(Stream2.map(() => {
+    return;
+  }));
+}
+function registrySnapshotStream(projectRoot, filter = {}) {
+  const namespaceKey = namespaceKeyFor(projectRoot, filter);
+  if (!namespaceKey)
+    return Stream2.never;
+  return subscribeDiscovery(namespaceKey, filter.selectedRepo ?? null, { baseUrl: registryBaseUrl(projectRoot) });
+}
+var DEFAULT_ATTACH_TIMEOUT_MS = 15000;
+async function attachViaRelay(input, deps = {}) {
+  const timeoutMs = input.timeoutMs ?? DEFAULT_ATTACH_TIMEOUT_MS;
+  const root = input.projectRoot ?? process.cwd();
+  const listActive = deps.listActiveCollabSessions ?? ((filter) => defaultListActiveCollabSessions(root, filter));
+  const checkOnce = async () => {
+    const live = await listActive(input.identityFilter);
+    const exact = live.find((collab) => collab.sessionId === input.runId && !collab.stale);
+    const match = exact ?? live.find((collab) => matchesRun(collab, input.runId, input.taskId) && !collab.stale);
+    if (!match)
+      return null;
+    return { sessionPath: match.sessionPath ?? null, joinLink: match.joinLink ?? null, collabSessionId: match.sessionId ?? null };
+  };
+  const immediate = await checkOnce();
+  if (immediate)
+    return immediate;
+  const events = deps.discoveryStream ? deps.discoveryStream(root) : runDiscoveryStream(root);
+  return await Effect2.runPromise(events.pipe(Stream2.mapEffect(() => Effect2.promise(checkOnce)), Stream2.filter((m) => m !== null), Stream2.runHead, Effect2.timeout(Duration.millis(timeoutMs)), Effect2.map(Option.getOrNull), Effect2.catch(() => Effect2.succeed(null))));
+}
+export {
+  runDiscoveryStream,
+  registrySnapshotStream,
+  registryBaseUrl,
+  matchesRun,
+  listActiveRunCollab,
+  defaultListActiveCollabSessions,
+  collabFromRegistryEntry,
+  attachViaRelay
+};

package/dist/src/dispatch.d.ts

@@ -0,0 +1,47 @@
+import type { ChildProcess, SpawnOptions } from "node:child_process";
+import { type TransportCapability } from "@rig/contracts";
+import { type DispatchTransportPlacement } from "@rig/core/remote-config";
+import type { RegistrySnapshotFrame } from "./relay-registry";
+import { Stream } from "effect";
+export { resolveDispatchTransportPlacement, type DispatchTransportPlacement } from "@rig/core/remote-config";
+export type SpawnFunction = (command: string, args: readonly string[], options: SpawnOptions) => ChildProcess;
+export type DispatchPlacementResolver = (projectRoot: string, env: NodeJS.ProcessEnv) => DispatchTransportPlacement;
+export type DispatchRunOptions = {
+    readonly placement?: DispatchTransportPlacement | DispatchPlacementResolver;
+};
+export type SpawnRunProcessDeps = {
+    readonly spawn?: SpawnFunction;
+    readonly uuid?: () => string;
+    readonly resolveRigRunBin?: () => string;
+    readonly env?: NodeJS.ProcessEnv;
+    readonly resolvePlacement?: DispatchPlacementResolver;
+};
+export type DispatchRunDeps = SpawnRunProcessDeps & {
+    readonly spawnRunProcess?: (input: SpawnRunProcessInput, deps?: SpawnRunProcessDeps) => Promise<{
+        readonly runId: string;
+    }>;
+    readonly discoverySnapshots?: (projectRoot: string) => Stream.Stream<RegistrySnapshotFrame>;
+    readonly localSessionTimeoutMs?: number;
+    readonly remoteSessionTimeoutMs?: number;
+};
+export type SpawnRunProcessInput = {
+    readonly projectRoot: string;
+    readonly taskId: string;
+    readonly title?: string | null;
+    readonly model?: string | null;
+    readonly prompt?: string | null;
+    readonly force?: boolean;
+};
+export declare function resolveRigRunBin(): string;
+/**
+ * Inner process spawn. Its runId is the transient worktree handle/correlation key.
+ * Operator-facing dispatch uses dispatchRun(), which waits for and returns the OMP session id.
+ */
+export declare function spawnRunProcess(input: SpawnRunProcessInput, deps?: SpawnRunProcessDeps): Promise<{
+    readonly runId: string;
+}>;
+export declare function sessionIdFromDispatchSnapshot(snapshot: RegistrySnapshotFrame, dispatchHandle: string): string | null;
+export declare function dispatchRun(input: SpawnRunProcessInput, deps?: DispatchRunDeps): Promise<{
+    readonly runId: string;
+}>;
+export declare function createPlacementRunTransport(deps?: DispatchRunDeps): TransportCapability;