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.
TypeScript adhdagent-orchestrationai-agentscanvasclaude-codecodexcoding-agentsdeveloper-toolselectrongeminilinuxmacosmultiplexeropencodeparallel-agentsterminalterminal-emulatorterminal-multiplexertmuxworkspace-manager
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.tsindex 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.tsindex 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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.tsxindex 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.tsindex 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.tsindex 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.tsindex 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 = falselet unClose: () => void = () => {}+ let unLocal: () => void = () => {}let timer: ReturnType<typeof setTimeout> | null = nullconst finish = (fn: () => void) => {if (settled) returnsettled = trueunClose()+ 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) =>