From c4bddd9a4e614614686ee9ea34e564cd1d1a793b Mon Sep 17 00:00:00 2001 From: Zeus-Deus Date: Sun, 30 Aug 2026 13:52:39 +0200 Subject: [PATCH] fix(desktop): route session branches through the parent's owning connection MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Branching a session owned by one connection while another is active created the child on the wrong backend — or nowhere — while the sidebar still painted an optimistic row. That row pointed at an id no backend owned, so hydration retried, exhausted, and armed the stranded-session overlay: "Couldn't load this session. The connection to this session failed and automatic retries gave up." Retry re-ran the same mis-route, so it never recovered. branchStoredSession and branchCurrentSession resolved only the parent's PROFILE and called ensureGatewayProfile(profile), then dispatched through the ambient requestGateway. A profile name does not identify a backend once several connections expose the same name, so both the parent transcript read and the session.create/session.branch RPC landed on whichever socket happened to be active. removeSession, twelve lines away, already routed by (connectionId, profile) via SessionOwnerScope — branch simply never got the same treatment. Reuse that existing contract: derive the exact owner from the parent row with sessionOwnerRouteFromRow, activate it with ensureGatewayAgent, and dispatch via requestGatewayForAgent. getAllSessionMessages takes the same owner scope so the transcript read cannot silently come back empty and abort the branch as "nothing to branch" before any create is attempted. Both arms of forkBranch (session.branch for the open chat, session.create for a sidebar right-click) are covered. An untagged parent row — the single-backend case — keeps the previous profile-only path exactly, so behaviour is unchanged for users with one connection. Tests: three call-site regressions asserting the create rides the owning (connection, profile) socket, that the transcript read carries the same owner scope, and that an untagged parent still uses the ambient socket. Plus an integration test that mocks nothing inside the router — the real requestGatewayForAgent runs against a fake Electron bridge and transport, so a regression that re-collapses a registry route onto the ambient socket fails even if the call-site assertions still pass. --- .../branch-owner-routing.integration.test.ts | 127 ++++++++++++++++++ .../hooks/use-session-actions.test.tsx | 116 ++++++++++++++++ .../hooks/use-session-actions/index.ts | 85 +++++++++--- 3 files changed, 312 insertions(+), 16 deletions(-) create mode 100644 apps/desktop/src/app/session/hooks/branch-owner-routing.integration.test.ts diff --git a/apps/desktop/src/app/session/hooks/branch-owner-routing.integration.test.ts b/apps/desktop/src/app/session/hooks/branch-owner-routing.integration.test.ts new file mode 100644 index 0000000000..d4a8f0fb8a --- /dev/null +++ b/apps/desktop/src/app/session/hooks/branch-owner-routing.integration.test.ts @@ -0,0 +1,127 @@ +/** + * End-to-end owner routing for BRANCH (the #97764-adjacent strand). + * + * The unit tests in use-session-actions.test.tsx mock `@/store/gateway`, so + * they prove the branch path ASKS for the right route. They cannot prove the + * routing layer HONOURS it. This file mocks nothing inside the router: the real + * `requestGatewayForAgent` runs against a fake Electron bridge + transport, so + * a regression that re-collapses a registry route onto the ambient socket fails + * here even if the call-site assertions still pass. + * + * Reproduces the reported shape: a session owned by a remote connection + * ("pandora") is branched while a different backend is active. Before the fix + * the create rode the ambient socket and the child was created on the wrong + * backend (or nowhere), stranding an optimistic sidebar row on an id no backend + * owned — "Couldn't load this session". + */ +import { beforeEach, describe, expect, it, vi } from 'vitest' + +// Every socket the registry dials, and every RPC that travelled over one. +const dialed: { connectionId: string; profile: string }[] = [] +const sent: { method: string; params: Record; url: string }[] = [] + +class FakeHermesGateway { + connectionState = 'closed' + private url = '' + + async connect(wsUrl: string) { + if (typeof wsUrl !== 'string' || !wsUrl.startsWith('ws')) { + throw new Error(`bad ws url: ${String(wsUrl)}`) + } + + this.url = wsUrl + this.connectionState = 'open' + } + + async request(method: string, params: Record = {}): Promise { + sent.push({ method, params, url: this.url }) + + if (method === 'session.create' || method === 'session.branch') { + return { session_id: 'branch-runtime', stored_session_id: 'branch-stored' } as T + } + + return {} as T + } + + close() { + this.connectionState = 'closed' + } + + onEvent(_listener: (event: unknown) => void) { + return () => undefined + } + + onState(_listener: (state: unknown) => void) { + return () => undefined + } + + onStateChange(_listener: (state: unknown) => void) { + return () => undefined + } + + on() {} + off() {} + addEventListener() {} + removeEventListener() {} +} + +vi.mock('@/hermes', async importOriginal => ({ + ...(await importOriginal>()), + HermesGateway: FakeHermesGateway, + setApiRequestConnection: vi.fn() +})) + +describe('branch owner routing (real router, faked transport)', () => { + beforeEach(() => { + dialed.length = 0 + sent.length = 0 + vi.resetModules() + + // A registry with two backends exposing the SAME profile name — the exact + // ambiguity that makes profile-only routing wrong. + ;(window as unknown as { hermesDesktop: unknown }).hermesDesktop = { + getConnection: async () => ({ mode: 'local' }), + getConnectionFor: async ({ connectionId, profile }: { connectionId: string; profile: string }) => { + dialed.push({ connectionId, profile }) + + return { connectionId, mode: 'remote', profile } + }, + getGatewayWsUrlFor: async ({ connectionId, profile }: { connectionId: string; profile: string }) => + `ws://${connectionId}/gateway?profile=${profile}`, + touchBackend: async () => undefined + } + }) + + it('dials the parent connection and sends the create over that socket', async () => { + const { requestGatewayForAgent } = await import('@/store/gateway') + + await requestGatewayForAgent('pandora', 'default', 'session.create', { + parent_session_id: 'stored-parent', + source: 'desktop' + }) + + // The registry resolved a socket for the PARENT's connection... + expect(dialed).toContainEqual({ connectionId: 'pandora', profile: 'default' }) + + // ...and the create actually travelled over that socket. + const create = sent.find(entry => entry.method === 'session.create') + expect(create).toBeDefined() + expect(create!.url).toContain('pandora') + expect(create!.params).toMatchObject({ parent_session_id: 'stored-parent' }) + }) + + it('keeps two same-named profiles on separate sockets', async () => { + const { requestGatewayForAgent } = await import('@/store/gateway') + + await requestGatewayForAgent('pandora', 'default', 'session.create', { source: 'desktop' }) + await requestGatewayForAgent('other-box', 'default', 'session.create', { source: 'desktop' }) + + const urls = sent.filter(entry => entry.method === 'session.create').map(entry => entry.url) + + expect(urls).toHaveLength(2) + // Same profile name, different backends — they must NOT share a socket. + expect(new Set(urls).size).toBe(2) + expect(urls.some(url => url.includes('pandora'))).toBe(true) + expect(urls.some(url => url.includes('other-box'))).toBe(true) + }) +}) diff --git a/apps/desktop/src/app/session/hooks/use-session-actions.test.tsx b/apps/desktop/src/app/session/hooks/use-session-actions.test.tsx index 7aaef72699..bdf9ae8eca 100644 --- a/apps/desktop/src/app/session/hooks/use-session-actions.test.tsx +++ b/apps/desktop/src/app/session/hooks/use-session-actions.test.tsx @@ -1802,6 +1802,122 @@ describe('branchStoredSession desktop source tagging', () => { }) }) + // A branch belongs to the backend that OWNS its parent. Routing on profile + // alone silently sends session.create to whatever socket is active, so a + // remote-owned parent branched while another connection is active creates + // the child on the wrong backend — or nowhere — while the sidebar still + // paints an optimistic row that can never hydrate ("Couldn't load this + // session"). Same ownership contract removeSession already honours. + it('routes a connection-tagged parent branch through its owning connection', async () => { + const ambientRequest = vi.fn(async () => ({}) as never) + + vi.mocked(requestGatewayForAgent).mockImplementation((async ( + _connectionId: null | string, + _profile: string, + method: string + ) => { + if (method === 'session.create') { + return { session_id: 'branch-runtime', stored_session_id: 'branch-stored' } as never + } + + return {} as never + }) as never) + + setSessions([ + storedSession({ connection_id: 'pandora', id: 'stored-parent', message_count: 1, profile: 'default' }) + ]) + vi.mocked(getAllSessionMessages).mockResolvedValue({ + messages: [{ content: 'branch me', role: 'user', timestamp: 1 }], + session_id: 'stored-parent' + } as never) + + let branchStoredSession: ((storedSessionId: string) => Promise) | null = null + render( (branchStoredSession = branch)} requestGateway={ambientRequest} />) + await waitFor(() => expect(branchStoredSession).not.toBeNull()) + + await expect(branchStoredSession!('stored-parent')).resolves.toBe(true) + + // The create must ride the parent's own (connection, profile) socket... + expect(requestGatewayForAgent).toHaveBeenCalledWith( + 'pandora', + 'default', + 'session.create', + expect.objectContaining({ parent_session_id: 'stored-parent', source: 'desktop' }) + ) + // ...and never the ambient socket, which may serve a different machine. + expect(ambientRequest).not.toHaveBeenCalledWith('session.create', expect.anything()) + }) + + // The parent transcript read must land on the owning backend too: reading it + // from the ambient socket returns nothing for a foreign-owned parent, which + // aborts the branch as "nothing to branch" before any create is attempted. + it('reads a connection-tagged parent transcript from its owning connection', async () => { + const ambientRequest = vi.fn(async () => ({}) as never) + + vi.mocked(requestGatewayForAgent).mockImplementation((async ( + _connectionId: null | string, + _profile: string, + method: string + ) => { + if (method === 'session.create') { + return { session_id: 'branch-runtime', stored_session_id: 'branch-stored' } as never + } + + return {} as never + }) as never) + + setSessions([ + storedSession({ connection_id: 'pandora', id: 'stored-parent', message_count: 1, profile: 'default' }) + ]) + vi.mocked(getAllSessionMessages).mockResolvedValue({ + messages: [{ content: 'branch me', role: 'user', timestamp: 1 }], + session_id: 'stored-parent' + } as never) + + let branchStoredSession: ((storedSessionId: string) => Promise) | null = null + render( (branchStoredSession = branch)} requestGateway={ambientRequest} />) + await waitFor(() => expect(branchStoredSession).not.toBeNull()) + + await expect(branchStoredSession!('stored-parent')).resolves.toBe(true) + + expect(getAllSessionMessages).toHaveBeenCalledWith('stored-parent', { + connectionId: 'pandora', + profile: 'default' + }) + }) + + // An untagged row (single-backend users, the overwhelmingly common case) + // must keep the ambient path exactly as before — no behaviour change. + it('keeps an untagged parent branch on the ambient socket', async () => { + let createParams: Record | undefined + + const ambientRequest = vi.fn(async (method: string, params?: Record) => { + if (method === 'session.create') { + createParams = params + + return { session_id: 'branch-runtime', stored_session_id: 'branch-stored' } as never + } + + return {} as never + }) + + vi.mocked(requestGatewayForAgent).mockClear() + setSessions([storedSession({ id: 'stored-parent', message_count: 1 })]) + vi.mocked(getAllSessionMessages).mockResolvedValue({ + messages: [{ content: 'branch me', role: 'user', timestamp: 1 }], + session_id: 'stored-parent' + } as never) + + let branchStoredSession: ((storedSessionId: string) => Promise) | null = null + render( (branchStoredSession = branch)} requestGateway={ambientRequest} />) + await waitFor(() => expect(branchStoredSession).not.toBeNull()) + + await expect(branchStoredSession!('stored-parent')).resolves.toBe(true) + + expect(createParams).toMatchObject({ parent_session_id: 'stored-parent', source: 'desktop' }) + expect(requestGatewayForAgent).not.toHaveBeenCalled() + }) + it('branches an open live chat via session.branch with a trimmed message count (bug #1/#3 fix)', async () => { let branchParams: Record | undefined diff --git a/apps/desktop/src/app/session/hooks/use-session-actions/index.ts b/apps/desktop/src/app/session/hooks/use-session-actions/index.ts index df31c30c75..f659d4c0d6 100644 --- a/apps/desktop/src/app/session/hooks/use-session-actions/index.ts +++ b/apps/desktop/src/app/session/hooks/use-session-actions/index.ts @@ -101,6 +101,8 @@ import { import { isSessionOwnerResolutionError } from '@/store/session-owner-resolution' import { requestForSessionProfile, + type SessionOwnerRoute, + sessionOwnerRouteFromRow, type SessionOwnerScope, type SessionProfileRoute } from '@/store/session-request-router' @@ -1954,27 +1956,48 @@ export function useSessionActions({ parentStoredId: null | string, cwd?: string, profile?: null | string, - branchCount?: number + branchCount?: number, + ownerRoute?: SessionOwnerRoute ): Promise => { creatingSessionRef.current = true try { - // A branch belongs to its parent's OWNING profile. Swapping the live - // gateway first AND passing `profile` on the create mirrors - // desktopSessionCreateParams/resumeSession: in app-global remote mode - // one backend serves every profile, so an omitted profile silently - // lands the branch on the launch (default) profile — the "session - // jumps between profiles after branching" bug. The swap also makes - // upsertOptimisticSession's $activeGatewayProfile stamp correct. - await ensureGatewayProfile(profile) + // A branch belongs to its parent's OWNING backend. Two facets, and both + // matter once more than one connection is configured: + // + // 1. PROFILE — passing `profile` on the create mirrors + // desktopSessionCreateParams/resumeSession: in app-global remote mode + // one backend serves every profile, so an omitted profile silently + // lands the branch on the launch (default) profile — the "session + // jumps between profiles after branching" bug. + // 2. CONNECTION — a profile name alone does not identify a backend when + // several connections expose the same name. Routing on profile only + // sends session.create to whatever socket happens to be active, so + // branching a remote-owned parent from another connection creates the + // child on the wrong backend (or nowhere), while the optimistic + // sidebar row below still points at an id no backend owns — the + // "Couldn't load this session" strand. removeSession already routes + // by (connection, profile); this is the same ownership contract. + // + // An untagged parent keeps the historic profile-only path exactly. + if (ownerRoute) { + await ensureGatewayAgent(ownerRoute.connectionId, ownerRoute.profile) + } else { + await ensureGatewayProfile(profile) + } + + const requestBranchGateway = (method: string, params: Record): Promise => + ownerRoute + ? requestGatewayForAgent(ownerRoute.connectionId, ownerRoute.profile, method, params) + : requestGateway(method, params) // No title: the backend auto-names the branch from its parent's lineage. const branched = sourceSessionId - ? await requestGateway('session.branch', { + ? await requestBranchGateway('session.branch', { session_id: sourceSessionId, ...(branchCount !== undefined ? { count: branchCount } : {}) }) - : await requestGateway('session.create', { + : await requestBranchGateway('session.create', { cols: 96, source: 'desktop', ...(cwd && { cwd }), @@ -2094,9 +2117,17 @@ export function useSessionActions({ let authoritativeMessages: ChatMessage[] | null = null const profile = await resolveSessionProfile(storedSessionId) + // The open chat's exact owner, when its row carries a connection tag. + // Same contract as branchStoredSession: the transcript read and the + // branch RPC must both land on the backend that owns the parent, not on + // whichever socket is active. + const ownerRoute = storedSessionId + ? sessionOwnerRouteFromRow($sessions.get().find(session => sessionMatchesStoredId(session, storedSessionId))) + : undefined + if (storedSessionId) { try { - const persisted = await getAllSessionMessages(storedSessionId, profile) + const persisted = await getAllSessionMessages(storedSessionId, ownerRoute ?? profile) const hydrated = toChatMessages(persisted.messages) if (hydrated.length) { @@ -2144,7 +2175,8 @@ export function useSessionActions({ storedSessionId, startingCwd, profile, - messageId ? branchMessages.length : undefined + messageId ? branchMessages.length : undefined, + ownerRoute ) }, [activeSessionIdRef, busyRef, copy, forkBranch, getRouteToken, selectedStoredSessionIdRef] @@ -2166,9 +2198,22 @@ export function useSessionActions({ const profile = sessionProfile ?? stored?.profile + // An exact owner from the parent row — connection AND profile. Undefined + // for an untagged row, which keeps the ambient/profile-only path. + const ownerRoute = sessionOwnerRouteFromRow(stored) + try { - await ensureGatewayProfile(profile) - const { messages } = await getAllSessionMessages(storedSessionId, profile) + if (ownerRoute) { + await ensureGatewayAgent(ownerRoute.connectionId, ownerRoute.profile) + } else { + await ensureGatewayProfile(profile) + } + + // Read the parent transcript from the backend that OWNS it. A bare + // profile scope resolves against the active connection, which for a + // foreign-owned parent holds no such session: the read comes back empty + // and the branch aborts as "nothing to branch" before any create. + const { messages } = await getAllSessionMessages(storedSessionId, ownerRoute ?? profile) const branchMessages = toBranchMessages(toChatMessages(messages)) if (!branchMessages.length) { @@ -2177,7 +2222,15 @@ export function useSessionActions({ return false } - return await forkBranch(branchMessages, null, stored?.id ?? storedSessionId, stored?.cwd?.trim(), profile) + return await forkBranch( + branchMessages, + null, + stored?.id ?? storedSessionId, + stored?.cwd?.trim(), + profile, + undefined, + ownerRoute + ) } catch (err) { notifyError(err, copy.branchFailed)