@adhdev/session-host-core 1.0.82-rc.26 → 1.0.82-rc.27

package/dist/index.mjs

@@ -746,6 +746,19 @@ function disconnectSessionHostClients(endpoint, error) {
     }
   }
 }
+function findConnectedSessionHostClient(endpoint) {
+  for (const ref of activeClientRefs) {
+    const client = ref.deref();
+    if (!client) {
+      activeClientRefs.delete(ref);
+      continue;
+    }
+    if ((!endpoint || client.endpoint.path === endpoint.path) && client.isConnected()) {
+      return client;
+    }
+  }
+  return null;
+}
 var SessionHostClient = class {
   endpoint;
   socket = null;
@@ -763,11 +776,17 @@ var SessionHostClient = class {
     if (typeof options.requestTimeoutMs === "number" && options.requestTimeoutMs > 0) {
       this.requestTimeoutMs = options.requestTimeoutMs;
     }
-    activeClientRefs.add(new WeakRef(this));
+    if (options.registerAsShared !== false) activeClientRefs.add(new WeakRef(this));
   }
   static disconnectClients(endpoint, error) {
     disconnectSessionHostClients(endpoint, error);
   }
+  static findConnectedClient(endpoint) {
+    return findConnectedSessionHostClient(endpoint);
+  }
+  isConnected() {
+    return Boolean(this.socket && !this.socket.destroyed && establishedSockets.has(this.socket));
+  }
   /**
    * Fires when an established connection to the session host goes away.
    *
@@ -829,18 +848,17 @@ var SessionHostClient = class {
       }
     }
   }
-  sendRawRequestOnSocket(socket, request) {
+  sendRawRequestOnSocket(socket, request, timeoutMs = this.requestTimeoutMs) {
     const requestId = generateUUID();
     const envelope = {
       kind: "request",
       requestId,
       request
     };
-    const timeoutMs = this.requestTimeoutMs > 0 ? this.requestTimeoutMs : 3e4;
     const timeoutLabel = timeoutMs % 1e3 === 0 ? `${timeoutMs / 1e3}s` : `${timeoutMs}ms`;
     return new Promise((resolve3, reject) => {
       const timeout = setTimeout(() => {
-        const timeoutError = new Error(`Session host request timed out after ${timeoutLabel} (${request.type})`);
+        const timeoutError = Object.assign(new Error(`Session host request timed out after ${timeoutLabel} (${request.type})`), { code: "SESSION_HOST_REQUEST_TIMEOUT", requestType: request.type });
         if (this.socket === socket) {
           this.disconnect(timeoutError);
         } else {
@@ -866,7 +884,7 @@ var SessionHostClient = class {
       socket.write(serializeEnvelope(envelope));
     });
   }
-  async connect() {
+  async connect(timeoutMs = this.requestTimeoutMs) {
     if (this.socket && !this.socket.destroyed) {
       if (this.connectPromise) await this.connectPromise;
       return;
@@ -914,11 +932,30 @@ var SessionHostClient = class {
     });
     const connectTask = (async () => {
       await new Promise((resolve3, reject) => {
-        socket.once("connect", () => {
+        const cleanup = () => {
+          clearTimeout(timer);
+          socket.off("connect", connected);
+          socket.off("error", failed);
+          socket.off("close", closed);
+        };
+        const connected = () => {
+          cleanup();
           establishedSockets.add(socket);
           resolve3();
-        });
-        socket.once("error", reject);
+        };
+        const failed = (error) => {
+          cleanup();
+          reject(error);
+        };
+        const closed = () => failed(new Error("Session host connection closed before connect"));
+        const timer = setTimeout(() => {
+          const error = Object.assign(new Error(`Session host connect timed out after ${timeoutMs}ms`), { code: "SESSION_HOST_CONNECT_TIMEOUT" });
+          failed(error);
+          if (this.socket === socket) this.disconnect(error);
+        }, timeoutMs);
+        socket.once("connect", connected);
+        socket.once("error", failed);
+        socket.once("close", closed);
       });
       if (this.attachedSessions.size > 0 && this.socket === socket && !socket.destroyed) {
         for (const [sessionId, sub] of [...this.attachedSessions.entries()]) {
@@ -948,11 +985,32 @@ var SessionHostClient = class {
       this.eventListeners.delete(listener);
     };
   }
-  async request(request) {
-    await this.connect();
+  async request(request, options = {}) {
+    const timeoutMs = Math.max(1, options.timeoutMs ?? this.requestTimeoutMs);
+    const deadline = Date.now() + timeoutMs;
+    const alreadyConnected = this.isConnected() && !this.connectPromise;
+    if (options.timeoutMs !== void 0) {
+      let timer;
+      try {
+        await Promise.race([
+          this.connect(timeoutMs),
+          new Promise((_resolve, reject) => {
+            timer = setTimeout(() => {
+              const error = Object.assign(new Error(`Session host connect timed out after ${timeoutMs}ms`), { code: "SESSION_HOST_CONNECT_TIMEOUT" });
+              reject(error);
+              this.disconnect(error);
+            }, timeoutMs);
+          })
+        ]);
+      } finally {
+        if (timer) clearTimeout(timer);
+      }
+    } else {
+      await this.connect(timeoutMs);
+    }
     const requestSocket = this.socket;
     if (!requestSocket) throw new Error("Session host socket unavailable");
-    const response = await this.sendRawRequestOnSocket(requestSocket, request);
+    const response = await this.sendRawRequestOnSocket(requestSocket, request, options.timeoutMs === void 0 || alreadyConnected ? timeoutMs : Math.max(1, deadline - Date.now()));
     if (response.success) {
       if (request.type === "attach_session") {
         this.attachedSessions.set(request.payload.sessionId, {
@@ -1212,6 +1270,7 @@ export {
   createSessionHostControlPlane,
   disconnectSessionHostClients,
   ensureNodePtySpawnHelperPermissions,
+  findConnectedSessionHostClient,
   formatRuntimeOwner,
   getDefaultSessionHostEndpoint,
   getSessionHostRecoveryLabel,