Import apps/vscode/src/remote.ts
This commit is contained in:
parent
22cf526bf4
commit
e42f399e5a
|
|
@ -0,0 +1,348 @@
|
|||
import { HarnessAlphaClient, RemoteClientCore, probeRemoteHostFeatures } from '@dsh-remote/client-core'
|
||||
import { NoiseIkSession, createNoisePrologue } from '@dsh-remote/crypto'
|
||||
import { SecureMessageCodec, type HarnessApiCallParams } from '@dsh-remote/protocol'
|
||||
import {
|
||||
AdaptiveTransport,
|
||||
stunOnlyIceServers,
|
||||
type RemoteTransport,
|
||||
type RtcIceServer,
|
||||
type SecureHandshakeTransport,
|
||||
} from '@dsh-remote/webrtc'
|
||||
import { ServerApi } from './server-api.js'
|
||||
import type { ChatMessage, DeviceIdentity, DirectoryListing, HistoryEntry, HostDescriptor, ModelSelection, MuxFrame, RemoteHost, RemoteSession, RemoteWorkspace, SessionModels } from './types.js'
|
||||
import { loadNodeRtcFactory } from './werift-rtc.js'
|
||||
|
||||
type NativeResult<T> = { ok: true; value: T } | { ok: false; error: { code: string; message: string } }
|
||||
interface NativeResponse<T> { rpcId: string; result: NativeResult<T> }
|
||||
|
||||
type TransportAttempt = 'direct' | 'turn' | 'relay'
|
||||
|
||||
const DIRECT_WEBRTC_NEGOTIATE_TIMEOUT_MS = 12_000
|
||||
|
||||
export class RemoteConnection {
|
||||
private core?: RemoteClientCore
|
||||
private alpha?: HarnessAlphaClient
|
||||
private host?: RemoteHost
|
||||
private closeMux?: () => Promise<void>
|
||||
private readonly frameHandlers = new Set<(frame: MuxFrame) => void>()
|
||||
private readonly closeHandlers = new Set<() => void>()
|
||||
|
||||
get connectedHost(): RemoteHost | undefined { return this.host }
|
||||
|
||||
async connect(serverUrl: string, identity: DeviceIdentity, host: RemoteHost, accessToken: string, forceRelay: boolean): Promise<void> {
|
||||
await this.close()
|
||||
const wsUrl = new URL('/ws/v1/connect', serverUrl)
|
||||
wsUrl.protocol = wsUrl.protocol === 'https:' ? 'wss:' : 'ws:'
|
||||
const rtcFactory = forceRelay ? undefined : await loadNodeRtcFactory({ routeTargets: [serverUrl] })
|
||||
const server = new ServerApi(serverUrl, accessToken)
|
||||
let webRtcFallback = false
|
||||
const createCore = (attempt: TransportAttempt): RemoteClientCore => {
|
||||
const transport = new AdaptiveTransport(wsUrl.toString(), {
|
||||
role: 'client', deviceId: identity.deviceId, accessToken, targetDeviceId: host.deviceId,
|
||||
// This client has not implemented the authenticated control lease.
|
||||
capabilities: ['transport.lan', 'transport.p2p', 'transport.turn', 'transport.relay', 'transport.relay.attach', 'harness.api.v1'],
|
||||
forceRelay: forceRelay || attempt === 'relay',
|
||||
preferredTransports: preferredTransportsForAttempt(attempt),
|
||||
negotiateTimeoutMs: attempt === 'direct' ? DIRECT_WEBRTC_NEGOTIATE_TIMEOUT_MS : undefined,
|
||||
...(rtcFactory === undefined || attempt === 'relay' ? {} : { rtcFactory }),
|
||||
fetchIceServers: async connectionId => iceServersForAttempt(attempt, await server.turnCredentials(connectionId)),
|
||||
onWebRtcFallback: () => { webRtcFallback = true },
|
||||
})
|
||||
return new RemoteClientCore(new SecureTransport(transport, identity, host), 60_000)
|
||||
}
|
||||
const attempts: TransportAttempt[] = forceRelay || rtcFactory === undefined ? ['relay'] : ['direct', 'turn', 'relay']
|
||||
let core: RemoteClientCore | undefined
|
||||
const prepareCore = (nextCore: RemoteClientCore): void => {
|
||||
this.core = nextCore
|
||||
nextCore.onClose(() => this.handleCoreClose(nextCore))
|
||||
}
|
||||
try {
|
||||
for (const attempt of attempts) {
|
||||
webRtcFallback = false
|
||||
core = createCore(attempt)
|
||||
prepareCore(core)
|
||||
await core.connect()
|
||||
if (attempt === 'relay' || !webRtcFallback) break
|
||||
if (this.core === core) this.core = undefined
|
||||
await core.close()
|
||||
core = undefined
|
||||
}
|
||||
if (core === undefined) throw new Error('Unable to establish a remote transport.')
|
||||
const features = await probeRemoteHostFeatures(core, host.clientVersion)
|
||||
const closeMux = features.remoteGateway
|
||||
? this.openAlphaClient(core, host, features.sessionFormat)
|
||||
: await this.openMuxStream(core)
|
||||
if (this.core !== core) {
|
||||
await closeMux().catch(() => undefined)
|
||||
throw new Error('The remote connection closed during initialization.')
|
||||
}
|
||||
this.closeMux = closeMux
|
||||
this.host = host
|
||||
} catch (error) {
|
||||
if (this.core === core) await this.close()
|
||||
throw error
|
||||
}
|
||||
}
|
||||
|
||||
async sessions(): Promise<RemoteSession[]> {
|
||||
if (this.alpha !== undefined) return this.alpha.sessionList()
|
||||
const result = await this.call<{ items: RemoteSession[] }>('session.list', {})
|
||||
return Array.isArray(result.items) ? result.items : []
|
||||
}
|
||||
|
||||
async workspaces(): Promise<RemoteWorkspace[]> {
|
||||
if (this.alpha !== undefined) return (await this.alpha.workspaceList()).items
|
||||
const result = await this.call<{ items: RemoteWorkspace[] }>('workspace.list', {})
|
||||
return Array.isArray(result.items) ? result.items : []
|
||||
}
|
||||
|
||||
async listDirectory(path?: string): Promise<DirectoryListing> {
|
||||
if (this.alpha !== undefined) return this.alpha.hostListDirectory(path)
|
||||
const result = await this.call<DirectoryListing>('host.listDirectory', path ? { path } : {})
|
||||
if (typeof result.path !== 'string' || !Array.isArray(result.entries)) throw new Error('Host returned an invalid directory listing.')
|
||||
return result
|
||||
}
|
||||
|
||||
async createWorkspace(path: string): Promise<RemoteWorkspace> {
|
||||
if (this.alpha !== undefined) return (await this.alpha.workspaceCreate(path)).workspace
|
||||
const result = await this.call<{ workspace: RemoteWorkspace }>('workspace.create', { path })
|
||||
if (typeof result.workspace?.workspaceId !== 'string') throw new Error('Host returned an invalid workspace.')
|
||||
return result.workspace
|
||||
}
|
||||
|
||||
async models(sessionId: string): Promise<SessionModels> {
|
||||
if (this.alpha !== undefined) return this.alpha.sessionModels(sessionId)
|
||||
return this.call('session.models', { sessionId })
|
||||
}
|
||||
|
||||
async selectModel(sessionId: string, selection: ModelSelection): Promise<ModelSelection> {
|
||||
if (this.alpha !== undefined) return this.alpha.sessionSelectModel(sessionId, selection)
|
||||
const result = await this.call<{ selected: ModelSelection }>('session.selectModel', { sessionId, ...selection })
|
||||
return result.selected
|
||||
}
|
||||
|
||||
async selectPermission(sessionId: string, preset: string): Promise<void> {
|
||||
if (this.alpha !== undefined) return this.alpha.sessionSelectPermission(sessionId, preset)
|
||||
const execution = await this.call<{ result: { kind: 'success' | 'error'; text?: string } } | undefined>(
|
||||
'commands.execute',
|
||||
{ agentId: sessionId, line: `/permission ${preset}`, images: [] },
|
||||
)
|
||||
if (execution === undefined) throw new Error('Harness does not provide the permission command.')
|
||||
if (execution.result.kind === 'error') throw new Error(execution.result.text ?? 'Harness rejected the permission preset.')
|
||||
}
|
||||
|
||||
async hostDescriptor(): Promise<HostDescriptor> {
|
||||
if (this.alpha !== undefined) return this.alpha.hostDescribe()
|
||||
return this.call('host.describe', {})
|
||||
}
|
||||
stats() { return this.core?.getStats() }
|
||||
onFrame(handler: (frame: MuxFrame) => void): () => void { this.frameHandlers.add(handler); return () => this.frameHandlers.delete(handler) }
|
||||
onClose(handler: () => void): () => void { this.closeHandlers.add(handler); return () => this.closeHandlers.delete(handler) }
|
||||
|
||||
async respondApproval(frameRpcId: string, sessionId: string, approvalId: string, outcome: 'allowed-once' | 'rejected'): Promise<void> {
|
||||
if (this.alpha !== undefined) return this.alpha.respondApproval(frameRpcId, sessionId, approvalId, outcome)
|
||||
await this.core?.rpc('harness.api.respond', { message: { type: 'client-response', rpcId: frameRpcId, result: { ok: true, value: { sessionId, approvalId, outcome } } } })
|
||||
}
|
||||
|
||||
async history(sessionId: string): Promise<ChatMessage[]> {
|
||||
if (this.alpha !== undefined) return foldHistory(await this.alpha.sessionHistory(sessionId, undefined, 100).then(result => result.events as HistoryEntry[]))
|
||||
const result = await this.call<{ events: HistoryEntry[] }>('session.history', { sessionId, maxMessages: 100 })
|
||||
return foldHistory(Array.isArray(result.events) ? result.events : [])
|
||||
}
|
||||
|
||||
async createSession(options: { workspaceId?: string; cwd?: string } = {}): Promise<{ sessionId: string }> {
|
||||
if (this.alpha !== undefined) return this.alpha.sessionCreate(options.workspaceId, options.cwd)
|
||||
return this.call('session.create', options.workspaceId ? { workspaceId: options.workspaceId } : options.cwd ? { cwd: options.cwd } : {})
|
||||
}
|
||||
|
||||
async prompt(sessionId: string, text: string): Promise<void> {
|
||||
if (this.alpha !== undefined) return this.alpha.sessionPrompt(sessionId, text)
|
||||
await this.call('session.prompt', { sessionId, mode: 'queue', content: [{ type: 'text', text }] })
|
||||
}
|
||||
|
||||
async cancelSession(sessionId: string): Promise<void> {
|
||||
if (this.alpha !== undefined) return this.alpha.sessionCancel(sessionId)
|
||||
const result = await this.call<{ accepted: true }>('session.cancel', { sessionId })
|
||||
if (result.accepted !== true) throw new Error('Harness did not accept the stop request.')
|
||||
}
|
||||
|
||||
async close(): Promise<void> {
|
||||
const closeMux = this.closeMux
|
||||
this.closeMux = undefined
|
||||
const core = this.core
|
||||
this.core = undefined
|
||||
this.alpha = undefined
|
||||
this.host = undefined
|
||||
await closeMux?.().catch(() => undefined)
|
||||
await core?.close()
|
||||
}
|
||||
|
||||
private async call<T>(method: string, payload: unknown): Promise<T> {
|
||||
if (!this.core) throw new Error('Connect to a host first.')
|
||||
const rpcId = crypto.randomUUID()
|
||||
const response = await this.core.rpc<NativeResponse<T>>('harness.api.call', { method, rpcId, payload } satisfies HarnessApiCallParams)
|
||||
if (response.rpcId !== rpcId) throw new Error('Host returned a mismatched response.')
|
||||
if (!response.result.ok) throw new Error(response.result.error.message)
|
||||
return response.result.value
|
||||
}
|
||||
|
||||
private openAlphaClient(core: RemoteClientCore, host: RemoteHost, sessionFormat?: 3): () => Promise<void> {
|
||||
const alpha = new HarnessAlphaClient(
|
||||
core,
|
||||
{
|
||||
clientVersion: host.clientVersion,
|
||||
harnessVersion: host.harnessVersion,
|
||||
...(sessionFormat === undefined ? {} : { sessionFormat }),
|
||||
},
|
||||
frame => this.dispatchFrame(frame as unknown as MuxFrame),
|
||||
)
|
||||
alpha.start()
|
||||
this.alpha = alpha
|
||||
return async () => { await alpha.close() }
|
||||
}
|
||||
|
||||
private async openMuxStream(core: RemoteClientCore): Promise<() => Promise<void>> {
|
||||
const streamId = crypto.randomUUID()
|
||||
const unsubscribe = core.onEvent(event => {
|
||||
if (event.event !== 'harness.api.frame' || !isRecord(event.data)) return
|
||||
if (event.data.streamId !== streamId || !isRecord(event.data.frame) || typeof event.data.frame.rpcId !== 'string' || !isRecord(event.data.frame.payload)) return
|
||||
const frame = { rpcId: event.data.frame.rpcId, payload: event.data.frame.payload }
|
||||
this.dispatchFrame(frame)
|
||||
})
|
||||
try {
|
||||
await core.rpc('harness.api.stream.open', { streamId, stream: 'mux', rpcId: crypto.randomUUID(), payload: {} })
|
||||
} catch (error) {
|
||||
unsubscribe()
|
||||
throw error
|
||||
}
|
||||
return async () => { unsubscribe(); await core.rpc('harness.api.stream.close', { streamId }).catch(() => undefined) }
|
||||
}
|
||||
|
||||
private dispatchFrame(frame: MuxFrame): void {
|
||||
for (const handler of this.frameHandlers) handler(frame)
|
||||
}
|
||||
|
||||
private handleCoreClose(core: RemoteClientCore): void {
|
||||
if (this.core !== core) return
|
||||
const closeMux = this.closeMux
|
||||
this.closeMux = undefined
|
||||
this.core = undefined
|
||||
this.alpha = undefined
|
||||
this.host = undefined
|
||||
void closeMux?.().catch(() => undefined)
|
||||
void core.close().catch(() => undefined)
|
||||
for (const handler of this.closeHandlers) {
|
||||
try { handler() } catch { /* One UI handler must not block the remaining handlers. */ }
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
function preferredTransportsForAttempt(attempt: TransportAttempt): Array<'lan' | 'p2p' | 'turn' | 'relay'> {
|
||||
if (attempt === 'direct') return ['lan', 'p2p', 'relay']
|
||||
if (attempt === 'turn') return ['turn', 'relay']
|
||||
return ['relay']
|
||||
}
|
||||
|
||||
function iceServersForAttempt(attempt: TransportAttempt, iceServers: RtcIceServer[]): RtcIceServer[] {
|
||||
return attempt === 'direct' ? stunOnlyIceServers(iceServers) : iceServers
|
||||
}
|
||||
|
||||
function foldHistory(entries: HistoryEntry[]): ChatMessage[] {
|
||||
const messages: ChatMessage[] = []
|
||||
const toolRows = new Map<string, number>()
|
||||
let stream = ''
|
||||
for (const entry of entries) {
|
||||
const event = entry.event
|
||||
const data = isRecord(event.data) ? event.data : {}
|
||||
if (event.type === 'user/message' || event.type === 'assistant/message') {
|
||||
if (stream) { messages.push({ role: 'assistant', text: stream }); stream = '' }
|
||||
const text = messageText(data)
|
||||
if (text) messages.push({ role: event.type === 'user/message' ? 'user' : 'assistant', text })
|
||||
} else if (event.type === 'assistant/chunk') {
|
||||
const chunk = isRecord(data.chunk) ? data.chunk : {}
|
||||
if ((chunk.type === 'text-delta' || chunk.type === 'reasoning-delta') && typeof chunk.text === 'string') stream += chunk.text
|
||||
} else if (event.type === 'tool/call') {
|
||||
if (stream) { messages.push({ role: 'assistant', text: stream }); stream = '' }
|
||||
const view = entry.view?.for === 'call' && isRecord(entry.view.view) ? entry.view.view : undefined
|
||||
const name = typeof view?.title === 'string' ? view.title : typeof data.name === 'string' ? data.name : typeof data.toolName === 'string' ? data.toolName : 'Tool'
|
||||
const callId = typeof data.callId === 'string' ? data.callId : undefined
|
||||
const detail = typeof view?.description === 'string' ? view.description : typeof view?.cwd === 'string' ? view.cwd : undefined
|
||||
messages.push({ role: 'tool', text: name, toolState: 'running', ...(callId === undefined ? {} : { toolCallId: callId }), ...(typeof view?.kind === 'string' ? { toolKind: view.kind } : {}), ...(typeof view?.card === 'string' ? { toolCard: view.card } : {}), ...(detail === undefined ? {} : { toolDetail: detail }) })
|
||||
if (callId !== undefined) toolRows.set(callId, messages.length - 1)
|
||||
} else if (event.type === 'tool/result') {
|
||||
if (stream) { messages.push({ role: 'assistant', text: stream }); stream = '' }
|
||||
const message = isRecord(data.message) ? data.message : {}
|
||||
const source = isRecord(message.source) ? message.source : {}
|
||||
const callId = typeof source.callId === 'string' ? source.callId : typeof data.callId === 'string' ? data.callId : undefined
|
||||
const failed = isRecord(data.error)
|
||||
const view = entry.view?.for === 'result' && isRecord(entry.view.view) ? entry.view.view : undefined
|
||||
const row = callId === undefined ? undefined : toolRows.get(callId)
|
||||
if (row !== undefined) {
|
||||
const current = messages[row]
|
||||
messages[row] = { ...current, ...(typeof view?.title === 'string' ? { text: view.title } : {}), toolState: failed ? 'failed' : 'completed', ...(typeof view?.card === 'string' ? { toolCard: view.card } : {}) }
|
||||
} else {
|
||||
const name = typeof view?.title === 'string' ? view.title : typeof data.name === 'string' ? data.name : typeof data.toolName === 'string' ? data.toolName : 'Tool'
|
||||
messages.push({ role: 'tool', text: name, toolState: failed ? 'failed' : 'completed', ...(callId === undefined ? {} : { toolCallId: callId }), ...(typeof view?.card === 'string' ? { toolCard: view.card } : {}) })
|
||||
}
|
||||
}
|
||||
}
|
||||
if (stream) messages.push({ role: 'assistant', text: stream })
|
||||
return messages
|
||||
}
|
||||
|
||||
function messageText(data: Record<string, unknown>): string {
|
||||
const message = isRecord(data.message) ? data.message : data
|
||||
const content = Array.isArray(message.content) ? message.content : []
|
||||
return content.flatMap(block => isRecord(block) && block.type === 'text' && typeof block.text === 'string' ? [block.text] : []).join('\n')
|
||||
}
|
||||
function isRecord(value: unknown): value is Record<string, unknown> { return typeof value === 'object' && value !== null && !Array.isArray(value) }
|
||||
|
||||
class SecureTransport implements RemoteTransport {
|
||||
private noise?: NoiseIkSession
|
||||
private unsubscribe?: () => void
|
||||
private readonly incoming = new SecureMessageCodec()
|
||||
private readonly outgoing = new SecureMessageCodec()
|
||||
|
||||
constructor(private readonly inner: SecureHandshakeTransport, private readonly identity: DeviceIdentity, private readonly host: RemoteHost) {}
|
||||
|
||||
async connect(): Promise<void> {
|
||||
await this.inner.connect()
|
||||
const info = this.inner.connectionInfo()
|
||||
if (info.localDeviceId !== this.identity.deviceId || info.remoteDeviceId !== this.host.deviceId) throw new Error('Connection was bound to an unexpected device.')
|
||||
const noise = new NoiseIkSession({ role: 'initiator', localPrivateKey: this.identity.privateKey, localPublicKey: this.identity.publicKey, remotePublicKey: this.host.identityKey, prologue: createNoisePrologue(info.connectionId, this.host.deviceId, this.identity.deviceId) })
|
||||
this.noise = noise
|
||||
await new Promise<void>((resolve, reject) => {
|
||||
const timer = setTimeout(() => finish(new Error('Noise handshake timed out.')), 10_000)
|
||||
const off = this.inner.onHandshake((step, data) => {
|
||||
try {
|
||||
if (step !== 2) throw new Error('Out-of-order Noise handshake.')
|
||||
noise.readHandshake(data)
|
||||
if (!noise.complete) throw new Error('Noise handshake did not complete.')
|
||||
finish()
|
||||
} catch (error) { finish(error instanceof Error ? error : new Error('Noise handshake failed.')) }
|
||||
})
|
||||
const finish = (error?: Error): void => { clearTimeout(timer); off(); error ? reject(error) : resolve() }
|
||||
void this.inner.sendHandshake(1, noise.writeHandshake()).catch(error => finish(error instanceof Error ? error : new Error('Noise handshake failed.')))
|
||||
})
|
||||
}
|
||||
|
||||
async send(data: Uint8Array): Promise<void> {
|
||||
if (!this.noise?.complete) throw new Error('Secure channel is not connected.')
|
||||
const plaintextFrames = this.outgoing.encode(data)
|
||||
try {
|
||||
for (const plaintext of plaintextFrames) await this.inner.send(this.noise.encrypt(plaintext))
|
||||
} catch (error) {
|
||||
await this.close().catch(() => undefined)
|
||||
throw error
|
||||
}
|
||||
}
|
||||
onMessage(handler: (data: Uint8Array) => void): () => void {
|
||||
this.unsubscribe = this.inner.onMessage(data => {
|
||||
try { const decoded = this.noise?.complete ? this.incoming.decode(this.noise.decrypt(data)) : undefined; if (decoded) handler(decoded) } catch { void this.close() }
|
||||
})
|
||||
return () => { this.unsubscribe?.(); this.unsubscribe = undefined }
|
||||
}
|
||||
onClose(handler: () => void): () => void { return this.inner.onClose?.(handler) ?? (() => undefined) }
|
||||
getStats() { return this.inner.getStats() }
|
||||
async close(): Promise<void> { this.unsubscribe?.(); this.unsubscribe = undefined; this.noise?.destroy(); this.noise = undefined; this.incoming.reset(); this.outgoing.reset(); await this.inner.close() }
|
||||
}
|
||||
Loading…
Reference in New Issue