@scp-dev/broker 0.1.3 → 0.1.4

package/src/server.ts

@@ -26,7 +26,7 @@ import {
   stripControl,
 } from "@scp-dev/core"
 import { FederatedCore } from "@scp-dev/hub"
-import { type Bridge, type BridgeConfig, remoteSend, startBridge } from "./bridge"
+import { type Bridge, type BridgeConfig, type BridgeHooks, remoteSend, startBridge } from "./bridge"
 import { type Deliver, type JudgeClientFactory, JudgeGate } from "./judge-gate"
 import { releaseBrokerLock, takeBrokerLock } from "./lock"
 import { encodeLine, LineReader, LineWriter, MAX_LINE } from "./ndjson"
@@ -60,6 +60,8 @@ export interface BrokerOptions {
   bridge?: BridgeConfig | undefined
   /** reads the bridge configuration again for bridge_relink; one that appeared or names another hub or machine restarts the broker */
   bridgeConfig?: (() => Promise<BridgeConfig | undefined>) | undefined
+  /** experimental: another link to other machines in place of the hub's, started only when `bridge` is unset */
+  link?: LinkFactory | undefined
   /** how often presence that decays without a request (a hook-only endpoint) is checked for changes (default 60 s) */
   presenceEveryMs?: number | undefined
   /** where a judge model's key_env is read (default the broker's environment) */
@@ -68,6 +70,15 @@ export interface BrokerOptions {
   judgeClient?: JudgeClientFactory | undefined
 }
 
+/** what a link gets from the broker: its core, the remote hooks a bridge gets, and a send as a local endpoint or a mirrored one through the judge */
+export interface LinkContext {
+  core: FederatedCore
+  hooks: BridgeHooks
+  send: Deliver
+}
+
+export type LinkFactory = (context: LinkContext) => Bridge
+
 export interface Broker {
   socket: string
   core: FederatedCore
@@ -88,6 +99,8 @@ interface Connection {
   tty?: boolean
   /** the connection holds the human inbox */
   human?: boolean
+  /** a human hello bound to the agent of this shell's lineage said a terminal was attached: the human at that agent's shell */
+  terminal?: boolean
   /**
    * the lineage endpoint of an observer, or of a hello bound to it: the connection sees and acts with that endpoint's view,
    * never widening unless `own`, and never counts as connected
@@ -269,21 +282,17 @@ export async function startBroker(options: BrokerOptions): Promise<Broker> {
     }
     for (const id of known.keys()) if (!live.has(id)) known.delete(id)
   }, options.presenceEveryMs ?? PRESENCE_MS)
-  if (options.bridge) {
-    bridge = startBridge({
-      ...options.bridge,
-      core,
-      onRemote: {
-        wake,
-        fleet: notifyFleet,
-        policyError: () => {
-          loadPolicy()
-          return policyError
-        },
-        log,
-      },
-    })
+  const remoteHooks: BridgeHooks = {
+    wake,
+    fleet: notifyFleet,
+    policyError: () => {
+      loadPolicy()
+      return policyError
+    },
+    log,
   }
+  if (options.bridge) bridge = startBridge({ ...options.bridge, core, onRemote: remoteHooks })
+  else if (options.link) bridge = options.link({ core, hooks: remoteHooks, send: (from, params, origin) => judge.send(from, params, origin, deliver) })
 
   /** links the bridge again with the credential on disk; a configuration this broker cannot take without a restart stops it */
   async function relink(): Promise<object> {
@@ -697,18 +706,24 @@ export async function startBroker(options: BrokerOptions): Promise<Broker> {
         }
         const join = params.join
         if (join !== undefined && (typeof join !== "object" || join === null || Array.isArray(join)))
-          throw new RelayError("invalid_params", "join is {handle?}")
+          throw new RelayError("invalid_params", "join is {handle?, under?}")
+        const under = (join as { under?: unknown } | undefined)?.under
         const before = new Map(core.list({ all: true }).map((view) => [view.id, view]))
         const { endpoint, subagent, created } =
           join === undefined
             ? core.claim((params.claim ?? {}) as Claim, { transient: true })
-            : { endpoint: core.joinSession((params.claim ?? {}) as Claim, (join as { handle?: unknown }).handle), subagent: undefined, created: undefined }
+            : {
+                endpoint: core.joinSession((params.claim ?? {}) as Claim, (join as { handle?: unknown }).handle, under),
+                subagent: undefined,
+                created: undefined,
+              }
         s.data.endpoint = endpoint.id
         s.data.transient = true
         const key = (params.claim as Claim | undefined)?.process
         if (typeof key === "string") s.data.process = key
         const was = before.get(endpoint.id)?.address
         if (join !== undefined) membership(endpoint, core.sessionOf(endpoint.id), true, was?.slice(was.lastIndexOf("/") + 1))
+        if (under !== undefined && before.get(endpoint.id)?.parent !== endpoint.parent) bridge?.resync()
         else if ((before.get(endpoint.id)?.presence ?? "offline") !== endpoint.presence) presenceChanged(endpoint)
         return {
           endpoint,
@@ -741,7 +756,10 @@ export async function startBroker(options: BrokerOptions): Promise<Broker> {
       const claim = params.claim as Claim | undefined
       if (params.human === true && params.resume === undefined && params.lineage !== undefined) {
         const placed = core.placeLineage(params.lineage)
-        if (placed) return bindLineage(s, placed, params)
+        if (placed) {
+          s.data.terminal = params.tty === true
+          return bindLineage(s, placed, params)
+        }
       } else if (params.human !== true && params.resume === undefined && claim?.process === undefined && typeof claim?.handle === "string") {
         const placed = claim.lineage === undefined ? null : core.placeLineage(claim.lineage, claim.handle)
         if (placed && (claim.grant === undefined || core.grantBinds(claim.grant, placed))) {
@@ -858,6 +876,21 @@ export async function startBroker(options: BrokerOptions): Promise<Broker> {
         membership(renamed.endpoint, renamed.session, true, renamed.from)
         return renamed.endpoint
       }
+      case "adopt": {
+        const actor = actorOf(s)
+        const adopted = core.adopt(
+          actor,
+          { endpoint: params.endpoint, ...(params.parent !== undefined ? { parent: params.parent } : {}) },
+          { tty: actor.kind === "endpoint" && s.data.terminal === true },
+        )
+        bridge?.resync()
+        return adopted
+      }
+      case "unlink": {
+        const unlinked = core.unlink(actorOf(s), params.endpoint !== undefined ? { endpoint: params.endpoint } : {})
+        bridge?.resync()
+        return unlinked
+      }
       case "leave": {
         const left = core.leaveSession(actorOf(s), params.endpoint !== undefined ? { endpoint: params.endpoint } : {})
         for (const c of connections) if (c.data.endpoint === left.endpoint.id && !c.data.transient && !c.data.lineage && c !== s) c.end()