@itookit/dsht 0.3.8 → 0.5.2

package/dist/controller/connection.js

@@ -1,22 +1,20 @@
 /** Owns the physical connection, its generations, and the host event subscriptions. */
 import { setTimeout as delay } from 'node:timers/promises';
 import { AuthenticationRequired } from "../transport/auth.js";
-import { HttpError, RemoteError } from "../transport/client.js";
-import { array, errorText, object, string } from "../transport/wire.js";
-import { Telemetry } from "../session/telemetry.js";
-/** Projection keys this client consumes; the host retains every other capability. */
-const RETAINED_PROJECTIONS = new Set(['title', 'modelSelection', 'contextPressure', 'tokenUsage', 'sessionStats', 'agentPreset']);
-/** Host events that invalidate the model catalog. */
-const CATALOG_EVENTS = ['llm/adapters-updated', 'settings/document-updated', 'credentials/reference-updated'];
-/** Owns reconnects, subscriptions and the telemetry generation. User commands remain single-attempt operations. */
+import { HttpError } from "../transport/client.js";
+import { errorText } from "../transport/wire.js";
+import { ConnectionStreams } from "./connection-streams.js";
+/** Owns the physical connection: reconnects, subscriptions and generation lifecycle.
+ *
+ * Host running state, projections and interactions belong to the session domain; this class only
+ * decodes wire frames into `HostEvent` and hands them to the application, which routes them on.
+ * User commands remain single-attempt operations.
+ */
 export class ConnectionController {
     store;
     options;
     listener;
-    telemetry = new Telemetry(RETAINED_PROJECTIONS);
     clientId = '';
-    runningUpdates = new Map();
-    observedRunningAt = new Map();
     current;
     abort = new AbortController();
     runTask;
@@ -47,119 +45,72 @@ export class ConnectionController {
     online() { return this.store.state.online; }
     /** @returns The client lifetime signal. */
     signal() { return this.abort.signal; }
-    /** @returns The projection store of the current generation. */
-    telemetryView() { return this.telemetry; }
-    /** @returns Cached host running state, or undefined when never reported. */
-    runningFor(sessionId) { return this.runningUpdates.get(sessionId); }
-    /** @returns When this client first observed the session, for the elapsed-time fallback. */
-    observedAt(sessionId) { return this.observedRunningAt.get(sessionId); }
-    /** Record an observation start for a session this client just opened. */
-    observe(sessionId) { if (!this.observedRunningAt.has(sessionId))
-        this.observedRunningAt.set(sessionId, Date.now()); }
     /** Fail the current generation, so the controller reopens a snapshot. */
     fail(error) { this.generationFailed?.(error); }
     /** Answer one retained host waterfall through the event-result endpoint. */
-    async reply(frame, outcome) {
-        await this.require().call('$events/result', { clientId: this.clientId, eventId: string(frame.eventId), outcome });
+    async reply(eventId, outcome) {
+        await this.require().call('$events/result', { clientId: this.clientId, eventId, outcome });
     }
     /** Run one generation, then retry with bounded jittered backoff until stopped. */
     async run() {
         let attempt = 0;
         while (!this.abort.signal.aborted) {
-            this.runningUpdates.clear();
-            this.observedRunningAt.clear();
-            this.telemetry = new Telemetry(RETAINED_PROJECTIONS);
             this.listener.begin();
+            if (this.abort.signal.aborted)
+                break;
             const client = this.options.makeClient();
             this.current = client;
+            const generation = new AbortController();
+            const signal = AbortSignal.any([this.abort.signal, generation.signal]);
+            let disconnect;
+            const disconnected = new Promise(resolve => { disconnect = resolve; });
+            const fail = (error) => {
+                if (generation.signal.aborted)
+                    return;
+                generation.abort(error);
+                disconnect(error);
+                // End HTTP as well as streams, including requests the ready callback is awaiting.
+                void client.close();
+            };
+            this.generationFailed = fail;
+            const streams = new ConnectionStreams(client, {
+                identified: id => { this.clientId = id; }, event: event => this.listener.event(event),
+                changed: () => this.store.update({}), degraded: controlError => this.store.update({ controlError }), fail,
+            }, signal);
             try {
+                signal.throwIfAborted();
                 await this.options.authenticate(client);
+                signal.throwIfAborted();
                 await client.connect();
-                let fail;
-                const disconnected = new Promise(resolve => { fail = resolve; });
-                this.generationFailed = fail;
-                const ready = new Promise((resolve, reject) => {
-                    const timer = setTimeout(() => reject(new Error('Host ready timed out')), client.timeoutMs);
-                    client.subscribe('$events', {}, {
-                        item: value => {
-                            const frame = object(value);
-                            if (frame.type === 'ready') {
-                                this.clientId = string(frame.clientId);
-                                clearTimeout(timer);
-                                resolve();
-                            }
-                            else if (frame.type === 'waterfall') {
-                                if (this.listener.waterfall(frame))
-                                    return;
-                                void client.call('$events/result', { clientId: this.clientId,
-                                    eventId: string(frame.eventId), outcome: { kind: 'next' } }).catch(error => fail(new Error(errorText(error))));
-                            }
-                            else if (frame.type === 'cancel') {
-                                this.listener.cancelled(string(frame.eventId));
-                            }
-                            else if (frame.type === 'emit' && frame.event === 'api-session/status') {
-                                this.acceptStatus(array(frame.args));
-                            }
-                            else if (frame.type === 'emit' && CATALOG_EVENTS.includes(String(frame.event))) {
-                                this.listener.invalidated();
-                            }
-                            else if (frame.type === 'emit' && frame.event === 'api-session/error') {
-                                const args = array(frame.args);
-                                this.listener.error(args[0], args[1]);
-                            }
-                        },
-                        end: error => { clearTimeout(timer); const reason = error ?? new Error('Event stream ended'); reject(reason); fail(reason); },
-                    });
-                });
-                await ready;
-                await new Promise((resolve, reject) => {
-                    const timer = setTimeout(() => reject(new Error('Session control baseline timed out')), client.timeoutMs);
-                    client.subscribe('session/control', {}, {
-                        item: value => {
-                            try {
-                                this.telemetry.accept(value);
-                                this.store.update({});
-                                clearTimeout(timer);
-                                resolve();
-                            }
-                            catch (error) {
-                                clearTimeout(timer);
-                                reject(error);
-                                fail(new Error(errorText(error)));
-                            }
-                        },
-                        end: error => {
-                            clearTimeout(timer);
-                            if (error instanceof RemoteError && error.code === 'gateway/method-unavailable') {
-                                this.store.update({ controlError: 'Live metrics unavailable on this host' });
-                                resolve();
-                            }
-                            else {
-                                const reason = error ?? new Error('Session control stream ended');
-                                reject(reason);
-                                fail(reason);
-                            }
-                        },
-                    });
-                });
+                signal.throwIfAborted();
+                await streams.start();
+                signal.throwIfAborted();
                 await this.listener.ready();
+                signal.throwIfAborted();
                 attempt = 0;
                 const error = await disconnected;
                 if (!this.abort.signal.aborted)
                     throw error;
             }
             catch (error) {
-                if (error instanceof AuthenticationRequired || error instanceof HttpError && [401, 403].includes(error.status)) {
-                    this.store.update({ error: `${errorText(error)}. Set DSH_TOKEN and restart to log in.`, status: 'Login required' });
+                if (this.abort.signal.aborted)
+                    break;
+                const reason = generation.signal.aborted ? generation.signal.reason : error;
+                if (reason instanceof AuthenticationRequired || reason instanceof HttpError && [401, 403].includes(reason.status)) {
+                    this.store.update({ lastFailure: `${errorText(reason)}. Set DSH_TOKEN and restart to log in.`, status: 'Login required' });
                     return;
                 }
-                if (!this.abort.signal.aborted)
-                    this.store.update({ error: errorText(error), status: 'Reconnecting…' });
+                this.store.update({ lastFailure: errorText(reason), status: 'Reconnecting…' });
             }
             finally {
                 this.generationFailed = undefined;
-                this.store.update({ online: false, pending: [] });
+                generation.abort();
+                streams.close();
+                this.clientId = '';
+                this.store.update({ online: false });
                 await client.close();
+                if (this.current === client)
+                    this.current = undefined;
                 await this.listener.ended();
             }
             if (!this.abort.signal.aborted) {
@@ -173,18 +124,4 @@ export class ConnectionController {
             }
         }
     }
-    /** Apply one `api-session/status` notification to the running maps and the session view. */
-    acceptStatus(args) {
-        const sessionId = string(args[0]);
-        if (typeof args[1] !== 'boolean')
-            throw new Error('Invalid session running state');
-        if (args[1] && !this.runningUpdates.get(sessionId))
-            this.observedRunningAt.set(sessionId, Date.now());
-        if (!args[1])
-            this.observedRunningAt.delete(sessionId);
-        this.runningUpdates.set(sessionId, args[1]);
-        this.listener.status(sessionId, args[1]);
-        if (!args[1])
-            this.listener.idle();
-    }
 }