The fastest, cheapest, most efficient open-source agent harness. Run more than 500 agents on a $10 VPS.
Rust agent-orchestrationai-agentsai-assistantdesktopllmlocal-firstmcppersonal-aiprivacyrustsecond-braintauri
fix(socket): retry a rejected handshake and keep the bearer with its endpoint
M3gA-Minddd08973389b0
diff --git a/app/src/services/__tests__/coreSocket.test.ts b/app/src/services/__tests__/coreSocket.test.tsindex f4be7be90f..c370aac610 100644--- a/app/src/services/__tests__/coreSocket.test.ts+++ b/app/src/services/__tests__/coreSocket.test.ts@@ -1,6 +1,6 @@import { beforeEach, describe, expect, it, vi } from 'vitest';-import { connectCoreSocket, createCoreSocket } from '../coreSocket';+import { connectCoreSocket, createCoreSocket, lastHandshakeToken } from '../coreSocket';const hoisted = vi.hoisted(() => ({ioMock: vi.fn(() => ({ on: vi.fn(), id: 'mock-sid' })),@@ -74,6 +74,17 @@ describe('createCoreSocket', () => {expect((await handshake(call[1].auth)).token).toBe('launch-2-bearer');});+ it('falls back to its own bearer when resolveToken declines (another core is active)', async () => {+ const socket = createCoreSocket('http://127.0.0.1:7788', {+ coreToken: 'core-a-bearer',+ resolveToken: async () => null,+ });+ getCoreRpcTokenMock.mockResolvedValue('core-b-bearer');+ const call = ioMock.mock.calls[0] as unknown as [string, { auth: unknown }];+ expect((await handshake(call[1].auth)).token).toBe('core-a-bearer');+ expect(lastHandshakeToken(socket as never)).toBe('core-a-bearer');+ });+it('honours overrides without dropping the auth payload', async () => {createCoreSocket('http://127.0.0.1:7788', {coreToken: 'core',diff --git a/app/src/services/__tests__/socketService.events.test.ts b/app/src/services/__tests__/socketService.events.test.tsindex 41a62c8813..f6a35807ee 100644--- a/app/src/services/__tests__/socketService.events.test.ts+++ b/app/src/services/__tests__/socketService.events.test.ts@@ -45,6 +45,7 @@ vi.mock('../../lib/mcp', () => ({ SocketIOMCPTransportImpl: MockMCPTransport }))// getCoreRpcUrl mock — each test sets what it needs.const getCoreRpcUrlMock = vi.fn<() => Promise<string>>();const clearCoreRpcTokenCacheMock = vi.fn();+const getCoreRpcTokenMock = vi.fn(async (): Promise<string | null> => 'mock-core-bearer');vi.mock('../coreRpcClient', () => ({getCoreRpcUrl: getCoreRpcUrlMock,clearCoreRpcUrlCache: vi.fn(),@@ -52,7 +53,7 @@ vi.mock('../coreRpcClient', () => ({// socketService now reads the per-process bearer for the Socket.IO// handshake `auth.token` payload; tests only care that the resolve// chain proceeds, not what the bearer value is.- getCoreRpcToken: vi.fn(async () => 'mock-core-bearer'),+ getCoreRpcToken: getCoreRpcTokenMock,resolveCoreSocketEndpoint: vi.fn(async (baseUrl: string) => ({ baseUrl, path: '/socket.io/' })),}));@@ -107,6 +108,8 @@ describe('socketService — socket event handler dispatches (lines 212, 230, 237});setBackendMock.mockClear();getCoreRpcUrlMock.mockReset();+ getCoreRpcTokenMock.mockReset();+ getCoreRpcTokenMock.mockResolvedValue('mock-core-bearer');});afterEach(() => {@@ -223,4 +226,42 @@ describe('socketService — socket event handler dispatches (lines 212, 230, 237expect(disconnectedCall).toBeDefined();expect((disconnectedCall![0] as { error: string }).error).toBe('connection refused');});++ // The core refuses a stale bearer by disconnecting the namespace, which+ // socket.io never retries by itself.+ async function connectAndHandshake() {+ const { handlers, mockSocket } = buildMockSocket();+ let auth: ((cb: (data: object) => void) => void) | undefined;+ vi.doMock('socket.io-client', () => ({+ io: vi.fn((_url: string, opts: { auth: typeof auth }) => {+ auth = opts.auth;+ return mockSocket;+ }),+ }));+ getCoreRpcUrlMock.mockResolvedValue('http://127.0.0.1:7788/rpc');+ const { socketService } = await import('../socketService');+ socketService.connect('jwt-test-server-disconnect');+ await pollUntil(() => expect(handlers['disconnect']).toBeDefined());+ const sent = await new Promise<object>(resolve => auth!(resolve));+ expect(sent).toMatchObject({ token: 'mock-core-bearer' });+ // Forget the initial connect so only a reconnect is counted.+ const connect = (mockSocket as { connect: ReturnType<typeof vi.fn> }).connect;+ connect.mockClear();+ return { handlers, connect };+ }++ it('reconnects with the refreshed bearer after the core rejects the handshake', async () => {+ const { handlers, connect } = await connectAndHandshake();+ getCoreRpcTokenMock.mockResolvedValue('restarted-core-bearer');+ handlers['disconnect']!('io server disconnect');+ await pollUntil(() => expect(connect).toHaveBeenCalledTimes(1));+ expect(clearCoreRpcTokenCacheMock).toHaveBeenCalled();+ });++ it('does not loop when the core rejects the same bearer again', async () => {+ const { handlers, connect } = await connectAndHandshake();+ handlers['disconnect']!('io server disconnect');+ await new Promise(r => setTimeout(r, 50));+ expect(connect).not.toHaveBeenCalled();+ });});diff --git a/app/src/services/coreSocket.ts b/app/src/services/coreSocket.tsindex beb12395f2..6c725dfc7b 100644--- a/app/src/services/coreSocket.ts+++ b/app/src/services/coreSocket.ts@@ -28,6 +28,13 @@ interface CoreSocketOptions {* logged-in user.*/authExtras?: Record<string, unknown>;+ /**+ * Re-reads the bearer for each handshake. Defaults to `getCoreRpcToken`.+ * Return `null` to fall back to `coreToken` — e.g. when the active core has+ * changed and the fresh bearer belongs to a different endpoint than the one+ * this socket targets.+ */+ resolveToken?: () => Promise<string | null>;/*** Override of the underlying Socket.IO connect options. The default* shape matches what the previous in-line callers used.@@ -44,18 +51,31 @@ const DEFAULT_OPTIONS: Partial<ManagerOptions & SocketOptions> = {forceNew: true,};+const handshakeTokens = new WeakMap<Socket, string>();++/** The bearer this socket presented on its most recent handshake. */+export function lastHandshakeToken(socket: Socket): string | undefined {+ return handshakeTokens.get(socket);+}+export function createCoreSocket(baseUrl: string, opts: CoreSocketOptions): Socket {const extras = opts.authExtras ?? {};+ const resolveToken = opts.resolveToken ?? getCoreRpcToken;// socket.io-client resends an object `auth` unchanged on every reconnect, so// after a core restart (new per-launch bearer) it would retry the dead one// forever. A function `auth` runs on every handshake and re-reads the bearer.const auth = (cb: (data: object) => void) => {- void getCoreRpcToken().then(- token => cb({ token: token ?? opts.coreToken ?? '', ...extras }),- () => cb({ token: opts.coreToken ?? '', ...extras })+ const send = (token: string) => {+ handshakeTokens.set(socket, token);+ cb({ token, ...extras });+ };+ void resolveToken().then(+ token => send(token ?? opts.coreToken ?? ''),+ () => send(opts.coreToken ?? ''));};- return io(baseUrl, { ...DEFAULT_OPTIONS, ...(opts.overrides ?? {}), auth });+ const socket = io(baseUrl, { ...DEFAULT_OPTIONS, ...(opts.overrides ?? {}), auth });+ return socket;}interface ConnectCoreSocketOptions {diff --git a/app/src/services/socketService.ts b/app/src/services/socketService.tsindex c60c5c46e1..873189517d 100644--- a/app/src/services/socketService.ts+++ b/app/src/services/socketService.ts@@ -18,7 +18,7 @@ import {getCoreRpcUrl,resolveCoreSocketEndpoint,} from './coreRpcClient';-import { createCoreSocket } from './coreSocket';+import { createCoreSocket, lastHandshakeToken } from './coreSocket';// Socket service logger using debug package// To change these namespaces at runtime, set `localStorage.debug` — NOT the@@ -191,6 +191,11 @@ class SocketService {this.socket = createCoreSocket(endpoint.baseUrl, {coreToken,authExtras: { session: token },+ // Only a bearer for the core this socket targets: after a gateway+ // switch the fresh bearer belongs to another endpoint, so fall back to+ // this socket's own instead of handing it to the old core.+ resolveToken: async () =>+ (await resolveCoreSocketBaseUrl()) === backendUrl ? getCoreRpcToken() : null,overrides: {path: endpoint.path,...(endpoint.transports ? { transports: endpoint.transports } : {}),@@ -259,12 +264,14 @@ class SocketService {socketError('Server error', { userId: uid, error: sanitizeError(error) });});+ const socket = this.socket;this.socket.on('disconnect', (reason: string) => {const uid = getSocketUserId();socketLog('Disconnected', { userId: uid, reason });store.dispatch(setStatusForUser({ userId: uid, status: 'disconnected' }));store.dispatch(setSocketIdForUser({ userId: uid, socketId: null }));store.dispatch(setBackend({ value: 'disconnected', error: reason }));+ if (reason === 'io server disconnect') void this.retryRejectedHandshake(socket);});this.socket.on('connect_error', (error: Error) => {@@ -384,6 +391,22 @@ class SocketService {/*** Disconnect from the socket server*/+ /**+ * The core refuses a stale bearer by disconnecting the namespace+ * (`io server disconnect`), which socket.io never retries on its own. Re-read+ * the bearer and reconnect — only when it changed, so a bearer the core+ * genuinely rejects does not loop.+ */+ private async retryRejectedHandshake(socket: Socket): Promise<void> {+ const used = lastHandshakeToken(socket);+ clearCoreRpcTokenCache();+ const fresh = await getCoreRpcToken();+ if (this.socket === socket && fresh && fresh !== used) {+ socketLog('Core rejected the socket bearer; reconnecting with the refreshed one');+ socket.connect();+ }+ }+disconnect(): void {const uid = getSocketUserId();if (this.socket) {