diff --git a/packages/plugin/tests/remote-tools.test.ts b/packages/plugin/tests/remote-tools.test.ts new file mode 100644 index 0000000..fa52e2b --- /dev/null +++ b/packages/plugin/tests/remote-tools.test.ts @@ -0,0 +1,127 @@ +import { mkdtemp, rm } from 'node:fs/promises' +import { tmpdir } from 'node:os' +import { join } from 'node:path' +import { afterEach, describe, expect, it, vi } from 'vitest' +import { runScenarios } from '../../../scripts/test-scenarios.mjs' +import { ClientModeRuntime } from '../src/client-runtime.js' +import type { ClientConnection } from '../src/client-connection.js' +import type { ConnectedRemote } from '../src/client-runtime-contract.js' +import { resolveConfig } from '../src/config.js' +import { IdentityStore } from '../src/identity-store.js' +import { SafeLogger } from '../src/logging.js' +import type { ClientServerApi } from '../src/server-api.js' +import { remoteDiscoveryTools, type RemoteDiscoveryClient } from '../src/remote-tools.js' + +const cleanups: Array<() => Promise> = [] +async function cleanup() { + for (const dispose of cleanups.splice(0).reverse()) await dispose() + vi.restoreAllMocks() +} +afterEach(cleanup) + +async function fixture() { + const directory = await mkdtemp(join(tmpdir(), 'remote-tools-')) + cleanups.push(() => rm(directory, { recursive: true, force: true })) + const gateway = { invoke: vi.fn(), dispatchRpc: vi.fn(), openWireStream: vi.fn() } + const server = { bindIdentity: vi.fn(), revokeCurrentDevice: vi.fn() } + const runtime = new ClientModeRuntime(resolveConfig({ serverUrl: 'https://example.com' }), + new IdentityStore({ directory }), server as unknown as ClientServerApi, gateway, + new SafeLogger({ debug() {}, info() {}, warn() {}, error() {} }, 'error')) + await runtime.start() + cleanups.push(() => runtime.close()) + const state = runtime as unknown as { connection: ClientConnection; connected?: ConnectedRemote } + return { runtime, state } +} + +describe('Remote discovery authority and lifecycle', () => { + it('projects only online Host metadata and rejects mutation-shaped input before dispatch', async () => { + const client = { + devices: vi.fn(async () => [ + { deviceId: 'online', online: true, name: 'Host', platform: 'linux', membershipId: 'private-membership', identityKey: 'secret' }, + { deviceId: 'offline', online: false, name: 'Offline', platform: 'linux', membershipId: 'member' }, + ]), + discoverToolWorkspaces: vi.fn(), + } + const [hosts, workspaces] = remoteDiscoveryTools(() => client) + const exec = { signal: new AbortController().signal } + expect(await hosts!.execute({}, exec)).toEqual({ hosts: [{ hostId: 'online', name: 'Host', platform: 'linux' }] }) + for (const args of [{ hostId: '' }, { hostId: 'online', method: 'session/create' }, { hostId: 'online', path: '/tmp' }]) { + expect(() => workspaces!.execute(args, exec)).toThrow() + } + expect(client.discoverToolWorkspaces).not.toHaveBeenCalled() + const aborted = AbortSignal.abort() + await expect(workspaces!.execute({ hostId: 'online' }, { signal: aborted })).rejects.toThrow() + expect(client.discoverToolWorkspaces).not.toHaveBeenCalled() + }) + + it('discards stale authority results and never exposes upstream error details', async () => { + await runScenarios(['replace', 'error', 'cancel'].map(action => ({ name: action, run: async () => { + let finish!: (value: never[]) => void + const controller = new AbortController() + let current: RemoteDiscoveryClient | undefined = { + devices: vi.fn(() => action === 'error' ? Promise.reject(new Error('token=secret')) : new Promise(resolve => { finish = resolve })), + discoverToolWorkspaces: vi.fn(), + } + const tool = remoteDiscoveryTools(() => current)[0]! + const pending = tool.execute({}, { signal: controller.signal }) + if (action === 'replace') current = undefined + if (action === 'cancel') controller.abort() + if (action !== 'error') finish([]) + await expect(pending).rejects.toThrow() + await pending.catch(error => expect(String(error)).not.toContain('token=secret')) + } }))) + }) + + it('routes concurrent catalogs to their own temporary carriers and leaves the UI connection intact', async () => { + const { runtime, state } = await fixture() + const ui = { client: { close: vi.fn() }, target: { deviceId: 'ui-host' } } as unknown as ConnectedRemote + state.connected = ui + const carriers: Array<{ close: ReturnType; rpc: ReturnType }> = [] + const connect = vi.spyOn(state.connection, 'connect').mockImplementation(async hostId => { + const client = { + close: vi.fn(async () => undefined), + rpc: vi.fn(async (_method, request) => { + if (request.params.backend === 'cursor') throw new Error('private backend error') + return [{ path: `/${hostId}/project`, title: hostId }] + }), + } + carriers.push(client) + return { client, target: { deviceId: hostId }, features: { antigravity: true, cursor: true } } as unknown as ConnectedRemote + }) + const results = await Promise.all(['host-a', 'host-b'].map(hostId => runtime.discoverToolWorkspaces(hostId, new AbortController().signal))) + for (const [index, hostId] of ['host-a', 'host-b'].entries()) { + expect(results[index]).toEqual({ + workspaces: [{ backend: 'antigravity', workspaceId: `antigravity:cwd:${encodeURIComponent(`/${hostId}/project`)}`, path: `/${hostId}/project`, title: hostId }], + unavailable: [{ backend: 'cursor', code: 'BACKEND_UNAVAILABLE' }], + }) + expect(connect.mock.calls[index]?.[2]).toEqual({ background: true }) + } + for (const carrier of carriers) { + expect(carrier.close).toHaveBeenCalledOnce() + expect(carrier.rpc.mock.calls.every(([method, request]) => method === 'agent.acp.call' && request.method === 'dsh/workspaceList')).toBe(true) + } + expect(state.connected).toBe(ui) + expect(ui.client.close).not.toHaveBeenCalled() + state.connected = undefined + }) + + it('closes late discovery carriers after caller cancellation, sign-out or shutdown', async () => { + await runScenarios(['cancel', 'sign-out', 'shutdown'].map(action => ({ name: action, run: async () => { + const { runtime, state } = await fixture() + let finish!: (remote: ConnectedRemote) => void + vi.spyOn(state.connection, 'connect').mockImplementation(() => new Promise(resolve => { finish = resolve })) + const controller = new AbortController() + const pending = runtime.discoverToolWorkspaces('host', controller.signal) + const rejected = expect(pending).rejects.toThrow() + if (action === 'cancel') controller.abort() + else if (action === 'sign-out') await runtime.clearClientAuthorization() + else await runtime.close() + const close = vi.fn(async () => undefined) + const rpc = vi.fn() + finish({ client: { close, rpc }, features: { antigravity: true } } as unknown as ConnectedRemote) + await rejected + expect(close).toHaveBeenCalledOnce() + expect(rpc).not.toHaveBeenCalled() + } })), cleanup) + }) +})