@cydm/happy-elves 0.1.0-beta.45 → 0.1.0-beta.47

package/apps/daemon/dist/session/directory.js

@@ -1,10 +1,11 @@
 import fs from "node:fs/promises";
+import os from "node:os";
 import path from "node:path";
 import { claimCommandRequest, sendCommandResponse } from "../relay/send.js";
-import { assertPathInsideWorkspace, pathInsideRoot, workspaceRealRoots } from "./workspace-paths.js";
+import { isUncPath, workspaceRealRoots } from "./workspace-paths.js";
 const directoryEntryLimit = 500;
 const directoryStatConcurrency = 16;
-async function findRepoRoot(startPath, workspaceRoots) {
+async function findRepoRoot(startPath) {
     let current = startPath;
     while (true) {
         try {
@@ -15,16 +16,42 @@ async function findRepoRoot(startPath, workspaceRoots) {
             const parent = path.dirname(current);
             if (parent === current)
                 return null;
-            if (!workspaceRoots.some((root) => pathInsideRoot(root, parent)))
-                return null;
             current = parent;
         }
     }
 }
+async function directoryRoots(workspaceRoots, currentPath) {
+    const roots = [];
+    const seen = new Set();
+    async function add(candidate, label) {
+        if (!candidate || isUncPath(candidate))
+            return;
+        try {
+            const real = await fs.realpath(path.resolve(candidate));
+            if (seen.has(real))
+                return;
+            seen.add(real);
+            roots.push({ name: (label ?? path.basename(real)) || real, path: real });
+        }
+        catch {
+            // Optional navigation shortcuts should not break directory listing.
+        }
+    }
+    for (const root of workspaceRoots)
+        await add(root);
+    await add(os.homedir(), "home");
+    await add(path.parse(currentPath).root);
+    const homeRoot = path.parse(os.homedir()).root;
+    if (homeRoot !== path.parse(currentPath).root)
+        await add(homeRoot);
+    return roots;
+}
 export async function buildDirectoryList(config, requestedPath) {
+    if (requestedPath && isUncPath(requestedPath)) {
+        throw Object.assign(new Error("UNC paths are not supported for directory browsing."), { code: "DIRECTORY_UNSUPPORTED_PATH" });
+    }
     const resolvedPath = path.resolve(requestedPath || process.cwd());
     const realPath = await fs.realpath(resolvedPath);
-    await assertPathInsideWorkspace(realPath);
     const workspaceRoots = await workspaceRealRoots();
     const entries = [];
     let truncated = false;
@@ -66,13 +93,12 @@ export async function buildDirectoryList(config, requestedPath) {
         return a.name.localeCompare(b.name);
     });
     const parentPath = path.dirname(realPath);
-    const parentInsideWorkspace = parentPath !== realPath && workspaceRoots.some((root) => pathInsideRoot(root, parentPath));
     return {
         machineId: config.machineId,
         path: realPath,
-        parentPath: parentInsideWorkspace ? parentPath : null,
-        repoRoot: await findRepoRoot(realPath, workspaceRoots),
-        roots: workspaceRoots.map((root) => ({ name: path.basename(root) || root, path: root })),
+        parentPath: parentPath !== realPath ? parentPath : null,
+        repoRoot: await findRepoRoot(realPath),
+        roots: await directoryRoots(workspaceRoots, realPath),
         entries: sortedEntries,
         truncated,
         entryLimit: directoryEntryLimit,

package/apps/daemon/dist/session/file-preview.js

@@ -2,7 +2,7 @@ import fs from "node:fs/promises";
 import path from "node:path";
 import { appendAudit } from "../audit.js";
 import { claimCommandRequest, sendCommandResponse } from "../relay/send.js";
-import { assertRootInsideWorkspace, isUncPath, pathInsideRoot } from "./workspace-paths.js";
+import { isUncPath, pathInsideRoot } from "./workspace-paths.js";
 const textLimitBytes = 256 * 1024;
 const textHardLimitBytes = 1024 * 1024;
 const imageLimitBytes = 16 * 1024 * 1024;
@@ -60,7 +60,6 @@ export async function buildFilePreview(config, rootPath, requestedPath, mode = "
         ? requestedPath
         : path.resolve(rootAbsolutePath, requestedPath);
     const rootRealPath = await fs.realpath(rootAbsolutePath);
-    await assertRootInsideWorkspace(rootRealPath);
     const targetRealPath = await fs.realpath(targetPath);
     assertInsideRoot(rootRealPath, targetRealPath);
     const stat = await fs.stat(targetRealPath);

package/apps/daemon/dist/session/workspace-paths.d.ts

@@ -1,5 +1,3 @@
 export declare function workspaceRealRoots(): Promise<string[]>;
-export declare function assertPathInsideWorkspace(realPath: string): Promise<void>;
-export declare function assertRootInsideWorkspace(rootRealPath: string): Promise<void>;
 export declare function pathInsideRoot(rootPath: string, targetPath: string): boolean;
 export declare function isUncPath(input: string): boolean;

package/apps/daemon/dist/session/workspace-paths.js

@@ -16,23 +16,11 @@ export async function workspaceRealRoots() {
             roots.push(real);
         }
         catch {
-            // A stale session cwd should not widen or break the daemon workspace boundary.
+            // A stale session cwd should not break directory root shortcuts.
         }
     }
     return roots;
 }
-export async function assertPathInsideWorkspace(realPath) {
-    const roots = await workspaceRealRoots();
-    if (roots.some((root) => pathInsideRoot(root, realPath)))
-        return;
-    throw Object.assign(new Error("Path must stay inside a known workspace."), { code: "WORKSPACE_PATH_FORBIDDEN" });
-}
-export async function assertRootInsideWorkspace(rootRealPath) {
-    const roots = await workspaceRealRoots();
-    if (roots.some((root) => pathInsideRoot(root, rootRealPath)))
-        return;
-    throw Object.assign(new Error("Root path must stay inside a known workspace."), { code: "WORKSPACE_ROOT_FORBIDDEN" });
-}
 export function pathInsideRoot(rootPath, targetPath) {
     const relative = path.relative(rootPath, targetPath);
     return relative === "" || (!relative.startsWith("..") && !path.isAbsolute(relative));

package/apps/daemon/package.json

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

package/npm-shrinkwrap.json

@@ -1,12 +1,12 @@
 {
   "name": "@cydm/happy-elves",
-  "version": "0.1.0-beta.45",
+  "version": "0.1.0-beta.47",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "@cydm/happy-elves",
-      "version": "0.1.0-beta.45",
+      "version": "0.1.0-beta.47",
       "license": "Apache-2.0",
       "dependencies": {
         "@fastify/cors": "11.2.0",
@@ -799,9 +799,9 @@
       }
     },
     "node_modules/bare-os": {
-      "version": "3.9.1",
-      "resolved": "https://registry.npmjs.org/bare-os/-/bare-os-3.9.1.tgz",
-      "integrity": "sha512-6M5XjcnsygQNPMCMPXSK379xrJFiZ/AEMNBmFEmQW8d/789VQATvriyi5r0HYTL9TkQ26rn3kgdTG3aisbrXkQ==",
+      "version": "3.9.3",
+      "resolved": "https://registry.npmjs.org/bare-os/-/bare-os-3.9.3.tgz",
+      "integrity": "sha512-fF4Q7QsyKVF5Rj0qvI8BgUNjqzC2JvQlpTaPLjVJVxYVUX5Zr9un+y3w1HmA4nNKdFmRBT8z/WmrjvXzXVerKQ==",
       "license": "Apache-2.0",
       "engines": {
         "bare": ">=1.14.0"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cydm/happy-elves",
-  "version": "0.1.0-beta.45",
+  "version": "0.1.0-beta.47",
   "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"];