ds-harness-remote 0.4.26 → 0.5.0

package/dist/client-runtime.js

@@ -1,5 +1,6 @@
 import { LoopbackPreview } from './loopback-preview.js';
-import { CodexRemoteClient, RemoteClientCore } from '@dsh-remote/client-core';
+import { parseRemoteWorkspaceTypes, } from '@dsh-remote/protocol';
+import { AgentAcpClient, CodexRemoteClient, RemoteClientCore, remoteWorkspaceTypeAvailable } 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';
@@ -9,13 +10,22 @@ import { harnessSessionGeneration } from './harness-version.js';
 import { RemoteHarnessApiProxy } from './remote-api-proxy.js';
 import { RemoteTypertGateway } from './remote-typert-gateway.js';
 import { codexProjectWorkspaceId, CodexVirtualHarness, discoverCodexVirtualWorkspaces, } from './codex/virtual-harness.js';
+import { AcpVirtualHarness, discoverAcpVirtualWorkspaces, } from './acp/virtual-harness.js';
 import { ServerApiError, } from './server-api.js';
 import { TypertGatewaySwitch } from './typert-gateway-switch.js';
 import { loadNodeRtcFactory } from './werift-rtc.js';
+import { safeErrorCode } from './safe-error.js';
 const REMOTE_COMMAND_LIST_MIN_VERSION = [0, 3, 16];
 const REMOTE_FILE_VIEWER_MIN_VERSION = [0, 3, 17];
 const DIRECT_WEBRTC_NEGOTIATE_TIMEOUT_MS = 12_000;
 const DIRECT_LAN_PROGRESS_DISPLAY_MS = 1_400;
+const HOST_AUTHORIZATION_ERRORS = new Set([
+    'ACCOUNT_AUTH_REQUIRED',
+    'AUTH_INVALID',
+    'DEVICE_OWNERSHIP_REQUIRED',
+    'DEVICE_REVOKED',
+    'TOKEN_EXPIRED',
+]);
 export class ClientModeRuntime {
     config;
     identities;
@@ -28,6 +38,8 @@ export class ClientModeRuntime {
     connected;
     pendingWorkspaceSelection;
     codexVirtual;
+    cursorVirtual;
+    acpVirtualBackend = 'cursor';
     proxySwitch;
     gatewaySwitch;
     codexStreams = new Map();
@@ -55,6 +67,39 @@ export class ClientModeRuntime {
             deviceId: shortId(this.identity.deviceId),
             fingerprint: this.identity.fingerprint,
         });
+        // A previously authorized Client should make the local Host controllable
+        // on startup as well. Do not register an anonymous Client just to probe:
+        // only persisted Client credentials opt into this default.
+        if (this.config.hostControl?.enabled !== false
+            && this.host !== undefined
+            && this.server.hasStoredAuthorization !== undefined) {
+            try {
+                if (await this.server.hasStoredAuthorization()
+                    && (this.host.hasStoredAuthorization === undefined || !await this.host.hasStoredAuthorization())) {
+                    await this.authorizeHostByDefault();
+                }
+            }
+            catch (error) {
+                this.logger.warn('automatic Host authorization failed', { code: safeErrorCode(error) });
+            }
+        }
+    }
+    async authorizeHostByDefault() {
+        try {
+            if (this.host === undefined)
+                return;
+            if (this.config.hostControl?.enabled === false)
+                return;
+            if (this.host.hostStatus().authorized)
+                return;
+            if (this.host.hasStoredAuthorization !== undefined && await this.host.hasStoredAuthorization())
+                return;
+            const credentials = await this.server.authenticate(this.requireIdentity());
+            await this.host.authorizeHostAsOwned(credentials.accessToken, credentials.account);
+        }
+        catch (error) {
+            this.logger.warn('automatic Host authorization failed', { code: safeErrorCode(error) });
+        }
     }
     registerControl(connection, webServer) {
         return registerControlRoute(connection, (endpoint, payload, signal) => this.handleControl(endpoint, payload, signal), webServer);
@@ -87,7 +132,9 @@ export class ClientModeRuntime {
             ...(this.pendingWorkspaceSelection === undefined
                 ? {}
                 : { workspaceSelection: { ...this.pendingWorkspaceSelection } }),
-            backend: this.codexVirtual === undefined ? 'harness' : 'codex',
+            backend: this.cursorVirtual !== undefined
+                ? this.acpVirtualBackend
+                : this.codexVirtual === undefined ? 'harness' : 'codex',
             hostAuthorizationAvailable: this.host !== undefined,
             ...(this.host === undefined ? {} : { host: this.host.hostStatus() }),
         };
@@ -122,6 +169,7 @@ export class ClientModeRuntime {
         };
     }
     async devices() {
+        this.assertHostAuthorizationForDeviceDiscovery();
         this.requireIdentity();
         const serverDevices = await this.server.listDevices();
         const remoteDevices = serverDevices.filter(device => device.deviceId !== this.host?.hostStatus().deviceId);
@@ -131,6 +179,23 @@ export class ClientModeRuntime {
             return { ...device, ...presence };
         }));
     }
+    /**
+     * Device discovery is exposed through the local app control route. When this
+     * installation also runs a Host, keep that route closed after the Host's
+     * Server credential has become terminally invalid. The Client credential can
+     * remain usable for a short time after a revoke, so checking only
+     * `ClientServerApi.listDevices()` would otherwise leak the device directory
+     * from a Host that the user has already been told to re-authorize.
+     */
+    assertHostAuthorizationForDeviceDiscovery() {
+        const status = this.host?.hostStatus();
+        if (status === undefined || status.error === undefined || !HOST_AUTHORIZATION_ERRORS.has(status.error))
+            return;
+        const message = status.error === 'DEVICE_REVOKED'
+            ? 'The local Host was revoked on the Server. Sign out and authorize this Host again.'
+            : 'The local Host authorization is no longer valid. Sign out and authorize this Host again.';
+        throw new ClientModeError(status.error, message);
+    }
     async authorizeClientWithAccount(email, password) {
         let authorization;
         try {
@@ -143,6 +208,7 @@ export class ClientModeRuntime {
             this.server.bindIdentity(this.identity);
             authorization = await this.server.authorizeWithAccount(this.identity, email, password);
         }
+        await this.authorizeHostByDefault();
         this.logger.info('Client account authorized');
         return authorization;
     }
@@ -158,6 +224,8 @@ export class ClientModeRuntime {
         });
         if (result.status === 'complete')
             this.logger.info('Client account authorized with QR login');
+        if (result.status === 'complete')
+            await this.authorizeHostByDefault();
         return result;
     }
     async clearClientAuthorization() {
@@ -166,6 +234,7 @@ export class ClientModeRuntime {
         this.connectionProgress = undefined;
         this.pendingWorkspaceSelection = undefined;
         await this.closeCodexVirtual();
+        await this.closeCursorVirtual();
         this.proxySwitch?.selectLocal();
         await this.closePreview();
         this.gatewaySwitch.selectLocal();
@@ -189,6 +258,7 @@ export class ClientModeRuntime {
     async setMode(mode, targetDeviceId, signal) {
         if (mode === 'local') {
             await this.closeCodexVirtual();
+            await this.closeCursorVirtual();
             this.proxySwitch?.selectLocal();
             await this.closePreview();
             this.gatewaySwitch.selectLocal();
@@ -219,6 +289,7 @@ export class ClientModeRuntime {
         this.clearConnectionProgress(next.progressRunId);
         this.pendingWorkspaceSelection = undefined;
         await this.closeCodexVirtual();
+        await this.closeCursorVirtual();
         this.selectRemoteTarget(next);
         await this.closeCodexStreams(previous?.client);
         await previous?.client.close().catch(() => undefined);
@@ -279,6 +350,7 @@ export class ClientModeRuntime {
             workspace = unwrapNativeResult(response);
         }
         await this.closeCodexVirtual();
+        await this.closeCursorVirtual();
         this.selectRemoteTarget(remote, transport);
         const workspaceId = workspaceRecordId(workspace.workspace);
         this.pendingWorkspaceSelection = { targetDeviceId: remote.target.deviceId, workspaceId };
@@ -313,6 +385,7 @@ export class ClientModeRuntime {
             throw new ClientModeError('WORKSPACE_NOT_FOUND', 'The selected CodeX workspace is no longer available.');
         }
         await this.closeCodexVirtual();
+        await this.closeCursorVirtual();
         this.codexVirtual = virtual;
         this.selectCodexTarget(virtual, remote);
         const preferredSessionId = await virtual.preferredSessionId(signal);
@@ -346,6 +419,81 @@ export class ClientModeRuntime {
         }
         return this.openCodexWorkspace(targetDeviceId, codexProjectWorkspaceId(project.id), signal);
     }
+    async listCursorWorkspaces(targetDeviceId, signal, backend = 'cursor') {
+        const remote = await this.ensureConnected(targetDeviceId, signal);
+        remote.features = await probeRemoteHostFeatures(remote.client, remote.clientVersion);
+        if (backend === 'antigravity' ? !remote.features.antigravity : !remote.features.cursor) {
+            throw new ClientModeError('FEATURE_NOT_SUPPORTED', `The selected Host does not provide ${backend} workspaces.`);
+        }
+        if (this.cursorVirtual !== undefined && this.connected?.target.deviceId === targetDeviceId && this.acpVirtualBackend === backend) {
+            return this.cursorVirtual.workspaces();
+        }
+        const acpClient = new AgentAcpClient(remote.client);
+        const workspaces = await discoverAcpVirtualWorkspaces(acpClient, backend, signal);
+        return workspaces;
+    }
+    async openCursorWorkspace(targetDeviceId, workspaceId, signal, backend = 'cursor') {
+        const remote = await this.ensureConnected(targetDeviceId, signal);
+        remote.features = await probeRemoteHostFeatures(remote.client, remote.clientVersion);
+        if (backend === 'antigravity' ? !remote.features.antigravity : !remote.features.cursor) {
+            throw new ClientModeError('FEATURE_NOT_SUPPORTED', `The selected Host does not provide ${backend} workspaces.`);
+        }
+        this.assertLocalHarnessCarrierAvailable();
+        const virtual = AcpVirtualHarness.remote(remote.client, {
+            deviceId: remote.target.deviceId,
+            name: remote.target.name,
+        }, backend, remote.features.acpModelLoadsSession ? ['agent.acp.antigravity.model-load.v1'] : []);
+        let workspace;
+        try {
+            workspace = await virtual.selectWorkspace(workspaceId);
+        }
+        catch {
+            await virtual.close();
+            throw new ClientModeError('WORKSPACE_NOT_FOUND', `The selected ${backend} workspace is no longer available.`);
+        }
+        await this.closeCodexVirtual();
+        await this.closeCursorVirtual();
+        this.cursorVirtual = virtual;
+        this.acpVirtualBackend = backend;
+        this.selectCursorTarget(virtual, remote);
+        const preferredSessionId = await virtual.preferredSessionId();
+        this.pendingWorkspaceSelection = {
+            targetDeviceId: remote.target.deviceId,
+            workspaceId: workspace.workspaceId,
+            backend,
+            ...(preferredSessionId === undefined ? {} : { sessionId: preferredSessionId }),
+        };
+        this.logger.info(`${backend} virtual workspace opened`, { targetDeviceId: shortId(remote.target.deviceId) });
+        return { ...this.status(), workspace };
+    }
+    async createCursorWorkspace(targetDeviceId, path, signal, backend = 'cursor') {
+        const trimmedPath = path.trim();
+        if (trimmedPath === '')
+            throw new ClientModeError('INVALID_MESSAGE', `A ${backend} project directory is required.`);
+        const remote = await this.ensureConnected(targetDeviceId, signal);
+        remote.features = await probeRemoteHostFeatures(remote.client, remote.clientVersion);
+        if (backend === 'antigravity' ? !remote.features.antigravity : !remote.features.cursor) {
+            throw new ClientModeError('FEATURE_NOT_SUPPORTED', `The selected Host does not provide ${backend} workspaces.`);
+        }
+        this.assertLocalHarnessCarrierAvailable();
+        const virtual = AcpVirtualHarness.remote(remote.client, {
+            deviceId: remote.target.deviceId,
+            name: remote.target.name,
+        }, backend, remote.features.acpModelLoadsSession ? ['agent.acp.antigravity.model-load.v1'] : []);
+        const workspace = await virtual.selectOrCreateWorkspace(trimmedPath);
+        await this.closeCodexVirtual();
+        await this.closeCursorVirtual();
+        this.cursorVirtual = virtual;
+        this.acpVirtualBackend = backend;
+        this.selectCursorTarget(virtual, remote);
+        this.pendingWorkspaceSelection = {
+            targetDeviceId: remote.target.deviceId,
+            workspaceId: workspace.workspaceId,
+            backend,
+        };
+        this.logger.info(`${backend} virtual workspace created`, { targetDeviceId: shortId(remote.target.deviceId) });
+        return { ...this.status(), workspace };
+    }
     consumeWorkspaceSelection(selection) {
         const pending = this.pendingWorkspaceSelection;
         if (pending?.targetDeviceId === selection.targetDeviceId
@@ -365,6 +513,7 @@ export class ClientModeRuntime {
         this.gatewaySwitch.selectLocal();
         this.pendingWorkspaceSelection = undefined;
         await this.closeCodexVirtual();
+        await this.closeCursorVirtual();
         await this.closeCodexStreams(this.connected?.client);
         await this.connected?.client.close().catch(() => undefined);
         this.connected = undefined;
@@ -563,6 +712,20 @@ export class ClientModeRuntime {
         this.codexVirtual = undefined;
         await virtual?.close();
     }
+    async closeCursorVirtual() {
+        const virtual = this.cursorVirtual;
+        this.cursorVirtual = undefined;
+        await virtual?.close();
+    }
+    selectCursorTarget(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);
+    }
     assertRemoteCompatible(remote) {
         this.selectHarnessRemoteTransport(remote);
     }
@@ -682,10 +845,11 @@ export class ClientModeRuntime {
                 this.connectionProgress = undefined;
                 this.pendingWorkspaceSelection = undefined;
                 void this.closeCodexVirtual();
-                this.proxySwitch?.selectLocal();
-                this.gatewaySwitch.selectLocal();
+                void this.closeCursorVirtual();
+                this.proxySwitch?.disconnectRemote();
+                this.gatewaySwitch.disconnectRemote();
                 void connectedClient.close().catch(() => undefined);
-                this.logger.warn('remote Harness transport closed; falling back to local mode', {
+                this.logger.warn('remote Harness transport closed; keeping Remote authority disconnected', {
                     targetDeviceId: shortId(target.deviceId),
                 });
             });
@@ -837,6 +1001,46 @@ export class ClientModeRuntime {
                 }
                 return ok(await this.createCodexWorkspace(value.targetDeviceId, value.path, signal));
             }
+            if (endpoint === 'cursor.workspaces.list') {
+                const value = record(payload);
+                if (typeof value.targetDeviceId !== 'string')
+                    throw new ClientModeError('INVALID_MESSAGE', 'A Host is required.');
+                return ok(await this.listCursorWorkspaces(value.targetDeviceId, signal, 'cursor'));
+            }
+            if (endpoint === 'cursor.workspace.open') {
+                const value = record(payload);
+                if (typeof value.targetDeviceId !== 'string' || typeof value.workspaceId !== 'string') {
+                    throw new ClientModeError('INVALID_MESSAGE', 'A Host and Cursor Workspace are required.');
+                }
+                return ok(await this.openCursorWorkspace(value.targetDeviceId, value.workspaceId, signal, 'cursor'));
+            }
+            if (endpoint === 'cursor.workspace.create') {
+                const value = record(payload);
+                if (typeof value.targetDeviceId !== 'string' || typeof value.path !== 'string') {
+                    throw new ClientModeError('INVALID_MESSAGE', 'A Host and Cursor project directory are required.');
+                }
+                return ok(await this.createCursorWorkspace(value.targetDeviceId, value.path, signal, 'cursor'));
+            }
+            if (endpoint === 'antigravity.workspaces.list') {
+                const value = record(payload);
+                if (typeof value.targetDeviceId !== 'string')
+                    throw new ClientModeError('INVALID_MESSAGE', 'A Host is required.');
+                return ok(await this.listCursorWorkspaces(value.targetDeviceId, signal, 'antigravity'));
+            }
+            if (endpoint === 'antigravity.workspace.open') {
+                const value = record(payload);
+                if (typeof value.targetDeviceId !== 'string' || typeof value.workspaceId !== 'string') {
+                    throw new ClientModeError('INVALID_MESSAGE', 'A Host and Antigravity Workspace are required.');
+                }
+                return ok(await this.openCursorWorkspace(value.targetDeviceId, value.workspaceId, signal, 'antigravity'));
+            }
+            if (endpoint === 'antigravity.workspace.create') {
+                const value = record(payload);
+                if (typeof value.targetDeviceId !== 'string' || typeof value.path !== 'string') {
+                    throw new ClientModeError('INVALID_MESSAGE', 'A Host and Antigravity project directory are required.');
+                }
+                return ok(await this.createCursorWorkspace(value.targetDeviceId, value.path, signal, 'antigravity'));
+            }
             if (endpoint === 'workspace.selection.consume') {
                 const value = record(payload);
                 if (typeof value.targetDeviceId !== 'string' || typeof value.workspaceId !== 'string') {
@@ -845,7 +1049,7 @@ export class ClientModeRuntime {
                 return ok(this.consumeWorkspaceSelection({
                     targetDeviceId: value.targetDeviceId,
                     workspaceId: value.workspaceId,
-                    ...(value.backend === 'codex' ? { backend: 'codex' } : {}),
+                    ...(value.backend === 'codex' || value.backend === 'cursor' || value.backend === 'antigravity' ? { backend: value.backend } : {}),
                     ...(typeof value.sessionId === 'string' ? { sessionId: value.sessionId } : {}),
                 }));
             }
@@ -1096,6 +1300,8 @@ export function remoteHostFeatures(clientVersion) {
         apiProxy: true,
         remoteGateway: false,
         codex: false,
+        cursor: false,
+        antigravity: false,
     };
 }
 export async function probeRemoteHostFeatures(client, clientVersion) {
@@ -1118,13 +1324,17 @@ export async function probeRemoteHostFeatures(client, clientVersion) {
     const remoteV1 = capabilities.has('harness.remote.v1');
     const remoteV3 = capabilities.has('harness.remote.v3');
     const terminal = capabilities.has('harness.terminal.v1');
-    const codex = capabilities.has('codex.appserver.v1');
+    const workspaceTypes = 'workspaceTypes' in value ? parseRemoteWorkspaceTypes(value.workspaceTypes) : undefined;
+    const available = (id, capability) => remoteWorkspaceTypeAvailable(value.capabilities, workspaceTypes, id, capability);
+    const codex = available('codex', 'codex.appserver.v1');
+    const cursor = available('cursor', 'agent.acp.cursor.v1');
+    const antigravity = available('antigravity', 'agent.acp.antigravity.v1');
     if (remoteV1 && remoteV3) {
         throw new ClientModeError('INVALID_MESSAGE', 'The remote Host advertised conflicting Harness Session formats.');
     }
     const sessionFormat = remoteV3 ? 3 : undefined;
     const remoteGateway = remoteV3 || remoteV1;
-    if (!apiProxy && !remoteGateway && !codex) {
+    if (!apiProxy && !remoteGateway && !codex && !cursor && !antigravity) {
         throw new ClientModeError('FEATURE_NOT_SUPPORTED', 'The remote Host exposes no supported Harness transport.');
     }
     return {
@@ -1135,6 +1345,10 @@ export async function probeRemoteHostFeatures(client, clientVersion) {
         remoteGateway,
         ...(sessionFormat === undefined ? {} : { sessionFormat }),
         codex,
+        cursor,
+        antigravity,
+        ...(capabilities.has('agent.acp.antigravity.model-load.v1') ? { acpModelLoadsSession: true } : {}),
+        ...(workspaceTypes === undefined ? {} : { workspaceTypes }),
     };
 }
 async function waitForCodexFrames(stream, signal) {