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

package/dist/index.mjs

@@ -16,6 +16,7 @@ var SESSION_HOST_SUPPORTED_REQUEST_TYPES = [
   "send_input",
   "resize_session",
   "stop_session",
+  "stop_mesh_writer",
   "delete_session",
   "resume_session",
   "acquire_write",
@@ -746,6 +747,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 +777,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 +849,32 @@ 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`;
+    const startedAt = Date.now();
+    const startedMonotonicAt = performance.now();
     return new Promise((resolve3, reject) => {
       const timeout = setTimeout(() => {
-        const timeoutError = new Error(`Session host request timed out after ${timeoutLabel} (${request.type})`);
+        const actualElapsedMs = Math.max(0, Math.round(performance.now() - startedMonotonicAt));
+        const wallElapsedMs = Math.max(0, Date.now() - startedAt);
+        const observerLagMs = Math.max(0, actualElapsedMs - timeoutMs);
+        const timeoutError = Object.assign(
+          new Error(`Session host request timed out after ${timeoutLabel} (${request.type})`),
+          {
+            code: "SESSION_HOST_REQUEST_TIMEOUT",
+            requestType: request.type,
+            scheduledTimeoutMs: timeoutMs,
+            actualElapsedMs,
+            wallElapsedMs,
+            observerLagMs
+          }
+        );
         if (this.socket === socket) {
           this.disconnect(timeoutError);
         } else {
@@ -866,7 +900,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 +948,44 @@ 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 connectStartedAt = Date.now();
+        const connectStartedMonotonicAt = performance.now();
+        const timer = setTimeout(() => {
+          const actualElapsedMs = Math.max(0, Math.round(performance.now() - connectStartedMonotonicAt));
+          const wallElapsedMs = Math.max(0, Date.now() - connectStartedAt);
+          const observerLagMs = Math.max(0, actualElapsedMs - timeoutMs);
+          const error = Object.assign(
+            new Error(`Session host connect timed out after ${timeoutMs}ms`),
+            {
+              code: "SESSION_HOST_CONNECT_TIMEOUT",
+              scheduledTimeoutMs: timeoutMs,
+              actualElapsedMs,
+              wallElapsedMs,
+              observerLagMs
+            }
+          );
+          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 +1015,46 @@ 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;
+      const raceStartedAt = Date.now();
+      const raceStartedMonotonicAt = performance.now();
+      try {
+        await Promise.race([
+          this.connect(timeoutMs),
+          new Promise((_resolve, reject) => {
+            timer = setTimeout(() => {
+              const actualElapsedMs = Math.max(0, Math.round(performance.now() - raceStartedMonotonicAt));
+              const wallElapsedMs = Math.max(0, Date.now() - raceStartedAt);
+              const observerLagMs = Math.max(0, actualElapsedMs - timeoutMs);
+              const error = Object.assign(
+                new Error(`Session host connect timed out after ${timeoutMs}ms`),
+                {
+                  code: "SESSION_HOST_CONNECT_TIMEOUT",
+                  scheduledTimeoutMs: timeoutMs,
+                  actualElapsedMs,
+                  wallElapsedMs,
+                  observerLagMs
+                }
+              );
+              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 +1314,7 @@ export {
   createSessionHostControlPlane,
   disconnectSessionHostClients,
   ensureNodePtySpawnHelperPermissions,
+  findConnectedSessionHostClient,
   formatRuntimeOwner,
   getDefaultSessionHostEndpoint,
   getSessionHostRecoveryLabel,