ds-harness-remote 0.4.1 → 0.4.3

package/dist/client-runtime.js

@@ -1,4 +1,4 @@
-import { RemoteClientCore } from '@dsh-remote/client-core';
+import { CodexRemoteClient, RemoteClientCore } from '@dsh-remote/client-core';
 import { AdaptiveTransport, stunOnlyIceServers, } from '@dsh-remote/webrtc';
 import { ApiProxySwitch } from './api-proxy-switch.js';
 import { ClientSecureTransport } from './client-secure-transport.js';
@@ -6,6 +6,7 @@ import { CONTROL_RPC_PREFIX } from './control-route.js';
 import { uuidV7 } from './ids.js';
 import { RemoteHarnessApiProxy } from './remote-api-proxy.js';
 import { RemoteTypertGateway } from './remote-typert-gateway.js';
+import { CodexVirtualHarness, discoverCodexVirtualWorkspaces, } from './codex/virtual-harness.js';
 import { ServerApiError, } from './server-api.js';
 import { TypertGatewaySwitch } from './typert-gateway-switch.js';
 import { loadNodeRtcFactory } from './werift-rtc.js';
@@ -22,8 +23,10 @@ export class ClientModeRuntime {
     identity;
     connected;
     pendingWorkspaceSelection;
+    codexVirtual;
     proxySwitch;
     gatewaySwitch;
+    codexStreams = new Map();
     closed = false;
     constructor(config, identities, server, apiProxy, typertGateway, logger, host, rtcFactoryProvider = loadNodeRtcFactory) {
         this.config = config;
@@ -70,6 +73,7 @@ export class ClientModeRuntime {
             ...(this.pendingWorkspaceSelection === undefined
                 ? {}
                 : { workspaceSelection: { ...this.pendingWorkspaceSelection } }),
+            backend: this.codexVirtual === undefined ? 'harness' : 'codex',
             hostAuthorizationAvailable: this.host !== undefined,
             ...(this.host === undefined ? {} : { host: this.host.hostStatus() }),
         };
@@ -141,8 +145,10 @@ export class ClientModeRuntime {
         const previous = this.connected;
         this.connected = undefined;
         this.pendingWorkspaceSelection = undefined;
+        await this.closeCodexVirtual();
         this.proxySwitch?.selectLocal();
         this.gatewaySwitch.selectLocal();
+        await this.closeCodexStreams(previous?.client);
         await previous?.client.close().catch(() => undefined);
         await this.server.revokeCurrentDevice();
         this.identity = await this.identities.reset(this.config.deviceName);
@@ -161,11 +167,13 @@ export class ClientModeRuntime {
     }
     async setMode(mode, targetDeviceId, signal) {
         if (mode === 'local') {
+            await this.closeCodexVirtual();
             this.proxySwitch?.selectLocal();
             this.gatewaySwitch.selectLocal();
             const previous = this.connected;
             this.connected = undefined;
             this.pendingWorkspaceSelection = undefined;
+            await this.closeCodexStreams(previous?.client);
             await previous?.client.close().catch(() => undefined);
             this.logger.info('Harness target switched', { mode: 'local' });
             return this.status();
@@ -184,7 +192,9 @@ export class ClientModeRuntime {
         const previous = this.connected;
         this.connected = next;
         this.pendingWorkspaceSelection = undefined;
+        await this.closeCodexVirtual();
         this.selectRemoteTarget(next);
+        await this.closeCodexStreams(previous?.client);
         await previous?.client.close().catch(() => undefined);
         this.logger.info('Harness target switched', { mode: 'remote', targetDeviceId: shortId(next.target.deviceId) });
         return this.status();
@@ -242,15 +252,58 @@ export class ClientModeRuntime {
             });
             workspace = unwrapNativeResult(response);
         }
+        await this.closeCodexVirtual();
         this.selectRemoteTarget(remote);
         const workspaceId = workspaceRecordId(workspace.workspace);
         this.pendingWorkspaceSelection = { targetDeviceId: remote.target.deviceId, workspaceId };
         this.logger.info('Remote workspace opened', { targetDeviceId: shortId(remote.target.deviceId) });
         return { ...this.status(), workspace };
     }
+    async listCodexWorkspaces(targetDeviceId, signal) {
+        const remote = await this.ensureConnected(targetDeviceId, signal);
+        remote.features = await probeRemoteHostFeatures(remote.client, remote.clientVersion);
+        if (!remote.features.codex) {
+            throw new ClientModeError('FEATURE_NOT_SUPPORTED', 'The selected Host does not provide CodeX workspaces.');
+        }
+        return discoverCodexVirtualWorkspaces(new CodexRemoteClient(remote.client), signal);
+    }
+    async openCodexWorkspace(targetDeviceId, workspaceId, signal) {
+        const remote = await this.ensureConnected(targetDeviceId, signal);
+        remote.features = await probeRemoteHostFeatures(remote.client, remote.clientVersion);
+        if (!remote.features.codex) {
+            throw new ClientModeError('FEATURE_NOT_SUPPORTED', 'The selected Host does not provide CodeX workspaces.');
+        }
+        this.assertRemoteCompatible(remote);
+        const virtual = CodexVirtualHarness.remote(remote.client, {
+            deviceId: remote.target.deviceId,
+            name: remote.target.name,
+        });
+        let workspace;
+        try {
+            workspace = await virtual.selectWorkspace(workspaceId, signal);
+        }
+        catch {
+            await virtual.close();
+            throw new ClientModeError('WORKSPACE_NOT_FOUND', 'The selected CodeX workspace is no longer available.');
+        }
+        await this.closeCodexVirtual();
+        this.codexVirtual = virtual;
+        this.selectCodexTarget(virtual, remote);
+        const preferredSessionId = await virtual.preferredSessionId(signal);
+        this.pendingWorkspaceSelection = {
+            targetDeviceId: remote.target.deviceId,
+            workspaceId,
+            backend: 'codex',
+            ...(preferredSessionId === undefined ? {} : { sessionId: preferredSessionId }),
+        };
+        this.logger.info('CodeX virtual workspace opened', { targetDeviceId: shortId(remote.target.deviceId) });
+        return { ...this.status(), workspace };
+    }
     consumeWorkspaceSelection(selection) {
         const pending = this.pendingWorkspaceSelection;
-        if (pending?.targetDeviceId === selection.targetDeviceId && pending.workspaceId === selection.workspaceId) {
+        if (pending?.targetDeviceId === selection.targetDeviceId
+            && pending.workspaceId === selection.workspaceId
+            && (pending.backend ?? 'harness') === (selection.backend ?? 'harness')) {
             this.pendingWorkspaceSelection = undefined;
         }
         return this.status();
@@ -262,6 +315,8 @@ export class ClientModeRuntime {
         this.proxySwitch?.selectLocal();
         this.gatewaySwitch.selectLocal();
         this.pendingWorkspaceSelection = undefined;
+        await this.closeCodexVirtual();
+        await this.closeCodexStreams(this.connected?.client);
         await this.connected?.client.close().catch(() => undefined);
         this.connected = undefined;
         this.proxySwitch?.restore();
@@ -277,6 +332,157 @@ export class ClientModeRuntime {
         }
         return remote.client.rpc('fileviewer.call', { endpoint, payload }, signal);
     }
+    activeRemote() {
+        return this.connected;
+    }
+    activeCodexRemote() {
+        const remote = this.activeRemote();
+        if (remote === undefined)
+            return undefined;
+        if (!remote.features.codex) {
+            return undefined;
+        }
+        return remote;
+    }
+    async openCodexStream(payload, signal) {
+        const remote = this.activeCodexRemote();
+        const value = record(payload);
+        if (typeof value.streamId !== 'string' || value.streamId.length === 0 || value.streamId.length > 128
+            || typeof value.threadId !== 'string' || value.threadId.length === 0) {
+            throw new ClientModeError('INVALID_MESSAGE', 'A Codex stream and thread are required.');
+        }
+        if (this.codexStreams.has(value.streamId))
+            throw new ClientModeError('REQUEST_CONFLICT', 'The Codex stream is already open.');
+        let wake = () => undefined;
+        const stream = {
+            target: remote === undefined ? { kind: 'local' } : { kind: 'remote', client: remote.client },
+            frames: [],
+            unsubscribe: () => undefined,
+            close: async () => {
+                if (remote === undefined) {
+                    await this.host?.codexCloseStream?.({ streamId: value.streamId }).catch(() => undefined);
+                    return;
+                }
+                await remote.client.rpc('codex.app.stream.close', { streamId: value.streamId }).catch(() => undefined);
+            },
+            wake: () => wake(),
+        };
+        if (remote === undefined) {
+            const host = this.requireLocalCodex();
+            this.codexStreams.set(value.streamId, stream);
+            try {
+                const result = await host.codexOpenStream({ streamId: value.streamId, threadId: value.threadId }, this.publishLocalCodexFrame, signal);
+                return result;
+            }
+            catch (error) {
+                this.codexStreams.delete(value.streamId);
+                stream.wake();
+                throw error;
+            }
+        }
+        stream.unsubscribe = remote.client.onEvent(event => {
+            if (event.event === 'codex.app.frame' && isRecord(event.data) && event.data.streamId === value.streamId) {
+                this.appendCodexFrame(stream, event.data);
+            }
+            if (event.event === 'codex.app.stream.closed' && isRecord(event.data) && event.data.streamId === value.streamId) {
+                stream.closed = typeof event.data.reason === 'string' ? event.data.reason : 'closed';
+                stream.wake();
+            }
+        });
+        try {
+            // Subscribe before opening the Host stream so the first App Server
+            // notification cannot race past the loopback listener.
+            await remote.client.rpc('codex.app.stream.open', { streamId: value.streamId, threadId: value.threadId }, signal);
+        }
+        catch (error) {
+            stream.unsubscribe();
+            throw error;
+        }
+        this.codexStreams.set(value.streamId, stream);
+        return { opened: true, streamId: value.streamId, threadId: value.threadId };
+    }
+    publishLocalCodexFrame = async (event, data) => {
+        const streamId = data.streamId;
+        const stream = this.codexStreams.get(streamId);
+        if (stream === undefined || stream.target.kind !== 'local')
+            return;
+        if (event === 'codex.app.frame') {
+            this.appendCodexFrame(stream, data);
+            return;
+        }
+        const closed = data;
+        stream.closed = typeof closed.reason === 'string' ? closed.reason : 'closed';
+        stream.wake();
+    };
+    appendCodexFrame(stream, data) {
+        if (!isRecord(data) || !isRecord(data.frame) || typeof data.frame.method !== 'string')
+            return;
+        if (stream.frames.length >= 256) {
+            stream.closed = 'overflow';
+        }
+        else {
+            stream.frames.push({ method: data.frame.method, params: data.frame.params });
+        }
+        stream.wake();
+    }
+    localCodexAvailable() {
+        return this.host?.codexStatus?.().available === true;
+    }
+    requireLocalCodex() {
+        if (!this.localCodexAvailable()
+            || this.host?.codexCall === undefined
+            || this.host.codexRespond === undefined
+            || this.host.codexOpenStream === undefined
+            || this.host.codexCloseStream === undefined) {
+            throw new ClientModeError('FEATURE_NOT_SUPPORTED', 'Local CodeX is disabled or unavailable on this Host.');
+        }
+        return {
+            codexCall: this.host.codexCall.bind(this.host),
+            codexRespond: this.host.codexRespond.bind(this.host),
+            codexOpenStream: this.host.codexOpenStream.bind(this.host),
+            codexCloseStream: this.host.codexCloseStream.bind(this.host),
+        };
+    }
+    async nextCodexFrames(payload, signal) {
+        const value = record(payload);
+        if (typeof value.streamId !== 'string')
+            throw new ClientModeError('INVALID_MESSAGE', 'A Codex stream is required.');
+        const stream = this.codexStreams.get(value.streamId);
+        if (stream === undefined)
+            throw new ClientModeError('STREAM_NOT_FOUND', 'The Codex stream is not open.');
+        if (stream.frames.length === 0 && stream.closed === undefined)
+            await waitForCodexFrames(stream, signal);
+        const frames = stream.frames.splice(0, 100);
+        return {
+            streamId: value.streamId,
+            frames,
+            closed: stream.closed !== undefined,
+            ...(stream.closed === undefined ? {} : { reason: stream.closed }),
+        };
+    }
+    async closeCodexStream(payload) {
+        const value = record(payload);
+        if (typeof value.streamId !== 'string')
+            throw new ClientModeError('INVALID_MESSAGE', 'A Codex stream is required.');
+        const stream = this.codexStreams.get(value.streamId);
+        if (stream === undefined)
+            return { closed: false, streamId: value.streamId };
+        this.codexStreams.delete(value.streamId);
+        stream.unsubscribe();
+        stream.wake();
+        await stream.close();
+        return { closed: true, streamId: value.streamId };
+    }
+    async closeCodexStreams(client) {
+        const targets = [...this.codexStreams.entries()].filter(([, stream]) => (client === undefined || (stream.target.kind === 'remote' && stream.target.client === client)));
+        await Promise.all(targets.map(async ([streamId, stream]) => {
+            this.codexStreams.delete(streamId);
+            stream.unsubscribe();
+            stream.closed = 'peer-disconnected';
+            stream.wake();
+            await stream.close();
+        }));
+    }
     selectRemoteTarget(remote) {
         const target = { deviceId: remote.target.deviceId, name: remote.target.name };
         if (this.gatewaySwitch.supportsCarrier()) {
@@ -289,6 +495,20 @@ export class ClientModeRuntime {
             list: remote.features.commandList,
         }, target);
     }
+    selectCodexTarget(virtual, remote) {
+        const target = { deviceId: remote.target.deviceId, name: remote.target.name };
+        if (this.gatewaySwitch.supportsCarrier()) {
+            this.gatewaySwitch.selectRemote(virtual, undefined, target);
+            return;
+        }
+        this.proxySwitch.selectRemote(virtual.api, target);
+        this.gatewaySwitch.selectRemote(request => virtual.invoke(request), { execute: true, list: true }, target);
+    }
+    async closeCodexVirtual() {
+        const virtual = this.codexVirtual;
+        this.codexVirtual = undefined;
+        await virtual?.close();
+    }
     assertRemoteCompatible(remote) {
         const localRemoteGateway = this.gatewaySwitch.supportsCarrier();
         if ((localRemoteGateway && remote.features.remoteGateway)
@@ -337,8 +557,14 @@ export class ClientModeRuntime {
                     targetDeviceId: shortId(target.deviceId),
                     attempt,
                     reason: diagnosticReason(error),
-                    ...webrtcDiagnosticsLogFields(diagnostics),
                 });
+                if (diagnostics !== undefined) {
+                    this.logger.debug('remote Harness WebRTC fallback diagnostics', {
+                        targetDeviceId: shortId(target.deviceId),
+                        attempt,
+                        ...webrtcDiagnosticsLogFields(diagnostics),
+                    });
+                }
             },
         });
         const attempts = this.config.forceRelay || rtcFactory === undefined
@@ -374,6 +600,7 @@ export class ClientModeRuntime {
                     return;
                 this.connected = undefined;
                 this.pendingWorkspaceSelection = undefined;
+                void this.closeCodexVirtual();
                 this.proxySwitch?.selectLocal();
                 this.gatewaySwitch.selectLocal();
                 void connectedClient.close().catch(() => undefined);
@@ -390,10 +617,21 @@ export class ClientModeRuntime {
                     negotiatedCapabilities: connectionDetails.negotiatedCapabilities,
                     webRtcEnabled: connectionDetails.webRtcEnabled,
                 }),
-                ...webrtcDiagnosticsLogFields(connectionDetails?.webRtc?.diagnostics),
             });
+            if (connectionDetails?.webRtc?.diagnostics !== undefined) {
+                this.logger.debug('remote Harness transport diagnostics', {
+                    targetDeviceId: shortId(target.deviceId),
+                    ...webrtcDiagnosticsLogFields(connectionDetails.webRtc.diagnostics),
+                });
+            }
             const features = await probeRemoteHostFeatures(connectedClient, serverDevice.clientVersion);
-            return { client: connectedClient, target, transport: connectedTransport, features };
+            return {
+                client: connectedClient,
+                target,
+                transport: connectedTransport,
+                features,
+                ...(serverDevice.clientVersion === undefined ? {} : { clientVersion: serverDevice.clientVersion }),
+            };
         }
         catch (error) {
             await client?.close().catch(() => undefined);
@@ -449,6 +687,12 @@ export class ClientModeRuntime {
                     throw new ClientModeError('INVALID_MESSAGE', 'A Host is required.');
                 return ok(await this.listRemoteWorkspaces(value.targetDeviceId, signal));
             }
+            if (endpoint === 'codex.workspaces.list') {
+                const value = record(payload);
+                if (typeof value.targetDeviceId !== 'string')
+                    throw new ClientModeError('INVALID_MESSAGE', 'A Host is required.');
+                return ok(await this.listCodexWorkspaces(value.targetDeviceId, signal));
+            }
             if (endpoint === 'workspace.open') {
                 const value = record(payload);
                 if (typeof value.targetDeviceId !== 'string' || typeof value.path !== 'string') {
@@ -456,6 +700,13 @@ export class ClientModeRuntime {
                 }
                 return ok(await this.openRemoteWorkspace(value.targetDeviceId, value.path, signal));
             }
+            if (endpoint === 'codex.workspace.open') {
+                const value = record(payload);
+                if (typeof value.targetDeviceId !== 'string' || typeof value.workspaceId !== 'string') {
+                    throw new ClientModeError('INVALID_MESSAGE', 'A Host and CodeX Workspace are required.');
+                }
+                return ok(await this.openCodexWorkspace(value.targetDeviceId, value.workspaceId, signal));
+            }
             if (endpoint === 'workspace.selection.consume') {
                 const value = record(payload);
                 if (typeof value.targetDeviceId !== 'string' || typeof value.workspaceId !== 'string') {
@@ -464,6 +715,8 @@ export class ClientModeRuntime {
                 return ok(this.consumeWorkspaceSelection({
                     targetDeviceId: value.targetDeviceId,
                     workspaceId: value.workspaceId,
+                    ...(value.backend === 'codex' ? { backend: 'codex' } : {}),
+                    ...(typeof value.sessionId === 'string' ? { sessionId: value.sessionId } : {}),
                 }));
             }
             if (endpoint === 'fileviewer.stat' || endpoint === 'fileviewer.readRange' || endpoint === 'fileviewer.list') {
@@ -472,6 +725,47 @@ export class ClientModeRuntime {
                     : endpoint === 'fileviewer.readRange' ? 'readRange' : 'list';
                 return ok(await this.callRemoteFileViewer(method, payload, signal));
             }
+            if (endpoint === 'codex.call') {
+                const value = record(payload);
+                if (typeof value.method !== 'string' || !('params' in value)) {
+                    throw new ClientModeError('INVALID_MESSAGE', 'A Codex method and params are required.');
+                }
+                const remote = this.activeCodexRemote();
+                if (remote !== undefined)
+                    return ok(await new CodexRemoteClient(remote.client).request(value.method, value.params, signal));
+                const host = this.requireLocalCodex();
+                return ok(await host.codexCall(value, signal));
+            }
+            if (endpoint === 'codex.probe') {
+                const local = this.localCodexAvailable();
+                let remoteSupported = false;
+                const remote = this.activeRemote();
+                if (remote !== undefined) {
+                    try {
+                        remote.features = await probeRemoteHostFeatures(remote.client, remote.clientVersion);
+                        remoteSupported = remote.features.codex;
+                    }
+                    catch (error) {
+                        if (!local)
+                            throw error;
+                    }
+                }
+                return ok({ supported: local || remoteSupported, local, remote: remoteSupported });
+            }
+            if (endpoint === 'codex.respond') {
+                const value = record(payload);
+                const remote = this.activeCodexRemote();
+                if (remote !== undefined)
+                    return ok(await remote.client.rpc('codex.app.respond', value, signal));
+                const host = this.requireLocalCodex();
+                return ok(await host.codexRespond(value, signal));
+            }
+            if (endpoint === 'codex.stream.open')
+                return ok(await this.openCodexStream(payload, signal));
+            if (endpoint === 'codex.stream.next')
+                return ok(await this.nextCodexFrames(payload, signal));
+            if (endpoint === 'codex.stream.close')
+                return ok(await this.closeCodexStream(payload));
             if (endpoint === 'host.account.login') {
                 if (this.host === undefined)
                     throw new ClientModeError('METHOD_NOT_ALLOWED', 'This plugin is not running as a Host.');
@@ -666,6 +960,7 @@ export function remoteHostFeatures(clientVersion) {
         fileViewer: isVersionAtLeast(clientVersion, REMOTE_FILE_VIEWER_MIN_VERSION),
         apiProxy: true,
         remoteGateway: false,
+        codex: false,
     };
 }
 export async function probeRemoteHostFeatures(client, clientVersion) {
@@ -694,8 +989,35 @@ export async function probeRemoteHostFeatures(client, clientVersion) {
         fileViewer: capabilities.has('fileviewer.read.v1'),
         apiProxy,
         remoteGateway,
+        codex: capabilities.has('codex.appserver.v1'),
     };
 }
+async function waitForCodexFrames(stream, signal) {
+    if (signal?.aborted)
+        throw new ClientModeError('RPC_ABORTED', 'The Codex event poll was cancelled.');
+    await new Promise((resolve, reject) => {
+        const previousWake = stream.wake;
+        const timer = setTimeout(done, 25_000);
+        const onAbort = () => {
+            cleanup();
+            reject(new ClientModeError('RPC_ABORTED', 'The Codex event poll was cancelled.'));
+        };
+        function cleanup() {
+            clearTimeout(timer);
+            stream.wake = previousWake;
+            signal?.removeEventListener('abort', onAbort);
+        }
+        function done() {
+            cleanup();
+            resolve();
+        }
+        stream.wake = () => {
+            previousWake();
+            done();
+        };
+        signal?.addEventListener('abort', onAbort, { once: true });
+    });
+}
 function isVersionAtLeast(value, minimum) {
     const match = value?.match(/^v?(\d+)\.(\d+)\.(\d+)(?:[-+].*)?$/);
     if (match === undefined || match === null)