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

package/src/ipc.ts

@@ -4,6 +4,7 @@ import * as net from 'net';
 import { generateUUID } from './uuid.js';
 import { StringDecoder } from 'string_decoder';
 import type {
+  AttachSessionPayload,
   SessionHostEvent,
   SessionHostRequest,
   SessionHostRequestEnvelope,
@@ -122,6 +123,9 @@ function createLineParser<TEnvelope = SessionHostWireEnvelope>(
 export interface SessionHostClientOptions {
   endpoint?: SessionHostEndpoint;
   appName?: string;
+  requestTimeoutMs?: number;
+  /** Join the shared client registry (default true). Disable for short-lived probes. */
+  registerAsShared?: boolean;
 }
 
 /**
@@ -138,6 +142,34 @@ export type SessionHostDisconnectReason = 'error' | 'ended' | 'closed';
  * (host not up yet) — only the former is a session-host death signal.
  */
 const establishedSockets = new WeakSet<net.Socket>();
+const activeClientRefs = new Set<WeakRef<SessionHostClient>>();
+
+export function disconnectSessionHostClients(endpoint?: SessionHostEndpoint, error?: Error): void {
+  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);
+    }
+  }
+}
+
+export function findConnectedSessionHostClient(endpoint?: SessionHostEndpoint): SessionHostClient | null {
+  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;
+}
 
 export interface SessionHostDisconnectInfo {
   reason: SessionHostDisconnectReason;
@@ -161,14 +193,34 @@ export class SessionHostClient {
   readonly endpoint: SessionHostEndpoint;
 
   private socket: net.Socket | null = null;
+  private connectPromise: Promise<void> | null = null;
+  private requestTimeoutMs = 30_000;
   private requestWaiters = new Map<string, { resolve: (value: SessionHostResponse) => void; reject: (error: Error) => void }>();
   private eventListeners = new Set<(event: SessionHostEvent) => void>();
   private disconnectListeners = new Set<(info: SessionHostDisconnectInfo) => void>();
   /** Guards against emitting both an 'error'-path and a 'close'-path disconnect for one socket. */
   private disconnectedSockets = new WeakSet<net.Socket>();
+  /** Session subscriptions established via create_session/attach_session, replayed automatically on reconnect. */
+  private attachedSessions = new Map<string, AttachSessionPayload>();
 
   constructor(options: SessionHostClientOptions = {}) {
     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?: SessionHostEndpoint, error?: Error): void {
+    disconnectSessionHostClients(endpoint, error);
+  }
+
+  static findConnectedClient(endpoint?: SessionHostEndpoint): SessionHostClient | null {
+    return findConnectedSessionHostClient(endpoint);
+  }
+
+  isConnected(): boolean {
+    return Boolean(this.socket && !this.socket.destroyed && establishedSockets.has(this.socket));
   }
 
   /**
@@ -228,6 +280,7 @@ export class SessionHostClient {
     // guard at the top of connect().
     if (this.socket === socket) {
       this.socket = null;
+      this.connectPromise = null;
     }
     try { socket.destroy(); } catch { /* noop */ }
 
@@ -246,13 +299,49 @@ export class SessionHostClient {
     }
   }
 
-  async connect(): Promise<void> {
-    if (this.socket && !this.socket.destroyed) return;
+  private sendRawRequestOnSocket<T = unknown>(
+    socket: net.Socket,
+    request: SessionHostRequest,
+    timeoutMs = this.requestTimeoutMs,
+  ): Promise<SessionHostResponse<T>> {
+    const requestId = generateUUID();
+    const envelope: SessionHostRequestEnvelope = {
+      kind: 'request',
+      requestId,
+      request,
+    };
+    const timeoutLabel = timeoutMs % 1000 === 0 ? `${timeoutMs / 1000}s` : `${timeoutMs}ms`;
+    return new Promise<SessionHostResponse<T>>((resolve, 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 { /* noop */ }
+          reject(timeoutError);
+        }
+      }, timeoutMs);
+      this.requestWaiters.set(requestId, {
+        resolve: (value) => { clearTimeout(timeout); resolve(value as SessionHostResponse<T>); },
+        reject: (error) => { clearTimeout(timeout); reject(error); },
+      });
+      socket.write(serializeEnvelope(envelope));
+    });
+  }
+
+  async connect(timeoutMs = this.requestTimeoutMs): Promise<void> {
+    if (this.socket && !this.socket.destroyed) {
+      if (this.connectPromise) await this.connectPromise;
+      return;
+    }
     // Cleanup stale socket reference left after error/disconnect
     if (this.socket) {
       try { this.socket.destroy(); } catch { /* noop */ }
       this.socket = null;
     }
+    this.connectPromise = null;
 
     const socket = net.createConnection(this.endpoint.path);
     this.socket = socket;
@@ -314,13 +403,48 @@ export class SessionHostClient {
       this.handleDisconnect(socket, 'ended', undefined, flushParser().length);
     });
 
-    await new Promise<void>((resolve, reject) => {
-      socket.once('connect', () => {
-        establishedSockets.add(socket);
-        resolve();
+    const connectTask = (async () => {
+      await new Promise<void>((resolve, reject) => {
+        const cleanup = () => {
+          clearTimeout(timer);
+          socket.off('connect', connected);
+          socket.off('error', failed);
+          socket.off('close', closed);
+        };
+        const connected = () => { cleanup(); establishedSockets.add(socket); resolve(); };
+        const failed = (error: 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: (event: SessionHostEvent) => void): () => void {
@@ -330,33 +454,76 @@ export class SessionHostClient {
     };
   }
 
-  async request<T = unknown>(request: SessionHostRequest): Promise<SessionHostResponse<T>> {
-    await this.connect();
-    if (!this.socket) throw new Error('Session host socket unavailable');
-
-    const requestId = generateUUID();
-    const envelope: SessionHostRequestEnvelope = {
-      kind: 'request',
-      requestId,
-      request,
-    };
-
-    const response = await new Promise<SessionHostResponse>((resolve, reject) => {
-      const timeout = setTimeout(() => {
-        this.requestWaiters.delete(requestId);
-        reject(new Error(`Session host request timed out after 30s (${request.type})`));
-      }, 30_000);
-      this.requestWaiters.set(requestId, {
-        resolve: (value) => { clearTimeout(timeout); resolve(value); },
-        reject: (error) => { clearTimeout(timeout); reject(error); },
-      });
-      this.socket?.write(serializeEnvelope(envelope));
-    });
+  async request<T = unknown>(request: SessionHostRequest, options: { timeoutMs?: number } = {}): Promise<SessionHostResponse<T>> {
+    const timeoutMs = Math.max(1, options.timeoutMs ?? this.requestTimeoutMs);
+    const deadline = Date.now() + timeoutMs;
+    const alreadyConnected = this.isConnected() && !this.connectPromise;
+    // A probe must also bound a connect/re-attach already in flight on this
+    // client; that task may have started with the normal 30s timeout.
+    if (options.timeoutMs !== undefined) {
+      let timer: ReturnType<typeof setTimeout> | undefined;
+      try {
+        await Promise.race([
+          this.connect(timeoutMs),
+          new Promise<never>((_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<T>(requestSocket, request, options.timeoutMs === undefined || 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 as { sessionId?: string } | undefined)?.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,
+          });
+        }
+      } else if (request.type === 'detach_session' || request.type === 'delete_session') {
+        this.attachedSessions.delete(request.payload.sessionId);
+      }
+    }
+    return response;
+  }
 
-    return response as SessionHostResponse<T>;
+  disconnect(error?: Error): void {
+    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(): Promise<void> {
+    this.attachedSessions.clear();
+    this.connectPromise = null;
     if (!this.socket) return;
     const socket = this.socket;
     this.socket = null;