@medplum/agent 4.3.15 → 4.4.1

package/dist/cjs/index.cjs

@@ -7921,7 +7921,7 @@ var require_websocket = __commonJS({
     var EventEmitter = require("events");
     var https = require("https");
     var http = require("http");
-    var net = require("net");
+    var net2 = require("net");
     var tls = require("tls");
     var { randomBytes, createHash } = require("crypto");
     var { Duplex, Readable: Readable2 } = require("stream");
@@ -8652,12 +8652,12 @@ var require_websocket = __commonJS({
     }
     function netConnect(options) {
       options.path = options.socketPath;
-      return net.connect(options);
+      return net2.connect(options);
     }
     function tlsConnect(options) {
       options.path = void 0;
       if (!options.servername && options.servername !== "") {
-        options.servername = net.isIP(options.host) ? "" : options.host;
+        options.servername = net2.isIP(options.host) ? "" : options.host;
       }
       return tls.connect(options);
     }
@@ -68386,7 +68386,7 @@ function Re() {
     return (r6 === "x" ? e : e & 3 | 8).toString(16);
   });
 }
-var A = { CSS: "text/css", DICOM: "application/dicom", FAVICON: "image/vnd.microsoft.icon", FHIR_JSON: "application/fhir+json", FORM_URL_ENCODED: "application/x-www-form-urlencoded", HL7_V2: "x-application/hl7-v2+er7", HTML: "text/html", JAVASCRIPT: "text/javascript", JSON: "application/json", JSON_PATCH: "application/json-patch+json", JWT: "application/jwt", MULTIPART_FORM_DATA: "multipart/form-data", PNG: "image/png", SCIM_JSON: "application/scim+json", SVG: "image/svg+xml", TEXT: "text/plain", TYPESCRIPT: "text/typescript", PING: "x-application/ping", XML: "text/xml", CDA_XML: "application/cda+xml" };
+var A = { CSS: "text/css", DICOM: "application/dicom", FAVICON: "image/vnd.microsoft.icon", FHIR_JSON: "application/fhir+json", FORM_URL_ENCODED: "application/x-www-form-urlencoded", HL7_V2: "x-application/hl7-v2+er7", HTML: "text/html", JAVASCRIPT: "text/javascript", JSON: "application/json", JSON_PATCH: "application/json-patch+json", JWT: "application/jwt", MULTIPART_FORM_DATA: "multipart/form-data", PNG: "image/png", SCIM_JSON: "application/scim+json", SVG: "image/svg+xml", TEXT: "text/plain", TYPESCRIPT: "text/typescript", PING: "x-application/ping", XML: "text/xml", CDA_XML: "application/cda+xml", OCTET_STREAM: "application/octet-stream" };
 var Gr = class {
   constructor() {
     this.listeners = {};
@@ -69008,7 +69008,7 @@ var $t = class {
     return this.masterSubEmitter || (this.masterSubEmitter = new et(...Array.from(this.criteriaEntries.keys()))), this.masterSubEmitter;
   }
 };
-var Yr = "4.3.15-dbf6882a3";
+var Yr = "4.4.1-672cfe139";
 var va = A.FHIR_JSON + ", */*; q=0.1";
 var Ta = "https://api.medplum.com/";
 var Sa = 1e3;
@@ -70323,7 +70323,7 @@ var H = class {
 // src/app.ts
 var import_node_child_process = require("node:child_process");
 var import_node_fs4 = require("node:fs");
-var import_node_net3 = require("node:net");
+var import_node_net4 = require("node:net");
 var import_node_os4 = require("node:os");
 var import_node_process2 = __toESM(require("node:process"));
 var semver = __toESM(require_semver2());
@@ -70336,6 +70336,11 @@ var import_websocket = __toESM(require_websocket(), 1);
 var import_websocket_server = __toESM(require_websocket_server(), 1);
 var wrapper_default = import_websocket.default;
 
+// src/bytestream.ts
+var import_node_assert2 = __toESM(require("node:assert"));
+var import_node_crypto = require("node:crypto");
+var import_node_net3 = __toESM(require("node:net"));
+
 // src/channel.ts
 var BaseChannel = class {
   constructor(app, definition, endpoint) {
@@ -70352,7 +70357,8 @@ var BaseChannel = class {
 };
 var ChannelType = {
   HL7_V2: "HL7_V2",
-  DICOM: "DICOM"
+  DICOM: "DICOM",
+  BYTE_STREAM: "BYTE_STREAM"
 };
 function getChannelType(endpoint) {
   if (endpoint.address.startsWith("dicom")) {
@@ -70361,19 +70367,182 @@ function getChannelType(endpoint) {
   if (endpoint.address.startsWith("mllp")) {
     return ChannelType.HL7_V2;
   }
+  if (endpoint.address.startsWith("tcp")) {
+    return ChannelType.BYTE_STREAM;
+  }
   throw new Error(`Unsupported endpoint type: ${endpoint.address}`);
 }
 function getChannelTypeShortName(endpoint) {
-  switch (getChannelType(endpoint)) {
-    case ChannelType.HL7_V2:
-      return "HL7";
-    case ChannelType.DICOM:
-      return "DICOM";
-    default:
-      throw new Error(`Invalid endpoint type with address '${endpoint.address}'`);
+  try {
+    const channelType = getChannelType(endpoint);
+    switch (channelType) {
+      case ChannelType.HL7_V2:
+        return "HL7";
+      case ChannelType.DICOM:
+        return "DICOM";
+      case ChannelType.BYTE_STREAM:
+        return "Byte Stream";
+      default:
+        channelType;
+        throw new Error("Unreachable");
+    }
+  } catch (err) {
+    throw new Error(`Invalid endpoint type with address '${endpoint.address}'`, { cause: err });
   }
 }
 
+// src/bytestream.ts
+var AgentByteStreamChannel = class extends BaseChannel {
+  constructor(app, definition, endpoint) {
+    super(app, definition, endpoint);
+    this.started = false;
+    this.connections = /* @__PURE__ */ new Map();
+    this.startChar = -1;
+    this.endChar = -1;
+    this.app = app;
+    this.server = import_node_net3.default.createServer((socket) => this.handleNewConnection(socket));
+    this.log = app.log.clone({ options: { prefix: `[Byte Stream:${definition.name}] ` } });
+    this.channelLog = app.channelLog.clone({ options: { prefix: `[Byte Stream:${definition.name}] ` } });
+  }
+  start() {
+    if (this.started) {
+      return;
+    }
+    this.started = true;
+    const address = new URL(this.getEndpoint().address);
+    this.log.info(`Channel starting on ${address}...`);
+    this.configureTcpServerAndConnections();
+    this.server.listen(Number.parseInt(address.port, 10));
+    this.log.info("Channel started successfully");
+  }
+  async stop() {
+    if (!this.started) {
+      return;
+    }
+    this.log.info("Channel stopping...");
+    for (const [_, connection] of this.connections) {
+      connection.close();
+    }
+    await new Promise((resolve2, reject) => {
+      this.server.close((err) => {
+        if (err) {
+          reject(err);
+        } else {
+          resolve2();
+        }
+      });
+    });
+    this.started = false;
+    this.log.info("Channel stopped successfully");
+  }
+  async reloadConfig(definition, endpoint) {
+    const previousEndpoint = this.endpoint;
+    this.definition = definition;
+    this.endpoint = endpoint;
+    this.log.info("Reloading config... Evaluating if channel needs to change address...");
+    if (this.needToRebindToPort(previousEndpoint, endpoint)) {
+      await this.stop();
+      this.start();
+      this.log.info(`Address changed: ${previousEndpoint.address} => ${endpoint.address}`);
+    } else if (previousEndpoint.address !== endpoint.address) {
+      this.log.info(
+        `Reconfiguring TCP server and ${this.connections.size} connections based on new endpoint settings: ${previousEndpoint.address} => ${endpoint.address}`
+      );
+      this.configureTcpServerAndConnections();
+    } else {
+      this.log.info(`No address change needed. Listening at ${endpoint.address}`);
+    }
+  }
+  needToRebindToPort(firstEndpoint, secondEndpoint) {
+    if (firstEndpoint.address === secondEndpoint.address || new URL(firstEndpoint.address).port === new URL(secondEndpoint.address).port) {
+      return false;
+    }
+    return true;
+  }
+  configureTcpServerAndConnections() {
+    const address = new URL(this.getEndpoint().address);
+    const startCharStr = address.searchParams.get("startChar");
+    const endCharStr = address.searchParams.get("endChar");
+    if (!(startCharStr && endCharStr)) {
+      throw new Error(`Failed to parse startChar and/or endChar query param(s) from ${address}`);
+    }
+    this.startChar = startCharStr.codePointAt(0) ?? -1;
+    this.endChar = endCharStr.codePointAt(0) ?? -1;
+    (0, import_node_assert2.default)(this.startChar !== -1 && this.endChar !== -1);
+  }
+  sendToRemote(msg) {
+    const connection = this.connections.get(msg.remote);
+    if (connection) {
+      connection.write(Buffer.from(msg.body, "hex"));
+    }
+  }
+  handleNewConnection(socket) {
+    const c2 = new ByteStreamChannelConnection(this, socket);
+    this.log.info(`Byte stream connection established: ${c2.remote}`);
+    this.connections.set(c2.remote, c2);
+  }
+};
+var ByteStreamChannelConnection = class {
+  constructor(channel, socket) {
+    this.msgChunks = [];
+    this.msgTotalLength = -1;
+    this.channel = channel;
+    this.socket = socket;
+    this.remote = `${socket.remoteAddress}:${socket.remotePort}`;
+    this.socket.on("data", (data2) => this.handler(data2));
+  }
+  async handler(data2) {
+    try {
+      this.channel.channelLog.info(`Received: ${data2.toString("hex").replaceAll("\r", "\n")}`);
+      let lastEndIndex = -1;
+      for (let i = 0; i < data2.length; i++) {
+        const char = data2[i];
+        if (char === this.channel.startChar) {
+          this.msgChunks.length = 0;
+          this.msgTotalLength = 0;
+        } else if (char === this.channel.endChar) {
+          if (this.msgTotalLength === -1) {
+            continue;
+          }
+          const startSlice = lastEndIndex + 1;
+          const slice = data2.subarray(startSlice, i + 1);
+          this.msgChunks.push(slice);
+          this.msgTotalLength += slice.length;
+          const messageBuffer = Buffer.concat(this.msgChunks, this.msgTotalLength);
+          this.channel.app.addToWebSocketQueue({
+            type: "agent:transmit:request",
+            accessToken: "placeholder",
+            channel: this.channel.getDefinition().name,
+            remote: this.remote,
+            contentType: A.OCTET_STREAM,
+            body: messageBuffer.toString("hex"),
+            callback: `Agent/${this.channel.app.agentId}-${(0, import_node_crypto.randomUUID)()}`
+          });
+          this.msgChunks.length = 0;
+          lastEndIndex = i;
+          this.msgTotalLength = -1;
+        }
+      }
+      if (lastEndIndex < data2.length - 1) {
+        const remainingSlice = data2.subarray(lastEndIndex + 1);
+        if (remainingSlice.length > 0) {
+          this.msgChunks.push(remainingSlice);
+          this.msgTotalLength += remainingSlice.length;
+        }
+      }
+    } catch (err) {
+      this.channel.log.error(`Byte stream error occurred - check channel logs`);
+      this.channel.channelLog.error(`Byte stream error: ${Ie(err)}`);
+    }
+  }
+  write(data2) {
+    this.socket.write(data2);
+  }
+  close() {
+    this.socket.end();
+  }
+};
+
 // src/constants.ts
 var RETRY_WAIT_DURATION_MS = 1e4;
 var DEFAULT_PING_TIMEOUT = 3600;
@@ -70384,7 +70553,7 @@ var MAX_MISSED_HEARTBEATS = 1;
 // src/dicom.ts
 var dcmjs = __toESM(require_dcmjs());
 var dimse = __toESM(require_dcmjs_dimse_min());
-var import_node_crypto = require("node:crypto");
+var import_node_crypto2 = require("node:crypto");
 var import_node_fs = require("node:fs");
 var import_node_os = require("node:os");
 var import_node_path = require("node:path");
@@ -70438,7 +70607,7 @@ var AgentDicomChannel = class extends BaseChannel {
           let binary = void 0;
           let dicomJson = void 0;
           if (dataset) {
-            const tempFileName = (0, import_node_path.join)(DcmjsDimseScp.channel.tempDir, (0, import_node_crypto.randomUUID)() + ".dcm");
+            const tempFileName = (0, import_node_path.join)(DcmjsDimseScp.channel.tempDir, (0, import_node_crypto2.randomUUID)() + ".dcm");
             dataset.toFile(tempFileName);
             const buffer2 = (0, import_node_fs.readFileSync)(tempFileName);
             const medplum = App.instance.medplum;
@@ -70471,7 +70640,7 @@ var AgentDicomChannel = class extends BaseChannel {
             remote: this.association?.getCallingAeTitle(),
             contentType: A.JSON,
             body: JSON.stringify(payload),
-            callback: `Agent/${App.instance.agentId}-${(0, import_node_crypto.randomUUID)()}`
+            callback: `Agent/${App.instance.agentId}-${(0, import_node_crypto2.randomUUID)()}`
           });
           response2.setStatus(dimse.constants.Status.Success);
         } catch (err) {
@@ -70548,7 +70717,7 @@ var AgentDicomChannel = class extends BaseChannel {
 };
 
 // src/hl7.ts
-var import_node_crypto2 = require("node:crypto");
+var import_node_crypto3 = require("node:crypto");
 
 // src/stats.ts
 var currentStats = {
@@ -70677,7 +70846,7 @@ var AgentHl7ChannelConnection = class {
         remote: this.remote,
         contentType: A.HL7_V2,
         body: event.message.toString(),
-        callback: `Agent/${this.channel.app.agentId}-${(0, import_node_crypto2.randomUUID)()}`
+        callback: `Agent/${this.channel.app.agentId}-${(0, import_node_crypto3.randomUUID)()}`
       });
     } catch (err) {
       this.channel.log.error(`HL7 error occurred - check channel logs`);
@@ -71449,6 +71618,7 @@ var App = class _App {
       pendingRemoval.delete(leftover);
       this.channels.delete(leftover);
     }
+    const errors = [];
     for (let i = 0; i < filteredChannels.length; i++) {
       const definition = filteredChannels[i];
       const endpoint = filteredEndpoints[i];
@@ -71458,9 +71628,31 @@ var App = class _App {
       try {
         await this.startOrReloadChannel(definition, endpoint);
       } catch (err) {
+        errors.push(err);
         this.log.error(Ie(err));
       }
     }
+    if (errors.length) {
+      throw new p({
+        resourceType: "OperationOutcome",
+        issue: [
+          {
+            severity: "error",
+            code: "invalid",
+            details: {
+              text: `${errors.length} error(s) occurred while reloading channels`
+            }
+          },
+          ...errors.map(
+            (err) => ({
+              severity: "error",
+              code: "invalid",
+              details: { text: Ie(err) }
+            })
+          )
+        ]
+      });
+    }
   }
   /**
    * Validates whether all endpoints are valid. Also ensures that there are no conflicting ports between any endpoints in the group.
@@ -71503,15 +71695,24 @@ var App = class _App {
       await channel.reloadConfig(definition, endpoint);
       return;
     }
-    switch (getChannelType(endpoint)) {
-      case ChannelType.DICOM:
-        channel = new AgentDicomChannel(this, definition, endpoint);
-        break;
-      case ChannelType.HL7_V2:
-        channel = new AgentHl7Channel(this, definition, endpoint);
-        break;
-      default:
-        throw new Error(`Unsupported endpoint type: ${endpoint.address}`);
+    try {
+      const channelType = getChannelType(endpoint);
+      switch (channelType) {
+        case ChannelType.DICOM:
+          channel = new AgentDicomChannel(this, definition, endpoint);
+          break;
+        case ChannelType.HL7_V2:
+          channel = new AgentHl7Channel(this, definition, endpoint);
+          break;
+        case ChannelType.BYTE_STREAM:
+          channel = new AgentByteStreamChannel(this, definition, endpoint);
+          break;
+        default:
+          throw new Error(`Unsupported endpoint type: ${endpoint.address}`);
+      }
+    } catch (err) {
+      this.log.error(Ie(err));
+      return;
     }
     channel.start();
     this.channels.set(definition.name, channel);
@@ -71599,14 +71800,14 @@ var App = class _App {
         const warnMsg = "Message body present but unused. Body for a ping request should be empty or a message formatted as `PING[ count]`.";
         this.log.warn(warnMsg);
       }
-      if ((0, import_node_net3.isIPv6)(message.remote)) {
+      if ((0, import_node_net4.isIPv6)(message.remote)) {
         const errMsg = `Attempted to ping an IPv6 address: ${message.remote}
 
 IPv6 is currently unsupported.`;
         this.log.error(errMsg);
         throw new Error(errMsg);
       }
-      if (!((0, import_node_net3.isIPv4)(message.remote) || _l(message.remote))) {
+      if (!((0, import_node_net4.isIPv4)(message.remote) || _l(message.remote))) {
         const errMsg = `Attempted to ping an invalid host.
 
 "${message.remote}" is not a valid IPv4 address or a resolvable hostname.`;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@medplum/agent",
-  "version": "4.3.15",
+  "version": "4.4.1",
   "description": "Medplum Agent",
   "homepage": "https://www.medplum.com/",
   "bugs": {
@@ -25,8 +25,8 @@
     "test": "jest"
   },
   "dependencies": {
-    "@medplum/core": "4.3.15",
-    "@medplum/hl7": "4.3.15",
+    "@medplum/core": "4.4.1",
+    "@medplum/hl7": "4.4.1",
     "dcmjs-dimse": "0.3.0",
     "iconv-lite": "0.7.0",
     "semver": "7.7.2",
@@ -35,8 +35,8 @@
     "ws": "8.18.3"
   },
   "devDependencies": {
-    "@medplum/fhirtypes": "4.3.15",
-    "@medplum/mock": "4.3.15",
+    "@medplum/fhirtypes": "4.4.1",
+    "@medplum/mock": "4.4.1",
     "@types/async-eventemitter": "0.2.4",
     "@types/ws": "8.18.1",
     "mock-socket": "9.3.1",