@adhdev/daemon-core 0.9.76-rc.51 → 0.9.76-rc.52

package/dist/session-host/runtime-support.d.ts

@@ -1,8 +1,9 @@
-import { type SessionHostEndpoint } from '@adhdev/session-host-core';
+import { type SessionHostEndpoint, type SessionHostRequestType } from '@adhdev/session-host-core';
 import type { HostedCliRuntimeDescriptor } from '../commands/cli-manager.js';
 export declare function ensureSessionHostReady(options: {
     appName?: string;
     spawnHost: () => void;
     timeoutMs?: number;
+    requiredRequestTypes?: readonly SessionHostRequestType[];
 }): Promise<SessionHostEndpoint>;
 export declare function listHostedCliRuntimes(endpoint: SessionHostEndpoint): Promise<HostedCliRuntimeDescriptor[]>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adhdev/daemon-core",
-  "version": "0.9.76-rc.51",
+  "version": "0.9.76-rc.52",
   "description": "ADHDev daemon core — CDP, IDE detection, providers, command execution",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/session-host/runtime-support.ts

@@ -1,8 +1,10 @@
 import {
     SessionHostClient,
     getDefaultSessionHostEndpoint,
+    type SessionHostDiagnostics,
     type SessionHostEndpoint,
     type SessionHostRecord,
+    type SessionHostRequestType,
 } from '@adhdev/session-host-core';
 import type { HostedCliRuntimeDescriptor } from '../commands/cli-manager.js';
 import { DEFAULT_SESSION_HOST_READY_TIMEOUT_MS } from '../runtime-defaults.js';
@@ -10,21 +12,65 @@ import { DEFAULT_SESSION_HOST_READY_TIMEOUT_MS } from '../runtime-defaults.js';
 const STARTUP_TIMEOUT_MS = DEFAULT_SESSION_HOST_READY_TIMEOUT_MS;
 const STARTUP_POLL_MS = 200;
 
-async function canConnect(endpoint: SessionHostEndpoint): Promise<boolean> {
+class SessionHostCompatibilityError extends Error {
+    constructor(message: string) {
+        super(message);
+        this.name = 'SessionHostCompatibilityError';
+    }
+}
+
+function getMissingRequestTypes(
+    diagnostics: SessionHostDiagnostics | undefined,
+    requiredRequestTypes: readonly SessionHostRequestType[],
+): SessionHostRequestType[] {
+    const supported = new Set(diagnostics?.supportedRequestTypes || []);
+    return requiredRequestTypes.filter((requestType) => !supported.has(requestType));
+}
+
+async function assertRequiredRequestTypes(
+    client: SessionHostClient,
+    requiredRequestTypes: readonly SessionHostRequestType[],
+): Promise<void> {
+    if (requiredRequestTypes.length === 0) return;
+
+    const response = await client.request<SessionHostDiagnostics>({
+        type: 'get_host_diagnostics',
+        payload: { includeSessions: false },
+    });
+    const missing = getMissingRequestTypes(response.success ? response.result : undefined, requiredRequestTypes);
+    if (missing.length > 0) {
+        const detail = response.success ? '' : ` (${response.error || 'capability probe failed'})`;
+        throw new SessionHostCompatibilityError(
+            `Session host does not support required request types: ${missing.join(', ')}${detail}`,
+        );
+    }
+}
+
+async function canConnect(
+    endpoint: SessionHostEndpoint,
+    requiredRequestTypes: readonly SessionHostRequestType[] = [],
+): Promise<boolean> {
     const client = new SessionHostClient({ endpoint });
     try {
         await client.connect();
-        await client.close();
+        await assertRequiredRequestTypes(client, requiredRequestTypes);
         return true;
-    } catch {
+    } catch (error) {
+        if (error instanceof SessionHostCompatibilityError) throw error;
         return false;
+    } finally {
+        await client.close().catch(() => {});
     }
 }
 
-async function waitForReady(endpoint: SessionHostEndpoint, timeoutMs = STARTUP_TIMEOUT_MS): Promise<void> {
+async function waitForReady(
+    endpoint: SessionHostEndpoint,
+    timeoutMs = STARTUP_TIMEOUT_MS,
+    requiredRequestTypes: readonly SessionHostRequestType[] = [],
+): Promise<void> {
     const deadline = Date.now() + timeoutMs;
     while (Date.now() < deadline) {
-        if (await canConnect(endpoint)) return;
+        if (await canConnect(endpoint, requiredRequestTypes)) return;
         await new Promise((resolve) => setTimeout(resolve, STARTUP_POLL_MS));
     }
     throw new Error(`Session host did not become ready within ${timeoutMs}ms`);
@@ -34,11 +80,13 @@ export async function ensureSessionHostReady(options: {
     appName?: string;
     spawnHost: () => void;
     timeoutMs?: number;
+    requiredRequestTypes?: readonly SessionHostRequestType[];
 }): Promise<SessionHostEndpoint> {
     const endpoint = getDefaultSessionHostEndpoint(options.appName || 'adhdev');
-    if (await canConnect(endpoint)) return endpoint;
+    const requiredRequestTypes = options.requiredRequestTypes || [];
+    if (await canConnect(endpoint, requiredRequestTypes)) return endpoint;
     options.spawnHost();
-    await waitForReady(endpoint, options.timeoutMs);
+    await waitForReady(endpoint, options.timeoutMs, requiredRequestTypes);
     return endpoint;
 }