@medplum/agent 2.1.5 → 2.1.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@medplum/agent",
-  "version": "2.1.5",
+  "version": "2.1.7",
   "description": "Medplum Agent",
   "author": "Medplum <hello@medplum.com>",
   "license": "Apache-2.0",
@@ -25,13 +25,13 @@
     "@medplum/core": "*",
     "@medplum/hl7": "*",
     "node-windows": "1.0.0-beta.8",
-    "ws": "8.14.1"
+    "ws": "8.14.2"
   },
   "devDependencies": {
     "@medplum/fhirtypes": "*",
     "@medplum/mock": "*",
-    "@types/node-windows": "0.1.3",
-    "@types/ws": "8.5.5",
+    "@types/node-windows": "0.1.4",
+    "@types/ws": "8.5.7",
     "mock-socket": "9.3.1",
     "pkg": "5.8.1"
   }

package/src/main.test.ts

@@ -1,8 +1,8 @@
-import { allOk, createReference, Hl7Message } from '@medplum/core';
+import { allOk, createReference, Hl7Message, sleep } from '@medplum/core';
 import { Agent, Bot, Endpoint, Resource } from '@medplum/fhirtypes';
-import { Hl7Client } from '@medplum/hl7';
+import { Hl7Client, Hl7Server } from '@medplum/hl7';
 import { MockClient } from '@medplum/mock';
-import { Server } from 'mock-socket';
+import { Client, Server } from 'mock-socket';
 import { App } from './main';
 
 jest.mock('node-windows');
@@ -23,11 +23,28 @@ describe('Agent', () => {
 
     endpoint = await medplum.createResource<Endpoint>({
       resourceType: 'Endpoint',
-      address: 'mllp://0.0.0.0:56000',
+      address: 'mllp://0.0.0.0:57000',
     });
   });
 
   test('Runs successfully', async () => {
+    const mockServer = new Server('wss://example.com/ws/agent');
+
+    mockServer.on('connection', (socket) => {
+      socket.on('message', (data) => {
+        const command = JSON.parse((data as Buffer).toString('utf8'));
+        if (command.type === 'connect') {
+          socket.send(
+            Buffer.from(
+              JSON.stringify({
+                type: 'connected',
+              })
+            )
+          );
+        }
+      });
+    });
+
     const agent = await medplum.createResource<Agent>({
       resourceType: 'Agent',
       channel: [
@@ -42,6 +59,7 @@ describe('Agent', () => {
     await app.start();
     app.stop();
     app.stop();
+    mockServer.stop();
   });
 
   test('Send and receive', async () => {
@@ -61,13 +79,15 @@ describe('Agent', () => {
         }
 
         if (command.type === 'transmit') {
-          const hl7Message = Hl7Message.parse(command.message);
+          const hl7Message = Hl7Message.parse(command.body);
           const ackMessage = hl7Message.buildAck();
           socket.send(
             Buffer.from(
               JSON.stringify({
                 type: 'transmit',
-                message: ackMessage.toString(),
+                channel: command.channel,
+                remote: command.remote,
+                body: ackMessage.toString(),
               })
             )
           );
@@ -79,6 +99,7 @@ describe('Agent', () => {
       resourceType: 'Agent',
       channel: [
         {
+          name: 'test',
           endpoint: createReference(endpoint),
           targetReference: createReference(bot),
         },
@@ -90,11 +111,9 @@ describe('Agent', () => {
 
     const client = new Hl7Client({
       host: 'localhost',
-      port: 56000,
+      port: 57000,
     });
 
-    await client.connect();
-
     const response = await client.sendAndWait(
       Hl7Message.parse(
         'MSH|^~\\&|ADT1|MCM|LABADT|MCM|198808181126|SECURITY|ADT^A01|MSG00001|P|2.2\r' +
@@ -112,4 +131,90 @@ describe('Agent', () => {
     app.stop();
     mockServer.stop();
   });
+
+  test('Push', async () => {
+    const mockServer = new Server('wss://example.com/ws/agent');
+    let mySocket: Client | undefined = undefined;
+
+    mockServer.on('connection', (socket) => {
+      mySocket = socket;
+      socket.on('message', (data) => {
+        const command = JSON.parse((data as Buffer).toString('utf8'));
+        if (command.type === 'connect') {
+          socket.send(
+            Buffer.from(
+              JSON.stringify({
+                type: 'connected',
+              })
+            )
+          );
+        }
+      });
+    });
+
+    const agent = await medplum.createResource<Agent>({
+      resourceType: 'Agent',
+      channel: [
+        {
+          endpoint: createReference(endpoint),
+          targetReference: createReference(bot),
+        },
+      ],
+    });
+
+    // Start an HL7 listener
+    const hl7Messages = [];
+    const hl7Server = new Hl7Server((conn) => {
+      conn.addEventListener('message', ({ message }) => {
+        hl7Messages.push(message);
+        conn.send(message.buildAck());
+      });
+    });
+    hl7Server.start(57001);
+
+    // Wait for server to start listening
+    while (!hl7Server.server?.listening) {
+      await sleep(100);
+    }
+
+    // Start the app
+    const app = new App(medplum, agent.id as string);
+    await app.start();
+
+    // Wait for the WebSocket to connect
+    // eslint-disable-next-line no-unmodified-loop-condition
+    while (!mySocket) {
+      await sleep(100);
+    }
+
+    // At this point, we expect the websocket to be connected
+    expect(mySocket).toBeDefined();
+
+    // Send a push message
+    const wsClient = mySocket as unknown as Client;
+    wsClient.send(
+      Buffer.from(
+        JSON.stringify({
+          type: 'push',
+          body:
+            'MSH|^~\\&|ADT1|MCM|LABADT|MCM|198808181126|SECURITY|ADT^A01|MSG00001|P|2.2\r' +
+            'PID|||PATID1234^5^M11||JONES^WILLIAM^A^III||19610615|M-\r' +
+            'NK1|1|JONES^BARBARA^K|SPO|||||20011105\r' +
+            'PV1|1|I|2000^2012^01||||004777^LEBAUER^SIDNEY^J.|||SUR||-||1|A0-',
+          remote: 'mllp://localhost:57001',
+        })
+      )
+    );
+
+    // Wait for the HL7 message to be received
+    while (hl7Messages.length < 1) {
+      await sleep(100);
+    }
+    expect(hl7Messages.length).toBe(1);
+
+    // Shutdown everything
+    hl7Server.stop();
+    app.stop();
+    mockServer.stop();
+  });
 });

package/src/main.ts

@@ -1,12 +1,22 @@
-import { Hl7Message, MedplumClient, resolveId } from '@medplum/core';
-import { AgentChannel, Bot, Endpoint, Reference } from '@medplum/fhirtypes';
-import { Hl7Connection, Hl7MessageEvent, Hl7Server } from '@medplum/hl7';
+import { Hl7Message, MedplumClient, normalizeErrorString } from '@medplum/core';
+import { AgentChannel, Endpoint, Reference } from '@medplum/fhirtypes';
+import { Hl7Client, Hl7Connection, Hl7MessageEvent, Hl7Server } from '@medplum/hl7';
 import { EventLogger } from 'node-windows';
 import WebSocket from 'ws';
 
+interface QueueItem {
+  channel: string;
+  remote: string;
+  body: string;
+}
+
 export class App {
   readonly log: EventLogger;
-  readonly channels: AgentHl7Channel[];
+  readonly webSocket: WebSocket;
+  readonly webSocketQueue: QueueItem[] = [];
+  readonly channels = new Map<string, AgentHl7Channel>();
+  readonly hl7Queue: QueueItem[] = [];
+  live = false;
 
   constructor(
     readonly medplum: MedplumClient,
@@ -18,7 +28,46 @@ export class App {
       error: console.error,
     } as EventLogger;
 
-    this.channels = [];
+    const webSocketUrl = new URL(medplum.getBaseUrl());
+    webSocketUrl.protocol = webSocketUrl.protocol === 'https:' ? 'wss:' : 'ws:';
+    webSocketUrl.pathname = '/ws/agent';
+    this.log.info(`Connecting to WebSocket: ${webSocketUrl.href}`);
+
+    this.webSocket = new WebSocket(webSocketUrl);
+    this.webSocket.binaryType = 'nodebuffer';
+    this.webSocket.addEventListener('error', (err) => this.log.error(err.message));
+    this.webSocket.addEventListener('open', () => {
+      this.webSocket.send(
+        JSON.stringify({
+          type: 'connect',
+          accessToken: medplum.getAccessToken(),
+          agentId,
+        })
+      );
+    });
+
+    this.webSocket.addEventListener('message', (e) => {
+      try {
+        const data = e.data as Buffer;
+        const str = data.toString('utf8');
+        this.log.info(`Received from WebSocket: ${str.replaceAll('\r', '\n')}`);
+        const command = JSON.parse(str);
+        switch (command.type) {
+          case 'connected':
+            this.live = true;
+            this.trySendToWebSocket();
+            break;
+          case 'transmit':
+            this.addToHl7Queue(command);
+            break;
+          case 'push':
+            this.pushMessage(command);
+            break;
+        }
+      } catch (err) {
+        this.log.error(`WebSocket error: ${normalizeErrorString(err)}`);
+      }
+    });
   }
 
   async start(): Promise<void> {
@@ -30,7 +79,7 @@ export class App {
       const endpoint = await this.medplum.readReference(definition.endpoint as Reference<Endpoint>);
       const channel = new AgentHl7Channel(this, definition, endpoint);
       channel.start();
-      this.channels.push(channel);
+      this.channels.set(definition.name as string, channel);
     }
 
     this.log.info('Medplum service started successfully');
@@ -41,21 +90,80 @@ export class App {
     this.channels.forEach((channel) => channel.stop());
     this.log.info('Medplum service stopped successfully');
   }
+
+  addToWebSocketQueue(message: QueueItem): void {
+    this.webSocketQueue.push(message);
+    this.trySendToWebSocket();
+  }
+
+  addToHl7Queue(message: QueueItem): void {
+    this.hl7Queue.push(message);
+    this.trySendToHl7Connection();
+  }
+
+  private trySendToWebSocket(): void {
+    if (this.live) {
+      while (this.webSocketQueue.length > 0) {
+        const msg = this.webSocketQueue.shift();
+        if (msg) {
+          this.webSocket.send(
+            JSON.stringify({
+              type: 'transmit',
+              accessToken: this.medplum.getAccessToken(),
+              ...msg,
+            })
+          );
+        }
+      }
+    }
+  }
+
+  private trySendToHl7Connection(): void {
+    while (this.hl7Queue.length > 0) {
+      const msg = this.hl7Queue.shift();
+      if (msg) {
+        const channel = this.channels.get(msg.channel);
+        if (channel) {
+          const connection = channel.connections.get(msg.remote);
+          if (connection) {
+            connection.hl7Connection.send(Hl7Message.parse(msg.body));
+          }
+        }
+      }
+    }
+  }
+
+  private pushMessage(message: QueueItem): void {
+    const address = new URL(message.remote);
+    const client = new Hl7Client({
+      host: address.hostname,
+      port: parseInt(address.port, 10),
+    });
+
+    client
+      .sendAndWait(Hl7Message.parse(message.body))
+      .then((response) => {
+        this.log.info(`Response: ${response.toString().replaceAll('\r', '\n')}`);
+      })
+      .catch((err) => {
+        this.log.error(`HL7 error: ${normalizeErrorString(err)}`);
+      })
+      .finally(() => {
+        client.close();
+      });
+  }
 }
 
 export class AgentHl7Channel {
   readonly server: Hl7Server;
-  readonly connections: AgentHl7ChannelConnection[] = [];
+  readonly connections = new Map<string, AgentHl7ChannelConnection>();
 
   constructor(
     readonly app: App,
     readonly definition: AgentChannel,
     readonly endpoint: Endpoint
   ) {
-    this.server = new Hl7Server((connection) => {
-      this.app.log.info('HL7 connection established');
-      this.connections.push(new AgentHl7ChannelConnection(this, connection));
-    });
+    this.server = new Hl7Server((connection) => this.handleNewConnection(connection));
   }
 
   start(): void {
@@ -67,111 +175,47 @@ export class AgentHl7Channel {
 
   stop(): void {
     this.app.log.info('Channel stopping...');
-    for (const connection of this.connections) {
-      connection.close();
-    }
+    this.connections.forEach((connection) => connection.close());
     this.server.stop();
     this.app.log.info('Channel stopped successfully');
   }
+
+  private handleNewConnection(connection: Hl7Connection): void {
+    const c = new AgentHl7ChannelConnection(this, connection);
+    this.app.log.info(`HL7 connection established: ${c.remote}`);
+    this.connections.set(c.remote, c);
+  }
 }
 
 export class AgentHl7ChannelConnection {
-  readonly webSocket: WebSocket;
-  readonly webSocketQueue: Hl7Message[] = [];
-  readonly hl7ConnectionQueue: Hl7Message[] = [];
-  live = false;
+  readonly remote: string;
 
   constructor(
     readonly channel: AgentHl7Channel,
     readonly hl7Connection: Hl7Connection
   ) {
-    const app = channel.app;
-    const medplum = app.medplum;
+    this.remote = `${hl7Connection.socket.remoteAddress}:${hl7Connection.socket.remotePort}`;
 
     // Add listener immediately to handle incoming messages
     this.hl7Connection.addEventListener('message', (event) => this.handler(event));
-
-    const webSocketUrl = new URL(medplum.getBaseUrl());
-    webSocketUrl.protocol = webSocketUrl.protocol === 'https:' ? 'wss:' : 'ws:';
-    webSocketUrl.pathname = '/ws/agent';
-    console.log('Connecting to WebSocket:', webSocketUrl.href);
-
-    this.webSocket = new WebSocket(webSocketUrl);
-    this.webSocket.binaryType = 'nodebuffer';
-    this.webSocket.addEventListener('error', console.error);
-    this.webSocket.addEventListener('open', () => {
-      this.webSocket.send(
-        JSON.stringify({
-          type: 'connect',
-          accessToken: medplum.getAccessToken(),
-          agentId: channel.app.agentId,
-          botId: resolveId(channel.definition.targetReference as Reference<Bot>),
-        })
-      );
-    });
-
-    this.webSocket.addEventListener('message', (e) => {
-      try {
-        const data = e.data as Buffer;
-        const str = data.toString('utf8');
-        console.log('Received from WebSocket:', str.replaceAll('\r', '\n'));
-        const command = JSON.parse(str);
-        switch (command.type) {
-          case 'connected':
-            this.live = true;
-            this.trySendToWebSocket();
-            break;
-          case 'transmit':
-            this.hl7ConnectionQueue.push(Hl7Message.parse(command.message));
-            this.trySendToHl7Connection();
-            break;
-        }
-      } catch (err) {
-        console.log('WebSocket error', err);
-      }
-    });
   }
 
   private async handler(event: Hl7MessageEvent): Promise<void> {
     try {
-      console.log('Received:');
-      console.log(event.message.toString().replaceAll('\r', '\n'));
-      this.webSocketQueue.push(event.message);
-      this.trySendToWebSocket();
+      this.channel.app.log.info('Received:');
+      this.channel.app.log.info(event.message.toString().replaceAll('\r', '\n'));
+      this.channel.app.addToWebSocketQueue({
+        channel: this.channel.definition.name as string,
+        remote: this.remote,
+        body: event.message.toString(),
+      });
     } catch (err) {
-      console.log('HL7 error', err);
-    }
-  }
-
-  private trySendToWebSocket(): void {
-    if (this.live) {
-      while (this.webSocketQueue.length > 0) {
-        const msg = this.webSocketQueue.shift();
-        if (msg) {
-          this.webSocket.send(
-            JSON.stringify({
-              type: 'transmit',
-              forwardedFor: this.hl7Connection.socket.remoteAddress,
-              message: msg.toString(),
-            })
-          );
-        }
-      }
-    }
-  }
-
-  private trySendToHl7Connection(): void {
-    while (this.hl7ConnectionQueue.length > 0) {
-      const msg = this.hl7ConnectionQueue.shift();
-      if (msg) {
-        this.hl7Connection.send(msg);
-      }
+      this.channel.app.log.error(`HL7 error: ${normalizeErrorString(err)}`);
     }
   }
 
   close(): void {
     this.hl7Connection.close();
-    this.webSocket.close();
   }
 }
 

package/tsconfig.json

@@ -1,5 +1,5 @@
 {
-  "extends": "../../tsconfig.base.json",
+  "extends": "../../tsconfig.json",
   "compilerOptions": {
     "outDir": "dist",
     "lib": ["esnext"]