diff --git a/packages/plugin/tests/harness-rc1.test.ts b/packages/plugin/tests/harness-rc1.test.ts new file mode 100644 index 0000000..2b307b5 --- /dev/null +++ b/packages/plugin/tests/harness-rc1.test.ts @@ -0,0 +1,114 @@ +import { Context } from '@deepseek-ai/cordis' +import { Peer } from '@deepseek-ai/dsh-client-connection' +import Gateway from '@deepseek-ai/dsh-api-gateway' +import RemoteAccess from '@deepseek-ai/dsh-api-remote-access' +import Registry from '@deepseek-ai/dsh-typert-registry' +import { describe, expect, it, vi } from 'vitest' +import { z } from 'zod' +import { HarnessRemoteBridge } from '../src/harness-remote-bridge.js' +import { TypertGatewaySwitch } from '../src/typert-gateway-switch.js' +import type { TypertGatewayLike } from '../src/typert-gateway-contract.js' + +// Exercise the installed RC.1 implementation, including its Peer identity check. +describe('Harness RC.1 authenticated carrier', () => { + it('reports an incomplete Host with the official Gateway and no Remote API packages', async () => { + const ctx = new Context() + try { + await ctx.plugin(Registry).await() + await ctx.plugin(RemoteAccess).await() + await ctx.plugin(Gateway).await() + const gateway = ctx.get('typertGateway') as Gateway + const peer = new Peer(ctx, { principal: { kind: 'owner' }, interactions: 'answer' }) + const local = new TypertGatewaySwitch(gateway as unknown as TypertGatewayLike).local(peer) + expect(await local.dispatch('session/list', { args: { _request: {} } }, new AbortController().signal)) + .toMatchObject({ ok: false, error: { code: 'gateway/invocation-unavailable' } }) + const publish = vi.fn(async () => undefined) + const warn = vi.fn() + const bridge = new HarnessRemoteBridge(local, publish, { warn } as never) + await bridge.openStream({ streamId: 'missing-events', endpoint: '$events', payload: { args: {} } }) + await vi.waitFor(() => expect(publish).toHaveBeenCalledWith('harness.remote.stream.closed', { + streamId: 'missing-events', reason: 'failed', + failure: expect.objectContaining({ code: 'gateway/service-unavailable' }), + })) + expect(warn).toHaveBeenCalledOnce() + expect(warn).toHaveBeenCalledWith(expect.stringContaining('Install @deepseek-ai/dsh-api-remotes')) + expect(publish).not.toHaveBeenCalledWith('harness.remote.frame', expect.anything()) + await bridge.closeAll() + await peer.dispose() + } finally { await ctx.fiber.dispose() } + }) + + it('calls an active Session API through the official Gateway', async () => { + const ctx = new Context() + try { + await ctx.plugin(Registry).await() + await ctx.plugin(RemoteAccess).await() + await ctx.plugin(Gateway).await() + const list = vi.fn(async (_request: object) => []) + const session = { list } as { list: typeof list; typertRemote?: unknown } + session.typertRemote = { service: session, serviceKey: 'session', namespace: 'session' } + ctx.provide('session', session as never) + ctx.typert.register({ + package: 'session-fixture', face: 'host', schemas: [], + model: { services: [], events: [], objects: [] }, + invocations: [{ + id: 'session-fixture:list', service: 'session', namespace: 'session', method: 'list', + invocation: { kind: 'direct' }, + parameters: [{ name: '_request', wire: '_request', source: 'json', codec: { + mode: 'strict', typeSymbol: 'SessionListRequest', create: () => z.object({ cursor: z.string().optional() }), + } }], + result: { mode: 'src-json' }, + }], + }) + const gateway = ctx.get('typertGateway') as Gateway + const peer = new Peer(ctx, { principal: { kind: 'owner' }, interactions: 'answer' }) + const local = new TypertGatewaySwitch(gateway as unknown as TypertGatewayLike).local(peer) + const signal = new AbortController().signal + expect(await local.dispatch('session/list', { args: {} }, signal)) + .toMatchObject({ ok: false, error: { code: 'gateway/arguments-invalid' } }) + expect(await local.dispatch('session/list', { args: { _request: {} } }, signal)) + .toEqual({ ok: true, value: [] }) + expect(list).toHaveBeenCalledWith({}) + await peer.dispose() + } finally { await ctx.fiber.dispose() } + }) + + it('isolates event replies and ends all carrier access with its admitted Peer', async () => { + const ctx = new Context() + try { + await ctx.plugin(Registry).await() + await ctx.plugin(RemoteAccess).await() + await ctx.plugin(Gateway).await() + const gateway = ctx.get('typertGateway') as Gateway + gateway.registerRemoteEvents(async function* (signal) { + if (!signal.aborted) await new Promise(resolve => signal.addEventListener('abort', () => resolve(), { once: true })) + }, { home: '/fixture' }) + const peerA = new Peer(ctx, { principal: { kind: 'owner' } }) + const peerB = new Peer(ctx, { principal: { kind: 'owner' } }) + const switching = new TypertGatewaySwitch(gateway as unknown as TypertGatewayLike) + const a = switching.local(peerA) + // Creating B after the switch installs must still capture the original Host. + switching.install() + switching.selectRemote({ invoke: async () => { throw new Error('recursion') }, dispatch: async () => { throw new Error('recursion') }, open: async () => { throw new Error('recursion') } }) + const b = switching.local(peerB) + const control = new AbortController() + const streamA = (await a.open('$events', { args: {} }, control.signal))[Symbol.asyncIterator]() + const streamB = (await b.open('$events', { args: {} }, control.signal))[Symbol.asyncIterator]() + const readyA = (await streamA.next()).value as { clientId: string } + await streamB.next() + const payload = { args: { clientId: readyA.clientId, eventId: '00000000-0000-4000-8000-000000000001', outcome: { kind: 'next' } } } + expect(await b.dispatch('$events/result', payload, control.signal)).toMatchObject({ ok: false, error: { code: 'gateway/interactions-forbidden' } }) + const access = (await a.open('remoteAccess/follow', { args: {} }, control.signal))[Symbol.asyncIterator]() + expect((await access.next()).value).toMatchObject({ type: 'baseline', owner: true }) + a.dispose = () => peerA.dispose() + await new HarnessRemoteBridge(a, async () => undefined).closeAll() + expect(await a.dispatch('session/list', { args: {} }, control.signal)).toMatchObject({ ok: false, error: { code: 'gateway/peer-disposed' } }) + await expect(a.invoke({ namespace: 'session', method: 'list', args: {}, peer: peerB })).rejects.toMatchObject({ code: 'gateway/peer-disposed' }) + await expect(a.open('$events', { args: {} }, control.signal)).rejects.toMatchObject({ code: 'gateway/peer-disposed' }) + expect(peerB.signal.aborted).toBe(false) + control.abort() + await Promise.all([streamA.return?.(), streamB.return?.(), access.return?.()]) + switching.restore() + } finally { await ctx.fiber.dispose() } + }) +})