@agentshouse/kit 0.2.1-c9c41d009d46a → 0.2.1-ca0e1517cce79

package/dist/{stream.js → connection.js}

@@ -1,24 +1,24 @@
 import { subscribe } from 'node:diagnostics_channel';
-import { finalRefusal, HouseRefusal, retryDelay } from './api.js';
-import { end, REPLACED, signInAgain, updateRequired } from './end.js';
+import { HouseRefusal, retryDelay } from './api.js';
+import { end, REPLACED, signInAgain } from './end.js';
 import { readEnrolment } from './home.js';
 import { relayed } from './relay.js';
-import { KIT_WIRE, tooOld } from './wire.js';
+import { endUnserved, KIT_WIRE } from './wire.js';
 const PATH = '/kit/stream';
 const SUBPROTOCOL = `house.kit.stream.${KIT_WIRE}`;
 const REFUSAL_HEADER = 'x-house-refusal';
-// House beats each stream every thirty seconds, so two silent beats mean this Kit cannot hear House.
-export const STREAM_SILENCE_MS = 60_000;
-const SYSTEM_STREAM_CLOCK = {
+// House beats each Kit connection every thirty seconds, so two silent beats mean this Kit process cannot hear House.
+export const CONNECTION_SILENCE_MS = 60_000;
+const SYSTEM_CONNECTION_CLOCK = {
     later: (delay, callback) => setTimeout(callback, delay),
     clear: (timer) => clearTimeout(timer),
 };
-export class StreamSilence {
+export class ConnectionSilence {
     timer = null;
     silent;
     clock;
     interval;
-    constructor(silent, clock = SYSTEM_STREAM_CLOCK, interval = STREAM_SILENCE_MS) {
+    constructor(silent, clock = SYSTEM_CONNECTION_CLOCK, interval = CONNECTION_SILENCE_MS) {
         this.silent = silent;
         this.clock = clock;
         this.interval = interval;
@@ -37,7 +37,7 @@ export class StreamSilence {
         this.timer = null;
     }
 }
-function streamUrl(house) {
+function connectionUrl(house) {
     const url = new URL(PATH, house);
     url.protocol = url.protocol === 'https:' ? 'wss:' : 'ws:';
     return url;
@@ -56,13 +56,13 @@ subscribe('undici:request:headers', (message) => {
         return;
     refused = new HouseRefusal(PATH, response.statusCode, header(response.headers, REFUSAL_HEADER) || response.statusText);
 });
-export function holdStream(handlers) {
-    let socket = null;
+export function holdConnection(handlers) {
+    let connection = null;
     let failures = 0;
     const connect = async () => {
         const { house, credential } = (await readEnrolment());
         refused = null;
-        const opening = new WebSocket(relayed(streamUrl(house)), {
+        const opening = new WebSocket(relayed(connectionUrl(house)), {
             protocols: [SUBPROTOCOL],
             headers: { authorization: `Bearer ${credential}` },
         });
@@ -71,30 +71,31 @@ export function holdStream(handlers) {
         const closed = (event) => {
             silence?.stop();
             silence = null;
-            if (socket === opening)
-                socket = null;
-            process.stderr.write(`kit: control stream closed ${event.code} ${event.reason}\n`);
+            if (connection === opening)
+                connection = null;
+            handlers.closed();
+            process.stderr.write(`kit: connection closed ${event.code} ${event.reason}\n`);
             if (event.reason === 'replaced')
                 end(REPLACED);
             if (event.reason === 'credential_rejected' || refused?.status === 401) {
                 void signInAgain(credential);
                 return;
             }
-            if (refused !== null && tooOld(refused.text))
-                updateRequired();
-            if (finalRefusal(refused))
-                end(refused.message);
-            // A closed socket reopens in one to three seconds, spread so Kits one restart closed return apart; an opening House refused as retryable or left unanswered backs off on the jittered curve.
+            if (refused !== null)
+                endUnserved(refused.text);
+            if (!opened && refused !== null)
+                process.stderr.write(`kit: ${refused.message}\n`);
+            // A closed connection reopens in one to three seconds, spread so Kit processes one restart closed return apart; an opening House refused or left unanswered backs off on the jittered curve, retryable or not, since a resident outlives a House deploy.
             setTimeout(() => void connect(), opened ? 1000 + Math.random() * 2000 : retryDelay(failures++));
         };
         opening.onopen = () => {
             opened = true;
             failures = 0;
-            socket = opening;
-            silence = new StreamSilence(() => {
-                if (socket !== opening)
+            connection = opening;
+            silence = new ConnectionSilence(() => {
+                if (connection !== opening)
                     return;
-                socket = null;
+                connection = null;
                 opening.onclose = null;
                 opening.close();
                 closed(new CloseEvent('close', { code: 1006, reason: 'heartbeat_missed' }));
@@ -104,19 +105,21 @@ export function holdStream(handlers) {
         };
         opening.onmessage = (event) => {
             silence?.heard();
-            const frame = JSON.parse(String(event.data));
-            if (frame.type !== 'beat')
-                handlers.frame(frame);
+            const arrived = JSON.parse(String(event.data));
+            if (arrived.type === 'input')
+                handlers.call(arrived);
+            else if (arrived.type !== 'beat')
+                handlers.notification(arrived);
         };
         opening.onerror = () => undefined;
         opening.onclose = closed;
     };
     void connect();
     return {
-        send(frame) {
-            if (socket === null || socket.readyState !== WebSocket.OPEN)
+        send(notification) {
+            if (connection === null || connection.readyState !== WebSocket.OPEN)
                 return false;
-            socket.send(JSON.stringify(frame));
+            connection.send(JSON.stringify(notification));
             return true;
         },
     };