@medplum/agent 2.1.6 → 2.1.7

package/dist/cjs/index.cjs

@@ -3523,7 +3523,7 @@ var require_websocket_server = __commonJS({
       socket.once("finish", socket.destroy);
       socket.end(
         `HTTP/1.1 ${code} ${http.STATUS_CODES[code]}\r
-` + Object.keys(headers).map((h2) => `${h2}: ${headers[h2]}`).join("\r\n") + "\r\n\r\n" + message
+` + Object.keys(headers).map((h3) => `${h3}: ${headers[h3]}`).join("\r\n") + "\r\n\r\n" + message
       );
     }
     function abortHandshakeOrEmitwsClientError(server, req, socket, code, message) {
@@ -3652,9 +3652,6 @@ function K(r4) {
 function $t(r4) {
   return r4.resourceType + "/" + r4.id;
 }
-function So(r4) {
-  return r4?.reference?.split("/")[1];
-}
 function un(r4) {
   return r4.resourceType === "Patient" || r4.resourceType === "Practitioner" || r4.resourceType === "RelatedPerson";
 }
@@ -4576,7 +4573,7 @@ function ue() {
 }
 var ri = ue();
 var Cr = ((p2) => (p2.BOOLEAN = "BOOLEAN", p2.NUMBER = "NUMBER", p2.QUANTITY = "QUANTITY", p2.TEXT = "TEXT", p2.REFERENCE = "REFERENCE", p2.CANONICAL = "CANONICAL", p2.DATE = "DATE", p2.DATETIME = "DATETIME", p2.PERIOD = "PERIOD", p2.UUID = "UUID", p2))(Cr || {});
-var ui = ((g) => (g.EQUALS = "eq", g.NOT_EQUALS = "ne", g.GREATER_THAN = "gt", g.LESS_THAN = "lt", g.GREATER_THAN_OR_EQUALS = "ge", g.LESS_THAN_OR_EQUALS = "le", g.STARTS_AFTER = "sa", g.ENDS_BEFORE = "eb", g.APPROXIMATELY = "ap", g.CONTAINS = "contains", g.EXACT = "exact", g.TEXT = "text", g.NOT = "not", g.ABOVE = "above", g.BELOW = "below", g.IN = "in", g.NOT_IN = "not-in", g.OF_TYPE = "of-type", g.MISSING = "missing", g.IDENTIFIER = "identifier", g.ITERATE = "iterate", g))(ui || {});
+var ui = ((g2) => (g2.EQUALS = "eq", g2.NOT_EQUALS = "ne", g2.GREATER_THAN = "gt", g2.LESS_THAN = "lt", g2.GREATER_THAN_OR_EQUALS = "ge", g2.LESS_THAN_OR_EQUALS = "le", g2.STARTS_AFTER = "sa", g2.ENDS_BEFORE = "eb", g2.APPROXIMATELY = "ap", g2.CONTAINS = "contains", g2.EXACT = "exact", g2.TEXT = "text", g2.NOT = "not", g2.ABOVE = "above", g2.BELOW = "below", g2.IN = "in", g2.NOT_IN = "not-in", g2.OF_TYPE = "of-type", g2.MISSING = "missing", g2.IDENTIFIER = "identifier", g2.ITERATE = "iterate", g2))(ui || {});
 var ki = ((x) => (x.READ = "read", x.VREAD = "vread", x.UPDATE = "update", x.PATCH = "patch", x.DELETE = "delete", x.HISTORY = "history", x.HISTORY_INSTANCE = "history-instance", x.HISTORY_TYPE = "history-type", x.HISTORY_SYSTEM = "history-system", x.CREATE = "create", x.SEARCH = "search", x.SEARCH_TYPE = "search-type", x.SEARCH_SYSTEM = "search-system", x.SEARCH_COMPARTMENT = "search-compartment", x.CAPABILITIES = "capabilities", x.TRANSACTION = "transaction", x.BATCH = "batch", x.OPERATION = "operation", x))(ki || {});
 function Mr(r4) {
   if (typeof window < "u")
@@ -4858,20 +4855,21 @@ var Vt = class {
     return Array.from(this.data.keys())[e];
   }
 };
-var Ki = "https://api.medplum.com/";
-var zi = 1e3;
-var Ji = 6e4;
+var Ki = F.FHIR_JSON + ", */*; q=0.1";
+var zi = "https://api.medplum.com/";
+var Ji = 1e3;
+var Yi = 6e4;
 var Gr = "Binary/";
 var Kr = { resourceType: "Device", id: "system", deviceName: [{ name: "System" }] };
-var Yi = ((o) => (o.ClientCredentials = "client_credentials", o.AuthorizationCode = "authorization_code", o.RefreshToken = "refresh_token", o.JwtBearer = "urn:ietf:params:oauth:grant-type:jwt-bearer", o.TokenExchange = "urn:ietf:params:oauth:grant-type:token-exchange", o))(Yi || {});
-var Xi = ((o) => (o.AccessToken = "urn:ietf:params:oauth:token-type:access_token", o.RefreshToken = "urn:ietf:params:oauth:token-type:refresh_token", o.IdToken = "urn:ietf:params:oauth:token-type:id_token", o.Saml1Token = "urn:ietf:params:oauth:token-type:saml1", o.Saml2Token = "urn:ietf:params:oauth:token-type:saml2", o))(Xi || {});
-var Zi = ((e) => (e.JwtBearer = "urn:ietf:params:oauth:client-assertion-type:jwt-bearer", e))(Zi || {});
+var Xi = ((o) => (o.ClientCredentials = "client_credentials", o.AuthorizationCode = "authorization_code", o.RefreshToken = "refresh_token", o.JwtBearer = "urn:ietf:params:oauth:grant-type:jwt-bearer", o.TokenExchange = "urn:ietf:params:oauth:grant-type:token-exchange", o))(Xi || {});
+var Zi = ((o) => (o.AccessToken = "urn:ietf:params:oauth:token-type:access_token", o.RefreshToken = "urn:ietf:params:oauth:token-type:refresh_token", o.IdToken = "urn:ietf:params:oauth:token-type:id_token", o.Saml1Token = "urn:ietf:params:oauth:token-type:saml1", o.Saml2Token = "urn:ietf:params:oauth:token-type:saml2", o))(Zi || {});
+var eo = ((e) => (e.JwtBearer = "urn:ietf:params:oauth:client-assertion-type:jwt-bearer", e))(eo || {});
 var zr = class extends fe {
   constructor(t) {
     super();
     if (t?.baseUrl && !t.baseUrl.startsWith("http"))
       throw new Error("Base URL must start with http or https");
-    if (this.options = t ?? {}, this.fetch = t?.fetch ?? eo(), this.storage = t?.storage ?? new ze(), this.createPdfImpl = t?.createPdf, this.baseUrl = Yr(t?.baseUrl ?? Ki), this.fhirBaseUrl = Yr(Je(this.baseUrl, t?.fhirUrlPath ?? "fhir/R4/")), this.authorizeUrl = Je(this.baseUrl, t?.authorizeUrl ?? "oauth2/authorize"), this.tokenUrl = Je(this.baseUrl, t?.tokenUrl ?? "oauth2/token"), this.logoutUrl = Je(this.baseUrl, t?.logoutUrl ?? "oauth2/logout"), this.clientId = t?.clientId ?? "", this.clientSecret = t?.clientSecret ?? "", this.onUnauthenticated = t?.onUnauthenticated, this.cacheTime = t?.cacheTime ?? Ji, this.cacheTime > 0 ? this.requestCache = new Qe(t?.resourceCacheSize ?? zi) : this.requestCache = void 0, t?.autoBatchTime ? (this.autoBatchTime = t.autoBatchTime, this.autoBatchQueue = []) : (this.autoBatchTime = 0, this.autoBatchQueue = void 0), t?.accessToken)
+    if (this.options = t ?? {}, this.fetch = t?.fetch ?? to(), this.storage = t?.storage ?? new ze(), this.createPdfImpl = t?.createPdf, this.baseUrl = Yr(t?.baseUrl ?? zi), this.fhirBaseUrl = Yr(Je(this.baseUrl, t?.fhirUrlPath ?? "fhir/R4/")), this.authorizeUrl = Je(this.baseUrl, t?.authorizeUrl ?? "oauth2/authorize"), this.tokenUrl = Je(this.baseUrl, t?.tokenUrl ?? "oauth2/token"), this.logoutUrl = Je(this.baseUrl, t?.logoutUrl ?? "oauth2/logout"), this.clientId = t?.clientId ?? "", this.clientSecret = t?.clientSecret ?? "", this.onUnauthenticated = t?.onUnauthenticated, this.cacheTime = t?.cacheTime ?? Yi, this.cacheTime > 0 ? this.requestCache = new Qe(t?.resourceCacheSize ?? Ji) : this.requestCache = void 0, t?.autoBatchTime ? (this.autoBatchTime = t.autoBatchTime, this.autoBatchQueue = []) : (this.autoBatchTime = 0, this.autoBatchQueue = void 0), t?.accessToken)
       this.setAccessToken(t.accessToken);
     else {
       let n = this.getActiveLogin();
@@ -5256,7 +5254,7 @@ var zr = class extends fe {
   }
   async uploadMedia(t, n, i2, o, s) {
     let a = await this.createBinary(t, i2, n);
-    return this.createResource({ ...o, resourceType: "Media", content: { contentType: n, url: Gr + a.id, title: i2 } }, s);
+    return this.createResource({ resourceType: "Media", status: "completed", content: { contentType: n, url: Gr + a.id, title: i2 }, ...o }, s);
   }
   async bulkExport(t = "", n, i2, o) {
     let s = t && `${t}/`, a = this.fhirUrl(`${s}$export`);
@@ -5376,7 +5374,7 @@ var zr = class extends fe {
   }
   addFetchOptionsDefaults(t) {
     let n = t.headers;
-    n || (n = {}, t.headers = n), n.Accept = F.FHIR_JSON, n["X-Medplum"] = "extended", t.body && !n["Content-Type"] && (n["Content-Type"] = F.FHIR_JSON), this.accessToken ? n.Authorization = "Bearer " + this.accessToken : this.basicAuth && (n.Authorization = "Basic " + this.basicAuth), t.cache || (t.cache = "no-cache"), t.credentials || (t.credentials = "include");
+    n || (n = {}, t.headers = n), n.Accept || (n.Accept = Ki), n["X-Medplum"] = "extended", t.body && !n["Content-Type"] && (n["Content-Type"] = F.FHIR_JSON), this.accessToken ? n.Authorization = "Bearer " + this.accessToken : this.basicAuth && (n.Authorization = "Basic " + this.basicAuth), t.cache || (t.cache = "no-cache"), t.credentials || (t.credentials = "include");
   }
   setRequestContentType(t, n) {
     t.headers || (t.headers = {});
@@ -5505,7 +5503,7 @@ var zr = class extends fe {
       throw i2;
   }
 };
-function eo() {
+function to() {
   if (!globalThis.fetch)
     throw new Error("Fetch not available in this environment");
   return globalThis.fetch.bind(globalThis);
@@ -5534,10 +5532,10 @@ function Zr(r4) {
   let e = r4.entry?.map((t) => t.resource) ?? [];
   return Object.assign(e, { bundle: r4 });
 }
-var to = [...ce, "->", "<<", ">>"];
-var ro = ue().registerInfix("->", { precedence: f.Arrow }).registerInfix(";", { precedence: f.Semicolon });
-var no = [...ce, "eq", "ne", "co"];
-var so = ue();
+var ro = [...ce, "->", "<<", ">>"];
+var no = ue().registerInfix("->", { precedence: f.Arrow }).registerInfix(";", { precedence: f.Semicolon });
+var io = [...ce, "eq", "ne", "co"];
+var ao = ue();
 var G = class {
   constructor(e = "\r", t = "|", n = "^", i2 = "~", o = "\\", s = "&") {
     this.segmentSeparator = e;
@@ -5578,7 +5576,7 @@ var nn = class r {
   }
   buildAck() {
     let e = /* @__PURE__ */ new Date(), t = this.getSegment("MSH"), n = t?.getField(3)?.toString() ?? "", i2 = t?.getField(4)?.toString() ?? "", o = t?.getField(5)?.toString() ?? "", s = t?.getField(6)?.toString() ?? "", a = t?.getField(10)?.toString() ?? "", c2 = t?.getField(12)?.toString() ?? "2.5.1";
-    return new r([new me(["MSH", this.context.getMsh2(), o, s, n, i2, co(e), "", this.buildAckMessageType(t), e.getTime().toString(), "P", c2], this.context), new me(["MSA", "AA", a, "OK"], this.context)]);
+    return new r([new me(["MSH", this.context.getMsh2(), o, s, n, i2, uo(e), "", this.buildAckMessageType(t), e.getTime().toString(), "P", c2], this.context), new me(["MSA", "AA", a, "OK"], this.context)]);
   }
   buildAckMessageType(e) {
     let t = e?.getField(9), n = t?.getComponent(2), i2 = t?.getComponent(3), o = "ACK";
@@ -5639,13 +5637,14 @@ var oe = class r3 {
     return new r3(e.split(t.repetitionSeparator).map((n) => n.split(t.componentSeparator)), t);
   }
 };
-function co(r4) {
+function uo(r4) {
   let e = r4 instanceof Date ? r4 : new Date(r4), n = e.toISOString().replace(/[-:T]/g, "").replace(/(\.\d+)?Z$/, ""), i2 = e.getUTCMilliseconds();
   return i2 > 0 && (n += "." + i2.toString()), n;
 }
 
 // ../hl7/dist/esm/index.mjs
-var import_net = __toESM(require("net"), 1);
+var import_net = require("net");
+var import_net2 = __toESM(require("net"), 1);
 var i = class extends EventTarget {
   addEventListener(n, e, t) {
     super.addEventListener(n, e, t);
@@ -5705,12 +5704,34 @@ var c = class extends i {
     this.socket.end(), this.socket.destroy();
   }
 };
+var h2 = class extends i {
+  constructor(e) {
+    super();
+    this.options = e, this.host = this.options.host, this.port = this.options.port;
+  }
+  connect() {
+    return this.connection ? Promise.resolve(this.connection) : new Promise((e) => {
+      let t = (0, import_net.connect)({ host: this.host, port: this.port }, () => {
+        this.connection = new c(t), e(this.connection);
+      });
+    });
+  }
+  async send(e) {
+    return (await this.connect()).send(e);
+  }
+  async sendAndWait(e) {
+    return (await this.connect()).sendAndWait(e);
+  }
+  close() {
+    this.connection && (this.connection.close(), delete this.connection);
+  }
+};
 var E2 = class {
   constructor(n) {
     this.handler = n;
   }
   start(n, e) {
-    let t = import_net.default.createServer((o) => {
+    let t = import_net2.default.createServer((o) => {
       let s = new c(o, e);
       this.handler(s);
     });
@@ -5734,80 +5755,28 @@ var App = class {
   constructor(medplum, agentId) {
     this.medplum = medplum;
     this.agentId = agentId;
+    this.webSocketQueue = [];
+    this.channels = /* @__PURE__ */ new Map();
+    this.hl7Queue = [];
+    this.live = false;
     this.log = {
       info: console.log,
       warn: console.warn,
       error: console.error
     };
-    this.channels = [];
-  }
-  async start() {
-    this.log.info("Medplum service starting...");
-    const agent = await this.medplum.readResource("Agent", this.agentId);
-    for (const definition of agent.channel) {
-      const endpoint = await this.medplum.readReference(definition.endpoint);
-      const channel = new AgentHl7Channel(this, definition, endpoint);
-      channel.start();
-      this.channels.push(channel);
-    }
-    this.log.info("Medplum service started successfully");
-  }
-  stop() {
-    this.log.info("Medplum service stopping...");
-    this.channels.forEach((channel) => channel.stop());
-    this.log.info("Medplum service stopped successfully");
-  }
-};
-var AgentHl7Channel = class {
-  constructor(app, definition, endpoint) {
-    this.app = app;
-    this.definition = definition;
-    this.endpoint = endpoint;
-    this.connections = [];
-    this.server = new E2((connection) => {
-      this.app.log.info("HL7 connection established");
-      this.connections.push(new AgentHl7ChannelConnection(this, connection));
-    });
-  }
-  start() {
-    const address = new URL(this.endpoint.address);
-    this.app.log.info(`Channel starting on ${address}`);
-    this.server.start(parseInt(address.port, 10));
-    this.app.log.info("Channel started successfully");
-  }
-  stop() {
-    this.app.log.info("Channel stopping...");
-    for (const connection of this.connections) {
-      connection.close();
-    }
-    this.server.stop();
-    this.app.log.info("Channel stopped successfully");
-  }
-};
-var AgentHl7ChannelConnection = class {
-  constructor(channel, hl7Connection) {
-    this.channel = channel;
-    this.hl7Connection = hl7Connection;
-    this.webSocketQueue = [];
-    this.hl7ConnectionQueue = [];
-    this.live = false;
-    const app = channel.app;
-    const medplum = app.medplum;
-    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.log.info(`Connecting to WebSocket: ${webSocketUrl.href}`);
     this.webSocket = new wrapper_default(webSocketUrl);
     this.webSocket.binaryType = "nodebuffer";
-    this.webSocket.addEventListener("error", console.error);
+    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: channel.app.agentId,
-          botId: So(channel.definition.targetReference)
+          agentId
         })
       );
     });
@@ -5815,7 +5784,7 @@ var AgentHl7ChannelConnection = class {
       try {
         const data = e.data;
         const str = data.toString("utf8");
-        console.log("Received from WebSocket:", str.replaceAll("\r", "\n"));
+        this.log.info(`Received from WebSocket: ${str.replaceAll("\r", "\n")}`);
         const command = JSON.parse(str);
         switch (command.type) {
           case "connected":
@@ -5823,24 +5792,40 @@ var AgentHl7ChannelConnection = class {
             this.trySendToWebSocket();
             break;
           case "transmit":
-            this.hl7ConnectionQueue.push(nn.parse(command.message));
-            this.trySendToHl7Connection();
+            this.addToHl7Queue(command);
+            break;
+          case "push":
+            this.pushMessage(command);
             break;
         }
       } catch (err) {
-        console.log("WebSocket error", err);
+        this.log.error(`WebSocket error: ${qn(err)}`);
       }
     });
   }
-  async handler(event) {
-    try {
-      console.log("Received:");
-      console.log(event.message.toString().replaceAll("\r", "\n"));
-      this.webSocketQueue.push(event.message);
-      this.trySendToWebSocket();
-    } catch (err) {
-      console.log("HL7 error", err);
+  async start() {
+    this.log.info("Medplum service starting...");
+    const agent = await this.medplum.readResource("Agent", this.agentId);
+    for (const definition of agent.channel) {
+      const endpoint = await this.medplum.readReference(definition.endpoint);
+      const channel = new AgentHl7Channel(this, definition, endpoint);
+      channel.start();
+      this.channels.set(definition.name, channel);
     }
+    this.log.info("Medplum service started successfully");
+  }
+  stop() {
+    this.log.info("Medplum service stopping...");
+    this.channels.forEach((channel) => channel.stop());
+    this.log.info("Medplum service stopped successfully");
+  }
+  addToWebSocketQueue(message) {
+    this.webSocketQueue.push(message);
+    this.trySendToWebSocket();
+  }
+  addToHl7Queue(message) {
+    this.hl7Queue.push(message);
+    this.trySendToHl7Connection();
   }
   trySendToWebSocket() {
     if (this.live) {
@@ -5850,8 +5835,8 @@ var AgentHl7ChannelConnection = class {
           this.webSocket.send(
             JSON.stringify({
               type: "transmit",
-              forwardedFor: this.hl7Connection.socket.remoteAddress,
-              message: msg.toString()
+              accessToken: this.medplum.getAccessToken(),
+              ...msg
             })
           );
         }
@@ -5859,16 +5844,82 @@ var AgentHl7ChannelConnection = class {
     }
   }
   trySendToHl7Connection() {
-    while (this.hl7ConnectionQueue.length > 0) {
-      const msg = this.hl7ConnectionQueue.shift();
+    while (this.hl7Queue.length > 0) {
+      const msg = this.hl7Queue.shift();
       if (msg) {
-        this.hl7Connection.send(msg);
+        const channel = this.channels.get(msg.channel);
+        if (channel) {
+          const connection = channel.connections.get(msg.remote);
+          if (connection) {
+            connection.hl7Connection.send(nn.parse(msg.body));
+          }
+        }
       }
     }
   }
+  pushMessage(message) {
+    const address = new URL(message.remote);
+    const client = new h2({
+      host: address.hostname,
+      port: parseInt(address.port, 10)
+    });
+    client.sendAndWait(nn.parse(message.body)).then((response) => {
+      this.log.info(`Response: ${response.toString().replaceAll("\r", "\n")}`);
+    }).catch((err) => {
+      this.log.error(`HL7 error: ${qn(err)}`);
+    }).finally(() => {
+      client.close();
+    });
+  }
+};
+var AgentHl7Channel = class {
+  constructor(app, definition, endpoint) {
+    this.app = app;
+    this.definition = definition;
+    this.endpoint = endpoint;
+    this.connections = /* @__PURE__ */ new Map();
+    this.server = new E2((connection) => this.handleNewConnection(connection));
+  }
+  start() {
+    const address = new URL(this.endpoint.address);
+    this.app.log.info(`Channel starting on ${address}`);
+    this.server.start(parseInt(address.port, 10));
+    this.app.log.info("Channel started successfully");
+  }
+  stop() {
+    this.app.log.info("Channel stopping...");
+    this.connections.forEach((connection) => connection.close());
+    this.server.stop();
+    this.app.log.info("Channel stopped successfully");
+  }
+  handleNewConnection(connection) {
+    const c2 = new AgentHl7ChannelConnection(this, connection);
+    this.app.log.info(`HL7 connection established: ${c2.remote}`);
+    this.connections.set(c2.remote, c2);
+  }
+};
+var AgentHl7ChannelConnection = class {
+  constructor(channel, hl7Connection) {
+    this.channel = channel;
+    this.hl7Connection = hl7Connection;
+    this.remote = `${hl7Connection.socket.remoteAddress}:${hl7Connection.socket.remotePort}`;
+    this.hl7Connection.addEventListener("message", (event) => this.handler(event));
+  }
+  async handler(event) {
+    try {
+      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,
+        remote: this.remote,
+        body: event.message.toString()
+      });
+    } catch (err) {
+      this.channel.app.log.error(`HL7 error: ${qn(err)}`);
+    }
+  }
   close() {
     this.hl7Connection.close();
-    this.webSocket.close();
   }
 };
 if (typeof require !== "undefined" && require.main === module) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@medplum/agent",
-  "version": "2.1.6",
+  "version": "2.1.7",
   "description": "Medplum Agent",
   "author": "Medplum <hello@medplum.com>",
   "license": "Apache-2.0",

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();
   }
 }