@cadenza.io/service 1.10.5 → 1.10.6

package/dist/index.js

@@ -1345,9 +1345,9 @@ var SocketController = class _SocketController {
             return;
           }
           console.log("SocketServer: Setting up", ctx);
+          let server;
           try {
-            const server = new import_socket.Server((_a2 = ctx.__httpsServer) != null ? _a2 : ctx.__httpServer);
-            ctx.__socketServer = server;
+            server = new import_socket.Server((_a2 = ctx.__httpsServer) != null ? _a2 : ctx.__httpServer);
             console.log("SocketServer:", server);
             const profile = (_b2 = ctx.__securityProfile) != null ? _b2 : "medium";
             server.use((socket, next) => {
@@ -1397,114 +1397,101 @@ var SocketController = class _SocketController {
             console.log("SocketServer: Setup complete");
           } catch (err) {
             console.error("Socket setup error:", err);
-            return false;
+            return __spreadProps(__spreadValues({}, ctx), { __error: err, errored: true });
           }
-          return ctx;
-        }).then(
-          CadenzaService.createMetaTask(
-            "Start SocketServer",
-            (ctx) => {
-              const server = ctx.__socketServer;
-              console.log("SocketServer: Starting", server);
-              server.on("connection", (ws) => {
-                console.log("SocketServer: New connection");
-                ws.on("handshake", (ctx2) => {
-                  console.log("Socket HANDSHAKE", ctx2.serviceInstanceId);
-                  ws.emit("handshake", {
-                    serviceInstanceId: CadenzaService.serviceRegistry.serviceInstanceId,
-                    __status: "success"
-                  });
-                  CadenzaService.broker.emit("meta.socket.handshake", ctx2);
-                });
-                ws.on(
-                  "delegation",
-                  (ctx2, callback) => {
-                    const deputyExecId = ctx2.__metadata.__deputyExecId;
-                    CadenzaService.createEphemeralMetaTask(
-                      "Resolve delegation",
-                      callback,
-                      "Resolves a delegation request using the provided callback from the client (.emitWithAck())"
-                    ).doOn(`meta.node.graph_completed:${deputyExecId}`).emits(`meta.socket.delegation_resolved:${deputyExecId}`);
-                    CadenzaService.createEphemeralMetaTask(
-                      "Delegation progress update",
-                      (ctx3) => {
-                        if (ctx3.__progress !== void 0)
-                          ws.emit("delegation_progress", ctx3);
-                      },
-                      "Updates delegation progress",
-                      {
-                        once: false,
-                        destroyCondition: (ctx3) => {
-                          var _a2;
-                          return ctx3.data.progress === 1 || ((_a2 = ctx3.data) == null ? void 0 : _a2.progress) === void 0;
-                        }
-                      }
-                    ).doOn(
-                      `meta.node.routine_execution_progress:${deputyExecId}`,
-                      `meta.node.graph_completed:${deputyExecId}`
-                    ).emitsOnFail(
-                      `meta.socket.progress_failed:${deputyExecId}`
-                    );
-                    CadenzaService.broker.emit(
-                      "meta.socket.delegation_requested",
-                      ctx2
-                    );
-                  }
-                );
-                ws.on(
-                  "signal",
-                  (ctx2, callback) => {
-                    if (CadenzaService.broker.listObservedSignals().includes(ctx2.__signalName)) {
-                      callback({
-                        __status: "success",
-                        __signalName: ctx2.__signalName
-                      });
-                      CadenzaService.broker.emit(ctx2.__signalName, ctx2);
-                    } else {
-                      callback({
-                        __status: "error",
-                        __error: "No such signal",
-                        errored: true
-                      });
+          if (!server) {
+            console.error("Socket setup error: No server");
+            return __spreadProps(__spreadValues({}, ctx), { __error: "No server", errored: true });
+          }
+          server.on("connection", (ws) => {
+            console.log("SocketServer: New connection");
+            ws.on("handshake", (ctx2) => {
+              console.log("Socket HANDSHAKE", ctx2.serviceInstanceId);
+              ws.emit("handshake", {
+                serviceInstanceId: CadenzaService.serviceRegistry.serviceInstanceId,
+                __status: "success"
+              });
+              CadenzaService.broker.emit("meta.socket.handshake", ctx2);
+            });
+            ws.on(
+              "delegation",
+              (ctx2, callback) => {
+                const deputyExecId = ctx2.__metadata.__deputyExecId;
+                CadenzaService.createEphemeralMetaTask(
+                  "Resolve delegation",
+                  callback,
+                  "Resolves a delegation request using the provided callback from the client (.emitWithAck())"
+                ).doOn(`meta.node.graph_completed:${deputyExecId}`).emits(`meta.socket.delegation_resolved:${deputyExecId}`);
+                CadenzaService.createEphemeralMetaTask(
+                  "Delegation progress update",
+                  (ctx3) => {
+                    if (ctx3.__progress !== void 0)
+                      ws.emit("delegation_progress", ctx3);
+                  },
+                  "Updates delegation progress",
+                  {
+                    once: false,
+                    destroyCondition: (ctx3) => {
+                      var _a3;
+                      return ctx3.data.progress === 1 || ((_a3 = ctx3.data) == null ? void 0 : _a3.progress) === void 0;
                     }
                   }
-                );
-                ws.on(
-                  "status_check",
-                  (ctx2, callback) => {
-                    CadenzaService.createEphemeralMetaTask(
-                      "Resolve status check",
-                      callback,
-                      "Resolves a status check request"
-                    ).doAfter(CadenzaService.serviceRegistry.getStatusTask);
-                    CadenzaService.broker.emit(
-                      "meta.socket.status_check_requested",
-                      ctx2
-                    );
-                  }
-                );
-                ws.on("disconnect", () => {
-                  CadenzaService.broker.emit("meta.socket.disconnected", {
-                    __wsId: ws.id
+                ).doOn(
+                  `meta.node.routine_execution_progress:${deputyExecId}`,
+                  `meta.node.graph_completed:${deputyExecId}`
+                ).emitsOnFail(`meta.socket.progress_failed:${deputyExecId}`);
+                CadenzaService.broker.emit("meta.socket.delegation_requested", ctx2);
+              }
+            );
+            ws.on(
+              "signal",
+              (ctx2, callback) => {
+                if (CadenzaService.broker.listObservedSignals().includes(ctx2.__signalName)) {
+                  callback({
+                    __status: "success",
+                    __signalName: ctx2.__signalName
                   });
-                });
-                CadenzaService.broker.emit("meta.socket.connected", { __wsId: ws.id });
+                  CadenzaService.broker.emit(ctx2.__signalName, ctx2);
+                } else {
+                  callback({
+                    __status: "error",
+                    __error: "No such signal",
+                    errored: true
+                  });
+                }
+              }
+            );
+            ws.on(
+              "status_check",
+              (ctx2, callback) => {
+                CadenzaService.createEphemeralMetaTask(
+                  "Resolve status check",
+                  callback,
+                  "Resolves a status check request"
+                ).doAfter(CadenzaService.serviceRegistry.getStatusTask);
+                CadenzaService.broker.emit("meta.socket.status_check_requested", ctx2);
+              }
+            );
+            ws.on("disconnect", () => {
+              console.log("SocketServer: Disconnected");
+              CadenzaService.broker.emit("meta.socket.disconnected", {
+                __wsId: ws.id
               });
-              CadenzaService.createMetaTask(
-                "Broadcast status",
-                (ctx2) => server.emit("status_update", ctx2),
-                "Broadcasts the status of the server to all clients"
-              ).doOn("meta.service.updated");
-              CadenzaService.createMetaTask(
-                "Shutdown SocketServer",
-                () => server.close(),
-                "Shuts down the socket server"
-              ).doOn("meta.socket_server_shutdown_requested").emits("meta.socket.shutdown");
-              return true;
-            },
-            "Starts socket server and initiates meta-handling"
-          ).emitsOnFail("meta.socket.failed")
-        )
+            });
+            CadenzaService.broker.emit("meta.socket.connected", { __wsId: ws.id });
+          });
+          CadenzaService.createMetaTask(
+            "Broadcast status",
+            (ctx2) => server.emit("status_update", ctx2),
+            "Broadcasts the status of the server to all clients"
+          ).doOn("meta.service.updated");
+          CadenzaService.createMetaTask(
+            "Shutdown SocketServer",
+            () => server.close(),
+            "Shuts down the socket server"
+          ).doOn("meta.socket_server_shutdown_requested").emits("meta.socket.shutdown");
+          return ctx;
+        })
       ],
       "Bootstraps the socket server"
     ).doOn("meta.rest.network_configured");
@@ -1554,6 +1541,7 @@ var SocketController = class _SocketController {
           CadenzaService.broker.emit("meta.socket_client.status_received", status);
         });
         socket.on("disconnect", () => {
+          console.log("SocketClient: Disconnected", serviceInstanceId);
           CadenzaService.broker.emit("meta.socket_client.disconnected", {
             serviceInstanceId
           });