@intuned/runtime-dev 1.3.24-pipe.1 → 1.3.24-pipe.10

package/dist/commands/interface/run.js

@@ -141,7 +141,6 @@ function runAutomationCLI(importFunction) {
     if (!client.closed) {
       await client.close();
     }
-    process.exit(0);
   });
   _commander.program.parse(process.argv);
 }

package/dist/vendor/runtime-interface.js

@@ -357,34 +357,47 @@ var require_interfaceClient = __commonJS({
     var util_1 = require("util");
     var SocketClient = class _SocketClient {
       constructor(socket) {
+        this.dataListener = null;
         this.socket = socket;
+        this.closeAbortController = new AbortController();
       }
       async sendJSON(data) {
+        if (this.socket.closed) {
+          return;
+        }
         const dataToSend = JSON.stringify(data);
         const length = Buffer.byteLength(dataToSend);
         const buffer = Buffer.alloc(_SocketClient.LENGTH_HEADER_LENGTH + length);
         buffer.writeUInt32BE(length, 0);
         buffer.write(dataToSend, _SocketClient.LENGTH_HEADER_LENGTH);
-        console.log(`Sending ${dataToSend.length} bytes`);
         await (0, util_1.promisify)((cb) => this.socket.write(buffer, cb))();
       }
       async *receiveJSON() {
         let buffer = Buffer.alloc(0);
+        let endListener;
+        let rejectListener;
         const endPromise = new Promise((resolve, reject) => {
-          this.socket.once("end", () => {
-            resolve();
-          });
-          this.socket.once("error", reject);
+          endListener = () => resolve();
+          this.socket.once("end", endListener);
+          rejectListener = (e) => reject(e);
+          this.socket.once("error", rejectListener);
+        });
+        const closePromise = new Promise((resolve) => {
+          this.closeAbortController.signal.addEventListener("abort", () => resolve());
         });
         while (true) {
           const chunk = await Promise.race([
-            new Promise((resolve) => this.socket.once("data", (data2) => {
-              if (typeof data2 === "string") {
-                return resolve(Buffer.from(data2));
-              }
-              resolve(data2);
-            })),
-            endPromise
+            new Promise((resolve) => {
+              this.dataListener = (data2) => {
+                if (typeof data2 === "string") {
+                  return resolve(Buffer.from(data2));
+                }
+                resolve(data2);
+              };
+              this.socket.once("data", this.dataListener);
+            }),
+            endPromise,
+            closePromise
           ]);
           if (!(chunk instanceof Buffer)) {
             break;
@@ -405,8 +418,44 @@ var require_interfaceClient = __commonJS({
           yield JSON.parse(data.toString());
         }
       }
-      async close() {
-        this.socket.end();
+      async close(mode = "client") {
+        console.log(`[${process.pid}] Closing socket client`);
+        if (this.dataListener) {
+          this.socket.off("data", this.dataListener);
+          console.log(`[${process.pid}] Removed data listener`);
+        } else {
+          console.log(`[${process.pid}] No data listener to remove`);
+        }
+        this.closeAbortController.abort();
+        console.log(`[${process.pid}] Called abort on closeAbortController`);
+        if (mode === "client") {
+          console.log(`[${process.pid}] Sending FIN to socket`);
+          await (0, util_1.promisify)((cb) => this.socket.end(cb))();
+          console.log(`[${process.pid}] Waiting for socket to close gracefully for 3 seconds...`);
+          const closeResult = await Promise.race([
+            new Promise((resolve) => this.socket.once("close", () => resolve("closed"))),
+            new Promise((resolve) => this.socket.once("error", () => resolve("error"))),
+            (0, promises_1.setTimeout)(3e3, "timeout")
+          ]);
+          console.log(`[${process.pid}] Socket close result: ${closeResult}`);
+          if (closeResult === "timeout") {
+            console.warn(`[${process.pid}] Socket did not close within timeout, destroying socket`);
+            this.socket.destroy();
+          }
+          return;
+        }
+        console.log(`[${process.pid}] Waiting for socket to end gracefully for 3 seconds...`);
+        const receiveEndResult = await Promise.race([
+          new Promise((resolve) => this.socket.once("end", () => resolve("end"))),
+          new Promise((resolve) => this.socket.once("error", () => resolve("error"))),
+          (0, promises_1.setTimeout)(3e3, "timeout")
+        ]);
+        console.log(`[${process.pid}] Socket receive end result: ${receiveEndResult}`);
+        if (receiveEndResult === "end") {
+          console.log(`[${process.pid}] Socket ended gracefully`);
+          return;
+        }
+        console.log(`[${process.pid}] Socket did not end gracefully, destroying socket`);
         this.socket.destroy();
       }
       get closed() {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@intuned/runtime-dev",
-  "version": "1.3.24-pipe.1",
+  "version": "1.3.24-pipe.10",
   "description": "Intuned runtime",
   "packageManager": "yarn@4.12.0",
   "main": "./dist/index.js",