Import packages/plugin/src/service.ts

This commit is contained in:
QQ 2026-11-14 14:57:44 +08:00
parent 95b192796e
commit b9fe68bc6c
1 changed files with 645 additions and 0 deletions

View File

@ -0,0 +1,645 @@
import { HostPairing } from './host-pairing.js'
import type { HostPairingView } from './pairing-contract.js'
import { WorkspaceUploadHost } from './workspace-upload.js'
import { workspaceUploadRootResolver } from './workspace-upload-authority.js'
import { LoopbackHost } from './loopback-host.js'
import { TerminalPolicy } from './terminal-policy.js'
import { createEvent, type RemoteWorkspaceTypeDescription } from '@dsh-remote/protocol'
import { setLiteModeEnabled } from './lite-mode.js'
import { setForceRelayEnabled } from './relay-preference.js'
import { ConnectionController } from './connection-controller.js'
import type { ResolvedConfig } from './config.js'
import type { HostIdentity, IdentityStore } from './identity-store.js'
import {
harnessSessionGeneration,
readHarnessDistributionVersion,
} from './harness-version.js'
import type { SafeLogger } from './logging.js'
import { RpcRouter } from './rpc-router.js'
import { RemoteFileViewerBridge, type FileViewerHostServiceLike } from './file-viewer-bridge.js'
import {
HostServerApi,
ServerApiError,
type DeviceAuthorization,
type OAuthProvider,
type OAuthProviderInfo,
type OAuthQrPollResult,
type OAuthQrSession,
} from './server-api.js'
import { HostServerConnection } from './server-connection.js'
import { ServerCredentialStore } from './server-credentials.js'
import { HarnessRemoteBridge, type ScheduleCreateService } from './harness-remote-bridge.js'
import type { PluginRouteDispatcher } from './plugin-route-bridge.js'
import { PluginRouteBridge } from './plugin-route-bridge.js'
import type { LocalTypertGateway } from './typert-gateway-contract.js'
import { loadNodeRtcFactory } from './werift-rtc.js'
import type { AuthenticatedPeerChannel } from './types.js'
import { CodexRemoteDomain } from './codex/domain.js'
import { AcpGateway, StdioAcpAdapter } from './acp.js'
import { execFileSync } from 'node:child_process'
import { existsSync } from 'node:fs'
import type { CodexPeerBridge, PublishCodexFrame } from './codex/peer-bridge.js'
import { AcpRemoteGateway } from './acp/gateway.js'
import type { AcpPeerBridge, PublishAcpFrame } from './acp/peer-bridge.js'
import { RpcError } from './safe-error.js'
import { CodexWorkspaceBridge, CodexWorkspaceState, type RemoteTerminalSpawner } from './codex-workspace-bridge.js'
export interface HostConnectedClient {
deviceId: string
name: string
platform?: string
mode?: 'LAN' | 'P2P' | 'TURN' | 'Relay'
}
export interface HostRemoteStatus {
deviceId?: string
configured: boolean
online: boolean
reconnecting: boolean
recoveryExpiresAt?: number
lastActiveAt?: number
error?: string
account?: string
authorized: boolean
accountRequired: boolean
pairingHostOnly?: boolean
connectedClients: HostConnectedClient[]
}
export class HostPluginRuntime {
readonly connections: ConnectionController
private readonly terminalOwners = new Map<string, string>()
private readonly loopbackHosts = new Set<LoopbackHost>()
private terminalEnabled: boolean
private loopbackPorts: readonly number[]
private identity?: HostIdentity
private readonly serverApi?: HostServerApi
private serverConnection?: HostServerConnection
private harnessVersion?: string
private pairing?: HostPairing
private closed = false
private readonly codex: CodexRemoteDomain
private readonly acp: AcpRemoteGateway
private readonly codexWorkspaceState = new CodexWorkspaceState(key => TerminalPolicy.releaseOwner(this.terminalOwners, key))
private localCodexPeer?: CodexPeerBridge
private localCodexPublish: PublishCodexFrame = async () => undefined
private localAcpPeer?: AcpPeerBridge
private localAcpPublish: PublishAcpFrame = async () => undefined
private warnedMissingHostApi = false
constructor(
private readonly config: ResolvedConfig,
private readonly identities: IdentityStore,
private readonly logger: SafeLogger,
private readonly localGateway?: LocalTypertGateway,
private readonly fileViewerHost?: () => FileViewerHostServiceLike | undefined,
/** PTY-backed terminal provider from the Host `subprocess` service, when present. */
private readonly terminalSpawner?: RemoteTerminalSpawner,
private readonly pluginRoutes?: (peer?: unknown) => PluginRouteDispatcher | undefined,
/** Host `schedule` service; absent on Hosts whose composition omits reminders. */
private readonly schedule?: ScheduleCreateService,
) {
this.terminalEnabled = config.terminal.enabled
setLiteModeEnabled(config.liteMode === true)
setForceRelayEnabled(config.forceRelay === true)
this.loopbackPorts = [...config.loopback.ports]
this.codex = new CodexRemoteDomain(config.codex, logger)
this.acp = new AcpRemoteGateway(config.acp ?? { enabled: false, backends: [] }, logger, undefined, undefined, () => this.terminalEnabled, this.terminalSpawner)
this.connections = new ConnectionController(this.identities, (context, send) => {
const peerGateway = this.localGateway?.createPeer?.() ?? this.localGateway
const harnessRemote = peerGateway?.supportsCarrier === true
? new HarnessRemoteBridge(
peerGateway,
(event, data) => send(createEvent(event, data)),
this.logger,
this.harnessVersion,
new TerminalPolicy(() => this.terminalEnabled, context.peerDeviceId, this.terminalOwners),
new CodexWorkspaceBridge(
(threadId, signal) => this.codex.resolveThreadWorkspace(context.connectionId, threadId),
() => this.terminalEnabled,
this.codexWorkspaceState,
this.terminalSpawner,
),
workspaceUploadRootResolver(
peerGateway,
() => harnessSessionGeneration(this.harnessVersion) === 'v3',
threadId => this.codex.resolveThreadWorkspace(context.connectionId, threadId),
sessionId => this.acp.resolveUploadWorkspace(context.connectionId, sessionId),
),
this.schedule,
)
: undefined
const fileViewer = new RemoteFileViewerBridge(
() => this.fileViewerHost?.(),
this.logger,
)
const codex = this.codex.createPeer(
context,
(event, data) => send(createEvent(event, data)),
)
const cursor = this.acp.createPeer(
context,
(event, data) => send(createEvent(event, data)),
)
// The dispatcher must resolve inside the callback: the DSH connection
// service (and its shared fetch handler) may become ready after this
// plugin is activated.
const dispatcher = this.pluginRoutes?.(peerGateway?.peer)
const pluginRoute = dispatcher === undefined ? undefined : new PluginRouteBridge(dispatcher, this.logger)
return new RpcRouter(
undefined,
this.logger,
fileViewer,
harnessRemote,
() => this.transportCapabilities(peerGateway),
codex,
cursor,
// Handles and their lifetime belong to this connection; only policy is shared.
this.createLoopbackHost(),
() => this.hostWorkspaceTypes(),
pluginRoute,
new WorkspaceUploadHost(workspaceUploadRootResolver(
peerGateway,
() => harnessSessionGeneration(this.harnessVersion) === 'v3',
threadId => this.codex.resolveThreadWorkspace(context.connectionId, threadId),
sessionId => this.acp.resolveUploadWorkspace(context.connectionId, sessionId),
), undefined, context.transportMode),
)
}, this.logger)
if (config.serverUrl !== undefined) {
this.serverApi = new HostServerApi(config.serverUrl, new ServerCredentialStore(identities.directory), fetch, 'host', config.httpServerAllowlist)
}
}
setTerminalEnabled(enabled: boolean): void {
this.terminalEnabled = enabled
}
setLoopbackPorts(ports: readonly number[]): void {
this.loopbackPorts = [...ports]
for (const loopback of this.loopbackHosts) loopback.setPorts(this.loopbackPorts)
}
private backendUpdate: Promise<void> = Promise.resolve()
setAgentBackends(config: ResolvedConfig): Promise<void> {
const update = this.backendUpdate.catch(() => undefined).then(async () => {
if (this.closed) throw new Error('remote runtime is closed')
const codexChanged = JSON.stringify(this.config.codex) !== JSON.stringify(config.codex)
await Promise.all([this.codex.reconfigure(config.codex), this.acp.reconfigure(config.acp ?? { enabled: false, backends: [] })])
if (codexChanged) await this.codexWorkspaceState.dispose()
this.config.codex = config.codex
})
this.backendUpdate = update
return update
}
private createLoopbackHost(): LoopbackHost {
let loopback: LoopbackHost
loopback = new LoopbackHost(() => this.loopbackPorts, () => this.loopbackHosts.delete(loopback))
this.loopbackHosts.add(loopback)
return loopback
}
async start(): Promise<void> {
if (this.closed) throw new Error('remote runtime is closed')
this.identity = await this.identities.loadOrCreate(this.config.deviceName)
this.logger.info('host identity ready', {
deviceId: shortId(this.identity.deviceId),
fingerprint: this.identity.fingerprint,
server: this.config.serverUrl ?? 'not configured',
})
await this.codex.start()
void this.acp.start().catch(() => {
this.logger.warn('ACP background initialization failed', { code: 'ACP_START_FAILED' })
})
if (this.serverApi !== undefined) {
this.harnessVersion = await this.readHarnessVersion()
this.serverApi.setHarnessVersion(this.harnessVersion)
this.serverApi.bindIdentity(this.identity)
await this.serverApi.loadStoredPolicy()
this.initializePairing()
this.serverConnection = this.createServerConnection(this.identity)
if (this.config.hostControl?.enabled !== false) this.serverConnection.start()
}
}
currentIdentity(): HostIdentity {
if (this.identity === undefined) throw new Error('remote runtime has not started')
return this.identity
}
acceptAuthenticatedPeer(channel: AuthenticatedPeerChannel): Promise<void> {
this.currentIdentity()
return this.connections.accept(channel)
}
hostStatus(): HostRemoteStatus {
const error = this.serverConnection?.lastError()
const authorization = this.serverApi?.currentAuthorization()
return {
...(this.identity === undefined ? {} : { deviceId: this.identity.deviceId }),
configured: this.serverApi !== undefined,
online: this.serverConnection?.isOnline() ?? false,
reconnecting: this.serverConnection?.isReconnecting() ?? false,
recoveryExpiresAt: this.serverConnection?.recoveryExpiresAt(),
...(this.serverConnection?.lastActivity() === undefined
? {}
: { lastActiveAt: this.serverConnection.lastActivity() }),
...(error === undefined ? {} : { error }),
...(authorization?.account === undefined ? {} : { account: authorization.account }),
authorized: authorization !== undefined,
pairingHostOnly: this.serverApi?.pairingHostOnly() ?? false,
accountRequired: error === 'ACCOUNT_AUTH_REQUIRED' || error === 'AUTH_REQUIRED' || error === 'AUTH_INVALID' || error === 'TOKEN_EXPIRED' || error === 'DEVICE_REVOKED' || error === 'DEVICE_OWNERSHIP_REQUIRED',
connectedClients: this.listConnectedClients(),
}
}
private initializePairing(): void {
this.pairing?.close()
if (!this.serverApi || !this.identity || !this.config.serverUrl) { this.pairing = undefined; return }
this.pairing = new HostPairing(this.config.serverUrl!, this.identities.directory, this.identity, {
deviceId: this.identity.deviceId, name: this.identity.name, role: 'host', platform: process.platform,
identityKey: this.identity.publicKey,
...(this.harnessVersion === undefined ? {} : { harnessVersion: this.harnessVersion }),
}, async result => { await this.serverApi!.adoptPairing(result); if (!this.closed) this.serverConnection?.reconnect() }, fetch, this.config.httpServerAllowlist)
}
async pairingControl(action: 'start' | 'status' | 'confirm' | 'cancel', input: { sessionId?: string; verificationCode?: string }): Promise<HostPairingView | undefined> {
if (this.pairing === undefined || this.closed) throw new ServerApiError('SERVER_NOT_CONFIGURED', 'Configure and save the Server URL before pairing.', false)
if (action === 'start') return this.pairing.start()
if (action === 'status') return this.pairing.status()
if (typeof input.sessionId !== 'string') throw new ServerApiError('INVALID_MESSAGE', 'A specific pairing session is required.', false)
return action === 'confirm' ? this.pairing.confirm(input.sessionId, input.verificationCode) : this.pairing.cancel(input.sessionId)
}
async hasStoredAuthorization(): Promise<boolean> {
return this.serverApi?.hasStoredAuthorization() ?? false
}
private listConnectedClients(): HostConnectedClient[] {
return this.connections.connectedPeers().map(peer => {
const trusted = this.identities.trustedPeer(peer.deviceId)
return {
deviceId: peer.deviceId,
name: trusted?.name.trim() ?? '',
...(trusted === undefined ? {} : { platform: trusted.platform }),
...(peer.mode === undefined ? {} : { mode: peer.mode }),
}
})
}
localHarnessVersion(): string | undefined {
return this.harnessVersion
}
reconnectHost(): void {
if (this.closed) throw new Error('remote runtime is closed')
if (this.serverConnection === undefined) {
throw new ServerApiError('SERVER_NOT_CONFIGURED', 'Configure serverUrl before reconnecting.', false)
}
this.serverConnection.reconnect()
}
async hostOAuthProviders(): Promise<OAuthProviderInfo[]> {
if (this.serverApi === undefined) {
throw new ServerApiError('SERVER_NOT_CONFIGURED', 'Remote Host Server is unavailable.', false)
}
return this.serverApi.oauthProviders()
}
async startHostOAuthQrLogin(provider: OAuthProvider): Promise<OAuthQrSession> {
if (this.serverApi === undefined) {
throw new ServerApiError('SERVER_NOT_CONFIGURED', 'Remote Host Server is unavailable.', false)
}
return this.serverApi.startOAuthQrLogin(provider)
}
async pollHostOAuthQrLogin(qrId: string): Promise<OAuthQrPollResult> {
if (this.serverApi === undefined) {
throw new ServerApiError('SERVER_NOT_CONFIGURED', 'Remote Host Server is unavailable.', false)
}
const result = await this.serverApi.pollOAuthQrLogin(this.currentIdentity(), qrId, async () => {
await this.serverConnection?.stop()
await this.pairing?.discard()
this.pairing = undefined
this.identity = await this.identities.reset(this.config.deviceName)
this.serverApi!.bindIdentity(this.identity)
this.serverConnection = this.createServerConnection(this.identity)
this.initializePairing()
return this.identity
})
if (result.status === 'complete') {
this.serverConnection?.reconnect()
this.logger.info('Host account authorized through OAuth QR login')
}
return result
}
async clearHostAuthorization(): Promise<void> {
await this.pairing?.discard()
this.pairing = undefined
await this.serverConnection?.stop()
let revokeFailure: unknown
try {
await this.serverApi?.revokeCurrentDevice()
} catch (error) {
revokeFailure = error
}
this.identity = await this.identities.reset(this.config.deviceName)
this.serverApi?.bindIdentity(this.identity)
if (this.serverApi !== undefined) this.serverConnection = this.createServerConnection(this.identity)
this.initializePairing()
this.logger.info('Host authorization cleared')
if (revokeFailure !== undefined) throw revokeFailure
}
async authorizeHostAsOwned(accessToken: string, account?: string): Promise<DeviceAuthorization> {
if (this.serverApi === undefined) {
throw new ServerApiError('SERVER_NOT_CONFIGURED', 'Configure serverUrl before enabling Host access.', false)
}
let result
try {
result = await this.serverApi.authorizeOwnedRole(this.currentIdentity(), accessToken, account)
} catch (error) {
if (!(error instanceof ServerApiError) || error.code !== 'DEVICE_REVOKED') throw error
await this.serverConnection?.stop()
await this.pairing?.discard()
this.pairing = undefined
this.identity = await this.identities.reset(this.config.deviceName)
this.serverApi.bindIdentity(this.identity)
this.serverConnection = this.createServerConnection(this.identity)
this.initializePairing()
result = await this.serverApi.authorizeOwnedRole(this.identity, accessToken, account)
this.logger.info('Rotated revoked Host identity before owned-device authorization')
}
this.serverConnection?.resume()
this.logger.info('Host authorized as an owned device')
return result
}
async authorizeHostWithAccount(email: string, password: string): Promise<DeviceAuthorization> {
if (this.serverApi === undefined) {
throw new ServerApiError('SERVER_NOT_CONFIGURED', 'Configure serverUrl before signing in.', false)
}
const result = await this.serverApi.authorizeWithAccount(this.currentIdentity(), email, password, async () => {
await this.serverConnection?.stop()
await this.pairing?.discard()
this.pairing = undefined
this.identity = await this.identities.reset(this.config.deviceName)
this.serverApi!.bindIdentity(this.identity)
this.serverConnection = this.createServerConnection(this.identity)
this.initializePairing()
this.logger.info('Rotated revoked Host identity before account authorization')
return this.identity
})
this.serverConnection?.resume()
this.logger.info('Host account authorized')
return result
}
async authorizeHostWithCode(code: string): Promise<DeviceAuthorization> {
if (this.serverApi === undefined) {
throw new ServerApiError('SERVER_NOT_CONFIGURED', 'Configure serverUrl before entering a Host registration code.', false)
}
const result = await this.serverApi.authorizeHostWithCode(this.currentIdentity(), code)
this.serverConnection?.resume()
this.logger.info('Host registration code authorized')
return result
}
async revokePeer(deviceId: string): Promise<boolean> {
const revoked = await this.identities.revokePeer(deviceId)
if (revoked) await this.connections.revoke(deviceId)
return revoked
}
codexStatus(): ReturnType<CodexRemoteDomain['status']> {
return this.codex.status()
}
codexCall(input: unknown): Promise<unknown> {
return this.requireLocalCodexPeer().call(input)
}
codexRespond(input: unknown): Promise<{ resolved: true }> {
return this.requireLocalCodexPeer().respond(input)
}
codexOpenStream(input: unknown, publish: PublishCodexFrame): Promise<unknown> {
this.localCodexPublish = publish
return this.requireLocalCodexPeer().openStream(input)
}
async codexCloseStream(input: unknown): Promise<unknown> {
const peer = this.localCodexPeer
if (peer !== undefined) return peer.closeStream(input)
const streamId = isPlainRecord(input) && typeof input.streamId === 'string' ? input.streamId : undefined
if (streamId === undefined) throw new RpcError('INVALID_MESSAGE', 'A Codex stream is required.')
return { closed: false, streamId }
}
acpStatus(): ReturnType<AcpRemoteGateway['status']> {
return this.acp.status()
}
acpCall(input: unknown): Promise<unknown> {
return this.requireLocalAcpPeer().call(input)
}
acpRespond(input: unknown): Promise<{ resolved: true }> {
return this.requireLocalAcpPeer().respond(input)
}
acpOpenStream(input: unknown, publish: PublishAcpFrame): Promise<unknown> {
this.localAcpPublish = publish
return this.requireLocalAcpPeer().openStream(input)
}
async acpCloseStream(input: unknown): Promise<unknown> {
const peer = this.localAcpPeer
if (peer !== undefined) return peer.closeStream(input)
const streamId = isPlainRecord(input) && typeof input.streamId === 'string' ? input.streamId : undefined
if (streamId === undefined) throw new RpcError('INVALID_MESSAGE', 'A Cursor stream is required.')
return { closed: false, streamId }
}
async close(): Promise<void> {
if (this.closed) return
this.closed = true
this.pairing?.close()
this.serverApi?.close()
await this.serverConnection?.stop()
await this.connections.close()
await this.localCodexPeer?.closeAll()
this.localCodexPeer = undefined
await this.localAcpPeer?.closeAll()
this.localAcpPeer = undefined
const shutdown = await Promise.allSettled([this.codexWorkspaceState.dispose(), this.codex.close(), this.acp.close()])
if (shutdown.some(result => result.status === 'rejected')) throw new RpcError('HOST_SHUTDOWN_FAILED', 'Some Host backend processes could not be stopped.')
this.logger.info('host runtime stopped')
}
diagnostics() {
return {
loaded: this.identity !== undefined,
deviceId: this.identity === undefined ? undefined : shortId(this.identity.deviceId),
identityValid: this.identity !== undefined,
serverConfigured: this.config.serverUrl !== undefined,
serverOnline: this.serverConnection?.isOnline() ?? false,
serverError: this.serverConnection?.lastError(),
online: this.connections.isOnline(),
activeConnections: this.connections.connectionCount(),
peerDeviceId: this.connections.peerDeviceId() === undefined ? undefined : shortId(this.connections.peerDeviceId()!),
peerDeviceIds: this.connections.peerDeviceIds().map(shortId),
trustedPeers: this.identities.listTrustedPeers().length,
capabilities: this.hostCapabilities(),
workspaceTypes: this.hostWorkspaceTypes(),
codex: this.codex.status(),
acp: this.acp.status(),
}
}
private createServerConnection(identity: HostIdentity): HostServerConnection {
return new HostServerConnection(
this.config,
identity,
this.identities,
this.serverApi!,
this.connections,
this.logger,
undefined,
this.config.forceRelay
? undefined
: () => loadNodeRtcFactory({ routeTargets: this.config.serverUrl === undefined ? [] : [this.config.serverUrl] }),
() => this.hostCapabilities(),
this.harnessVersion,
)
}
private async readHarnessVersion(): Promise<string | undefined> {
const version = await readHarnessDistributionVersion()
if (version === undefined) this.logger.warn('Harness version is unavailable')
return version
}
private hostCapabilities(): string[] {
const capabilities: string[] = ['workspace.upload.v1']
if (this.loopbackPorts.length > 0) capabilities.push('loopback.http-ws.v1')
if (this.localGateway?.supportsCarrier === true) {
capabilities.push(
harnessSessionGeneration(this.harnessVersion) === 'v3' ? 'harness.remote.v3' : 'harness.remote.v1',
'harness.remote.transfer.v1',
)
}
if (this.localGateway?.supportsCarrier && this.terminalEnabled) capabilities.push('harness.terminal.v1')
if (this.fileViewerHost?.() !== undefined) capabilities.push('fileviewer.read.v1')
if (this.pluginRoutes?.() !== undefined) capabilities.push('plugin.route.v1')
if (this.codex.isAvailable()) capabilities.push('codex.appserver.v1', 'codex.appserver.transfer.v1')
// Protocol support is stable during background warmup; workspaceTypes reports readiness.
if (this.acp.enabledBackends().length > 0) {
capabilities.push('agent.acp.v1', 'agent.acp.transfer.v1', 'agent.acp.workspace-files.v1')
if (this.acp.enabledBackends().includes('opencode')) capabilities.push('agent.acp.opencode.archive.v1')
if (this.terminalEnabled) capabilities.push('agent.acp.terminal.v1')
if (this.acp.enabledBackends().includes('antigravity')) capabilities.push('agent.acp.antigravity.models.v1', 'agent.acp.antigravity.model-load.v1')
for (const backend of this.acp.enabledBackends()) {
capabilities.push(`agent.acp.${backend}.v1`)
}
}
return capabilities
}
private async transportCapabilities(gateway?: LocalTypertGateway): Promise<string[]> {
const capabilities = this.hostCapabilities()
if (gateway?.supportsCarrier !== true) return capabilities
let result: Awaited<ReturnType<LocalTypertGateway['dispatch']>>
try {
result = await gateway.dispatch('session/list', { args: { _request: {} } }, AbortSignal.timeout(5_000))
} catch {
throw new RpcError('CONNECTION_FAILED', 'Cannot verify the Host Session API.', undefined, true)
}
if (result.ok) return capabilities
if (result.error.code === 'gateway/service-unavailable') {
throw new RpcError('CONNECTION_FAILED', 'The Host Session API is not ready.', undefined, true)
}
if (result.error.code !== 'gateway/invocation-unavailable') {
throw new RpcError('CONNECTION_FAILED', 'Cannot verify the Host Session API.', undefined, true)
}
if (!this.warnedMissingHostApi) {
this.warnedMissingHostApi = true
this.logger.warn('Host Remote API is incomplete. Install @deepseek-ai/dsh-api-remotes and its Host API packages.')
}
return capabilities.filter(value => !value.startsWith('harness.remote.') && value !== 'harness.terminal.v1')
}
private hostWorkspaceTypes(): RemoteWorkspaceTypeDescription[] {
const types: RemoteWorkspaceTypeDescription[] = []
if (this.codex.isAvailable()) {
types.push({
id: 'codex',
name: 'CodeX',
capability: 'codex.appserver.v1',
available: true,
})
}
const readyBackends = this.acp.availableBackends()
for (const backend of this.acp.enabledBackends()) {
types.push({
id: backend,
name: backend === 'claude' ? 'Claude' : backend === 'hermes' ? 'Hermes' : backend === 'pi' ? 'Pi' : backend === 'cursor' ? 'Cursor' : backend === 'antigravity' ? 'Antigravity' : backend === 'opencode' ? 'OpenCode' : backend,
capability: `agent.acp.${backend}.v1`,
available: readyBackends.includes(backend),
})
}
return types
}
private acpAvailable(command: string): boolean {
if (command === 'opencode') {
try {
if (existsSync('/usr/local/bin/opencode') || existsSync('/var/lib/dsh/.opencode/bin/opencode')) return true
} catch {}
}
try { execFileSync(process.platform === 'win32' ? 'where' : 'which', [command], { stdio: 'ignore' }); return true } catch { return false }
}
private requireLocalCodexPeer(): CodexPeerBridge {
if (!this.codex.isAvailable()) {
throw new RpcError('CODEX_UNAVAILABLE', 'Local CodeX is disabled or unavailable on this Host.')
}
if (this.localCodexPeer !== undefined) return this.localCodexPeer
const identity = this.currentIdentity()
const peer = this.codex.createPeer({
connectionId: `loopback:${identity.deviceId}`,
peerDeviceId: identity.deviceId,
}, (event, data) => this.localCodexPublish(event, data))
if (peer === undefined) {
throw new RpcError('CODEX_UNAVAILABLE', 'Local CodeX is disabled or unavailable on this Host.')
}
this.localCodexPeer = peer
return peer
}
private requireLocalAcpPeer(): AcpPeerBridge {
if (!this.acp.isAvailable()) {
throw new RpcError('CURSOR_UNAVAILABLE', 'Local Agent ACP is disabled or unavailable on this Host.')
}
if (this.localAcpPeer !== undefined) return this.localAcpPeer
const identity = this.currentIdentity()
const peer = this.acp.createPeer({
connectionId: `loopback:${identity.deviceId}`,
peerDeviceId: identity.deviceId,
}, (event, data) => this.localAcpPublish(event, data))
if (peer === undefined) {
throw new RpcError('CURSOR_UNAVAILABLE', 'Local Agent ACP is disabled or unavailable on this Host.')
}
this.localAcpPeer = peer
return peer
}
}
function shortId(value: string): string { return value.length <= 12 ? value : `${value.slice(0, 8)}…${value.slice(-4)}` }
function isPlainRecord(value: unknown): value is Record<string, unknown> {
return typeof value === 'object' && value !== null && !Array.isArray(value)
}