@medplum/agent 2.0.29 → 2.0.30

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@medplum/agent",
-  "version": "2.0.29",
+  "version": "2.0.30",
   "description": "Medplum Agent",
   "author": "Medplum <hello@medplum.com>",
   "license": "Apache-2.0",
@@ -17,17 +17,21 @@
     "clean": "rimraf dist",
     "build": "npm run clean && tsc && node esbuild.mjs",
     "test": "jest",
+    "agent": "ts-node src/main.ts",
     "package": "pkg ./dist/cjs/index.cjs --targets node18-win-x64 --output dist/medplum-agent-win-x64.exe"
   },
   "dependencies": {
     "@medplum/core": "*",
     "@medplum/hl7": "*",
-    "node-windows": "1.0.0-beta.8"
+    "node-windows": "1.0.0-beta.8",
+    "ws": "8.13.0"
   },
   "devDependencies": {
     "@medplum/fhirtypes": "*",
     "@medplum/mock": "*",
     "@types/node-windows": "0.1.2",
+    "@types/ws": "8.5.5",
+    "mock-socket": "9.2.1",
     "pkg": "5.8.1"
   }
 }

package/src/__mocks__/ws.ts

@@ -0,0 +1 @@
+export { WebSocket as default } from 'mock-socket';

package/src/main.test.ts

@@ -2,6 +2,7 @@ import { allOk, Hl7Message } from '@medplum/core';
 import { Bot, Resource } from '@medplum/fhirtypes';
 import { Hl7Client } from '@medplum/hl7';
 import { MockClient } from '@medplum/mock';
+import { Server } from 'mock-socket';
 import { App } from './main';
 
 jest.mock('node-windows');
@@ -21,13 +22,51 @@ describe('Agent', () => {
   });
 
   test('Runs successfully', async () => {
-    const app = new App(medplum, bot);
+    const app = new App(medplum, { botId: bot.id as string });
     app.start();
     app.stop();
+    app.stop();
+  });
+
+  test('Use system event log', async () => {
+    const app = new App(medplum, { botId: bot.id as string, useSystemEventLog: true });
+    app.start();
+    app.stop();
+    app.stop();
   });
 
   test('Send and receive', async () => {
-    const app = new App(medplum, bot);
+    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',
+              })
+            )
+          );
+        }
+
+        if (command.type === 'transmit') {
+          const hl7Message = Hl7Message.parse(command.message);
+          const ackMessage = hl7Message.buildAck();
+          socket.send(
+            Buffer.from(
+              JSON.stringify({
+                type: 'transmit',
+                message: ackMessage.toString(),
+              })
+            )
+          );
+        }
+      });
+    });
+
+    const app = new App(medplum, { botId: bot.id as string });
     app.start();
 
     const client = new Hl7Client({
@@ -46,8 +85,12 @@ describe('Agent', () => {
       )
     );
     expect(response).toBeDefined();
+    expect(response.header.getComponent(9, 1)).toBe('ACK');
+    expect(response.segments).toHaveLength(2);
+    expect(response.segments[1].name).toBe('MSA');
 
     client.close();
     app.stop();
+    mockServer.stop();
   });
 });

package/src/main.ts

@@ -1,25 +1,37 @@
-import { ContentType, MedplumClient, normalizeErrorString } from '@medplum/core';
-import { Bot } from '@medplum/fhirtypes';
-import { Hl7MessageEvent, Hl7Server } from '@medplum/hl7';
+import { Hl7Message, MedplumClient } from '@medplum/core';
+import { Hl7Connection, Hl7MessageEvent, Hl7Server } from '@medplum/hl7';
+import { readFileSync } from 'fs';
 import { EventLogger } from 'node-windows';
+import WebSocket from 'ws';
 
-const log = new EventLogger({
-  source: 'MedplumService',
-  eventLog: 'SYSTEM',
-});
+export interface AgentConfig {
+  botId: string;
+  useSystemEventLog?: boolean;
+}
 
 export class App {
   readonly log: EventLogger;
   readonly server: Hl7Server;
+  readonly connections: Connection[] = [];
 
-  constructor(readonly medplum: MedplumClient, readonly bot: Bot) {
-    this.log = new EventLogger({
-      source: 'MedplumService',
-      eventLog: 'SYSTEM',
-    });
+  constructor(readonly medplum: MedplumClient, readonly config: AgentConfig) {
+    if (config.useSystemEventLog) {
+      this.log = new EventLogger({
+        source: 'MedplumService',
+        eventLog: 'SYSTEM',
+      });
+    } else {
+      this.log = {
+        info: console.log,
+        warn: console.warn,
+        error: console.error,
+      } as EventLogger;
+    }
 
-    this.server = new Hl7Server();
-    this.server.addEventListener('message', (event) => this.handler(event));
+    this.server = new Hl7Server((connection) => {
+      this.log.info('HL7 connection established');
+      this.connections.push(new Connection(this, connection));
+    });
   }
 
   start(): void {
@@ -30,32 +42,107 @@ export class App {
 
   stop(): void {
     this.log.info('Medplum service stopping...');
+    for (const connection of this.connections) {
+      connection.close();
+    }
     this.server.stop();
     this.log.info('Medplum service stopped successfully');
   }
+}
+
+export class Connection {
+  readonly webSocket: WebSocket;
+  readonly webSocketQueue: Hl7Message[] = [];
+  readonly hl7ConnectionQueue: Hl7Message[] = [];
+  live = false;
+
+  constructor(readonly app: App, readonly hl7Connection: Hl7Connection) {
+    // Add listener immediately to handle incoming messages
+    this.hl7Connection.addEventListener('message', (event) => this.handler(event));
+
+    const webSocketUrl = new URL(this.app.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: this.app.medplum.getAccessToken(),
+          botId: this.app.config.botId,
+        })
+      );
+    });
+
+    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'));
-
-      await this.medplum.post(
-        this.medplum.fhirUrl('Bot', this.bot.id as string, '$execute'),
-        event.message.toString(),
-        ContentType.HL7_V2
-      );
-
-      const ack = event.message.buildAck();
-      console.log('Response:');
-      console.log(ack.toString().replaceAll('\r', '\n'));
-      event.send(ack);
+      this.webSocketQueue.push(event.message);
+      this.trySendToWebSocket();
     } catch (err) {
       console.log('HL7 error', err);
-      log.error(normalizeErrorString(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',
+              message: msg.toString(),
+            })
+          );
+        }
+      }
+    }
+  }
+
+  private trySendToHl7Connection(): void {
+    while (this.hl7ConnectionQueue.length > 0) {
+      const msg = this.hl7ConnectionQueue.shift();
+      if (msg) {
+        this.hl7Connection.send(msg);
+      }
+    }
+  }
+
+  close(): void {
+    this.hl7Connection.close();
+    this.webSocket.close();
+  }
 }
 
 if (typeof require !== 'undefined' && require.main === module) {
-  new App(new MedplumClient(), { resourceType: 'Bot', id: '00000000-00000000-00000000-00000000' }).start();
+  const config = JSON.parse(readFileSync('medplum.config.json', 'utf8'));
+  new App(new MedplumClient(config), config).start();
 }