@platless/axom-cli 0.5.9 → 0.6.52

package/dist/workstation/desktopControl/deviceSockets.js

@@ -0,0 +1,246 @@
+import WebSocket from 'ws';
+import { randomBytes } from 'node:crypto';
+import { openQuicMedia } from './quicMedia.js';
+import { isTrustedPlaintextHost } from '../channels/url.js';
+import { decodeDesktopControl, encodeDesktopControl, parseDesktopJson } from './protocol.js';
+import { decodeDesktopTransport, encodeDesktopTransport } from './transport.js';
+import { bounded, DesktopQueue, NativeCommandError } from './helperProcess.js';
+import { mediaRequire } from './media.js';
+export function desktopSocketUrl(server, role, allow = false) {
+    const url = new URL(server);
+    mediaRequire(!url.username && !url.password && !url.search && !url.hash && ['https:', 'http:'].includes(url.protocol));
+    mediaRequire(url.protocol === 'https:' || allow && isTrustedPlaintextHost(url.hostname));
+    url.protocol = url.protocol === 'https:' ? 'wss:' : 'ws:';
+    url.pathname = `${url.pathname.replace(/\/$/, '')}/workstation/ws/desktop/${role}`;
+    return url;
+}
+/** Fixed paths, certificate validation on both legs, and no redirect/URL credential propagation. */
+export class DeviceSockets {
+    server;
+    allowPrivateWs;
+    quicRetryAt = 0;
+    constructor(server, allowPrivateWs = false) {
+        this.server = server;
+        this.allowPrivateWs = allowPrivateWs;
+    }
+    async uploadWallpaper(grant, wallpaper, unchanged = false) {
+        const url = desktopSocketUrl(this.server, 'media', this.allowPrivateWs);
+        url.protocol = url.protocol === 'wss:' ? 'https:' : 'http:';
+        url.pathname = url.pathname.replace(/\/ws\/desktop\/media$/, '/desktop/background');
+        const headers = { 'X-Axom-Background-Grant': grant, 'Content-Type': 'image/webp' };
+        if (wallpaper) {
+            headers['X-Axom-Background-Asset'] = Buffer.from(JSON.stringify(wallpaper.asset)).toString('base64url');
+            headers['X-Axom-Background-Unchanged'] = unchanged ? '1' : '0';
+        }
+        else
+            headers['X-Axom-Background-Error'] = 'unavailable';
+        const response = await fetch(url, { method: 'POST', redirect: 'error', signal: AbortSignal.timeout(10_000), headers,
+            body: wallpaper && !unchanged ? new Uint8Array(wallpaper.bytes) : undefined });
+        if (!response.ok)
+            throw new NativeCommandError('transport_failed');
+        await response.body?.cancel();
+    }
+    async control(binding, signal, current) {
+        const queue = new DesktopQueue();
+        const socket = await this.open(binding, binding.controlGrant, 'control', signal, current, bytes => {
+            const raw = parseDesktopJson(bytes);
+            if (raw.type === 'media_grant') {
+                const grant = decodeDesktopTransport(bytes);
+                mediaRequire(grant.type === 'media_grant' && grant.controlGeneration === binding.controlGeneration && grant.sessionId === binding.sessionId);
+                queue.push(grant);
+            }
+            else {
+                const message = decodeDesktopControl(bytes);
+                mediaRequire(message.sessionId === binding.sessionId && !['clipboard_result', 'offer', 'configured', 'input_result', 'resize_result', 'media_open', 'appearance_result', 'motion_cut_barrier', 'motion_cut_prepared', 'motion_cut_request', 'motion_cut_ack', 'motion_cut_fence', 'audio_configured', 'audio_state'].includes(message.type));
+                queue.push(message);
+            }
+        }, () => queue.close());
+        let overview;
+        let audio;
+        let audioOpening;
+        let audioSerial = 0;
+        const audioCostId = randomBytes(16).toString('hex');
+        let audioBytes = 0;
+        const prepareAudio = async () => {
+            if (!socket.audioToken || !current() || signal.aborted)
+                throw new NativeCommandError('audio_unavailable');
+            const serial = audioSerial;
+            audioOpening ??= this.open(binding, socket.audioToken, 'audio', signal, current, () => { });
+            const connection = await audioOpening;
+            if (serial !== audioSerial || !current()) {
+                connection.close();
+                throw new NativeCommandError('audio_unavailable');
+            }
+            audio = connection;
+            void connection.closed.then(() => { if (audio === connection) {
+                audio = undefined;
+                audioOpening = undefined;
+            } });
+        };
+        let retryAt = 0;
+        return { messages: queue, send: message => socket.send(encodeDesktopControl(message)),
+            prepareAudio: socket.audioToken ? prepareAudio : undefined,
+            sendAudio: socket.audioToken ? async (bytes) => {
+                if (!current() || signal.aborted)
+                    return false;
+                const serial = audioSerial;
+                try {
+                    if (!audio)
+                        await prepareAudio();
+                    const connection = audio;
+                    if (serial !== audioSerial || !current()) {
+                        connection.close();
+                        return false;
+                    }
+                    audio = connection;
+                    await bounded(connection.send(bytes), 80, 'audio_stale');
+                    audioBytes += bytes.length + 32;
+                    return true;
+                }
+                catch {
+                    audio?.close();
+                    audio = undefined;
+                    audioOpening = undefined;
+                    return false;
+                }
+            } : undefined,
+            stopAudio: () => {
+                audioSerial++;
+                audio?.close();
+                void audioOpening?.then(connection => connection.close(), () => { });
+                audio = undefined;
+                audioOpening = undefined;
+            },
+            audioTransportCost: () => ({ id: audioCostId, totalBytes: audioBytes }),
+            sendOverview: socket.overviewToken ? async (bytes) => {
+                if (performance.now() < retryAt || !current() || signal.aborted)
+                    return false;
+                try {
+                    overview ??= await this.open(binding, socket.overviewToken, 'overview', signal, current, () => { });
+                    await overview.send(bytes);
+                    return true;
+                }
+                catch {
+                    overview?.close();
+                    overview = undefined;
+                    retryAt = performance.now() + 5000;
+                    return false;
+                }
+            } : undefined,
+            close: () => { audioSerial++; audio?.close(); overview?.close(); socket.close(); } };
+    }
+    async media(binding, grant, signal, current, quic) {
+        desktopSocketUrl(this.server, 'media', this.allowPrivateWs); // Apply the same origin/TLS policy before either transport.
+        if (quic && binding.mediaTransport !== 'wss' && (binding.mediaTransport === 'quic' || performance.now() >= this.quicRetryAt)) {
+            const native = await openQuicMedia(this.server, quic, signal, current);
+            if (native) {
+                // Once the single-use credential is sent, recovery needs a fresh epoch;
+                // never replay it over WSS after an ambiguous attachment acknowledgement.
+                try {
+                    await native.send(2, Buffer.from(encodeDesktopTransport({ type: 'device_attach', sessionId: binding.sessionId, grant })));
+                    const ack = await native.receive(5000);
+                    mediaRequire(ack.kind === 2);
+                    const attached = decodeDesktopTransport(ack.bytes);
+                    mediaRequire(attached.type === 'attached' && attached.sessionId === binding.sessionId && attached.role === 'device_media' && attached.controlGeneration === binding.controlGeneration);
+                    console.error(JSON.stringify({ event: 'desktop_media_attached', transport: 'quic', role: 'device_media', session: binding.sessionId }));
+                    void native.receive().then(() => native.close(), () => native.close());
+                    const id = randomBytes(16).toString('hex');
+                    return { sendAudio: native.sendAudio, transportCost: () => ({ id, totalBytes: native.transportCost() }), networkSample: () => { const stats = native.pathStats(); return stats ? { ...stats, id } : undefined; }, send: bytes => native.send(3, bytes), close: () => native.close(), closed: native.closed, cutEvents: native.cutEvents, cutCommand: native.cutCommand, finishCut: native.finishCut };
+                }
+                catch (error) {
+                    this.quicRetryAt = performance.now() + 60000;
+                    native.close();
+                    throw error;
+                }
+            }
+            else
+                this.quicRetryAt = performance.now() + 60000;
+        }
+        if (binding.mediaTransport === 'quic')
+            throw new NativeCommandError('transport_failed');
+        const socket = await this.open(binding, grant, 'media', signal, current, () => { throw new NativeCommandError('invalid_request'); });
+        console.error(JSON.stringify({ event: 'desktop_media_attached', transport: 'wss', role: 'device_media', fallback: !quic ? 'not_offered' : 'connect_failed_or_backoff', session: binding.sessionId }));
+        const id = randomBytes(16).toString('hex');
+        let framingBytes = 0;
+        return { transportCost: () => ({ id, totalBytes: framingBytes }), send: async (bytes) => {
+                await socket.send(bytes);
+                framingBytes += bytes.length < 126 ? 6 : bytes.length <= 65535 ? 8 : 14;
+            }, sendCutBarrier: message => socket.send(encodeDesktopControl(message)), close: socket.close, closed: socket.closed };
+    }
+    async open(binding, grant, role, signal, current, onMessage, onClose = () => { }) {
+        mediaRequire(current() && !signal.aborted);
+        const ws = new WebSocket(desktopSocketUrl(this.server, role, this.allowPrivateWs), {
+            headers: role === 'control' ? { 'X-Axom-Desktop-Quic': '1', 'X-Axom-Desktop-Overview': '1', 'X-Axom-Desktop-Audio': '1' } : {},
+            rejectUnauthorized: true, followRedirects: false, maxPayload: 49152, perMessageDeflate: false,
+        });
+        let overviewToken;
+        let audioToken;
+        let attached = false, settle, reject;
+        const opening = new Promise((resolve, fail) => { settle = resolve; reject = fail; });
+        const close = () => { if (ws.readyState === WebSocket.CONNECTING || ws.readyState === WebSocket.OPEN)
+            ws.terminate(); };
+        const closed = new Promise(resolve => ws.once('close', () => {
+            signal.removeEventListener('abort', close);
+            onClose();
+            resolve();
+            if (!attached)
+                reject(new NativeCommandError('authorization_lost'));
+        }));
+        signal.addEventListener('abort', close, { once: true });
+        ws.on('error', () => { reject(new NativeCommandError('transport_failed')); close(); });
+        ws.once('open', () => {
+            if (!current() || signal.aborted) {
+                close();
+                return;
+            }
+            ws.send(encodeDesktopTransport({ type: 'device_attach', sessionId: binding.sessionId, grant }));
+        });
+        ws.on('message', (data, binary) => {
+            try {
+                if (!current() || signal.aborted) {
+                    close();
+                    return;
+                }
+                mediaRequire(!binary);
+                const bytes = Buffer.isBuffer(data) ? data : Buffer.from(data);
+                if (!attached) {
+                    const ack = decodeDesktopTransport(bytes);
+                    mediaRequire(ack.type === 'attached' && ack.sessionId === binding.sessionId && ack.role === (role === 'overview' || role === 'audio' ? 'device_control' : `device_${role}`) && ack.controlGeneration === binding.controlGeneration);
+                    overviewToken = ack.overviewToken;
+                    audioToken = ack.audioToken;
+                    attached = true;
+                    settle();
+                }
+                else
+                    onMessage(bytes);
+            }
+            catch {
+                reject(new NativeCommandError('invalid_request'));
+                close();
+            }
+        });
+        try {
+            await bounded(opening, 5000);
+            mediaRequire(current() && !signal.aborted);
+        }
+        catch (error) {
+            close();
+            throw error;
+        }
+        let sendTail = Promise.resolve();
+        let pending = 0;
+        return { close, closed, overviewToken, audioToken, send: bytes => {
+                if (pending >= (role === 'media' ? 3 : 2))
+                    return Promise.reject(new NativeCommandError('transport_failed'));
+                pending++;
+                const perform = async () => {
+                    // This is the last check after any queued await, immediately before ws.send.
+                    mediaRequire(current() && !signal.aborted && ws.readyState === WebSocket.OPEN && ws.bufferedAmount <= (role === 'media' ? 524288 : 65600));
+                    await bounded(new Promise((resolve, fail) => ws.send(bytes, error => error ? fail(new NativeCommandError('transport_failed')) : resolve())), 5000);
+                };
+                const sent = role === 'media' ? perform() : sendTail.then(perform);
+                sendTail = sent.catch(() => { close(); }).finally(() => { pending--; });
+                return sent;
+            } };
+    }
+}