diff --git a/packages/plugin/src/service.ts b/packages/plugin/src/service.ts new file mode 100644 index 0000000..353b36d --- /dev/null +++ b/packages/plugin/src/service.ts @@ -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() + private readonly loopbackHosts = new Set() + 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 = Promise.resolve() + + setAgentBackends(config: ResolvedConfig): Promise { + 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 { + 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 { + 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 { + 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 { + 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 { + 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 { + 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 { + 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 { + 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 { + 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 { + 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 { + 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 { + const revoked = await this.identities.revokePeer(deviceId) + if (revoked) await this.connections.revoke(deviceId) + return revoked + } + + codexStatus(): ReturnType { + return this.codex.status() + } + + codexCall(input: unknown): Promise { + return this.requireLocalCodexPeer().call(input) + } + + codexRespond(input: unknown): Promise<{ resolved: true }> { + return this.requireLocalCodexPeer().respond(input) + } + + codexOpenStream(input: unknown, publish: PublishCodexFrame): Promise { + this.localCodexPublish = publish + return this.requireLocalCodexPeer().openStream(input) + } + + async codexCloseStream(input: unknown): Promise { + 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 { + return this.acp.status() + } + + acpCall(input: unknown): Promise { + return this.requireLocalAcpPeer().call(input) + } + + acpRespond(input: unknown): Promise<{ resolved: true }> { + return this.requireLocalAcpPeer().respond(input) + } + + acpOpenStream(input: unknown, publish: PublishAcpFrame): Promise { + this.localAcpPublish = publish + return this.requireLocalAcpPeer().openStream(input) + } + + async acpCloseStream(input: unknown): Promise { + 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 { + 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 { + 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 { + const capabilities = this.hostCapabilities() + if (gateway?.supportsCarrier !== true) return capabilities + let result: Awaited> + 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 { + return typeof value === 'object' && value !== null && !Array.isArray(value) +}