@cydm/happy-elves 0.1.0-beta.44 → 0.1.0-beta.46

package/apps/daemon/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cydm/happy-elves-daemon",
-  "version": "0.1.0-beta.44",
+  "version": "0.1.0-beta.46",
   "private": true,
   "type": "module"
 }

package/npm-shrinkwrap.json

@@ -1,12 +1,12 @@
 {
   "name": "@cydm/happy-elves",
-  "version": "0.1.0-beta.44",
+  "version": "0.1.0-beta.46",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "@cydm/happy-elves",
-      "version": "0.1.0-beta.44",
+      "version": "0.1.0-beta.46",
       "license": "Apache-2.0",
       "dependencies": {
         "@fastify/cors": "11.2.0",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cydm/happy-elves",
-  "version": "0.1.0-beta.44",
+  "version": "0.1.0-beta.46",
   "description": "Remote controller for local coding agents with hosted or self-hosted relay support.",
   "type": "module",
   "bin": {

package/packages/client/dist/live.d.ts

@@ -38,6 +38,10 @@ export type ControllerLiveEvent = {
 } | {
     type: "connection";
     state: ControllerLiveState["connectionState"];
+} | {
+    type: "diagnostic";
+    kind: "snapshot" | "websocket";
+    detail: Record<string, string | number | boolean>;
 } | {
     type: "snapshot";
     source: string;

package/packages/client/dist/live.js

@@ -3,6 +3,7 @@ import { ControllerClientError, ControllerCommandError } from "./errors.js";
 import { oldestSessionEventId, shouldHoldHistoricalEventForOlderPage } from "./session-event-order.js";
 import { exactReplaceSessionEvents, mergeAuthoritativeSessionEventsByIdentity, mergeLatestPagePreservingLoadedOlderEvents, mergeSessionEventsById, } from "./session-event-window.js";
 import { subscribe as subscribeToRelay } from "./transport.js";
+import { wsUrl } from "./http.js";
 const defaultOptions = {
     olderSessionEventPageSize: 96,
     promptAckTimeoutMs: 12_000,
@@ -78,13 +79,42 @@ export class ControllerLiveProjectionImpl {
     async refreshSnapshot(reason) {
         if (this.disposed)
             return;
+        const startedAt = Date.now();
+        const url = `${this.client.config.relayUrl}/api/bootstrap`;
         this.setState({ snapshotHydrating: true });
+        this.emit({ type: "diagnostic", kind: "snapshot", detail: { phase: "start", reason, url } });
         try {
             const snapshot = await this.client.snapshot();
+            this.emit({
+                type: "diagnostic",
+                kind: "snapshot",
+                detail: {
+                    durationMs: Date.now() - startedAt,
+                    events: snapshot.events.length,
+                    machines: snapshot.machines.length,
+                    phase: "success",
+                    reason,
+                    sessions: snapshot.sessions.length,
+                    url,
+                },
+            });
             await this.applySnapshot(snapshot, `bootstrap:${reason}`);
             this.emit({ type: "snapshot", source: `bootstrap:${reason}`, snapshot });
         }
         catch (error) {
+            this.emit({
+                type: "diagnostic",
+                kind: "snapshot",
+                detail: {
+                    code: error instanceof ControllerClientError ? error.code : "",
+                    durationMs: Date.now() - startedAt,
+                    message: errorMessage(error),
+                    name: error instanceof Error ? error.name : typeof error,
+                    phase: "error",
+                    reason,
+                    url,
+                },
+            });
             this.emitError(error, undefined);
             this.setState({ lastError: errorMessage(error) });
         }
@@ -240,153 +270,188 @@ export class ControllerLiveProjectionImpl {
         if (this.socket && (this.socket.readyState === WebSocket.OPEN || this.socket.readyState === WebSocket.CONNECTING))
             return;
         this.setState({ connectionState: "connecting" });
-        const ws = subscribeToRelay(this.client.config, {
-            onHello: () => {
-                if (this.socket !== ws)
-                    return;
-                this.setState({ connectionState: "online" });
-                for (const resolve of this.onlineWaiters.splice(0))
-                    resolve();
-            },
-            onSnapshot: async (message) => {
-                if (!this.isCurrentSocket(ws))
-                    return;
-                await this.applySnapshot(message, "ws:snapshot", () => this.isCurrentSocket(ws));
-                if (!this.isCurrentSocket(ws))
-                    return;
-                this.emit({ type: "snapshot", source: "ws:snapshot", snapshot: message });
-            },
-            onMachine: async (message) => {
-                if (!this.isCurrentSocket(ws))
-                    return;
-                const metadata = await this.readMachineMetadata(message.machine);
-                if (!this.isCurrentSocket(ws))
-                    return;
-                this.upsertMachine(message.machine);
-                if (metadata)
-                    this.setMachineMetadata(message.machine.id, metadata);
-                this.emit({ type: "machine", machine: message.machine });
-                this.emitChange();
-            },
-            onSession: async (message) => {
-                if (!this.isCurrentSocket(ws))
-                    return;
-                const previousHead = this.selectedSessionEventHistoryHeads.get(message.session.id);
-                if (this.authoritativeProjectionHeadChanged(message.session))
+        const url = wsUrl(this.client.config.relayUrl);
+        this.emit({ type: "diagnostic", kind: "websocket", detail: { phase: "connect", url } });
+        let ws;
+        try {
+            ws = subscribeToRelay(this.client.config, {
+                onOpen: () => {
+                    if (this.socket !== ws)
+                        return;
+                    this.emit({ type: "diagnostic", kind: "websocket", detail: { phase: "open", url } });
+                },
+                onHello: () => {
+                    if (this.socket !== ws)
+                        return;
+                    this.setState({ connectionState: "online" });
+                    this.emit({ type: "diagnostic", kind: "websocket", detail: { phase: "hello", url } });
+                    for (const resolve of this.onlineWaiters.splice(0))
+                        resolve();
+                },
+                onSnapshot: async (message) => {
+                    if (!this.isCurrentSocket(ws))
+                        return;
+                    await this.applySnapshot(message, "ws:snapshot", () => this.isCurrentSocket(ws));
+                    if (!this.isCurrentSocket(ws))
+                        return;
+                    this.emit({ type: "snapshot", source: "ws:snapshot", snapshot: message });
+                },
+                onMachine: async (message) => {
+                    if (!this.isCurrentSocket(ws))
+                        return;
+                    const metadata = await this.readMachineMetadata(message.machine);
+                    if (!this.isCurrentSocket(ws))
+                        return;
+                    this.upsertMachine(message.machine);
+                    if (metadata)
+                        this.setMachineMetadata(message.machine.id, metadata);
+                    this.emit({ type: "machine", machine: message.machine });
+                    this.emitChange();
+                },
+                onSession: async (message) => {
+                    if (!this.isCurrentSocket(ws))
+                        return;
+                    const previousHead = this.selectedSessionEventHistoryHeads.get(message.session.id);
+                    if (this.authoritativeProjectionHeadChanged(message.session))
+                        this.bumpSessionProjectionGeneration(message.session.id);
+                    this.upsertSession(message.session);
+                    const requestFence = this.captureSessionHistoryFence(message.session.id, message.session);
+                    const metadata = await this.readSessionMetadata(message.session);
+                    if (!this.isCurrentSocket(ws))
+                        return;
+                    if (!this.isSessionHistoryFenceCurrent(requestFence))
+                        return;
+                    if (metadata)
+                        this.setSessionMetadata(message.session.id, metadata);
+                    this.emit({ type: "session", session: message.session });
+                    this.refreshSelectedSessionHeadIfNeeded(message.session, previousHead);
+                    this.emitChange();
+                },
+                onEvent: async (message) => {
+                    if (!this.isCurrentSocket(ws))
+                        return;
+                    if (this.isHistoricalBackfillEvent(message.event) && this.markHistoricalBackfillAvailable(message.event))
+                        return;
+                    const requestFence = this.captureSessionHistoryFence(message.event.sessionId);
+                    const event = await this.decodeEvent(message.event);
+                    if (!this.isCurrentSocket(ws))
+                        return;
+                    if (!this.isSessionHistoryFenceCurrent(requestFence))
+                        return;
+                    this.upsertDecodedEvent(event);
+                    this.bumpSessionLiveEventEpoch(event.sessionId);
+                    this.emit({ type: "event", event });
+                    this.emitChange();
+                },
+                onSessionTranscriptReplaced: async (message) => {
+                    if (!this.isCurrentSocket(ws))
+                        return;
                     this.bumpSessionProjectionGeneration(message.session.id);
-                this.upsertSession(message.session);
-                const requestFence = this.captureSessionHistoryFence(message.session.id, message.session);
-                const metadata = await this.readSessionMetadata(message.session);
-                if (!this.isCurrentSocket(ws))
-                    return;
-                if (!this.isSessionHistoryFenceCurrent(requestFence))
-                    return;
-                if (metadata)
-                    this.setSessionMetadata(message.session.id, metadata);
-                this.emit({ type: "session", session: message.session });
-                this.refreshSelectedSessionHeadIfNeeded(message.session, previousHead);
-                this.emitChange();
-            },
-            onEvent: async (message) => {
-                if (!this.isCurrentSocket(ws))
-                    return;
-                if (this.isHistoricalBackfillEvent(message.event) && this.markHistoricalBackfillAvailable(message.event))
-                    return;
-                const requestFence = this.captureSessionHistoryFence(message.event.sessionId);
-                const event = await this.decodeEvent(message.event);
-                if (!this.isCurrentSocket(ws))
-                    return;
-                if (!this.isSessionHistoryFenceCurrent(requestFence))
-                    return;
-                this.upsertDecodedEvent(event);
-                this.bumpSessionLiveEventEpoch(event.sessionId);
-                this.emit({ type: "event", event });
-                this.emitChange();
-            },
-            onSessionTranscriptReplaced: async (message) => {
-                if (!this.isCurrentSocket(ws))
-                    return;
-                this.bumpSessionProjectionGeneration(message.session.id);
-                const requestFence = this.captureSessionHistoryFence(message.session.id, undefined, { includeLiveEventEpoch: true });
-                const metadata = await this.readSessionMetadata(message.session);
-                const decodedEvents = await this.client.decodeEvents(message.events);
-                if (!this.isCurrentSocket(ws))
-                    return;
-                if (!this.isSessionHistoryFenceCurrent(requestFence))
-                    return;
-                this.upsertSession(message.session);
-                if (metadata)
-                    this.setSessionMetadata(message.session.id, metadata);
-                this.applyAuthoritativeReplacement(message.session, decodedEvents, { hasMoreBefore: message.hasMoreBefore, source: "transcript" });
-                this.emit({ type: "session", session: message.session });
-                this.emitChange();
-            },
-            onSessionTranscriptPrepended: async (message) => {
-                if (!this.isCurrentSocket(ws))
-                    return;
-                const requestFence = this.captureSessionHistoryFence(message.session.id, message.session);
-                const metadata = await this.readSessionMetadata(message.session);
-                const decodedEvents = await this.client.decodeEvents(message.events);
-                if (!this.isCurrentSocket(ws))
-                    return;
-                if (!this.isSessionHistoryFenceCurrent(requestFence))
-                    return;
-                this.upsertSession(message.session);
-                if (metadata)
-                    this.setSessionMetadata(message.session.id, metadata);
-                this.mergeSessionEvents(message.session.id, decodedEvents);
-                const pageState = this.stateValue.sessionPages[message.session.id];
-                this.updateSessionPage(message.session.id, {
-                    error: undefined,
-                    hasOlderEvents: message.events.length > 0 || pageState?.hasOlderEvents === true,
-                    hasOlderRelayEvents: message.events.length > 0 || pageState?.hasOlderRelayEvents === true,
-                    initialized: true,
-                    loadingOlderEvents: false,
-                    olderCursor: pageState?.olderCursor,
-                    olderRelayVersion: (pageState?.olderRelayVersion ?? 0) + (message.events.length > 0 ? 1 : 0),
-                    runtimeHistoryChecked: message.hasMoreBefore !== true,
-                    oldestEventId: pageState?.oldestEventId ?? this.oldestEventIdForSession(message.session.id),
-                });
-                this.emit({ type: "session", session: message.session });
-                this.emitChange();
-            },
-            onAck: (message) => {
-                if (!this.isCurrentSocket(ws))
-                    return;
-                const pending = this.pendingPrompts.get(message.requestId);
-                if (pending) {
-                    this.pendingPrompts.delete(message.requestId);
-                    clearTimeout(pending.timer);
-                    pending.resolve({ requestId: message.requestId, turnId: pending.turnId });
-                }
-                this.emit({ type: "ack", requestId: message.requestId, sessionId: message.sessionId });
-            },
-            onError: (message) => {
-                if (!this.isCurrentSocket(ws))
-                    return;
-                const pending = message.requestId ? this.pendingPrompts.get(message.requestId) : undefined;
-                if (pending) {
-                    this.pendingPrompts.delete(message.requestId);
-                    clearTimeout(pending.timer);
-                    pending.reject(new ControllerCommandError(message.message, message.code, message.capability, message.requestId));
-                }
-                this.setState({ lastError: message.message });
-                this.emit({ type: "error", message: message.message, code: message.code, requestId: message.requestId });
-            },
-            onClose: () => {
-                if (this.socket !== ws)
-                    return;
-                this.setState({ connectionState: "offline" });
-                if (this.disposed)
-                    return;
-                if (typeof document !== "undefined" && document.visibilityState === "hidden")
-                    return;
-                this.reconnectTimer = setTimeout(() => {
-                    this.reconnectTimer = undefined;
-                    this.connect();
-                }, this.options.reconnectMs);
-            },
-        });
+                    const requestFence = this.captureSessionHistoryFence(message.session.id, undefined, { includeLiveEventEpoch: true });
+                    const metadata = await this.readSessionMetadata(message.session);
+                    const decodedEvents = await this.client.decodeEvents(message.events);
+                    if (!this.isCurrentSocket(ws))
+                        return;
+                    if (!this.isSessionHistoryFenceCurrent(requestFence))
+                        return;
+                    this.upsertSession(message.session);
+                    if (metadata)
+                        this.setSessionMetadata(message.session.id, metadata);
+                    this.applyAuthoritativeReplacement(message.session, decodedEvents, { hasMoreBefore: message.hasMoreBefore, source: "transcript" });
+                    this.emit({ type: "session", session: message.session });
+                    this.emitChange();
+                },
+                onSessionTranscriptPrepended: async (message) => {
+                    if (!this.isCurrentSocket(ws))
+                        return;
+                    const requestFence = this.captureSessionHistoryFence(message.session.id, message.session);
+                    const metadata = await this.readSessionMetadata(message.session);
+                    const decodedEvents = await this.client.decodeEvents(message.events);
+                    if (!this.isCurrentSocket(ws))
+                        return;
+                    if (!this.isSessionHistoryFenceCurrent(requestFence))
+                        return;
+                    this.upsertSession(message.session);
+                    if (metadata)
+                        this.setSessionMetadata(message.session.id, metadata);
+                    this.mergeSessionEvents(message.session.id, decodedEvents);
+                    const pageState = this.stateValue.sessionPages[message.session.id];
+                    this.updateSessionPage(message.session.id, {
+                        error: undefined,
+                        hasOlderEvents: message.events.length > 0 || pageState?.hasOlderEvents === true,
+                        hasOlderRelayEvents: message.events.length > 0 || pageState?.hasOlderRelayEvents === true,
+                        initialized: true,
+                        loadingOlderEvents: false,
+                        olderCursor: pageState?.olderCursor,
+                        olderRelayVersion: (pageState?.olderRelayVersion ?? 0) + (message.events.length > 0 ? 1 : 0),
+                        runtimeHistoryChecked: message.hasMoreBefore !== true,
+                        oldestEventId: pageState?.oldestEventId ?? this.oldestEventIdForSession(message.session.id),
+                    });
+                    this.emit({ type: "session", session: message.session });
+                    this.emitChange();
+                },
+                onAck: (message) => {
+                    if (!this.isCurrentSocket(ws))
+                        return;
+                    const pending = this.pendingPrompts.get(message.requestId);
+                    if (pending) {
+                        this.pendingPrompts.delete(message.requestId);
+                        clearTimeout(pending.timer);
+                        pending.resolve({ requestId: message.requestId, turnId: pending.turnId });
+                    }
+                    this.emit({ type: "ack", requestId: message.requestId, sessionId: message.sessionId });
+                },
+                onError: (message) => {
+                    if (!this.isCurrentSocket(ws))
+                        return;
+                    this.emit({
+                        type: "diagnostic",
+                        kind: "websocket",
+                        detail: { code: message.code ?? "", message: message.message, phase: "server-error", requestId: message.requestId ?? "", url },
+                    });
+                    const pending = message.requestId ? this.pendingPrompts.get(message.requestId) : undefined;
+                    if (pending) {
+                        this.pendingPrompts.delete(message.requestId);
+                        clearTimeout(pending.timer);
+                        pending.reject(new ControllerCommandError(message.message, message.code, message.capability, message.requestId));
+                    }
+                    this.setState({ lastError: message.message });
+                    this.emit({ type: "error", message: message.message, code: message.code, requestId: message.requestId });
+                },
+                onTransportError: () => {
+                    if (this.socket !== ws)
+                        return;
+                    this.emit({ type: "diagnostic", kind: "websocket", detail: { phase: "error", url } });
+                },
+                onClose: (event) => {
+                    if (this.socket !== ws)
+                        return;
+                    this.emit({
+                        type: "diagnostic",
+                        kind: "websocket",
+                        detail: { code: event.code, phase: "close", reason: event.reason, url, wasClean: event.wasClean },
+                    });
+                    this.setState({ connectionState: "offline" });
+                    if (this.disposed)
+                        return;
+                    if (typeof document !== "undefined" && document.visibilityState === "hidden")
+                        return;
+                    this.reconnectTimer = setTimeout(() => {
+                        this.reconnectTimer = undefined;
+                        this.connect();
+                    }, this.options.reconnectMs);
+                },
+            });
+        }
+        catch (error) {
+            this.emit({
+                type: "diagnostic",
+                kind: "websocket",
+                detail: { message: errorMessage(error), name: error instanceof Error ? error.name : typeof error, phase: "create-error", url },
+            });
+            this.setState({ connectionState: "offline", lastError: errorMessage(error) });
+            return;
+        }
         this.socket = ws;
     }
     isCurrentSocket(ws) {

package/packages/client/dist/transport.js

@@ -12,6 +12,7 @@ function parseRelayMessage(raw) {
 export function subscribe(config, handlers) {
     const ws = new WebSocket(wsUrl(config.relayUrl));
     ws.addEventListener("open", () => {
+        handlers.onOpen?.();
         const hello = {
             type: "hello",
             clientType: "controller",
@@ -72,8 +73,9 @@ export function subscribe(config, handlers) {
             handlers.onError?.(message);
         }
     });
-    ws.addEventListener("close", () => handlers.onClose?.());
-    ws.addEventListener("error", () => {
+    ws.addEventListener("close", (event) => handlers.onClose?.(event));
+    ws.addEventListener("error", (event) => {
+        handlers.onTransportError?.(event);
         handlers.onError?.({ type: "server:error", message: "Relay websocket error", code: "RELAY_WEBSOCKET_ERROR" });
     });
     return ws;

package/packages/client/dist/types.d.ts

@@ -46,7 +46,9 @@ export type ControllerSubscriptionHandlers = {
     onError?: (message: Extract<ServerMessage, {
         type: "server:error";
     }>) => void;
-    onClose?: () => void;
+    onOpen?: () => void;
+    onClose?: (event: CloseEvent) => void;
+    onTransportError?: (event: Event) => void;
 };
 export type EventCursor = number | `cursor_${number}`;
 export type WaitCondition = "idle" | SessionSnapshot["status"];