@agent-glue/glue 0.1.0

package/src/server/memory.ts

@@ -0,0 +1,77 @@
+import { Actor, ActorInterface } from "../actor.js";
+import { defineMessage, Message } from "../message.js";
+import {
+  Commands,
+  Connect,
+  event,
+  Events,
+  isConnect,
+  isSend,
+  Send
+} from "./protocol.js";
+
+export interface LocalConnect extends Connect {
+  destination: string;
+  callback: (msg: Message) => void;
+}
+export const {
+  message: localConnect,
+  isMessage: isLocalConnect,
+  type: LocalConnectType
+} = defineMessage<LocalConnect>("local-connect");
+
+export interface LocalRegister extends Message {
+  name: string;
+  actor: Actor<Message, Message>;
+}
+export const {
+  message: localRegister,
+  isMessage: isLocalRegister,
+  type: LocalRegisterType
+} = defineMessage<LocalRegister>("local-register");
+
+export type LocalCommands = Send | LocalConnect | LocalRegister;
+export type LocalServerActor = ActorInterface<LocalCommands, never>;
+
+export class LocalServer extends Actor<LocalCommands, never> {
+  private store = new Map<string, Actor<Message, Message>>();
+
+  send(command: LocalCommands) {
+    if (isSend(command)) {
+      const { destination, message } = command;
+      const actor = this.store.get(destination);
+      if (actor) {
+        actor.send(message);
+      }
+    } else if (isLocalConnect(command)) {
+      const { destination, callback } = command;
+      const actor = this.store.get(destination);
+      if (actor) {
+        actor.connect(callback);
+      }
+    } else if (isLocalRegister(command)) {
+      const { name, actor } = command;
+      this.store.set(name, actor);
+    }
+  }
+}
+
+export class MemoryClient extends Actor<Commands, Events> {
+  constructor(private server: LocalServerActor) {
+    super();
+  }
+
+  send(command: Commands): void {
+    if (isSend(command)) {
+      this.server.send(command);
+    } else if (isConnect(command)) {
+      this.server.send(
+        localConnect({
+          destination: command.destination,
+          callback: (msg) =>
+            this.emit(event({ origin: command.destination, message: msg }))
+        })
+      );
+    }
+  }
+}

package/src/server/protocol.ts

@@ -0,0 +1,36 @@
+import { ActorInterface } from "../actor.js";
+import { defineMessage, Message } from "../message.js";
+
+export interface Send extends Message {
+  destination: string;
+  message: Message;
+}
+export const {
+  message: send,
+  isMessage: isSend,
+  type: SendType
+} = defineMessage<Send>("send");
+
+export interface Connect extends Message {
+  destination: string;
+}
+export const {
+  message: connect,
+  isMessage: isConnect,
+  type: ConnectType
+} = defineMessage<Connect>("connect");
+
+export interface Event extends Message {
+  origin: string;
+  message: Message;
+}
+export const {
+  message: event,
+  isMessage: isEvent,
+  type: EventType
+} = defineMessage<Event>("event");
+
+export type Commands = Send | Connect;
+export type Events = Event;
+
+export type ServerActor = ActorInterface<Commands, Events>;

package/src/server/websocket.ts

@@ -0,0 +1,137 @@
+import { Actor, ActorInterface } from "../actor.js";
+import { defineMessage, Message } from "../message.js";
+import type {
+  WebSocketServer as NodeWebSocketServer,
+  WebSocket as NodeWebsocket
+} from "ws";
+
+export interface SendCommand extends Message {
+  message: string;
+}
+export const {
+  message: sendCommand,
+  isMessage: isSendCommand,
+  type: SendCommandType
+} = defineMessage<SendCommand>("send-command");
+
+type OpenEvent = Message;
+export const {
+  message: openEvent,
+  isMessage: isOpenEvent,
+  type: OpenEventType
+} = defineMessage<OpenEvent>("open-event");
+
+type CloseEvent = Message;
+export const {
+  message: closeEvent,
+  isMessage: isCloseEvent,
+  type: CloseEventType
+} = defineMessage<CloseEvent>("close-event");
+
+export interface ErrorEvent extends Message {
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  error: any;
+}
+export const {
+  message: errorEvent,
+  isMessage: isErrorEvent,
+  type: ErrorEventType
+} = defineMessage<ErrorEvent>("error-event");
+export interface MessageEvent extends Message {
+  message: string;
+}
+export const {
+  message: messageEvent,
+  isMessage: isMessageEvent,
+  type: MessageEventType
+} = defineMessage<MessageEvent>("message-event");
+
+export type WebsocketCommands = SendCommand;
+export type WebsocketEvents =
+  | OpenEvent
+  | CloseEvent
+  | ErrorEvent
+  | MessageEvent;
+
+export class WebsocketClient extends Actor<WebsocketCommands, WebsocketEvents> {
+  constructor(private readonly ws: WebSocket | NodeWebsocket) {
+    super();
+
+    ws.addEventListener("open", () => {
+      this.emit(openEvent({}));
+    });
+    ws.addEventListener("message", (event) => {
+      this.emit(messageEvent({ message: event.data }));
+    });
+    ws.addEventListener("close", () => {
+      this.emit(closeEvent({}));
+    });
+    ws.addEventListener("error", (event) => {
+      this.emit(errorEvent({ error: event }));
+    });
+  }
+
+  send(command: WebsocketCommands) {
+    if (isSendCommand(command)) {
+      this.ws.send(command.message);
+    }
+  }
+}
+
+export class WebsocketClientWrapper<
+  Commands extends Message,
+  Events extends Message
+> extends Actor<Commands, Events> {
+  private readonly client: WebsocketClient;
+
+  constructor(private readonly ws: WebSocket | NodeWebsocket) {
+    super();
+    this.client = new WebsocketClient(ws);
+
+    this.client.connect((event) => {
+      if (isMessageEvent(event)) {
+        const message = JSON.parse(event.message) as Events;
+        this.emit(message);
+      }
+    });
+  }
+
+  send(command: Commands) {
+    this.client.send(sendCommand({ message: JSON.stringify(command) }));
+  }
+}
+
+export interface ConnectionEvent extends Message {
+  ws: NodeWebsocket;
+}
+export const {
+  message: connectionEvent,
+  isMessage: isConnectionEvent,
+  type: ConnectionEventType
+} = defineMessage<ConnectionEvent>("connection-event");
+
+export class WebsocketServer extends Actor<WebsocketCommands, WebsocketEvents> {
+  constructor(private readonly wss: NodeWebSocketServer) {
+    super();
+
+    this.wss.on("connection", (ws) => {
+      this.emit(connectionEvent({ ws }));
+    });
+  }
+}
+
+export class WebsocketServerWrapper<
+  Commands extends Message,
+  Events extends Message
+> {
+  constructor(ws: NodeWebsocket, actor: ActorInterface<Commands, Events>) {
+    //const client = new WebsocketClient(ws);
+    const wrapper = new WebsocketClientWrapper<Events, Commands>(ws);
+    wrapper.connect((command) => {
+      actor.send(command);
+    });
+    actor.connect((event) => {
+      wrapper.send(event);
+    });
+  }
+}

package/src/server.ts

@@ -0,0 +1,3 @@
+export * from "./server/protocol.js";
+export * from "./server/memory.js";
+export * from "./server/websocket.js";

package/src/transformers.ts

@@ -0,0 +1,66 @@
+import { ActorInterface, actor } from "./actor.js";
+import { Message } from "./message.js";
+
+export type Replace<U, A, B> = Exclude<U, A> | B;
+
+export type ActorTransformer<
+  A extends ActorInterface<C1, E1>,
+  B extends ActorInterface<C2, E2>,
+  C1 extends Message = never,
+  C2 extends Message = never,
+  E1 extends Message = never,
+  E2 extends Message = never
+> = (a: A) => B;
+
+export type CommandTransformer<
+  OldCommands extends Message,
+  NewCommands extends Message,
+  E extends Message = never,
+  A extends ActorInterface<OldCommands, E> = ActorInterface<OldCommands, E>,
+  B extends ActorInterface<NewCommands, E> = ActorInterface<NewCommands, E>
+> = ActorTransformer<A, B, OldCommands, NewCommands, E, E>;
+
+export type EventTransformer<
+  NewEvents extends Message,
+  OldEvents extends Message,
+  C extends Message = never,
+  A extends ActorInterface<C, OldEvents> = ActorInterface<C, OldEvents>,
+  B extends ActorInterface<C, NewEvents> = ActorInterface<C, NewEvents>
+> = ActorTransformer<A, B, C, C, OldEvents, NewEvents>;
+
+export type TransformerFunction<A extends Message, B extends Message> = (
+  message: A
+) => B;
+
+export function commandTransformer<
+  OldCommands extends Message,
+  NewCommands extends Message,
+  Events extends Message = never
+>(
+  fn: TransformerFunction<NewCommands, OldCommands>
+): CommandTransformer<OldCommands, NewCommands, Events> {
+  return (wrapped: ActorInterface<OldCommands, Events>) =>
+    actor((emit) => {
+      wrapped.connect(emit);
+
+      return (command) => {
+        wrapped.send(fn(command));
+      };
+    });
+}
+
+export function eventTransformer<
+  OldEvents extends Message,
+  NewEvents extends Message,
+  Commands extends Message = never
+>(
+  fn: TransformerFunction<OldEvents, NewEvents>
+): EventTransformer<NewEvents, OldEvents, Commands> {
+  return (wrapped: ActorInterface<Commands, OldEvents>) =>
+    actor((emit) => {
+      wrapped.connect((msg) => {
+        emit(fn(msg));
+      });
+      return (command) => wrapped.send(command);
+    });
+}

package/src/types.ts

@@ -0,0 +1,7 @@
+import { ActorInterface } from "./actor.js";
+import { Message } from "./message.js";
+
+export type Events<T> = T extends ActorInterface<Message, infer E> ? E : never;
+export type Commands<T> = T extends ActorInterface<infer C, Message>
+  ? C
+  : never;

package/src/utils/TypedEmitter.ts

@@ -0,0 +1,30 @@
+import EventEmitter from "node:events";
+
+export class TypedEmitter<TEvents extends Record<string, unknown>> {
+  private emitter = new EventEmitter();
+
+  emit<TEventName extends keyof TEvents & string>(
+    eventName: TEventName,
+    eventArg: TEvents[TEventName]
+  ) {
+    this.emitter.emit(eventName, eventArg);
+  }
+
+  on<TEventName extends keyof TEvents & string>(
+    eventName: TEventName,
+    handler: (eventArg: TEvents[TEventName]) => void
+  ) {
+    this.emitter.on(eventName, handler);
+  }
+
+  off<TEventName extends keyof TEvents & string>(
+    eventName: TEventName,
+    handler: (eventArg: TEvents[TEventName]) => void
+  ) {
+    this.emitter.off(eventName, handler);
+  }
+
+  removeAllListeners() {
+    this.emitter.removeAllListeners();
+  }
+}

package/tsconfig.json

@@ -0,0 +1,8 @@
+{
+  "extends": "@repo/typescript-config/tsconfig.base.json",
+  "compilerOptions": {
+    "outDir": "dist"
+  },
+  "include": ["src"],
+  "exclude": ["node_modules"]
+}