anorion 0.1.0

package/src/bridge/server.ts

@@ -0,0 +1,221 @@
+// Bridge Server — inbound WebSocket acceptor on /bridge path
+
+import type {
+  BridgeMessage,
+  HelloPayload,
+  MessageForwardPayload,
+  MessageResponsePayload,
+} from './protocol';
+import {
+  createBridgeMessage,
+  parseBridgeMessage,
+} from './protocol';
+import { logger } from '../shared/logger';
+import { agentRegistry } from '../agents/registry';
+
+interface BridgeConnection {
+  gatewayId: string;
+  ws: { send: (data: string) => void; addEventListener: (type: string, fn: (ev: any) => void) => void; close: (code?: number, reason?: string) => void; readyState?: number };
+  connectedAt: number;
+  lastPong: number;
+  agents: { id: string; name: string; status: string }[];
+}
+
+export class BridgeServer {
+  private connections = new Map<string, BridgeConnection>(); // gatewayId -> conn
+  private secret: string;
+  private ownGatewayId: string;
+  private pongTimeoutMs = 60_000;
+  private pendingResponses = new Map<string, (msg: BridgeMessage) => void>();
+
+  constructor(ownGatewayId: string, secret: string) {
+    this.ownGatewayId = ownGatewayId;
+    this.secret = secret;
+
+    // Health check: disconnect stale peers
+    setInterval(() => {
+      const now = Date.now();
+      for (const [id, conn] of this.connections) {
+        if (now - conn.lastPong > this.pongTimeoutMs) {
+          logger.warn({ peerId: id }, 'Bridge peer health check failed, disconnecting');
+          conn.ws.close(4008, 'Health check timeout');
+          this.connections.delete(id);
+        }
+      }
+    }, 30_000);
+  }
+
+  /** Handle an upgraded WebSocket connection for /bridge (called from Bun.serve websocket handlers) */
+  handleConnection(ws: { send: (data: string) => void; addEventListener: (type: string, fn: (ev: any) => void) => void; close: (code?: number, reason?: string) => void }, secret?: string): boolean {
+    if (secret !== this.secret) {
+      logger.warn('Bridge connection rejected: invalid secret');
+      ws.close(4001, 'Unauthorized');
+      return false;
+    }
+
+    const conn: BridgeConnection = {
+      gatewayId: '',
+      ws,
+      connectedAt: Date.now(),
+      lastPong: Date.now(),
+      agents: [],
+    };
+
+    ws.addEventListener('message', (event) => {
+      const msg = parseBridgeMessage(event.data as string);
+      if (!msg) {
+        ws.send(JSON.stringify({ error: 'Invalid message' }));
+        return;
+      }
+      void this.handleMessage(conn, msg);
+    });
+
+    ws.addEventListener('close', () => {
+      if (conn.gatewayId) {
+        this.connections.delete(conn.gatewayId);
+        logger.info({ peerId: conn.gatewayId }, 'Bridge peer disconnected');
+      }
+    });
+
+    return true;
+  }
+
+  /** Legacy attach — no-op for Bun.serve(), use handleConnection instead */
+  attach(_server: unknown): void {
+    logger.info('Bridge server ready on /bridge (via Bun.serve)');
+  }
+
+  private async handleMessage(conn: BridgeConnection, msg: BridgeMessage): Promise<void> {
+    switch (msg.type) {
+      case 'hello': {
+        const payload = msg.payload as HelloPayload;
+        conn.gatewayId = msg.gatewayId;
+        conn.agents = payload.agents || [];
+        conn.lastPong = Date.now();
+        this.connections.set(msg.gatewayId, conn);
+
+        logger.info({ peerId: msg.gatewayId, agentCount: conn.agents.length }, 'Bridge peer registered');
+
+        // Send hello-ack
+        const ack = createBridgeMessage('hello-ack', this.ownGatewayId, {
+          gatewayId: this.ownGatewayId,
+          agents: agentRegistry.list().map((a) => ({ id: a.id, name: a.name, status: a.state })),
+        });
+        conn.ws.send(JSON.stringify(ack));
+        break;
+      }
+
+      case 'agent-register':
+      case 'agent-update': {
+        conn.lastPong = Date.now();
+        // Update peer's agent list
+        if (msg.type === 'agent-register') {
+          conn.agents = (msg.payload as { agents: BridgeConnection['agents'] }).agents || [];
+        }
+        break;
+      }
+
+      case 'message-forward': {
+        conn.lastPong = Date.now();
+        await this.handleMessageForward(conn, msg);
+        break;
+      }
+
+      case 'message-response': {
+        conn.lastPong = Date.now();
+        const payload = msg.payload as MessageResponsePayload;
+        const handler = this.pendingResponses.get(payload.requestMessageId);
+        if (handler) {
+          handler(msg);
+          this.pendingResponses.delete(payload.requestMessageId);
+        }
+        break;
+      }
+
+      case 'health-ping': {
+        conn.lastPong = Date.now();
+        conn.ws.send(JSON.stringify(createBridgeMessage('health-pong', this.ownGatewayId, {})));
+        break;
+      }
+
+      case 'health-pong': {
+        conn.lastPong = Date.now();
+        break;
+      }
+
+      case 'unsubscribe': {
+        this.connections.delete(conn.gatewayId);
+        conn.ws.close();
+        break;
+      }
+    }
+  }
+
+  private async handleMessageForward(conn: BridgeConnection, msg: BridgeMessage): 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', this.ownGatewayId, {
+        requestMessageId: msg.messageId,
+        content: result.content,
+      } as MessageResponsePayload);
+      conn.ws.send(JSON.stringify(response));
+    } catch (err) {
+      const response = createBridgeMessage('message-response', this.ownGatewayId, {
+        requestMessageId: msg.messageId,
+        content: '',
+        error: (err as Error).message,
+      } as MessageResponsePayload);
+      conn.ws.send(JSON.stringify(response));
+    }
+  }
+
+  // Send a message to a specific peer gateway and wait for response
+  async sendToPeer(
+    gatewayId: string,
+    msg: BridgeMessage,
+    timeoutMs = 30_000,
+  ): Promise<BridgeMessage> {
+    const conn = this.connections.get(gatewayId);
+    if (!conn || (conn.ws as any).readyState !== 1) {
+      throw new Error(`Peer not connected: ${gatewayId}`);
+    }
+
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        this.pendingResponses.delete(msg.messageId);
+        reject(new Error('Bridge request timeout'));
+      }, timeoutMs);
+      this.pendingResponses.set(msg.messageId, (response) => {
+        clearTimeout(timer);
+        resolve(response);
+      });
+      conn.ws.send(JSON.stringify(msg));
+    });
+  }
+
+  // Broadcast agent update to all connected peers
+  broadcastAgentUpdate(agentId: string, status: string): void {
+    const msg = createBridgeMessage('agent-update', this.ownGatewayId, { agentId, status });
+    for (const [, conn] of this.connections) {
+      if ((conn.ws as any).readyState === 1) {
+        conn.ws.send(JSON.stringify(msg));
+      }
+    }
+  }
+
+  getConnections(): Map<string, BridgeConnection> {
+    return this.connections;
+  }
+
+  getConnection(gatewayId: string): BridgeConnection | undefined {
+    return this.connections.get(gatewayId);
+  }
+}

package/src/channels/base.ts

@@ -0,0 +1,43 @@
+import type { MessageEnvelope } from '../shared/types';
+
+export interface InlineKeyboardButton {
+  text: string;
+  url?: string;
+  callback_data?: string;
+}
+
+export interface InlineKeyboard {
+  buttons: InlineKeyboardButton[][];
+}
+
+export interface MediaAttachment {
+  type: 'photo' | 'document' | 'voice' | 'video';
+  data: Buffer | string; // Buffer or URL/file path
+  filename?: string;
+  caption?: string;
+  mimeType?: string;
+}
+
+export interface StreamChunk {
+  text: string;
+  done: boolean;
+}
+
+export interface ChannelAdapter {
+  name: string;
+  start(): Promise<void>;
+  stop(): Promise<void>;
+  onMessage(handler: (envelope: MessageEnvelope) => void): void;
+  send(envelope: MessageEnvelope, response: string): Promise<void>;
+  sendMedia?(envelope: MessageEnvelope, media: MediaAttachment): Promise<void>;
+  sendWithKeyboard?(
+    envelope: MessageEnvelope,
+    response: string,
+    keyboard: InlineKeyboard,
+  ): Promise<void>;
+  startTyping?(chatId: string): Promise<void>;
+  stopTyping?(chatId: string): void;
+  startStreaming?(envelope: MessageEnvelope, initialText?: string): Promise<string>;
+  editStreamingMessage?(messageId: string, text: string): Promise<void>;
+  finishStreaming?(messageId: string, finalText: string): Promise<void>;
+}

package/src/channels/router.ts

@@ -0,0 +1,122 @@
+import type { MessageEnvelope } from '../shared/types';
+import type { ChannelAdapter } from './base';
+import { sendMessage } from '../agents/runtime';
+import { logger } from '../shared/logger';
+
+interface RouteRule {
+  channelType: string;
+  channelId?: string;
+  agentName: string;
+}
+
+interface RouterConfig {
+  routes: RouteRule[];
+  defaultAgent: string;
+}
+
+class ChannelRouter {
+  private channels = new Map<string, ChannelAdapter>();
+  private rules: RouteRule[] = [];
+  private defaultAgent = 'example';
+
+  configure(config: RouterConfig): void {
+    this.rules = config.routes;
+    this.defaultAgent = config.defaultAgent;
+    logger.info(
+      { rules: this.rules.length, default: this.defaultAgent },
+      'Channel router configured',
+    );
+  }
+
+  registerChannel(channel: ChannelAdapter): void {
+    this.channels.set(channel.name, channel);
+    logger.info({ channel: channel.name }, 'Channel registered');
+
+    channel.onMessage((envelope) => {
+      this.routeMessage(channel, envelope).catch((err) => {
+        logger.error({ error: (err as Error).message, envelope: envelope.id }, 'Route error');
+      });
+    });
+  }
+
+  private async routeMessage(channel: ChannelAdapter, envelope: MessageEnvelope): Promise<void> {
+    const channelType = (envelope.metadata?.channelType as string) || channel.name;
+
+    // Find matching route
+    let agentName: string | undefined;
+
+    for (const rule of this.rules) {
+      if (rule.channelType === channelType) {
+        if (!rule.channelId || rule.channelId === envelope.channelId) {
+          agentName = rule.agentName;
+          break;
+        }
+      }
+    }
+
+    if (!agentName) {
+      agentName = this.defaultAgent;
+    }
+
+    logger.info(
+      {
+        envelope: envelope.id,
+        from: envelope.from,
+        channel: channelType,
+        agent: agentName,
+      },
+      'Routing message',
+    );
+
+    try {
+      const result = await sendMessage({
+        agentId: agentName,
+        text: envelope.text,
+        channelId: envelope.channelId,
+      });
+
+      const reply = result.content || 'I processed your request but had no text response to share.';
+      if (!result.content) {
+        logger.warn({ agent: agentName, sessionId: result.sessionId }, 'Agent returned empty content, sending fallback');
+      }
+      await channel.send(envelope, reply);
+    } catch (err) {
+      const errorMsg = `Error: ${(err as Error).message}`;
+      logger.error({ error: errorMsg, agent: agentName }, 'Agent processing failed');
+      await channel.send(envelope, errorMsg);
+    }
+  }
+
+  getChannel(name: string): ChannelAdapter | undefined {
+    return this.channels.get(name);
+  }
+
+  listChannels(): { name: string; running: boolean }[] {
+    return [...this.channels.keys()].map((name) => ({
+      name,
+      running: true,
+    }));
+  }
+
+  async startChannel(name: string): Promise<boolean> {
+    const channel = this.channels.get(name);
+    if (!channel) return false;
+    await channel.start();
+    return true;
+  }
+
+  async stopChannel(name: string): Promise<boolean> {
+    const channel = this.channels.get(name);
+    if (!channel) return false;
+    await channel.stop();
+    return true;
+  }
+
+  async stopAll(): Promise<void> {
+    for (const channel of this.channels.values()) {
+      await channel.stop();
+    }
+  }
+}
+
+export const channelRouter = new ChannelRouter();