anorion 0.1.0

package/src/bridge/client.ts

@@ -0,0 +1,221 @@
+// Bridge Client — outbound connection to a peer gateway
+
+import type {
+  BridgeMessage,
+  HelloPayload,
+  MessageForwardPayload,
+  MessageResponsePayload,
+} from './protocol';
+import {
+  createBridgeMessage,
+  parseBridgeMessage,
+  BRIDGE_VERSION,
+} from './protocol';
+import { logger } from '../shared/logger';
+import { agentRegistry } from '../agents/registry';
+
+export type ClientState = 'disconnected' | 'connecting' | 'connected';
+
+interface PendingRequest {
+  resolve: (msg: BridgeMessage) => void;
+  reject: (err: Error) => void;
+  timer: ReturnType<typeof setTimeout>;
+}
+
+export class BridgeClient {
+  readonly peerUrl: string;
+  readonly secret: string;
+  state: ClientState = 'disconnected';
+  private ws: WebSocket | null = null;
+  private reconnectTimer: ReturnType<typeof setTimeout> | null = null;
+  private heartbeatTimer: ReturnType<typeof setInterval> | null = null;
+  private backoffMs = 1000;
+  private queue: BridgeMessage[] = [];
+  private pendingRequests = new Map<string, PendingRequest>();
+  private peerGatewayId: string | null = null;
+  private onMessage: ((msg: BridgeMessage) => void) | null = null;
+  private onClose: (() => void) | null = null;
+  private stopped = false;
+
+  constructor(peerUrl: string, secret: string) {
+    this.peerUrl = peerUrl;
+    this.secret = secret;
+  }
+
+  get connected(): boolean {
+    return this.state === 'connected' && this.ws !== null && this.ws.readyState === WebSocket.OPEN;
+  }
+
+  setHandlers(onMessage: (msg: BridgeMessage) => void, onClose: () => void) {
+    this.onMessage = onMessage;
+    this.onClose = onClose;
+  }
+
+  async start(ownGatewayId: string): Promise<void> {
+    this.stopped = false;
+    this.connect(ownGatewayId);
+  }
+
+  stop(): void {
+    this.stopped = true;
+    this.cleanup();
+    // Reject pending
+    for (const [id, req] of this.pendingRequests) {
+      clearTimeout(req.timer);
+      req.reject(new Error('Client stopped'));
+      this.pendingRequests.delete(id);
+    }
+  }
+
+  send(msg: BridgeMessage): void {
+    if (this.connected) {
+      this.ws!.send(JSON.stringify(msg));
+    } else {
+      this.queue.push(msg);
+    }
+  }
+
+  async request(msg: BridgeMessage, timeoutMs = 30000): Promise<BridgeMessage> {
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        this.pendingRequests.delete(msg.messageId);
+        reject(new Error('Bridge request timeout'));
+      }, timeoutMs);
+      this.pendingRequests.set(msg.messageId, { resolve, reject, timer });
+      this.send(msg);
+    });
+  }
+
+  private connect(ownGatewayId: string): void {
+    if (this.stopped) return;
+    this.state = 'connecting';
+    logger.info({ url: this.peerUrl, backoff: this.backoffMs }, 'Bridge client connecting');
+
+    try {
+      const url = new URL(this.peerUrl);
+      url.searchParams.set('secret', this.secret);
+
+      this.ws = new WebSocket(url.toString());
+      this.ws.onopen = () => {
+        this.state = 'connected';
+        this.backoffMs = 1000;
+        logger.info({ url: this.peerUrl }, 'Bridge client connected');
+
+        // Send hello
+        const hello = createBridgeMessage('hello', ownGatewayId, {
+          secret: this.secret,
+          gatewayId: ownGatewayId,
+          agents: agentRegistry.list().map((a) => ({ id: a.id, name: a.name, status: a.state })),
+        } as HelloPayload);
+        this.ws!.send(JSON.stringify(hello));
+
+        // Flush queue
+        for (const msg of this.queue) {
+          this.ws!.send(JSON.stringify(msg));
+        }
+        this.queue = [];
+
+        // Start heartbeat
+        this.heartbeatTimer = setInterval(() => {
+          if (this.connected) {
+            this.send(createBridgeMessage('health-ping', ownGatewayId, {}));
+          }
+        }, 30_000);
+      };
+
+      this.ws.onmessage = (event) => {
+        const msg = parseBridgeMessage(event.data as string);
+        if (!msg) return;
+
+        // Handle pending requests
+        const pending = this.pendingRequests.get(msg.messageId);
+        if (pending) {
+          clearTimeout(pending.timer);
+          this.pendingRequests.delete(msg.messageId);
+          pending.resolve(msg);
+          return;
+        }
+
+        if (msg.type === 'hello-ack') {
+          this.peerGatewayId = msg.gatewayId;
+          logger.info({ peerGatewayId: this.peerGatewayId }, 'Bridge peer acknowledged');
+        }
+
+        if (msg.type === 'message-forward') {
+          // Handle incoming message-forward from peer (we are the target)
+          void this.handleMessageForward(msg, ownGatewayId);
+          return;
+        }
+
+        this.onMessage?.(msg);
+      };
+
+      this.ws.onclose = () => {
+        logger.info({ url: this.peerUrl }, 'Bridge client disconnected');
+        this.state = 'disconnected';
+        this.onClose?.();
+        this.scheduleReconnect(ownGatewayId);
+      };
+
+      this.ws.onerror = (err) => {
+        logger.error({ url: this.peerUrl, error: String(err) }, 'Bridge client error');
+      };
+    } catch (err) {
+      logger.error({ url: this.peerUrl, error: (err as Error).message }, 'Bridge client connect failed');
+      this.scheduleReconnect(ownGatewayId);
+    }
+  }
+
+  private async handleMessageForward(msg: BridgeMessage, ownGatewayId: string): Promise<void> {
+    const payload = msg.payload as MessageForwardPayload;
+    const { sendMessage } = await import('../agents/runtime');
+    try {
+      const result = await sendMessage({
+        agentId: payload.targetAgentId,
+        sessionId: payload.sessionId,
+        text: payload.text,
+        channelId: payload.channelId,
+      });
+      const response = createBridgeMessage('message-response', ownGatewayId, {
+        requestMessageId: msg.messageId,
+        content: result.content,
+      } as MessageResponsePayload);
+      this.send(response);
+    } catch (err) {
+      const response = createBridgeMessage('message-response', ownGatewayId, {
+        requestMessageId: msg.messageId,
+        content: '',
+        error: (err as Error).message,
+      } as MessageResponsePayload);
+      this.send(response);
+    }
+  }
+
+  private scheduleReconnect(ownGatewayId: string): void {
+    if (this.stopped) return;
+    this.cleanup();
+    this.reconnectTimer = setTimeout(() => {
+      this.connect(ownGatewayId);
+    }, this.backoffMs);
+    this.backoffMs = Math.min(this.backoffMs * 2, 30_000);
+  }
+
+  private cleanup(): void {
+    if (this.reconnectTimer) {
+      clearTimeout(this.reconnectTimer);
+      this.reconnectTimer = null;
+    }
+    if (this.heartbeatTimer) {
+      clearInterval(this.heartbeatTimer);
+      this.heartbeatTimer = null;
+    }
+    if (this.ws) {
+      this.ws.onclose = null;
+      this.ws.onerror = null;
+      if (this.ws.readyState === WebSocket.OPEN || this.ws.readyState === WebSocket.CONNECTING) {
+        this.ws.close();
+      }
+      this.ws = null;
+    }
+  }
+}

package/src/bridge/federator.ts

@@ -0,0 +1,221 @@
+// Federator — peer table management, agent discovery, message routing
+
+import { createBridgeMessage, type MessageForwardPayload, type MessageResponsePayload } from './protocol';
+import { BridgeClient } from './client';
+import { BridgeServer } from './server';
+import { agentRegistry } from '../agents/registry';
+import { logger } from '../shared/logger';
+
+export interface PeerInfo {
+  id: string;
+  url: string;
+  status: 'connecting' | 'connected' | 'disconnected';
+  agentCount: number;
+  connectedAt?: number;
+  lastPing: number;
+}
+
+interface RemoteAgent {
+  id: string;
+  name: string;
+  status: string;
+  gatewayId: string;
+}
+
+const MAX_QUEUE_SIZE = 100;
+
+export class Federator {
+  private ownGatewayId: string;
+  private secret: string;
+  private clients = new Map<string, BridgeClient>(); // url -> client
+  private bridgeServer: BridgeServer;
+  private messageQueue: Array<{ targetAgentId: string; payload: MessageForwardPayload; resolve: (v: unknown) => void; reject: (e: Error) => void }> = [];
+  private stats = { messagesForwarded: 0, messagesReceived: 0, queueDropped: 0, startTime: Date.now() };
+
+  constructor(ownGatewayId: string, secret: string, bridgeServer: BridgeServer) {
+    this.ownGatewayId = ownGatewayId;
+    this.secret = secret;
+    this.bridgeServer = bridgeServer;
+  }
+
+  async connectPeer(url: string, secret: string): Promise<void> {
+    if (this.clients.has(url)) {
+      logger.warn({ url }, 'Peer already configured');
+      return;
+    }
+
+    const client = new BridgeClient(url, secret);
+
+    client.setHandlers(
+      (msg) => this.handleClientMessage(url, msg),
+      () => logger.info({ url }, 'Bridge client closed'),
+    );
+
+    this.clients.set(url, client);
+    await client.start(this.ownGatewayId);
+  }
+
+  disconnectPeer(url: string): void {
+    const client = this.clients.get(url);
+    if (client) {
+      client.stop();
+      this.clients.delete(url);
+    }
+  }
+
+  private handleClientMessage(_url: string, _msg: unknown): void {
+    // Client-level messages handled internally (hello-ack etc.)
+  }
+
+  // Get all agents: local + remote
+  getAllAgents(): { local: ReturnType<typeof agentRegistry.list>; remote: RemoteAgent[] } {
+    const local = agentRegistry.list();
+    const remote: RemoteAgent[] = [];
+
+    // From server-side connections
+    for (const [, conn] of this.bridgeServer.getConnections()) {
+      for (const agent of conn.agents) {
+        remote.push({ ...agent, gatewayId: conn.gatewayId });
+      }
+    }
+
+    return { local, remote };
+  }
+
+  // Check if an agent is remote (hosted on a peer)
+  findRemoteAgent(agentId: string): { gatewayId: string; gatewayUrl?: string } | null {
+    // Check server-side connections (inbound)
+    for (const [gwId, conn] of this.bridgeServer.getConnections()) {
+      if (conn.agents.some((a) => a.id === agentId)) {
+        return { gatewayId: gwId };
+      }
+    }
+    return null;
+  }
+
+  // Route a message to an agent (local or remote)
+  async routeMessage(targetAgentId: string, text: string, sessionId?: string, channelId?: string): Promise<{ content: string; error?: string }> {
+    // Check local first
+    const local = agentRegistry.get(targetAgentId) || agentRegistry.getByName(targetAgentId);
+    if (local) {
+      const { sendMessage } = await import('../agents/runtime');
+      const result = await sendMessage({ agentId: local.id, sessionId, text, channelId });
+      return { content: result.content };
+    }
+
+    // Check remote
+    const remote = this.findRemoteAgent(targetAgentId);
+    if (remote) {
+      return this.sendToRemote(remote.gatewayId, targetAgentId, text, sessionId, channelId);
+    }
+
+    // Check remote by name too
+    const { remote: allRemote } = this.getAllAgents();
+    const namedRemote = allRemote.find((a) => a.name === targetAgentId);
+    if (namedRemote) {
+      return this.sendToRemote(namedRemote.gatewayId, namedRemote.id, text, sessionId, channelId);
+    }
+
+    // Queue if not found (maybe agent will appear)
+    if (this.messageQueue.length >= MAX_QUEUE_SIZE) {
+      // Drop the oldest queued message to cap memory
+      const oldest = this.messageQueue.shift();
+      if (oldest) {
+        oldest.reject(new Error('Message dropped: queue full'));
+        this.stats.queueDropped++;
+      }
+    }
+
+    return new Promise((resolve, reject) => {
+      this.messageQueue.push({ targetAgentId, payload: { targetAgentId, text, sessionId, channelId }, resolve, reject });
+      // Auto-reject after 30s
+      setTimeout(() => {
+        const idx = this.messageQueue.findIndex((m) => m.resolve === resolve);
+        if (idx !== -1) {
+          this.messageQueue.splice(idx, 1);
+          reject(new Error(`Agent not found: ${targetAgentId}`));
+        }
+      }, 30_000);
+    });
+  }
+
+  private async sendToRemote(gatewayId: string, targetAgentId: string, text: string, sessionId?: string, channelId?: string): Promise<{ content: string; error?: string }> {
+    const msg = createBridgeMessage('message-forward', this.ownGatewayId, {
+      targetAgentId,
+      sessionId,
+      text,
+      channelId,
+    } as MessageForwardPayload);
+
+    this.stats.messagesForwarded++;
+
+    try {
+      const response = await this.bridgeServer.sendToPeer(gatewayId, msg);
+      const payload = response.payload as MessageResponsePayload;
+      this.stats.messagesReceived++;
+      return { content: payload.content, error: payload.error };
+    } catch (err) {
+      return { content: '', error: (err as Error).message };
+    }
+  }
+
+  // Process queued messages if agents become available
+  flushQueue(): void {
+    const remaining = [];
+    for (const item of this.messageQueue) {
+      const local = agentRegistry.get(item.targetAgentId);
+      const remote = this.findRemoteAgent(item.targetAgentId);
+      if (local || remote) {
+        this.routeMessage(item.targetAgentId, item.payload.text, item.payload.sessionId, item.payload.channelId)
+          .then(item.resolve)
+          .catch(item.reject);
+      } else {
+        remaining.push(item);
+      }
+    }
+    this.messageQueue = remaining;
+  }
+
+  // Peer status for API
+  getPeers(): PeerInfo[] {
+    const peers: PeerInfo[] = [];
+
+    // Outbound clients
+    for (const [url, client] of this.clients) {
+      const gwId = 'outbound-' + url.replace(/[^a-zA-Z0-9]/g, '-');
+      peers.push({
+        id: gwId,
+        url,
+        status: client.state,
+        agentCount: 0,
+        lastPing: Date.now(),
+      });
+    }
+
+    // Inbound connections
+    for (const [gwId, conn] of this.bridgeServer.getConnections()) {
+      peers.push({
+        id: gwId,
+        url: 'inbound',
+        status: 'connected',
+        agentCount: conn.agents.length,
+        connectedAt: conn.connectedAt,
+        lastPing: conn.lastPong,
+      });
+    }
+
+    return peers;
+  }
+
+  getStatus() {
+    return {
+      enabled: true,
+      peerCount: this.clients.size + this.bridgeServer.getConnections().size,
+      queueSize: this.messageQueue.length,
+      messagesForwarded: this.stats.messagesForwarded,
+      messagesReceived: this.stats.messagesReceived,
+      queueDropped: this.stats.queueDropped,
+      uptime: Date.now() - this.stats.startTime,
+    };
+  }
+}

package/src/bridge/protocol.ts

@@ -0,0 +1,88 @@
+// Bridge wire protocol for gateway-to-gateway communication
+
+export const BRIDGE_VERSION = '1.0.0';
+
+export type BridgeMessageType =
+  | 'hello'
+  | 'agent-register'
+  | 'agent-update'
+  | 'message-forward'
+  | 'message-response'
+  | 'health-ping'
+  | 'health-pong'
+  | 'unsubscribe'
+  | 'hello-ack';
+
+export interface BridgeMessage {
+  version: string;
+  type: BridgeMessageType;
+  messageId: string;
+  gatewayId: string;
+  timestamp: number;
+  payload: unknown;
+}
+
+// Payloads
+
+export interface HelloPayload {
+  secret: string;
+  gatewayId: string;
+  agents: { id: string; name: string; status: string }[];
+  capabilities?: string[];
+}
+
+export interface HelloAckPayload {
+  gatewayId: string;
+  agents: { id: string; name: string; status: string }[];
+}
+
+export interface AgentRegisterPayload {
+  agents: { id: string; name: string; status: string }[];
+}
+
+export interface AgentUpdatePayload {
+  agentId: string;
+  status: string;
+}
+
+export interface MessageForwardPayload {
+  targetAgentId: string;
+  messageId: string;
+  sessionId?: string;
+  text: string;
+  channelId?: string;
+}
+
+export interface MessageResponsePayload {
+  requestMessageId: string;
+  content: string;
+  error?: string;
+}
+
+export function createBridgeMessage(
+  type: BridgeMessageType,
+  gatewayId: string,
+  payload: unknown,
+  messageId?: string,
+): BridgeMessage {
+  return {
+    version: BRIDGE_VERSION,
+    type,
+    messageId: messageId || crypto.randomUUID(),
+    gatewayId,
+    timestamp: Date.now(),
+    payload,
+  };
+}
+
+export function parseBridgeMessage(data: string): BridgeMessage | null {
+  try {
+    const msg = JSON.parse(data);
+    if (msg.version && msg.type && msg.messageId && msg.gatewayId && msg.timestamp !== undefined) {
+      return msg as BridgeMessage;
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}