import { runScenarios } from '../../../scripts/test-scenarios.mjs' import { createRpcRequest, type RemoteWorkspaceTypeDescription } from '@dsh-remote/protocol' import { describe, expect, it, vi } from 'vitest' import type { HarnessRemoteBridge } from '../src/harness-remote-bridge.js' import type { RemoteFileViewerBridge } from '../src/file-viewer-bridge.js' import type { SafeLogger } from '../src/logging.js' import { RpcRouter } from '../src/rpc-router.js' import type { PluginRouteBridge } from '../src/plugin-route-bridge.js' import type { CodexPeerBridge } from '../src/codex/peer-bridge.js' describe('RpcRouter', () => { it('rejects every retired ApiProxy entry point without invoking the Typert bridge', async () => { const call = vi.fn() const router = createRouter({ call }) await runScenarios(['call', 'respond', 'stream.open', 'stream.close', 'transfer.open', 'transfer.chunk', 'transfer.commit', 'transfer.read', 'transfer.close'].map(suffix => ({ name: suffix, run: async () => { const result = await router.handle(createRpcRequest(`harness.api.${suffix}` as Parameters[0], {})) expect(result).toMatchObject({ type: 'rpc.error', payload: { code: 'METHOD_NOT_FOUND' } }) }, }))) expect(call).not.toHaveBeenCalled() const description = await router.handle(createRpcRequest('harness.transport.describe', {})) expect((description.payload as { result: { capabilities: string[] } }).result.capabilities.some(value => value.startsWith('harness.api.'))).toBe(false) }) it('forwards only native Typert traffic', async () => { const call = vi.fn(async () => ({ rpcId: 'native-1', result: { ok: true, value: [] } })) const router = createRouter({ call }) const response = await router.handle(createRpcRequest('harness.remote.call', { endpoint: 'session/list', payload: { args: {} }, })) expect(call).toHaveBeenCalledWith({ endpoint: 'session/list', payload: { args: {} } }) expect(response).toMatchObject({ type: 'rpc.response', payload: { result: { rpcId: 'native-1' } } }) const legacy = await router.handle({ v: 1, id: 'legacy-1', type: 'rpc.request', timestamp: Date.now(), payload: { method: 'sessions.list', params: {} }, }) expect(legacy).toMatchObject({ type: 'rpc.error', payload: { code: 'METHOD_NOT_FOUND' } }) const unknown = await router.handle({ v: 1, id: 'unknown-1', type: 'rpc.request', timestamp: Date.now(), payload: { method: 'shell.exec', params: {} }, }) expect(unknown).toMatchObject({ type: 'rpc.error', payload: { code: 'METHOD_NOT_FOUND' } }) }) it('describes only the Host transports available on this encrypted connection', async () => { const capabilities = () => ['transport.relay', 'harness.remote.v1'] const router = createRouter({}, undefined, undefined, capabilities) const response = await router.handle(createRpcRequest('harness.transport.describe', {})) expect(response).toMatchObject({ type: 'rpc.response', payload: { result: { capabilities: ['transport.relay', 'harness.remote.v1', 'remote.history.compact.v1'] } }, }) const invalid = await router.handle(createRpcRequest('harness.transport.describe', { extra: true })) expect(invalid).toMatchObject({ type: 'rpc.error', payload: { code: 'INVALID_MESSAGE' } }) }) it('closes native streams with the peer connection', async () => { const closeAll = vi.fn(async () => undefined) const router = createRouter({ closeAll }) await router.closePeerStreams() expect(closeAll).toHaveBeenCalledOnce() }) it('routes only the explicit bounded Harness API transfer operations', async () => { const openTransfer = vi.fn(() => ({ opened: true, transferId: 'image-1' })) const appendTransfer = vi.fn(() => ({ accepted: true, transferId: 'image-1', index: 0 })) const router = createRouter({ openTransfer, appendTransfer }) const opened = await router.handle(createRpcRequest('harness.remote.transfer.open', { transferId: 'image-1', totalBytes: 3, totalChunks: 1, })) const chunked = await router.handle(createRpcRequest('harness.remote.transfer.chunk', { transferId: 'image-1', index: 0, data: 'YWJj', })) expect(openTransfer).toHaveBeenCalledOnce() expect(appendTransfer).toHaveBeenCalledOnce() expect(opened).toMatchObject({ type: 'rpc.response', payload: { result: { opened: true } } }) expect(chunked).toMatchObject({ type: 'rpc.response', payload: { result: { accepted: true } } }) }) it('routes only the explicit File Viewer call through its bridge', async () => { const fileViewer = { call: vi.fn(async () => ({ exists: true })) } as unknown as RemoteFileViewerBridge const router = createRouter({}, fileViewer) const response = await router.handle({ v: 1, id: 'fileviewer-request', type: 'rpc.request', timestamp: Date.now(), payload: { method: 'fileviewer.call', params: { endpoint: 'stat', payload: { path: '/workspace/report.md' } } }, }) expect(fileViewer.call).toHaveBeenCalledWith({ endpoint: 'stat', payload: { path: '/workspace/report.md' } }) expect(response).toMatchObject({ type: 'rpc.response', payload: { result: { exists: true } } }) }) it('does not log errors returned by Host bridges', async () => { const secret = 'prompt=/home/user/private.ts token=sk-secret' const logger = { debug: vi.fn(), info: vi.fn(), warn: vi.fn(), error: vi.fn(), } as unknown as SafeLogger const router = createRouter({ call: vi.fn(async () => { throw new Error(secret) }) }, undefined, logger) const response = await router.handle(createRpcRequest('harness.remote.call', { method: 'session.list', rpcId: 'native-secret', payload: {}, })) expect(response).toMatchObject({ type: 'rpc.error', payload: { code: 'INTERNAL_ERROR' } }) expect(logger.warn).toHaveBeenCalledWith('host rpc failed', expect.objectContaining({ method: 'harness.remote.call', code: 'INTERNAL_ERROR', })) expect(JSON.stringify(vi.mocked(logger.warn).mock.calls)).not.toContain(secret) }) it('routes Codex only through the optional independent domain bridge', async () => { const call = vi.fn(async () => ({ data: [] })) const closeAll = vi.fn(async () => undefined) const codex = { call, closeAll } as unknown as CodexPeerBridge const router = createRouter({}, undefined, undefined, () => ['codex.appserver.v1'], codex) const response = await router.handle(createRpcRequest('codex.app.call', { method: 'thread/list', params: {}, })) expect(call).toHaveBeenCalledWith({ method: 'thread/list', params: {} }) expect(response).toMatchObject({ type: 'rpc.response', payload: { result: { data: [] } } }) await router.closePeerStreams() expect(closeAll).toHaveBeenCalledOnce() const disabled = createRouter() const unavailable = await disabled.handle(createRpcRequest('codex.app.call', { method: 'thread/list', params: {}, })) expect(unavailable).toMatchObject({ type: 'rpc.error', payload: { code: 'FEATURE_NOT_SUPPORTED' } }) }) it('describes workspace types without leaking paths or inventing readiness', async () => { await runScenarios([ { name: 'describes workspace types when supported and avoids leaking project paths or session contents', run: async () => { const capabilities = () => ['transport.relay', 'codex.appserver.v1', 'codex.appserver.transfer.v1'] const workspaceTypes = () => [ { id: 'codex', name: 'CodeX', capability: 'codex.appserver.v1', available: true, projectPath: '/private/workspace', prompt: 'private prompt', fileContent: 'private source', toolOutput: 'private output', }, ] const router = createRouter({}, undefined, undefined, capabilities, undefined, workspaceTypes) const response = await router.handle(createRpcRequest('harness.transport.describe', {})) expect(response).toMatchObject({ type: 'rpc.response', payload: { result: { capabilities: ['transport.relay', 'codex.appserver.v1', 'codex.appserver.transfer.v1', 'remote.history.compact.v1'], workspaceTypes: [ { id: 'codex', name: 'CodeX', capability: 'codex.appserver.v1', available: true, }, ], }, }, }) const result = (response.payload as { result: Record }).result // Guarantee no leaking of project path, prompt, file content, or tool output const serialized = JSON.stringify(result) expect(serialized).not.toMatch( /(\/|\\)Users|(\/|\\)home|prompt|output|projectPath|fileContent|private|cwd/i, ) expect(Object.keys(result)).toEqual(['capabilities', 'workspaceTypes']) const types = result.workspaceTypes as Array> expect(types).toHaveLength(1) expect(Object.keys(types[0])).toEqual(['id', 'name', 'capability', 'available']) }, }, { name: 'omits or returns empty workspace types when CodeX is unavailable or negotiation fails', run: async () => { const router = createRouter( {}, undefined, undefined, () => ['transport.relay', 'harness.remote.v1'], undefined, () => [], ) const response = await router.handle(createRpcRequest('harness.transport.describe', {})) expect(response).toMatchObject({ type: 'rpc.response', payload: { result: { capabilities: ['transport.relay', 'harness.remote.v1', 'remote.history.compact.v1'], workspaceTypes: [], }, }, }) }, }, { name: 'preserves legacy capability declaration when workspaceTypes provider is omitted', run: async () => { const router = createRouter({}, undefined, undefined, () => ['transport.relay', 'codex.appserver.v1']) const response = await router.handle(createRpcRequest('harness.transport.describe', {})) expect(response).toMatchObject({ type: 'rpc.response', payload: { result: { capabilities: ['transport.relay', 'codex.appserver.v1', 'remote.history.compact.v1'], }, }, }) expect( (response.payload as { result: Record }).result.workspaceTypes, ).toBeUndefined() }, }, { name: 'safely handles malformed workspaceTypes without crashing the Host', run: async () => { const malformed = () => [ { id: 'codex', name: 'CodeX', capability: 'codex.appserver.v1', available: true }, { id: 123, name: 'Invalid' }, null, 'malformed string entry', ] as unknown as RemoteWorkspaceTypeDescription[] const router = createRouter( {}, undefined, undefined, () => ['codex.appserver.v1'], undefined, malformed, ) const response = await router.handle(createRpcRequest('harness.transport.describe', {})) expect(response).toMatchObject({ type: 'rpc.response', payload: { result: { capabilities: ['codex.appserver.v1', 'remote.history.compact.v1'], workspaceTypes: [ { id: 'codex', name: 'CodeX', capability: 'codex.appserver.v1', available: true, }, ], }, }, }) const throwing = () => { throw new Error('Querying workspace types failed') } const throwingRouter = createRouter( {}, undefined, undefined, () => ['codex.appserver.v1'], undefined, throwing, ) const throwingResponse = await throwingRouter.handle( createRpcRequest('harness.transport.describe', {}), ) expect(throwingResponse).toMatchObject({ type: 'rpc.response', payload: { result: { capabilities: ['codex.appserver.v1', 'remote.history.compact.v1'], workspaceTypes: [], }, }, }) }, }, ]) }, 20000) it('routes plugin.route.call only when the Host provides the bridge', async () => { const call = vi.fn(async () => ({ status: 200, json: { ok: true } })) const pluginRoute = { call } as unknown as PluginRouteBridge const router = createRouter({}, undefined, undefined, () => ['plugin.route.v1'], undefined, undefined, pluginRoute) const response = await router.handle(createRpcRequest('plugin.route.call', { route: 'api/bot', body: {} })) expect(call).toHaveBeenCalledWith({ route: 'api/bot', body: {} }) expect(response).toMatchObject({ type: 'rpc.response', payload: { result: { status: 200, json: { ok: true } } }, }) const disabled = createRouter() const unavailable = await disabled.handle(createRpcRequest('plugin.route.call', { route: 'api/bot', body: {} })) expect(unavailable).toMatchObject({ type: 'rpc.error', payload: { code: 'FEATURE_NOT_SUPPORTED' } }) }) }) function createRouter( overrides: Record = {}, fileViewer?: RemoteFileViewerBridge, logger?: SafeLogger, capabilities?: () => readonly string[], codex?: CodexPeerBridge, workspaceTypes?: () => readonly RemoteWorkspaceTypeDescription[], pluginRoute?: PluginRouteBridge, ): RpcRouter { const bridge = Object.keys(overrides).length === 0 ? undefined : { closeAll: vi.fn(async () => undefined), ...overrides, } as unknown as HarnessRemoteBridge return new RpcRouter(undefined, logger, fileViewer, bridge, capabilities, codex, undefined, undefined, workspaceTypes, pluginRoute) }