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

package/dist/src/relay-registry.d.ts

@@ -0,0 +1,3 @@
+export { connectWorkerProjection, createRegistryClient, subscribeDiscovery, type CollabRegistryFilter, type DiscoverySubscriptionOptions, type RegistryClient, type RegistryClientOptions, type WorkerProjectionConnection, type WorkerProjectionOptions, } from "../relay-registry/src/client";
+export { coerceRegistryStatus } from "../relay-registry/src/schema";
+export type { HeartbeatRequest, ListedRegistryEntry, ProjectionIngestRequest, RegisterRequest, RegistryDiscoveryFrame, RegistryEntry, RegistryRunProjection, RegistrySnapshotFrame, RemoveRequest, WorkerProjectionFrame, } from "../relay-registry/src/schema";

package/dist/src/relay-registry.js

@@ -0,0 +1,284 @@
+// @bun
+// 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 workerProjectionFrame(frame) {
+  return typeof frame === "object" && frame !== null && "type" in frame && frame.type === "projection" ? frame : { type: "projection", projection: frame };
+}
+function connectWorkerProjection(first, runId, options) {
+  const cfg = typeof first === "string" ? { baseUrl: options?.baseUrl ?? "", namespaceKey: first, runId: runId ?? "", ...options?.WebSocket ? { WebSocket: options.WebSocket } : {} } : first;
+  if (!cfg.baseUrl)
+    throw new Error("baseUrl is required for worker projection websocket");
+  if (!cfg.runId)
+    throw new Error("runId is required for worker projection websocket");
+  const WebSocketCtor = cfg.WebSocket ?? WebSocket;
+  const url = registryWsUrl(cfg.baseUrl, "worker");
+  url.searchParams.set("namespaceKey", cfg.namespaceKey);
+  url.searchParams.set("runId", cfg.runId);
+  const ws = new WebSocketCtor(url);
+  const pending = [];
+  let closed = false;
+  const ready = new Promise((resolve, reject) => {
+    ws.addEventListener("open", () => {
+      resolve();
+      while (pending.length && ws.readyState === WebSocketCtor.OPEN)
+        ws.send(JSON.stringify(pending.shift()));
+    }, { once: true });
+    ws.addEventListener("error", () => {
+      closed = true;
+      pending.length = 0;
+      reject(new Error("worker projection websocket error"));
+    }, { once: true });
+  });
+  ready.catch(() => {
+    return;
+  });
+  return {
+    ready,
+    push(frame) {
+      if (closed)
+        return;
+      const encoded = workerProjectionFrame(frame);
+      if (ws.readyState === WebSocketCtor.OPEN) {
+        ws.send(JSON.stringify(encoded));
+        return;
+      }
+      pending.push(encoded);
+    },
+    close() {
+      closed = true;
+      pending.length = 0;
+      try {
+        ws.close();
+      } catch {}
+    }
+  };
+}
+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);
+function isRegistryStatus(value) {
+  return typeof value === "string" && REGISTRY_STATUS_SET.has(value);
+}
+function coerceRegistryStatus(value, fallback) {
+  if (value === "starting")
+    return "preparing";
+  if (value === "waiting-input")
+    return "waiting-user-input";
+  return isRegistryStatus(value) ? value : fallback;
+}
+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
+});
+export {
+  subscribeDiscovery,
+  createRegistryClient,
+  connectWorkerProjection,
+  coerceRegistryStatus
+};

package/dist/src/run-discovery-bus.d.ts

@@ -0,0 +1,32 @@
+import { Effect, Layer, ServiceMap, Stream } from "effect";
+/**
+ * RunDiscoveryBus — an in-process event bus for run-discovery, following the
+ * t3code `RuntimeReceiptBus` pattern (a `ServiceMap.Service` backed by an Effect
+ * `PubSub`, exposed as a `Stream`). Producers (`localRunChanges` fs.watch,
+ * `remoteRunChanges` registry SSE) `publish` change events; the cockpit
+ * subscribes to `events` once and re-discovers, decoupled from how many sources
+ * feed it. New sources merge by publishing to the same bus — no consumer change.
+ */
+export interface RunDiscoveryEvent {
+    readonly source: "local" | "remote";
+    readonly kind: "registered" | "heartbeat" | "removed" | "changed";
+    readonly roomId?: string;
+}
+export interface RunDiscoveryBusShape {
+    readonly publish: (event: RunDiscoveryEvent) => Effect.Effect<void>;
+    readonly events: Stream.Stream<RunDiscoveryEvent>;
+}
+declare const RunDiscoveryBus_base: ServiceMap.ServiceClass<RunDiscoveryBus, "@rig/runtime/control-plane/RunDiscoveryBus", RunDiscoveryBusShape>;
+export declare class RunDiscoveryBus extends RunDiscoveryBus_base {
+    static readonly layer: Layer.Layer<RunDiscoveryBus, never, never>;
+}
+/**
+ * Fork each source stream so its signals become bus events, then return the
+ * deduped/debounced event stream for the caller to consume — the whole bus
+ * lifecycle in one Effect (provide `RunDiscoveryBus.layer` to run it).
+ */
+export declare const forkDiscoverySources: (sources: ReadonlyArray<{
+    readonly source: "local" | "remote";
+    readonly stream: Stream.Stream<void>;
+}>) => Effect.Effect<Stream.Stream<RunDiscoveryEvent>, never, RunDiscoveryBus>;
+export {};

package/dist/src/run-discovery-bus.js

@@ -0,0 +1,24 @@
+// @bun
+// packages/transport-plugin/src/run-discovery-bus.ts
+import { Effect, Layer, PubSub, ServiceMap, Stream } from "effect";
+
+class RunDiscoveryBus extends ServiceMap.Service()("@rig/runtime/control-plane/RunDiscoveryBus") {
+  static layer = Layer.effect(RunDiscoveryBus, Effect.gen(function* () {
+    const pubsub = yield* PubSub.unbounded();
+    return {
+      publish: (event) => PubSub.publish(pubsub, event).pipe(Effect.asVoid),
+      events: Stream.fromPubSub(pubsub)
+    };
+  }));
+}
+var forkDiscoverySources = (sources) => Effect.gen(function* () {
+  const bus = yield* RunDiscoveryBus;
+  for (const { source, stream } of sources) {
+    yield* Effect.forkChild(Stream.runForEach(stream, () => bus.publish({ source, kind: "changed" })));
+  }
+  return bus.events;
+});
+export {
+  forkDiscoverySources,
+  RunDiscoveryBus
+};

package/dist/src/transport-provider.d.ts

@@ -0,0 +1,9 @@
+import type { CapabilityProviderPlugin } from "@rig/kernel-seed/plugin-abi";
+import { type DispatchRunDeps } from "./dispatch";
+/**
+ * Build the placement-aware `transport` capability provider plugin (kernel-seed
+ * shape). Pass it to `adopt({ transport })` / `bootDefaultKernel({ extraPlugins })`.
+ * `deps` are the dispatch overrides (spawn/uuid/env/timeouts) — empty in
+ * production; the defaults reproduce exactly the former in-kernel auto-binding.
+ */
+export declare function createPlacementTransportProviderPlugin(deps?: DispatchRunDeps): CapabilityProviderPlugin;