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(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((_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(resolve => firstChild.once('exit', () => resolve())), new Promise(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 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) { 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 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 }