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

package/dist/index.mjs

@@ -733,16 +733,59 @@ function createLineParser(onEnvelope) {
   return parser;
 }
 var establishedSockets = /* @__PURE__ */ new WeakSet();
+var activeClientRefs = /* @__PURE__ */ new Set();
+function disconnectSessionHostClients(endpoint, error) {
+  for (const ref of activeClientRefs) {
+    const client = ref.deref();
+    if (!client) {
+      activeClientRefs.delete(ref);
+      continue;
+    }
+    if (!endpoint || client.endpoint.path === endpoint.path) {
+      client.disconnect(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;
+  connectPromise = null;
+  requestTimeoutMs = 3e4;
   requestWaiters = /* @__PURE__ */ new Map();
   eventListeners = /* @__PURE__ */ new Set();
   disconnectListeners = /* @__PURE__ */ new Set();
   /** Guards against emitting both an 'error'-path and a 'close'-path disconnect for one socket. */
   disconnectedSockets = /* @__PURE__ */ new WeakSet();
+  /** Session subscriptions established via create_session/attach_session, replayed automatically on reconnect. */
+  attachedSessions = /* @__PURE__ */ new Map();
   constructor(options = {}) {
     this.endpoint = options.endpoint || getDefaultSessionHostEndpoint(options.appName || "adhdev");
+    if (typeof options.requestTimeoutMs === "number" && options.requestTimeoutMs > 0) {
+      this.requestTimeoutMs = options.requestTimeoutMs;
+    }
+    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.
@@ -785,6 +828,7 @@ var SessionHostClient = class {
     this.requestWaiters.clear();
     if (this.socket === socket) {
       this.socket = null;
+      this.connectPromise = null;
     }
     try {
       socket.destroy();
@@ -804,8 +848,47 @@ var SessionHostClient = class {
       }
     }
   }
-  async connect() {
-    if (this.socket && !this.socket.destroyed) return;
+  sendRawRequestOnSocket(socket, request, timeoutMs = this.requestTimeoutMs) {
+    const requestId = generateUUID();
+    const envelope = {
+      kind: "request",
+      requestId,
+      request
+    };
+    const timeoutLabel = timeoutMs % 1e3 === 0 ? `${timeoutMs / 1e3}s` : `${timeoutMs}ms`;
+    return new Promise((resolve3, reject) => {
+      const timeout = setTimeout(() => {
+        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 {
+          this.requestWaiters.delete(requestId);
+          this.disconnectedSockets.add(socket);
+          try {
+            socket.destroy();
+          } catch {
+          }
+          reject(timeoutError);
+        }
+      }, timeoutMs);
+      this.requestWaiters.set(requestId, {
+        resolve: (value) => {
+          clearTimeout(timeout);
+          resolve3(value);
+        },
+        reject: (error) => {
+          clearTimeout(timeout);
+          reject(error);
+        }
+      });
+      socket.write(serializeEnvelope(envelope));
+    });
+  }
+  async connect(timeoutMs = this.requestTimeoutMs) {
+    if (this.socket && !this.socket.destroyed) {
+      if (this.connectPromise) await this.connectPromise;
+      return;
+    }
     if (this.socket) {
       try {
         this.socket.destroy();
@@ -813,6 +896,7 @@ var SessionHostClient = class {
       }
       this.socket = null;
     }
+    this.connectPromise = null;
     const socket = net.createConnection(this.endpoint.path);
     this.socket = socket;
     const parser = createLineParser((envelope) => {
@@ -846,13 +930,54 @@ var SessionHostClient = class {
     socket.on("end", () => {
       this.handleDisconnect(socket, "ended", void 0, flushParser().length);
     });
-    await new Promise((resolve3, reject) => {
-      socket.once("connect", () => {
-        establishedSockets.add(socket);
-        resolve3();
+    const connectTask = (async () => {
+      await new Promise((resolve3, reject) => {
+        const cleanup = () => {
+          clearTimeout(timer);
+          socket.off("connect", connected);
+          socket.off("error", failed);
+          socket.off("close", closed);
+        };
+        const connected = () => {
+          cleanup();
+          establishedSockets.add(socket);
+          resolve3();
+        };
+        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);
       });
-      socket.once("error", reject);
-    });
+      if (this.attachedSessions.size > 0 && this.socket === socket && !socket.destroyed) {
+        for (const [sessionId, sub] of [...this.attachedSessions.entries()]) {
+          if (this.socket !== socket || socket.destroyed) break;
+          const replayResponse = await this.sendRawRequestOnSocket(socket, {
+            type: "attach_session",
+            payload: sub
+          }).catch(() => null);
+          if (replayResponse && !replayResponse.success) {
+            this.attachedSessions.delete(sessionId);
+          }
+        }
+      }
+    })();
+    this.connectPromise = connectTask;
+    try {
+      await connectTask;
+    } finally {
+      if (this.connectPromise === connectTask) {
+        this.connectPromise = null;
+      }
+    }
   }
   onEvent(listener) {
     this.eventListeners.add(listener);
@@ -860,35 +985,73 @@ var SessionHostClient = class {
       this.eventListeners.delete(listener);
     };
   }
-  async request(request) {
-    await this.connect();
-    if (!this.socket) throw new Error("Session host socket unavailable");
-    const requestId = generateUUID();
-    const envelope = {
-      kind: "request",
-      requestId,
-      request
-    };
-    const response = await new Promise((resolve3, reject) => {
-      const timeout = setTimeout(() => {
-        this.requestWaiters.delete(requestId);
-        reject(new Error(`Session host request timed out after 30s (${request.type})`));
-      }, 3e4);
-      this.requestWaiters.set(requestId, {
-        resolve: (value) => {
-          clearTimeout(timeout);
-          resolve3(value);
-        },
-        reject: (error) => {
-          clearTimeout(timeout);
-          reject(error);
+  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, 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, {
+          sessionId: request.payload.sessionId,
+          clientId: request.payload.clientId,
+          clientType: request.payload.clientType,
+          readOnly: request.payload.readOnly === true
+        });
+      } else if (request.type === "create_session") {
+        const createdId = response.result?.sessionId || request.payload.sessionId;
+        const clientId = typeof request.payload.clientId === "string" ? request.payload.clientId.trim() : "";
+        if (createdId && clientId) {
+          this.attachedSessions.set(createdId, {
+            sessionId: createdId,
+            clientId,
+            clientType: request.payload.clientType || "daemon",
+            readOnly: false
+          });
         }
-      });
-      this.socket?.write(serializeEnvelope(envelope));
-    });
+      } else if (request.type === "detach_session" || request.type === "delete_session") {
+        this.attachedSessions.delete(request.payload.sessionId);
+      }
+    }
     return response;
   }
+  disconnect(error) {
+    const socket = this.socket;
+    if (socket) {
+      this.handleDisconnect(socket, error ? "error" : "closed", error, 0);
+      return;
+    }
+    this.connectPromise = null;
+    const failure = error || new Error(`Session host client disconnected (${this.endpoint.path})`);
+    for (const waiter of this.requestWaiters.values()) {
+      waiter.reject(failure);
+    }
+    this.requestWaiters.clear();
+  }
   async close() {
+    this.attachedSessions.clear();
+    this.connectPromise = null;
     if (!this.socket) return;
     const socket = this.socket;
     this.socket = null;
@@ -1105,7 +1268,9 @@ export {
   createLineParser,
   createResponseEnvelope,
   createSessionHostControlPlane,
+  disconnectSessionHostClients,
   ensureNodePtySpawnHelperPermissions,
+  findConnectedSessionHostClient,
   formatRuntimeOwner,
   getDefaultSessionHostEndpoint,
   getSessionHostRecoveryLabel,