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

package/src/index.ts

@@ -1,4 +1,7 @@
 export type {
+  MeshWriterAssignment,
+  MeshWriterStopTarget,
+  StopMeshWriterPayload,
   HostUpgradeLeasePayload,
   AcquireWritePayload,
   AttachSessionPayload,
@@ -77,6 +80,7 @@ export {
   createLineParser,
   createResponseEnvelope,
   disconnectSessionHostClients,
+  findConnectedSessionHostClient,
   getDefaultSessionHostEndpoint,
   writeEnvelope,
 } from './ipc.js';

package/src/ipc.ts

@@ -124,6 +124,8 @@ export interface SessionHostClientOptions {
   endpoint?: SessionHostEndpoint;
   appName?: string;
   requestTimeoutMs?: number;
+  /** Join the shared client registry (default true). Disable for short-lived probes. */
+  registerAsShared?: boolean;
 }
 
 /**
@@ -155,6 +157,20 @@ export function disconnectSessionHostClients(endpoint?: SessionHostEndpoint, err
   }
 }
 
+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;
   endpointPath: string;
@@ -192,13 +208,21 @@ export class SessionHostClient {
     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?: 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));
+  }
+
   /**
    * Fires when an established connection to the session host goes away.
    *
@@ -278,6 +302,7 @@ export class SessionHostClient {
   private sendRawRequestOnSocket<T = unknown>(
     socket: net.Socket,
     request: SessionHostRequest,
+    timeoutMs = this.requestTimeoutMs,
   ): Promise<SessionHostResponse<T>> {
     const requestId = generateUUID();
     const envelope: SessionHostRequestEnvelope = {
@@ -285,11 +310,25 @@ export class SessionHostClient {
       requestId,
       request,
     };
-    const timeoutMs = this.requestTimeoutMs > 0 ? this.requestTimeoutMs : 30_000;
     const timeoutLabel = timeoutMs % 1000 === 0 ? `${timeoutMs / 1000}s` : `${timeoutMs}ms`;
+    const startedAt = Date.now();
+    const startedMonotonicAt = performance.now();
     return new Promise<SessionHostResponse<T>>((resolve, 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 {
@@ -307,7 +346,7 @@ export class SessionHostClient {
     });
   }
 
-  async connect(): Promise<void> {
+  async connect(timeoutMs = this.requestTimeoutMs): Promise<void> {
     if (this.socket && !this.socket.destroyed) {
       if (this.connectPromise) await this.connectPromise;
       return;
@@ -381,11 +420,37 @@ export class SessionHostClient {
 
     const connectTask = (async () => {
       await new Promise<void>((resolve, reject) => {
-        socket.once('connect', () => {
-          establishedSockets.add(socket);
-          resolve();
-        });
-        socket.once('error', 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 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()]) {
@@ -418,12 +483,47 @@ export class SessionHostClient {
     };
   }
 
-  async request<T = unknown>(request: SessionHostRequest): Promise<SessionHostResponse<T>> {
-    await this.connect();
+  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;
+      const raceStartedAt = Date.now();
+      const raceStartedMonotonicAt = performance.now();
+      try {
+        await Promise.race([
+          this.connect(timeoutMs),
+          new Promise<never>((_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<T>(requestSocket, request);
+    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, {

package/src/types.ts

@@ -157,6 +157,15 @@ export interface ResizeSessionPayload {
 export interface StopSessionPayload {
   sessionId: string;
 }
+export interface MeshWriterAssignment {
+  meshId: string; nodeId: string; taskId: string; attemptId: string;
+  generation: number; dispatchNonce: number; ownerDaemonId: string;
+}
+export interface MeshWriterStopTarget {
+  runtimeKey: string; startedAt: number; osPid: number; providerType: string;
+  assignment: MeshWriterAssignment;
+}
+export interface StopMeshWriterPayload extends MeshWriterStopTarget { sessionId: string; clientId: string }
 
 export interface DeleteSessionPayload {
   sessionId: string;
@@ -317,6 +326,7 @@ export type SessionHostRequest =
   | { type: 'send_input'; payload: SendInputPayload }
   | { type: 'resize_session'; payload: ResizeSessionPayload }
   | { type: 'stop_session'; payload: StopSessionPayload }
+  | { type: 'stop_mesh_writer'; payload: StopMeshWriterPayload }
   | { type: 'delete_session'; payload: DeleteSessionPayload }
   | { type: 'resume_session'; payload: ResumeSessionPayload }
   | { type: 'acquire_write'; payload: AcquireWritePayload }
@@ -344,6 +354,7 @@ export const SESSION_HOST_SUPPORTED_REQUEST_TYPES: readonly SessionHostRequestTy
   'send_input',
   'resize_session',
   'stop_session',
+  'stop_mesh_writer',
   'delete_session',
   'resume_session',
   'acquire_write',