Skip to content

Node-based terminal manager for AI coding agents — tmux-backed terminals and parallel agent sessions as draggable nodes on an infinite pan/zoom canvas. macOS, Linux, and a browser Server Edition.

fix(relay): a session the host already closed is not a dead socket

review3274747ae55c
diff --git a/src/core/relay/relay-host.core.test.ts b/src/core/relay/relay-host.core.test.ts
index aabade1c3..8916a905c 100644
--- a/src/core/relay/relay-host.core.test.ts
+++ b/src/core/relay/relay-host.core.test.ts
@@ -7,6 +7,7 @@ import { genKeyPair, publicKeyToB64 } from './e2ee'
import { connectRelay } from './relay-socket'
import { createTrustGate, deniedFrame, type TrustGate } from './relay-trust'
import type { RpcRequest } from '../../shared/rpc'
+import type { UiSink } from '../ui-sink-registry'
function fakeAttach() {
const dispatched: RpcRequest[] = []
@@ -716,3 +717,54 @@ describe('core relay client — a confirm made before the client holds its socke
await vi.waitFor(() => expect(opened.sort()).toEqual(['host', 'peer']))
})
})
+
+describe('core relay host — a session it already closed is not a dead socket', () => {
+ // The real teardown (`attach.detach`) broadcasts on its way out: the presence hub sends its `leave`
+ // diff to EVERY registered sink, the leaver's own included, before that sink is unregistered
+ // (src/server/index.ts teardownClient → presenceHub.leave → platform.broadcast). Found on a real
+ // headless boot (src/server/hosted-e2e.test.ts): the leaver's sink threw 'relay socket is not
+ // connected', and every ordinary disconnect logged a false "[ui-sink] send … threw" strike.
+ it('the leaver’s own teardown broadcast is dropped, not thrown; a peer still connected receives it', async () => {
+ const hostKeys = genKeyPair()
+ const sinks = new Map<number, UiSink>()
+ const threw: string[] = []
+ let next = 1
+ const attach: PeerAttach = {
+ attach: (sink) => { const id = next++; sinks.set(id, sink); return id },
+ detach: (id) => {
+ for (const [to, sink] of [...sinks]) {
+ try {
+ sink.sendText(JSON.stringify({ t: 'ev', channel: 'presence:peer', args: [{ op: 'leave', clientId: id }] }))
+ sink.sendBinary(new Uint8Array([0]))
+ } catch (err) {
+ threw.push(`${to}: ${err instanceof Error ? err.message : String(err)}`)
+ }
+ }
+ sinks.delete(id)
+ },
+ dispatch: async (_id, req) => ({ t: 'res', id: req.id, ok: true, result: null }),
+ cast: () => {}
+ }
+ const peers = [0, 1].map(() => {
+ const { hostT, peerT } = transportPair()
+ const frames: string[] = []
+ connectRelayHost({
+ url: 'ws://127.0.0.1/x', token: 't', ourKeys: hostKeys, attach, transport: hostT,
+ autoApprove: () => true, onPeerPending: () => {}, onOpen: () => {}, onClose: () => {}
+ })
+ const client = connectRelayClient({
+ url: 'ws://127.0.0.1/x', token: 't', hostKeyB64: publicKeyToB64(hostKeys.publicKey), ourKeys: genKeyPair(),
+ transport: peerT, autoApprove: true, onSas: () => {}, onApproved: () => {},
+ onFrame: (j) => frames.push(j), onPtyData: () => {}, onClose: () => {}
+ })
+ return { client, frames }
+ })
+ await vi.waitFor(() => expect(sinks.size).toBe(2))
+ peers[0].client.close()
+ expect(threw).toEqual([])
+ expect(sinks.size).toBe(1)
+ await vi.waitFor(() => expect(peers[1].frames.some((f) => f.includes('"op":"leave"'))).toBe(true))
+ peers[1].client.close()
+ expect(threw).toEqual([])
+ })
+})
diff --git a/src/core/relay/relay-host.ts b/src/core/relay/relay-host.ts
index b579616ed..8229e7fdc 100644
--- a/src/core/relay/relay-host.ts
+++ b/src/core/relay/relay-host.ts
@@ -309,9 +309,23 @@ export function connectRelayHost(opts: ConnectRelayHostOptions): RelayHostSessio
// Never make this a constant.
//
// A `wrapSink` hook must keep its `bufferedAmount` pointing at `base.bufferedAmount`.
+ //
+ // A session this host already CLOSED is not a dead socket: it is being torn down right now, and
+ // `detach` broadcasts on its way out — the presence hub's `leave` diff goes to every registered
+ // sink, the leaver's own included, before the sink is unregistered. Delivering to a peer that is
+ // gone loses nothing, so that send is dropped; throwing would log a false dead-socket strike on
+ // every ordinary disconnect (measured on a real headless boot, src/server/hosted-e2e.test.ts).
+ // Only a socket that dies while the session still counts as open throws, which is what the
+ // registry's eviction is for.
const base: UiSink = {
- sendText: (json) => { if (!socket.sendTunnelText(json)) throw new Error('relay socket is not connected') },
- sendBinary: (buf) => { if (!socket.sendTunnelBinary(buf)) throw new Error('relay socket is not connected') },
+ sendText: (json) => {
+ if (closed) return
+ if (!socket.sendTunnelText(json)) throw new Error('relay socket is not connected')
+ },
+ sendBinary: (buf) => {
+ if (closed) return
+ if (!socket.sendTunnelBinary(buf)) throw new Error('relay socket is not connected')
+ },
bufferedAmount: () => socket.bufferedAmount()
}
let sink: UiSink = base
diff --git a/src/server/hosted-e2e.test.ts b/src/server/hosted-e2e.test.ts
index e16ba7f57..b08507196 100644
--- a/src/server/hosted-e2e.test.ts
+++ b/src/server/hosted-e2e.test.ts
@@ -294,6 +294,9 @@ describe.skipIf(process.platform === 'win32')('hosted team relay, end to end on
})
)
teardown.push(() => srv.close())
+ // After the boot, so the log sink the server installs is what this spy calls through to.
+ const warn = vi.spyOn(console, 'warn')
+ teardown.push(() => warn.mockRestore())
// ---- 1. The admin socket sets the team up, and hosting starts.
const init = await admin<AdminInitResult>(dataDir, { cmd: 'init' })
@@ -402,6 +405,8 @@ describe.skipIf(process.platform === 'win32')('hosted team relay, end to end on
{ label: 'Owner', role: 'owner', connected: true },
{ label: '', role: 'viewer', connected: false }
])
+ // An ordinary disconnect is not a dead socket: no send to the leaver was counted as a failure.
+ expect(warn.mock.calls.filter((c) => String(c[0]).startsWith('[ui-sink]'))).toEqual([])
const stillThere = owner.bytes(ownerSessionId)
spawned[0].onDataCb?.('still running\r\n')
expect(await step('owner still receives output', stillThere)).toContain('still running')