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(renderer): a hosted connection's own close ends its team's attempt

review1f9beeb2c9ad
diff --git a/src/renderer/bridge/relay-api.test.ts b/src/renderer/bridge/relay-api.test.ts
index c29ac8473..b4864d173 100644
--- a/src/renderer/bridge/relay-api.test.ts
+++ b/src/renderer/bridge/relay-api.test.ts
@@ -3,6 +3,7 @@ import { IPC } from '../../shared/ipc'
import type { NodeTerminalApi } from '../../shared/types'
import type { FrameTransport } from './frame-transport'
import { buildRelayApi } from './relay-api'
+import { onLocalRelayClose } from './relay-local-close'
/**
* The same in-memory `FrameTransport` double used by frame-transport.test.ts: records outbound
@@ -269,6 +270,18 @@ describe('buildRelayApi — hosted team tabs', () => {
await expect(handle.api.workspace.save({ version: 2, activeProjectId: '', projects: [] })).rejects.toMatchObject({ code: 'E_ROLE' })
})
+ it('closing a hosted tab\'s connection is announced locally (main never reports a close we asked for)', () => {
+ const heard = vi.fn()
+ onLocalRelayClose('conn-h', heard)
+ buildRelayApi('conn-h', new FakeTransport(), { hosted: true }).close()
+ expect(heard).toHaveBeenCalledTimes(1)
+ // A Team Access relay tab's close stays exactly what it was.
+ const legacy = vi.fn()
+ onLocalRelayClose('conn-l', legacy)
+ buildRelayApi('conn-l', new FakeTransport()).close()
+ expect(legacy).not.toHaveBeenCalled()
+ })
+
it('a commenter may also chat; an editor sends everything', () => {
const t = new FakeTransport()
const handle = buildRelayApi('conn-1', t, { hosted: true })
diff --git a/src/renderer/bridge/relay-api.ts b/src/renderer/bridge/relay-api.ts
index f97b216c2..2d42057ce 100644
--- a/src/renderer/bridge/relay-api.ts
+++ b/src/renderer/bridge/relay-api.ts
@@ -33,6 +33,7 @@
import type { HostedRole, NodeTerminalApi } from '../../shared/types'
import { type FrameTransport, RelayFrameTransport } from './frame-transport'
import { RoleGatedRpcClient } from './hosted-gate'
+import { emitLocalRelayClose } from './relay-local-close'
import {
RpcClient,
buildHostedApi,
@@ -195,7 +196,12 @@ export function buildRelayApi(
return {
api,
ready: () => client.ready(),
- close: () => local.relayClient.disconnect(connectionId),
+ close: () => {
+ local.relayClient.disconnect(connectionId)
+ // A hosted connection's own close is announced locally: main never reports it (see
+ // relay-local-close.ts), and this tab's team is held until its connection ends.
+ if (hosted) emitLocalRelayClose(connectionId)
+ },
...(hosted ? { setHostedRole: (role: HostedRole) => { hostedRole = role } } : {})
}
}
diff --git a/src/renderer/bridge/relay-local-close.test.ts b/src/renderer/bridge/relay-local-close.test.ts
new file mode 100644
index 000000000..c046ac7a7
--- /dev/null
+++ b/src/renderer/bridge/relay-local-close.test.ts
@@ -0,0 +1,25 @@
+import { describe, it, expect, vi } from 'vitest'
+import { emitLocalRelayClose, onLocalRelayClose } from './relay-local-close'
+
+describe('local relay close', () => {
+ it('tells the listeners of THAT connection, once each emit, and unsubscribes', () => {
+ const a = vi.fn()
+ const b = vi.fn()
+ const unA = onLocalRelayClose('c1', a)
+ onLocalRelayClose('c2', b)
+ emitLocalRelayClose('c1')
+ expect(a).toHaveBeenCalledTimes(1)
+ expect(b).not.toHaveBeenCalled()
+ unA()
+ emitLocalRelayClose('c1')
+ expect(a).toHaveBeenCalledTimes(1)
+ })
+
+ it('a listener that throws does not stop the others', () => {
+ const ok = vi.fn()
+ onLocalRelayClose('c3', () => { throw new Error('boom') })
+ onLocalRelayClose('c3', ok)
+ expect(() => emitLocalRelayClose('c3')).not.toThrow()
+ expect(ok).toHaveBeenCalled()
+ })
+})
diff --git a/src/renderer/bridge/relay-local-close.ts b/src/renderer/bridge/relay-local-close.ts
new file mode 100644
index 000000000..e843458d5
--- /dev/null
+++ b/src/renderer/bridge/relay-local-close.ts
@@ -0,0 +1,39 @@
+// A relay connection this renderer closed ITSELF, announced locally.
+//
+// Main never reports a close it was asked for: `relay:client:disconnect` ends the socket
+// intentionally, and an intentional close does not fire the relay socket's onClose
+// (core relay-socket `handleClose`), so `relay:client:closed` never arrives. For a hosted team's
+// connection that silence matters: the renderer holds ONE attempt per team until its connection
+// ends (lib/hostedAttempts.ts), and a declined SAS or a closed tab would otherwise hold the team for
+// good — or keep the approval wait running for the full ten minutes. So a hosted connection's own
+// close is said here, and its listeners take it as the close it is. Team Access relay tabs never
+// emit it, so their behaviour is unchanged. See docs/hosted-team-relay.md.
+
+const listeners = new Map<string, Set<() => void>>()
+
+/** Hear when this renderer closes `connectionId` itself. Returns the unsubscribe. */
+export function onLocalRelayClose(connectionId: string, listener: () => void): () => void {
+ let set = listeners.get(connectionId)
+ if (!set) {
+ set = new Set()
+ listeners.set(connectionId, set)
+ }
+ set.add(listener)
+ return () => {
+ const s = listeners.get(connectionId)
+ if (!s) return
+ s.delete(listener)
+ if (s.size === 0) listeners.delete(connectionId)
+ }
+}
+
+/** This renderer just closed `connectionId` (after `relayClient.disconnect`). */
+export function emitLocalRelayClose(connectionId: string): void {
+ for (const listener of [...(listeners.get(connectionId) ?? [])]) {
+ try {
+ listener()
+ } catch (err) {
+ console.warn('[relay] a local-close listener failed', err)
+ }
+ }
+}
diff --git a/src/renderer/canvas/Canvas.tsx b/src/renderer/canvas/Canvas.tsx
index a2dda5f15..c521ca7aa 100644
--- a/src/renderer/canvas/Canvas.tsx
+++ b/src/renderer/canvas/Canvas.tsx
@@ -481,6 +481,7 @@ import {
type RelayTab,
} from '../session/relay-tab'
import { HostedApprovalDialog } from '../components/HostedApprovalDialog'
+import { emitLocalRelayClose, onLocalRelayClose } from '../bridge/relay-local-close'
import { isJoinCode } from '@shared/relay-join-code'
import { createHostedJoiner, type HostedJoiner, type HostedMountOutcome } from '../lib/hostedJoin'
import { HOSTED_APPROVAL_WAIT_MS, isReadOnlyRole, stripIpcPrefix, viewerBannerText, waitingForOwnerText } from '../lib/hostedTeam'
@@ -4272,6 +4273,8 @@ export function Canvas() {
// Deliberate decline: mark it so the bootstrap's close-reject isn't surfaced as an error.
cancelledConnsRef.current.add(connectionId)
window.nodeTerminal.relayClient.disconnect(connectionId)
+ // Main never reports a close it was asked for; a hosted wait would otherwise run on.
+ if (hosted) emitLocalRelayClose(connectionId)
}
})
return mountRemoteMirror(connectionId, label, reconnectProjectId, staleSessionId, hosted)
@@ -4288,7 +4291,16 @@ export function Canvas() {
useEffect(() => {
const joiner = createHostedJoiner({
connect: (code) => window.nodeTerminal.relayClient.connect(code),
- onClosed: (id, listener) => window.nodeTerminal.relayClient.onClosed(id, listener),
+ // Main's close (a drop, a refusal) or our own (a closed tab, a declined SAS: main never reports
+ // those) — either way the team's connection is over.
+ onClosed: (id, listener) => {
+ const unMain = window.nodeTerminal.relayClient.onClosed(id, listener)
+ const unLocal = onLocalRelayClose(id, () => listener())
+ return () => {
+ unMain()
+ unLocal()
+ }
+ },
disconnect: (id) => window.nodeTerminal.relayClient.disconnect(id),
bookmarks: async () => (await window.nodeTerminal.relayHosted?.bookmarks()) ?? [],
removeBookmark: (hostId) => window.nodeTerminal.relayHosted.removeBookmark(hostId),
diff --git a/src/renderer/lib/hostedJoin.test.ts b/src/renderer/lib/hostedJoin.test.ts
index 483f79a05..6f1a22667 100644
--- a/src/renderer/lib/hostedJoin.test.ts
+++ b/src/renderer/lib/hostedJoin.test.ts
@@ -131,6 +131,22 @@ describe('hosted joiner', () => {
}
})
+ it('the user closing the tab (our own disconnect) ends the connection and never reconnects', async () => {
+ // Canvas disposes the tab's session (which announces the close synchronously) and marks the
+ // project closed right after, in the same tick: the reconnect decision must see the latter.
+ const h = harness([{ hostId: 'H1', label: 'box', approved: true, code: codeFor('H1') }])
+ const j = createHostedJoiner(h.deps)
+ await j.bootReconnect()
+ await goLive(h, 0, 'proj-1')
+ h.closeCbs.get('c0')!(undefined)
+ h.open.delete('proj-1')
+ await flush()
+ expect(h.connects).toHaveLength(1)
+ // …and the team is free again: a later paste of its code connects instead of "already connected".
+ j.joinWithCode(codeFor('H1'))
+ expect(h.connects).toHaveLength(2)
+ })
+
it('a close the host explained is told once and never reconnects', async () => {
const h = harness([{ hostId: 'H1', label: 'box', approved: true, code: codeFor('H1') }])
const j = createHostedJoiner(h.deps)
diff --git a/src/renderer/session/relay-tab.test.ts b/src/renderer/session/relay-tab.test.ts
index ddd1ca50b..7b2c4dcb1 100644
--- a/src/renderer/session/relay-tab.test.ts
+++ b/src/renderer/session/relay-tab.test.ts
@@ -17,6 +17,7 @@ import {
import { LocalTransport } from '../terminal/local-transport'
import type { NodeTerminalApi, Project, Workspace } from '@shared/types'
import type { RelayApiHandle } from '../bridge/relay-api'
+import { emitLocalRelayClose } from '../bridge/relay-local-close'
import { useHostedTeams } from '../state/hostedTeams'
import { useHostedPending } from '../state/hostedPending'
import { EMPTY_PENDING_QUEUE } from '../lib/hostedPendingQueue'
@@ -437,6 +438,34 @@ describe('openRelayTab — hosted team tabs', () => {
expect((err as { reason?: string }).reason).toBe('denied')
})
+ it('a hosted connection closed HERE (a declined SAS) ends the approval wait at once, not after ten minutes', async () => {
+ const h = fakeHostedApi({ role: 'viewer', label: '', hostLabel: 'box' })
+ const close = vi.fn()
+ const handle: RelayApiHandle = { api: h.api, ready: () => new Promise<void>(() => {}), close, setHostedRole: vi.fn() }
+ const bootstrap = openRelayTab('conn-decl', 'box', makeDeps({ handle, relayClient: reasonRelayClient(), timeoutMs: 600_000 }).deps)
+ emitLocalRelayClose('conn-decl')
+ await expect(bootstrap).rejects.toThrow(/^The relay connection closed before it was approved\.$/)
+ expect(close).toHaveBeenCalledTimes(1)
+ })
+
+ it('a Team Access tab does not listen for local closes (its old wait is unchanged)', async () => {
+ vi.useFakeTimers()
+ try {
+ const { api } = fakeBridgedApi()
+ const handle: RelayApiHandle = { api, ready: () => new Promise<void>(() => {}), close: vi.fn() }
+ let settled = false
+ const bootstrap = openRelayTab('conn-legacy-decl', 'Mac', makeDeps({ handle, timeoutMs: 50 }).deps)
+ void bootstrap.catch(() => {}).finally(() => { settled = true })
+ emitLocalRelayClose('conn-legacy-decl')
+ await vi.advanceTimersByTimeAsync(10)
+ expect(settled).toBe(false)
+ await vi.advanceTimersByTimeAsync(60)
+ await expect(bootstrap).rejects.toThrow(/Timed out waiting for the host to approve/)
+ } finally {
+ vi.useRealTimers()
+ }
+ })
+
it('a legacy close before approval keeps its old message exactly', async () => {
const { api } = fakeBridgedApi()
const handle: RelayApiHandle = { api, ready: () => new Promise<void>(() => {}), close: vi.fn() }
diff --git a/src/renderer/session/relay-tab.ts b/src/renderer/session/relay-tab.ts
index 1524c63a0..72a9e0db2 100644
--- a/src/renderer/session/relay-tab.ts
+++ b/src/renderer/session/relay-tab.ts
@@ -16,6 +16,7 @@
import type { HostedRole, HostedSessionApi, Project, RelayClientApi } from '@shared/types'
import { buildRelayApi, type RelayApiHandle } from '../bridge/relay-api'
+import { onLocalRelayClose } from '../bridge/relay-local-close'
import { closedReasonMessage, RelayApprovalError } from '../lib/hostedTeam'
import { attachHostedOwner } from '../lib/hostedOwner'
import { useHostedTeams, type HostedTeamInfo } from '../state/hostedTeams'
@@ -234,14 +235,23 @@ function raceApproval(
return new Promise<void>((resolve, reject) => {
let settled = false
let unClose: () => void = () => {}
+ let unLocal: () => void = () => {}
let timer: ReturnType<typeof setTimeout> | null = null
const finish = (fn: () => void) => {
if (settled) return
settled = true
unClose()
+ unLocal()
if (timer) clearTimeout(timer)
fn()
}
+ // A hosted connection this renderer closed itself (the SAS was declined) is closed NOW: main
+ // never reports it, and the approval wait would otherwise run its full ten minutes.
+ if (handle.api.hosted) {
+ unLocal = onLocalRelayClose(connectionId, () =>
+ finish(() => reject(new RelayApprovalError('The relay connection closed before it was approved.')))
+ )
+ }
// A hosted host may say WHY before it closes (an owner declined, nobody answered); a close
// without a reason keeps the old sentence exactly.
unClose = deps.relayClient.onClosed(connectionId, (reason) =>