diff --git a/packages/plugin/tests/rpc-router.test.ts b/packages/plugin/tests/rpc-router.test.ts new file mode 100644 index 0000000..78f488a --- /dev/null +++ b/packages/plugin/tests/rpc-router.test.ts @@ -0,0 +1,323 @@ +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) +}