Skip to content

The fastest, cheapest, most efficient open-source agent harness. Run more than 500 agents on a $10 VPS.

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.ts
index 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.ts
index 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, 237
expect(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.ts
index 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.ts
index 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) {