559 lines
25 KiB
TypeScript
559 lines
25 KiB
TypeScript
import { mkdtemp, rm } from 'node:fs/promises'
|
|
import { tmpdir } from 'node:os'
|
|
import { join } from 'node:path'
|
|
import { Context } from '@deepseek-ai/cordis'
|
|
import { afterEach, describe, expect, it, vi } from 'vitest'
|
|
import * as remotePlugin from '../src/index.js'
|
|
import type { Config } from '../src/config.js'
|
|
import type { ControlRouteHandler } from '../src/control-route.js'
|
|
|
|
const directories: string[] = []
|
|
const disabledAgentDomains = { codex: { enabled: false }, acp: { enabled: false } }
|
|
|
|
afterEach(async () => {
|
|
vi.unstubAllEnvs()
|
|
vi.unstubAllGlobals()
|
|
await Promise.all(directories.splice(0).map(directory => rm(directory, { recursive: true, force: true })))
|
|
})
|
|
|
|
describe('Cordis plugin lifecycle', () => {
|
|
it('migrates only owned legacy entries without disabling an unrelated plugin', async () => {
|
|
const dshHome = await mkdtemp(join(tmpdir(), 'dsh-remote-legacy-ownership-'))
|
|
directories.push(dshHome)
|
|
vi.stubEnv('DSH_HOME', dshHome)
|
|
vi.stubGlobal('fetch', vi.fn(async () => { throw new Error('offline fixture') }))
|
|
const entries = [
|
|
{ id: 'current', options: { id: 'current', name: '@dsh-remote/plugin', disabled: false } },
|
|
{ id: 'foreign', options: { id: 'foreign', name: 'dsh-remote', disabled: false } },
|
|
{ id: 'foreign-null', options: { id: 'foreign-null', name: 'dsh-remote', disabled: null } },
|
|
{ id: 'foreign-disabled', options: { id: 'foreign-disabled', name: 'dsh-remote', disabled: true } },
|
|
{ id: 'owned', options: { id: 'owned', name: '@dsh-remote/plugin', disabled: false } },
|
|
{ id: 'owned-disabled', options: { id: 'owned-disabled', name: '@dsh-remote/plugin', disabled: true } },
|
|
{ id: 'other', options: { id: 'other', name: 'another-plugin', disabled: false } },
|
|
]
|
|
const update = vi.fn(async (id: string, options: { disabled?: boolean | null }) => {
|
|
Object.assign(entries.find(entry => entry.id === id)!.options, options)
|
|
})
|
|
const ctx = new Context()
|
|
ctx.provide('loader', { locate: () => 'current', entries: () => entries, update } as never)
|
|
ctx.provide('settings', settings({ deviceName: 'Cordis ownership test host' }))
|
|
ctx.provide('typertGateway', typertGateway())
|
|
ctx.provide('connection', connection())
|
|
const fiber = await ctx.plugin(remotePlugin, { ...disabledAgentDomains, deviceName: 'Cordis ownership test host' })
|
|
try {
|
|
await vi.waitFor(() => expect(ctx.dshRemote.currentIdentity()).toBeDefined())
|
|
expect(update.mock.calls).toEqual([['owned', { disabled: true }]])
|
|
expect(entries.map(entry => [entry.id, entry.options.disabled])).toEqual([
|
|
['current', false], ['foreign', false], ['foreign-null', null], ['foreign-disabled', true],
|
|
['owned', true], ['owned-disabled', true], ['other', false],
|
|
])
|
|
} finally {
|
|
await fiber.dispose()
|
|
await ctx.fiber.dispose()
|
|
}
|
|
})
|
|
|
|
it('keeps the entry Config on a registry that resolves a registration without a stored section', async () => {
|
|
const dshHome = await mkdtemp(join(tmpdir(), 'dsh-remote-legacy-registry-'))
|
|
directories.push(dshHome)
|
|
vi.stubEnv('DSH_HOME', dshHome)
|
|
vi.stubGlobal('fetch', vi.fn(async () => { throw new Error('offline fixture') }))
|
|
const config: Config = {
|
|
...disabledAgentDomains,
|
|
serverUrl: 'https://legacy.example.com',
|
|
loopback: { ports: [8080] },
|
|
acp: { enabled: true },
|
|
}
|
|
// `dsh-settings@0.2.1-rc.3` resolves a registration as
|
|
// `schema(mergeLayers(base, user))`; a plugin with no stored section has no
|
|
// override layer, and `mergeLayers` then returns that layer unchanged, so
|
|
// `base` never reaches the schema. The registry also calls the schema
|
|
// directly, so a volatile entry schema resolves to a `{ get }` accessor.
|
|
let registerSchema: ((input?: unknown) => unknown) | undefined
|
|
let resolvedFromSchema: unknown
|
|
const register = vi.fn((_ns: string, schema: (input?: unknown) => unknown, options?: { validate?: (value: unknown) => void }) => {
|
|
registerSchema = schema
|
|
resolvedFromSchema = schema(undefined)
|
|
options?.validate?.(resolvedFromSchema)
|
|
return { get: () => resolvedFromSchema, replace: async () => undefined }
|
|
})
|
|
const ctx = new Context()
|
|
ctx.provide('settings', { register } as never)
|
|
ctx.provide('typertGateway', typertGateway())
|
|
ctx.provide('connection', connection())
|
|
const fiber = await ctx.plugin(remotePlugin, config)
|
|
try {
|
|
await vi.waitFor(() => { expect(ctx.get('dshRemote')).toBeDefined() })
|
|
expect(register).toHaveBeenCalledOnce()
|
|
expect(ctx.dshRemoteClient.status().serverUrl).toBe('https://legacy.example.com')
|
|
// Nested entry Config must survive: schemastery resolves `loopback` and
|
|
// `acp` to default-only containers, which previously overwrote the entry
|
|
// Config when it was merged as a flat layer on read.
|
|
expect(resolvedFromSchema).toMatchObject({ loopback: { ports: [8080] }, acp: { enabled: true } })
|
|
// A stored section still wins, including an explicit reset to an empty list.
|
|
expect(registerSchema?.({ loopback: { ports: [] } })).toMatchObject({ loopback: { ports: [] } })
|
|
} finally {
|
|
await fiber.dispose()
|
|
await ctx.fiber.dispose()
|
|
}
|
|
})
|
|
|
|
it('switches Server authority live and cancels discovery belonging to the old Server', async () => {
|
|
const dshHome = await mkdtemp(join(tmpdir(), 'dsh-remote-server-switch-'))
|
|
directories.push(dshHome)
|
|
vi.stubEnv('DSH_HOME', dshHome)
|
|
let config: Config = { ...disabledAgentDomains, serverUrl: 'https://old.example.com' }
|
|
let handler!: ControlRouteHandler
|
|
let oldRequestSignal: AbortSignal | null | undefined
|
|
const requests: string[] = []
|
|
vi.stubGlobal('fetch', vi.fn<typeof fetch>(async (input, init) => {
|
|
const url = String(input)
|
|
requests.push(url)
|
|
if (url === 'https://old.example.com/api/v1/auth/oauth/providers') {
|
|
oldRequestSignal = init?.signal
|
|
return new Promise<Response>((_resolve, reject) => {
|
|
oldRequestSignal!.addEventListener('abort', () => reject(oldRequestSignal!.reason), { once: true })
|
|
})
|
|
}
|
|
if (url === 'https://new.example.com/api/v1/auth/oauth/providers') {
|
|
return Response.json({ items: [{ id: 'github', displayName: 'GitHub',
|
|
startUrl: '/api/v1/auth/oauth/github/start', qrStartUrl: '/api/v1/auth/oauth/qr/start?provider=github' }] })
|
|
}
|
|
return Response.json({ error: { code: 'AUTHORIZATION_REQUIRED', message: 'Sign in required' } }, { status: 401 })
|
|
}))
|
|
const ctx = new Context()
|
|
ctx.provide('settings', { register: () => ({
|
|
get: () => config, replace: async (value: Config) => { config = value },
|
|
}) } as never)
|
|
ctx.provide('typertGateway', typertGateway())
|
|
ctx.provide('connection', { rpc: { handle: (_channel: string, value: ControlRouteHandler) => {
|
|
handler = value
|
|
return async () => undefined
|
|
} } } as never)
|
|
const fiber = await ctx.plugin(remotePlugin, config)
|
|
const call = (endpoint: string, payload: unknown = {}) => handler(endpoint, payload, new AbortController().signal)
|
|
try {
|
|
await vi.waitFor(() => { expect(ctx.dshRemoteClient.status().serverUrl).toBe(config.serverUrl) })
|
|
const oldHost = ctx.dshRemote, oldClient = ctx.dshRemoteClient
|
|
const hostClose = vi.spyOn(oldHost, 'close'), clientClose = vi.spyOn(oldClient, 'close')
|
|
const pending = call('client.account.providers')
|
|
await vi.waitFor(() => { expect(oldRequestSignal).toBeDefined() })
|
|
await expect(call('settings.server.set', { serverUrl: 'https://new.example.com/' })).resolves.toMatchObject({
|
|
ok: true, value: { config: { serverUrl: 'https://new.example.com' }, applies: 'live', associations: {} },
|
|
})
|
|
expect(oldRequestSignal?.aborted).toBe(true)
|
|
await expect(pending).resolves.toMatchObject({ ok: false })
|
|
expect(hostClose).toHaveBeenCalledOnce()
|
|
expect(clientClose).toHaveBeenCalledOnce()
|
|
expect(ctx.dshRemote).not.toBe(oldHost)
|
|
expect(ctx.dshRemoteClient).not.toBe(oldClient)
|
|
expect(ctx.dshRemote.currentIdentity().deviceId).not.toBe(oldHost.currentIdentity().deviceId)
|
|
await expect(call('status')).resolves.toMatchObject({ ok: true, value: { serverUrl: 'https://new.example.com' } })
|
|
await expect(call('client.account.providers')).resolves.toMatchObject({ ok: true, value: [{ id: 'github' }] })
|
|
const newHost = ctx.dshRemote
|
|
await call('settings.server.set', { serverUrl: 'https://new.example.com' })
|
|
expect(ctx.dshRemote).toBe(newHost)
|
|
expect(requests.filter(url => url === 'https://new.example.com/api/v1/auth/oauth/providers')).toHaveLength(1)
|
|
} finally {
|
|
await fiber.dispose()
|
|
await ctx.fiber.dispose()
|
|
}
|
|
})
|
|
|
|
it('does not block Harness startup while runtime services are unavailable', async () => {
|
|
const ctx = new Context()
|
|
const fiber = await ctx.plugin(remotePlugin, { ...disabledAgentDomains, deviceName: 'Cordis pending host' })
|
|
|
|
expect(fiber.state).toBe(2)
|
|
expect(fiber.inject).toEqual({})
|
|
expect(ctx.get('dshRemote')).toBeUndefined()
|
|
|
|
await fiber.dispose()
|
|
await ctx.fiber.dispose()
|
|
})
|
|
|
|
it('automatically migrates storage on upgrade before loading Typert and disposes its runtime', async () => {
|
|
const dshHome = await mkdtemp(join(tmpdir(), 'dsh-remote-cordis-'))
|
|
directories.push(dshHome)
|
|
vi.stubEnv('DSH_HOME', dshHome)
|
|
|
|
const original = await new remotePlugin.IdentityStore({ directory: join(dshHome, 'remote') }).loadOrCreate('Cordis test host')
|
|
|
|
const ctx = new Context()
|
|
let identityReadyWhenControlRegistered: boolean | undefined
|
|
ctx.provide('settings', settings({ deviceName: 'Cordis test host' }))
|
|
ctx.provide('typertGateway', typertGateway())
|
|
ctx.provide('connection', connection(() => {
|
|
try {
|
|
ctx.dshRemote.currentIdentity()
|
|
identityReadyWhenControlRegistered = true
|
|
} catch {
|
|
identityReadyWhenControlRegistered = false
|
|
}
|
|
}))
|
|
const fiber = await ctx.plugin(remotePlugin, { ...disabledAgentDomains, deviceName: 'Cordis test host' })
|
|
|
|
await vi.waitFor(() => {
|
|
expect(ctx.dshRemote.currentIdentity()).toMatchObject({ name: 'Cordis test host' })
|
|
expect(ctx.dshRemote.diagnostics()).toMatchObject({
|
|
loaded: true,
|
|
capabilities: expect.arrayContaining(['harness.remote.v1', 'harness.remote.transfer.v1']),
|
|
})
|
|
})
|
|
expect(ctx.dshRemote.currentIdentity()).toEqual(original)
|
|
|
|
expect(identityReadyWhenControlRegistered).toBe(false)
|
|
|
|
await fiber.dispose()
|
|
expect(ctx.get('dshRemote')).toBeUndefined()
|
|
await ctx.fiber.dispose()
|
|
})
|
|
|
|
it('migrates legacy storage with interrupted credential temp files and dead lock, then refreshes expired Host accessToken on startup', async () => {
|
|
const dshHome = await mkdtemp(join(tmpdir(), 'dsh-remote-367-upgrade-'))
|
|
directories.push(dshHome)
|
|
vi.stubEnv('DSH_HOME', dshHome)
|
|
|
|
const serverUrl = 'https://dsh.r2049.cn'
|
|
const legacyRoot = join(dshHome, 'remote')
|
|
const hostDir = remotePlugin.serverStorageDirectory(legacyRoot, serverUrl, 'host')
|
|
const clientDir = remotePlugin.serverStorageDirectory(legacyRoot, serverUrl, 'client')
|
|
const hostStore = new remotePlugin.IdentityStore({ directory: hostDir, role: 'host' })
|
|
const hostIdentity = await hostStore.loadOrCreate('Host')
|
|
const clientIdentity = await new remotePlugin.IdentityStore({ directory: clientDir, role: 'client' }).loadOrCreate('Client')
|
|
const trustedPeer = await hostStore.trustPeer({
|
|
deviceId: clientIdentity.deviceId,
|
|
name: 'Client',
|
|
platform: 'linux',
|
|
publicKey: clientIdentity.publicKey,
|
|
})
|
|
const now = Date.now()
|
|
await new remotePlugin.ServerCredentialStore(hostDir).save({
|
|
serverUrl,
|
|
deviceId: hostIdentity.deviceId,
|
|
authorizationMethod: 'account',
|
|
account: 'host@example.com',
|
|
accessToken: 'expired-access-token-0000',
|
|
accessTokenExpiresAt: now - 345_000,
|
|
refreshToken: 'valid-refresh-token-0000',
|
|
refreshTokenExpiresAt: now + 86_400_000,
|
|
})
|
|
const { readFile, writeFile } = await import('node:fs/promises')
|
|
const { createHash } = await import('node:crypto')
|
|
const { spawn } = await import('node:child_process')
|
|
const firstChild = spawn(process.execPath, ['-e', 'setTimeout(() => {}, 50)'], { stdio: 'ignore' })
|
|
const secondChild = spawn(process.execPath, ['-e', ''], { stdio: 'ignore' })
|
|
await Promise.all([
|
|
new Promise<void>(resolve => firstChild.once('exit', () => resolve())),
|
|
new Promise<void>(resolve => secondChild.once('exit', () => resolve())),
|
|
])
|
|
const exitedOwnerPid = firstChild.pid!
|
|
const exitedTakeoverPid = secondChild.pid!
|
|
const lockRecord = `${exitedOwnerPid}\n`
|
|
const takeoverName = `device.lock.takeover-${createHash('sha256').update(lockRecord).digest('hex').slice(0, 16)}`
|
|
const hostDeviceBytes = await readFile(join(hostDir, 'device.json'))
|
|
const hostKeyBytes = await readFile(join(hostDir, 'device.key'))
|
|
const hostPeersBytes = await readFile(join(hostDir, 'trusted-peers.json'))
|
|
await writeFile(join(hostDir, `server-credentials.json.${exitedOwnerPid}.01a1b6d8-e8b5-7000-8000-000000000002.tmp`), '{partial', { mode: 0o600 })
|
|
await writeFile(join(hostDir, 'device.lock'), lockRecord, { mode: 0o600 })
|
|
await writeFile(join(hostDir, takeoverName), `${exitedTakeoverPid}\n`, { mode: 0o600 })
|
|
|
|
const refreshedAccessToken = 'refreshed-access-token-1111'
|
|
const refreshedExpiresAt = now + 597_000
|
|
const refreshCalls: string[] = []
|
|
vi.stubGlobal('fetch', vi.fn(async (input: string | URL | Request) => {
|
|
const url = typeof input === 'string' ? input : input instanceof URL ? input.toString() : input.url
|
|
refreshCalls.push(url)
|
|
if (url.endsWith('/api/v1/auth/refresh')) {
|
|
return Response.json({
|
|
accessToken: refreshedAccessToken,
|
|
accessTokenExpiresAt: refreshedExpiresAt,
|
|
refreshToken: 'valid-refresh-token-1111',
|
|
refreshTokenExpiresAt: now + 86_400_000,
|
|
})
|
|
}
|
|
return Response.json({ items: [] })
|
|
}))
|
|
|
|
const ctx = new Context()
|
|
ctx.provide('settings', settings({ deviceName: 'Host', serverUrl }))
|
|
ctx.provide('typertGateway', typertGateway())
|
|
ctx.provide('connection', connection())
|
|
const fiber = await ctx.plugin(remotePlugin, { ...disabledAgentDomains, deviceName: 'Host', serverUrl })
|
|
try {
|
|
const migratedHostDir = remotePlugin.serverStorageDirectory(join(dshHome, 'ds-harness-remote'), serverUrl, 'host')
|
|
await vi.waitFor(async () => {
|
|
expect(refreshCalls.some(url => url.endsWith('/api/v1/auth/refresh'))).toBe(true)
|
|
const updated = await new remotePlugin.ServerCredentialStore(migratedHostDir).load(serverUrl, hostIdentity.deviceId)
|
|
expect(updated?.accessToken).toBe(refreshedAccessToken)
|
|
expect(updated?.accessTokenExpiresAt).toBe(refreshedExpiresAt)
|
|
}, { timeout: 5_000 })
|
|
expect(ctx.dshRemote.currentIdentity()).toEqual(hostIdentity)
|
|
expect(await readFile(join(migratedHostDir, 'device.json'))).toEqual(hostDeviceBytes)
|
|
expect(await readFile(join(migratedHostDir, 'device.key'))).toEqual(hostKeyBytes)
|
|
expect(await readFile(join(migratedHostDir, 'trusted-peers.json'))).toEqual(hostPeersBytes)
|
|
const reloadedStore = new remotePlugin.IdentityStore({ directory: migratedHostDir, role: 'host' })
|
|
await reloadedStore.loadOrCreate('Host')
|
|
expect(reloadedStore.listTrustedPeers()).toEqual([trustedPeer])
|
|
} finally {
|
|
await fiber.dispose()
|
|
await ctx.fiber.dispose()
|
|
}
|
|
})
|
|
|
|
it('waits for Desktop connection before activating even when Typert is ready', async () => {
|
|
const dshHome = await mkdtemp(join(tmpdir(), 'dsh-remote-late-connection-'))
|
|
directories.push(dshHome)
|
|
vi.stubEnv('DSH_HOME', dshHome)
|
|
|
|
const ctx = new Context()
|
|
const handle = vi.fn(() => async () => undefined)
|
|
ctx.provide('settings', settings({ deviceName: 'Cordis delayed connection host' }))
|
|
ctx.provide('typertGateway', typertGateway())
|
|
const fiber = await ctx.plugin(remotePlugin, { ...disabledAgentDomains, deviceName: 'Cordis delayed connection host' })
|
|
|
|
expect(ctx.get('dshRemote')).toBeUndefined()
|
|
ctx.provide('connection', { rpc: { handle } } as never)
|
|
await vi.waitFor(() => {
|
|
expect(ctx.dshRemote.currentIdentity()).toMatchObject({ name: 'Cordis delayed connection host' })
|
|
})
|
|
expect(handle).toHaveBeenCalledWith('/ds-harness-remote', expect.any(Function), {
|
|
authority: 'loopback',
|
|
})
|
|
|
|
await fiber.dispose()
|
|
expect(ctx.get('dshRemote')).toBeUndefined()
|
|
await ctx.fiber.dispose()
|
|
})
|
|
|
|
it('keeps a carrier-less Desktop unavailable even when legacy ApiProxy is provided', async () => {
|
|
const dshHome = await mkdtemp(join(tmpdir(), 'dsh-remote-late-apiproxy-'))
|
|
directories.push(dshHome)
|
|
vi.stubEnv('DSH_HOME', dshHome)
|
|
|
|
const ctx = new Context()
|
|
const handlers: Array<{
|
|
channel: string
|
|
handler: (endpoint: string, payload: unknown, signal: AbortSignal) => Promise<unknown>
|
|
disposed: boolean
|
|
}> = []
|
|
ctx.provide('settings', settings({ deviceName: 'Cordis delayed rc.2 host' }))
|
|
ctx.provide('typertGateway', { invoke: vi.fn() } as never)
|
|
ctx.provide('connection', {
|
|
rpc: {
|
|
handle: vi.fn((channel: string, handler: typeof handlers[number]['handler']) => {
|
|
const entry = { channel, handler, disposed: false }
|
|
handlers.push(entry)
|
|
return async () => { entry.disposed = true }
|
|
}),
|
|
},
|
|
} as never)
|
|
const fiber = await ctx.plugin(remotePlugin, { ...disabledAgentDomains, deviceName: 'Cordis delayed rc.2 host' })
|
|
|
|
expect(ctx.get('dshRemote')).toBeUndefined()
|
|
await vi.waitFor(() => expect(handlers).toHaveLength(1))
|
|
expect(handlers[0]?.channel).toBe('/ds-harness-remote')
|
|
await expect(handlers[0]?.handler('status', {}, new AbortController().signal)).resolves.toMatchObject({
|
|
ok: true,
|
|
value: {
|
|
mode: 'local',
|
|
available: false,
|
|
hostAuthorizationAvailable: false,
|
|
},
|
|
})
|
|
ctx.provide('apiProxy', {} as never)
|
|
await new Promise(resolve => setTimeout(resolve, 0))
|
|
expect(ctx.get('dshRemote')).toBeUndefined()
|
|
expect(handlers[0]?.disposed).toBe(false)
|
|
|
|
await fiber.dispose()
|
|
expect(ctx.get('dshRemote')).toBeUndefined()
|
|
await ctx.fiber.dispose()
|
|
})
|
|
|
|
it('keeps loopback control alive when legacy storage has a credentialed corrupt client and recovers live on reset', async () => {
|
|
const dshHome = await mkdtemp(join(tmpdir(), 'dsh-remote-corrupt-recovery-'))
|
|
directories.push(dshHome)
|
|
vi.stubEnv('DSH_HOME', dshHome)
|
|
vi.stubGlobal('fetch', vi.fn(async () => Response.json(
|
|
{ error: { code: 'AUTHORIZATION_REQUIRED', message: 'Sign in required' } },
|
|
{ status: 401 },
|
|
)))
|
|
|
|
const serverUrl = 'https://dsh.r2049.cn'
|
|
const legacyRoot = join(dshHome, 'remote')
|
|
const hostDir = remotePlugin.serverStorageDirectory(legacyRoot, serverUrl, 'host')
|
|
const clientDir = remotePlugin.serverStorageDirectory(legacyRoot, serverUrl, 'client')
|
|
const hostIdentity = await new remotePlugin.IdentityStore({ directory: hostDir, role: 'host' }).loadOrCreate('Host')
|
|
const clientIdentity = await new remotePlugin.IdentityStore({ directory: clientDir, role: 'client' }).loadOrCreate('Client')
|
|
const { writeFile } = await import('node:fs/promises')
|
|
await writeFile(join(clientDir, 'device.key'), 'corrupted-key\n')
|
|
await new remotePlugin.ServerCredentialStore(clientDir).save({
|
|
serverUrl,
|
|
deviceId: clientIdentity.deviceId,
|
|
authorizationMethod: 'owned_device',
|
|
accessToken: 'c'.repeat(24),
|
|
accessTokenExpiresAt: Date.now() + 60_000,
|
|
refreshToken: 'r'.repeat(24),
|
|
refreshTokenExpiresAt: Date.now() + 600_000,
|
|
})
|
|
|
|
let config: Config = { ...disabledAgentDomains, serverUrl }
|
|
let handler!: ControlRouteHandler
|
|
const ctx = new Context()
|
|
ctx.provide('settings', { register: () => ({
|
|
get: () => config,
|
|
replace: async (value: Config) => { config = value },
|
|
}) } as never)
|
|
ctx.provide('typertGateway', typertGateway())
|
|
ctx.provide('connection', { rpc: { handle: (_channel: string, value: ControlRouteHandler) => {
|
|
handler = value
|
|
return async () => undefined
|
|
} } } as never)
|
|
|
|
const fiber = await ctx.plugin(remotePlugin, config)
|
|
const call = (endpoint: string, payload: unknown = {}) => handler(endpoint, payload, new AbortController().signal)
|
|
try {
|
|
await vi.waitFor(() => expect(handler).toBeDefined())
|
|
await expect(call('status')).resolves.toMatchObject({
|
|
ok: true,
|
|
value: {
|
|
available: false,
|
|
controlUnavailable: false,
|
|
startupError: { code: 'IDENTITY_INVALID' },
|
|
},
|
|
})
|
|
await expect(call('settings.identity.reset', { role: 'client' })).resolves.toMatchObject({
|
|
ok: true,
|
|
value: { applies: 'live' },
|
|
})
|
|
expect(ctx.dshRemote.currentIdentity().deviceId).toBe(hostIdentity.deviceId)
|
|
const statusAfter = await call('status')
|
|
expect(statusAfter).toMatchObject({
|
|
ok: true,
|
|
value: {
|
|
available: true,
|
|
identityReady: true,
|
|
},
|
|
})
|
|
expect((statusAfter as { value?: { startupError?: unknown } }).value?.startupError).toBeUndefined()
|
|
} finally {
|
|
await fiber.dispose()
|
|
await ctx.fiber.dispose()
|
|
}
|
|
})
|
|
|
|
it('registers loopback control, remote tools, and live Server switching when another plugin already provides dshRemote services', async () => {
|
|
const dshHome = await mkdtemp(join(tmpdir(), 'dsh-remote-service-conflict-'))
|
|
directories.push(dshHome)
|
|
vi.stubEnv('DSH_HOME', dshHome)
|
|
vi.stubGlobal('fetch', vi.fn(async () => Response.json(
|
|
{ error: { code: 'AUTHORIZATION_REQUIRED', message: 'Sign in required' } },
|
|
{ status: 401 },
|
|
)))
|
|
|
|
let config: Config = { ...disabledAgentDomains, serverUrl: 'https://old.example.com' }
|
|
let handler: ControlRouteHandler | undefined
|
|
const registeredTools: string[] = []
|
|
const foreignHostService = { apiVersion: 1 }
|
|
const foreignClientService = { foreignClient: true }
|
|
|
|
const ctx = new Context()
|
|
ctx.provide('settings', { register: () => ({
|
|
get: () => config,
|
|
replace: async (value: Config) => { config = value },
|
|
}) } as never)
|
|
ctx.provide('typertGateway', typertGateway())
|
|
ctx.provide('connection', { rpc: { handle: (_channel: string, value: ControlRouteHandler) => {
|
|
handler = value
|
|
return async () => undefined
|
|
} } } as never)
|
|
ctx.provide('tools', {
|
|
register: (tool: { name: string }) => {
|
|
registeredTools.push(tool.name)
|
|
return () => undefined
|
|
},
|
|
} as never)
|
|
|
|
const foreignFiber = await ctx.plugin({
|
|
name: 'dsh-remote',
|
|
apply(peerCtx: Context) {
|
|
peerCtx.provide('dshRemote', foreignHostService as never)
|
|
peerCtx.provide('dshRemoteClient', foreignClientService as never)
|
|
},
|
|
})
|
|
const fiber = await ctx.plugin(remotePlugin, config)
|
|
const call = (endpoint: string, payload: unknown = {}) => handler!(endpoint, payload, new AbortController().signal)
|
|
try {
|
|
await vi.waitFor(() => {
|
|
expect(handler).toBeDefined()
|
|
expect(registeredTools).toContain('remote_list_hosts')
|
|
})
|
|
expect(ctx.get('dshRemote')).toBe(foreignHostService)
|
|
expect(ctx.get('dshRemoteClient')).toBe(foreignClientService)
|
|
await expect(call('status')).resolves.toMatchObject({
|
|
ok: true,
|
|
value: {
|
|
available: true,
|
|
serverUrl: 'https://old.example.com',
|
|
},
|
|
})
|
|
await expect(call('settings.server.set', { serverUrl: 'https://new.example.com/' })).resolves.toMatchObject({
|
|
ok: true,
|
|
value: {
|
|
config: { serverUrl: 'https://new.example.com' },
|
|
applies: 'live',
|
|
},
|
|
})
|
|
expect(ctx.get('dshRemote')).toBe(foreignHostService)
|
|
expect(ctx.get('dshRemoteClient')).toBe(foreignClientService)
|
|
|
|
await foreignFiber.dispose()
|
|
await expect(call('settings.server.set', { serverUrl: 'https://third.example.com/' })).resolves.toMatchObject({
|
|
ok: true,
|
|
value: {
|
|
config: { serverUrl: 'https://third.example.com' },
|
|
applies: 'live',
|
|
},
|
|
})
|
|
expect(ctx.dshRemote.currentIdentity()).toBeDefined()
|
|
expect(ctx.dshRemoteClient.status().serverUrl).toBe('https://third.example.com')
|
|
} finally {
|
|
await fiber.dispose()
|
|
await foreignFiber.dispose()
|
|
await ctx.fiber.dispose()
|
|
}
|
|
})
|
|
})
|
|
|
|
function settings(value: Record<string, unknown>) {
|
|
return {
|
|
configure: () => () => undefined,
|
|
// These tests exercise Harness registration/disposal, not installed Agent
|
|
// CLIs. Keep optional processes out of the fixture (including the bundled
|
|
// CodeX fallback, which is discoverable even with an isolated PATH).
|
|
describe: () => [{ ns: 'ds-harness-remote', value: {
|
|
...disabledAgentDomains,
|
|
...value,
|
|
} }],
|
|
replace: vi.fn(async () => undefined),
|
|
} as never
|
|
}
|
|
|
|
type ControlHandler = (endpoint: string, payload: unknown, signal: AbortSignal) => Promise<unknown>
|
|
|
|
function connection(onHandle?: () => void) {
|
|
return {
|
|
rpc: {
|
|
handle: vi.fn(() => {
|
|
onHandle?.()
|
|
return async () => undefined
|
|
}),
|
|
},
|
|
} as never
|
|
}
|
|
|
|
function typertGateway() {
|
|
return { invoke: vi.fn(async () => undefined), dispatchRpc: vi.fn(async () => ({ ok: true })), openWireStream: vi.fn(async () => (async function* () {})()) } as never
|
|
}
|