@platless/axom-cli 0.5.9 → 0.6.36

package/dist/workstation/protocol/management.js

@@ -1,3 +1,4 @@
+import { decodeDesktopManagementFrame, parseDesktopJson, DesktopProtocolError } from '../desktopControl/protocol.js';
 import { decodeChannelFrame, hasOptional, hasRequired, isBoolean, isBridgeInfoArray, isNullableString, isNumber, isObject, isString, } from './common.js';
 export const MANAGEMENT_WIRE_MIN_VERSION = 1;
 /** Adds the `DRAINING` value to ClientUpdatePhase. */
@@ -12,7 +13,8 @@ export const MANAGEMENT_WIRE_LOAD_AVERAGES_VERSION = 6;
 export const MANAGEMENT_WIRE_GPU_VERSION = 7;
 /** Adds `keepers` to heartbeats and the `keeper_control` / `keeper_control_result` pair (spec §8.1, Task 26). */
 export const MANAGEMENT_WIRE_KEEPERS_VERSION = 8;
-export const MANAGEMENT_WIRE_VERSION = MANAGEMENT_WIRE_KEEPERS_VERSION;
+export const MANAGEMENT_WIRE_DESKTOP_VERSION = 9;
+export const MANAGEMENT_WIRE_VERSION = MANAGEMENT_WIRE_DESKTOP_VERSION;
 /** Bounds of one heartbeat's `keepers` (spec §8.1). */
 export const KEEPER_STATUS_MAX_ITEMS = 32;
 export const KEEPER_LABEL_MAX_CHARS = 64;
@@ -137,9 +139,11 @@ function isManagementFrame(value) {
             playgroundCwd: isString,
             protocols: (protocols) => isProtocolRangeMap(protocols, false),
             os: isNullable(isOsInfo),
+            toolchain: (toolchain) => isObject(toolchain) && hasRequired(toolchain, { python: isNullableString, node: isNullableString }),
             update: isNullable(isUpdateStatus),
             metrics: isNullable(isWorkstationMetrics),
             keepers: isNullable((keepers) => Array.isArray(keepers) && keepers.every(isKeeperStatus)),
+            capabilitiesRevision: value => Number.isSafeInteger(value) && value > 0,
         });
         case 'heartbeat_ack': return hasRequired(value, { seq: isNumber });
         case 'channel_ticket_request': return hasRequired(value, { channel: isChannelKind });
@@ -157,8 +161,93 @@ function isManagementFrame(value) {
     }
 }
 export function encodeManagementFrame(frame) {
-    return JSON.stringify(frame);
-}
-export function decodeManagementFrame(text) {
+    const text = JSON.stringify(frame);
+    if (isDesktopManagementType(frame.t))
+        decodeDesktopManagementFrame(text);
+    return text;
+}
+export function decodeManagementFrame(source) {
+    const text = typeof source === 'string' ? source : new TextDecoder('utf-8', { fatal: true }).decode(source);
+    // Desktop extensions get the strict lexical/shape guard before any lossy object parsing.
+    const parsed = JSON.parse(text);
+    if (isObject(parsed) && isDesktopManagementType(parsed.t))
+        return decodeDesktopManagementFrame(text);
+    if (isObject(parsed) && parsed.t === 'heartbeat' && Object.hasOwn(parsed, 'capabilitiesRevision'))
+        validateHeartbeatRevision(text);
     return decodeChannelFrame(text, DISCRIMINATORS, isManagementFrame);
 }
+/** Select only the new root field. JSON.parse already validates syntax; legacy nesting, size,
+ * unknown fields and duplicate legacy keys keep their established decoder behavior. */
+function validateHeartbeatRevision(text) {
+    let depth = 0, count = 0;
+    for (let offset = 0; offset < text.length; offset++) {
+        const char = text[offset];
+        if (char === '"') {
+            const start = offset++;
+            while (offset < text.length) {
+                if (text[offset] === '\\')
+                    offset += 2;
+                else if (text[offset++] === '"')
+                    break;
+            }
+            const end = offset--;
+            if (depth !== 1 || JSON.parse(text.slice(start, end)) !== 'capabilitiesRevision')
+                continue;
+            let tokenStart = end;
+            while (/\s/.test(text[tokenStart] ?? ''))
+                tokenStart++;
+            if (text[tokenStart] !== ':')
+                continue; // This string was a legacy field's value.
+            let tokenEnd = ++tokenStart;
+            while (tokenEnd < text.length && text[tokenEnd] !== ',' && text[tokenEnd] !== '}')
+                tokenEnd++;
+            const token = text.slice(tokenStart, tokenEnd).trim();
+            if (++count !== 1 || !/^[1-9][0-9]*$/.test(token) || !Number.isSafeInteger(Number(token))) {
+                throw new DesktopProtocolError('Invalid capabilities revision');
+            }
+            parseDesktopJson(`{"capabilitiesRevision":${token}}`);
+        }
+        else if (char === '{' || char === '[')
+            depth++;
+        else if (char === '}' || char === ']')
+            depth--;
+    }
+}
+function isDesktopManagementType(type) {
+    return typeof type === 'string' && ['desktop_background', 'desktop_lobby', 'desktop_lobby_result', 'workstation_capabilities', 'workstation_capabilities_request', 'desktop_prepare',
+        'desktop_prepare_result', 'desktop_cancel', 'desktop_session_state'].includes(type);
+}
+export class ManagementFrameAdmission {
+    isCurrent;
+    ready;
+    disposed = false;
+    constructor(isCurrent = () => true) {
+        this.isCurrent = isCurrent;
+    }
+    admit(frame) {
+        if (this.disposed || !this.isCurrent())
+            return false;
+        if (frame.t === 'management_ready') {
+            if (this.ready || !Number.isInteger(frame.protocols.MANAGEMENT) || frame.protocols.MANAGEMENT < MANAGEMENT_WIRE_MIN_VERSION
+                || frame.protocols.MANAGEMENT > MANAGEMENT_WIRE_VERSION || !frame.generation)
+                return false;
+            this.ready = frame;
+            return true;
+        }
+        if (frame.t === 'heartbeat' && frame.capabilitiesRevision !== undefined)
+            return false;
+        if (!isDesktopManagementType(frame.t))
+            return true;
+        if (!this.ready || this.ready.protocols.MANAGEMENT < MANAGEMENT_WIRE_DESKTOP_VERSION)
+            return false;
+        switch (frame.t) {
+            case 'workstation_capabilities_request': return frame.generation === this.ready.generation;
+            case 'desktop_lobby':
+            case 'desktop_background':
+            case 'desktop_prepare': return frame.deviceGeneration === this.ready.generation;
+            case 'desktop_cancel': return true; // Current socket binding; T10 additionally fences its session/control generation.
+            default: return false; // Device-authored reports/results/states cannot be echoed as server activity.
+        }
+    }
+    dispose() { this.disposed = true; }
+}

package/dist/workstation/protocol/runtimeDiagnostics.js

@@ -0,0 +1,15 @@
+export function isRuntimeDiagnostics(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return false;
+    const input = value;
+    const bounded = (value, max) => typeof value === 'string' &&
+        value.trim().length > 0 && value.length <= max && !/[\x00-\x1f\x7f]/.test(value);
+    if (!bounded(input.generation, 256) || !Number.isSafeInteger(input.revision) ||
+        input.revision < 0 || typeof input.available !== 'boolean' ||
+        !input.launch || typeof input.launch !== 'object')
+        return false;
+    const launch = input.launch;
+    return ['command-override', 'registry', 'registry-fallback', 'direct'].includes(launch.source) &&
+        bounded(launch.executable, 4096) && bounded(launch.platform, 64) && bounded(launch.architecture, 64) &&
+        launch.transport === 'stdio' && (input.profile === undefined || (typeof input.profile === 'object' && input.profile !== null && !Array.isArray(input.profile)));
+}

package/dist/workstation/rd/artifact.js

@@ -0,0 +1,119 @@
+import { promises as fs, constants } from 'node:fs';
+import path from 'node:path';
+import { createHash } from 'node:crypto';
+import { gunzipSync } from 'node:zlib';
+import { z } from 'zod';
+import { deploymentDownloadURL } from '../control/serverIdentity.js';
+import { downloadVerified } from '../update/artifact.js';
+import { privateDirectory } from '../keepers/kit/paths.js';
+const legacyRdFiles = ['bin/axom-desktop-keeper', 'bin/axom-input-guardian', 'bin/axom-quic', 'xorg.conf'];
+export const rdFiles = [...legacyRdFiles, 'bin/axom-display', 'bin/axom-desktop-session'];
+const sha256 = z.string().regex(/^[a-f0-9]{64}$/);
+export const rdArtifactSchema = z.object({ version: z.string().regex(/^[a-zA-Z0-9][a-zA-Z0-9._+-]{0,127}$/),
+    filename: z.string().regex(/^[a-zA-Z0-9][a-zA-Z0-9._+-]*\.(?:tar\.gz|tgz)$/),
+    url: z.string(), size: z.number().int().min(1).max(134217728), sha512: z.string().regex(/^[a-f0-9]{128}$/),
+    unpackedSize: z.number().int().min(1).max(268435456), ipcVersion: z.union([z.literal(1), z.literal(2)]),
+    files: z.record(z.string(), sha256),
+}).refine(artifact => {
+    const files = artifact.ipcVersion === 1 ? legacyRdFiles : rdFiles;
+    const licensed = artifact.ipcVersion === 2 && 'opus-LICENSE' in artifact.files;
+    return Object.keys(artifact.files).length === files.length + (licensed ? 1 : 0) && files.every(file => file in artifact.files);
+}, 'RD artifact files do not match its runtime version');
+export function rdPlatform(osRelease, architecture) {
+    const values = Object.fromEntries(osRelease.split('\n').map(line => /^([A-Z_]+)=["']?([^"']*)["']?$/.exec(line)).filter(Boolean).map(match => [match[1], match[2]]));
+    if (values.ID !== 'debian' || values.VERSION_ID !== '13' || architecture !== 'x64') {
+        throw new Error('Remote desktop currently supports Debian 13 amd64; this distribution/architecture has no qualified RD package');
+    }
+    return 'linux-x64-debian-13';
+}
+export function unpackRd(bytes, artifact) {
+    const archive = gunzipSync(bytes, { maxOutputLength: artifact.unpackedSize + 65536 });
+    const files = new Map();
+    let unpackedSize = 0;
+    let terminated = false;
+    for (let offset = 0; offset + 512 <= archive.length;) {
+        const header = archive.subarray(offset, offset + 512);
+        if (header.every(byte => byte === 0)) {
+            if (offset + 1024 > archive.length || archive.subarray(offset).some(byte => byte !== 0))
+                throw new Error('RD archive has an invalid terminator or trailing records');
+            terminated = true;
+            break;
+        }
+        const field = (start, length) => header.subarray(start, start + length).toString('utf8').replace(/\0.*$/s, '');
+        const name = field(0, 100), prefix = field(345, 155), sizeText = field(124, 12).trim();
+        const checksum = field(148, 8).trim();
+        const actualChecksum = header.reduce((sum, byte, index) => sum + (index >= 148 && index < 156 ? 32 : byte), 0);
+        if (field(257, 6) !== 'ustar' || field(263, 2) !== '00' || !/^[0-7]+$/.test(checksum) || Number.parseInt(checksum, 8) !== actualChecksum)
+            throw new Error('RD archive has an invalid USTAR header');
+        if (prefix || !/^[0-7]+$/.test(sizeText) || !Object.hasOwn(artifact.files, name) || files.has(name) || ![0, 48].includes(header[156])) {
+            throw new Error('RD archive contains an unexpected file, path, link or duplicate');
+        }
+        const size = Number.parseInt(sizeText, 8);
+        offset += 512;
+        unpackedSize += size;
+        if (!Number.isSafeInteger(size) || offset + size > archive.length || unpackedSize > artifact.unpackedSize)
+            throw new Error('RD archive exceeds its declared size');
+        const contents = archive.subarray(offset, offset + size);
+        if (createHash('sha256').update(contents).digest('hex') !== artifact.files[name])
+            throw new Error(`RD component checksum mismatch: ${name}`);
+        files.set(name, contents);
+        offset += Math.ceil(size / 512) * 512;
+    }
+    if (!terminated || files.size !== Object.keys(artifact.files).length || unpackedSize !== artifact.unpackedSize)
+        throw new Error('RD archive is incomplete');
+    return files;
+}
+export async function verifyRdInstallation(directory, artifact) {
+    for (const name of Object.keys(rdArtifactSchema.parse(artifact).files)) {
+        const file = await fs.open(path.join(directory, name), constants.O_RDONLY | constants.O_NOFOLLOW);
+        try {
+            const info = await file.stat();
+            if (!info.isFile() || info.uid !== process.getuid?.() || info.mode & 0o022 || info.size > artifact.unpackedSize)
+                throw new Error('Unsafe RD installation');
+            if (createHash('sha256').update(await file.readFile()).digest('hex') !== artifact.files[name])
+                throw new Error(`RD component checksum mismatch: ${name}`);
+        }
+        finally {
+            await file.close();
+        }
+    }
+}
+export async function installRd(directory, server, platform, fetchImpl = globalThis.fetch) {
+    const response = await fetchImpl(deploymentDownloadURL(server, '/download/client/desktop/manifest.json'), { redirect: 'error', signal: AbortSignal.timeout(15000) });
+    if (!response.ok)
+        throw new Error(`The server does not publish Linux RD packages (HTTP ${response.status})`);
+    const text = await response.text();
+    if (Buffer.byteLength(text) > 1048576)
+        throw new Error('RD catalog is too large');
+    const catalog = z.object({ schemaVersion: z.literal(1), artifacts: z.record(z.string(), rdArtifactSchema) }).parse(JSON.parse(text));
+    const artifact = catalog.artifacts[platform];
+    if (!artifact)
+        throw new Error(`The server has no RD package for ${platform}`);
+    if (artifact.url !== `/download/client/desktop/${artifact.filename}`)
+        throw new Error('RD artifact URL does not match its filename');
+    const target = path.join(directory, 'rd', 'versions', artifact.sha512.slice(0, 32));
+    try {
+        await verifyRdInstallation(target, artifact);
+        return { directory: target, artifact };
+    }
+    catch (error) {
+        if (error.code !== 'ENOENT')
+            throw error;
+    }
+    const downloaded = await downloadVerified(artifact, { server, fetch: fetchImpl });
+    await privateDirectory(path.dirname(target));
+    const staging = await fs.mkdtemp(path.join(path.dirname(target), '.install-'));
+    try {
+        const files = unpackRd(await fs.readFile(downloaded.path), artifact);
+        await privateDirectory(path.join(staging, 'bin'));
+        for (const [name, contents] of files)
+            await fs.writeFile(path.join(staging, name), contents, { flag: 'wx', mode: name.startsWith('bin/') ? 0o700 : 0o600 });
+        await verifyRdInstallation(staging, artifact);
+        await fs.rename(staging, target);
+        return { directory: target, artifact };
+    }
+    finally {
+        await downloaded.cleanup();
+        await fs.rm(staging, { recursive: true, force: true });
+    }
+}

package/dist/workstation/rd/control.js

@@ -0,0 +1,119 @@
+import { promises as fs } from 'node:fs';
+import path from 'node:path';
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+import { z } from 'zod';
+import { loadConfig, resolveServer } from '../../config.js';
+import { loadClientConfig } from '../config.js';
+import { normalizeWorkstationServer } from '../control/serverIdentity.js';
+import { withPrivateLock } from '../control/locks.js';
+import { installRd, rdPlatform } from './artifact.js';
+import { readRdState, writeRdState } from './state.js';
+import { chooseSession, discoverSessions } from './sessions.js';
+const execute = promisify(execFile);
+export function rdSessionSelection(previous, options) {
+    const session = z.enum(['auto', 'existing', 'virtual']).parse(options.rdSession ?? previous?.session ?? 'auto');
+    const display = options.rdDisplay ?? (options.rdSession === undefined ? previous?.display : undefined);
+    if (display !== undefined && !/^:\d+(?:\.\d+)?$/.test(display))
+        throw new Error('--rd-display must be a local X11 display such as :10');
+    if (session === 'virtual' && display)
+        throw new Error('--rd-display selects an existing session and cannot be combined with --rd-session virtual');
+    return { session, display };
+}
+export async function configureRd(directory, options) {
+    if (!options.enableRd && !options.disableRd && options.rdSession === undefined && options.rdDisplay === undefined)
+        return;
+    if (process.platform !== 'linux' || process.getuid?.() === 0)
+        throw new Error('Linux RD must be configured and run as the workstation user, not root');
+    if (options.enableRd && options.disableRd)
+        throw new Error('--enable-rd and --disable-rd cannot be combined');
+    if (!options.enableRd && !options.disableRd)
+        throw new Error('--rd-session and --rd-display require --enable-rd');
+    await withPrivateLock(path.join(directory, 'rd', 'install'), async () => {
+        const previous = await readRdState(directory);
+        const registered = await loadClientConfig(directory).catch(error => {
+            if (error.code !== 'ENOENT')
+                throw error;
+            return undefined;
+        });
+        const server = normalizeWorkstationServer(options.server ?? registered?.server ?? resolveServer(await loadConfig()));
+        if (options.disableRd) {
+            await writeRdState(directory, previous ? { ...previous, enabled: false } : { schemaVersion: 1, enabled: false, server, session: 'auto' });
+            return;
+        }
+        if (registered && normalizeWorkstationServer(registered.server) !== server)
+            throw new Error('This workstation is already registered to another server; change its registration before enabling RD');
+        const { session, display } = rdSessionSelection(previous, options);
+        const platform = rdPlatform(await fs.readFile('/etc/os-release', 'utf8'), process.arch);
+        const installed = await installRd(directory, server, platform);
+        await ensureDependencies(installed.directory, session, display, installed.artifact);
+        await writeRdState(directory, { schemaVersion: 1, enabled: true, server, session, ...(display ? { display } : {}),
+            installation: installed.directory, artifact: installed.artifact });
+        console.log(`Remote desktop enabled (${session}, ${installed.artifact.version}); capture starts only when an authorized viewer connects`);
+    });
+}
+async function ensureDependencies(installation, session, display, artifact) {
+    let runtimeMissing = false;
+    try {
+        await execute(path.join(installation, 'bin/axom-desktop-keeper'), ['--self-test'], { timeout: 5000, maxBuffer: 8192 });
+    }
+    catch {
+        runtimeMissing = true;
+    }
+    const selected = chooseSession(await discoverSessions(), { session, display });
+    const packages = runtimeMissing ? ['libavcodec61', 'libavutil59', 'libswscale8', 'libgstreamer-plugins-bad1.0-0', 'libx11-6', 'libxext6', 'libxdamage1', 'libxfixes3', 'libxtst6', 'libxrandr2', 'libxcomposite1', 'zlib1g'] : [];
+    if (artifact?.ipcVersion === 2)
+        packages.push('python3', 'x11-xserver-utils', 'x11-utils', 'xauth', 'libpulse0', 'pulseaudio', 'pulseaudio-utils', 'libasound2-plugins');
+    if (!selected)
+        packages.push('xserver-xorg-core', 'xserver-xorg-video-dummy', 'xfce4-session', 'xfwm4', 'xfce4-panel', 'xfdesktop4', 'xfce4-settings', 'thunar', 'xfce4-terminal', 'dbus-x11', 'xauth', 'x11-utils', 'fonts-dejavu-core');
+    if (!packages.length)
+        return;
+    const missing = [];
+    for (const name of packages) {
+        try {
+            const { stdout } = await execute('dpkg-query', ['-W', '-f=${db:Status-Status}', name], { timeout: 2000, maxBuffer: 4096 });
+            if (stdout.trim() !== 'installed')
+                missing.push(name);
+        }
+        catch {
+            missing.push(name);
+        }
+    }
+    if (missing.length) {
+        console.log(`Installing remote desktop dependencies: ${missing.join(', ')}`);
+        try {
+            await execute('sudo', ['-n', 'apt-get', 'install', '-y', '--no-install-recommends', ...missing], { timeout: 180000, maxBuffer: 1048576 });
+        }
+        catch {
+            throw new Error(`Install the required RD packages, then retry: sudo apt-get install --no-install-recommends ${missing.join(' ')}`);
+        }
+    }
+    await execute(path.join(installation, 'bin/axom-desktop-keeper'), ['--self-test'], { timeout: 5000, maxBuffer: 8192 });
+    if (artifact?.ipcVersion === 2) {
+        for (const command of ['axom-display', 'axom-desktop-session'])
+            await execute(path.join(installation, 'bin', command), ['--self-test'], { timeout: 5000, maxBuffer: 8192 });
+    }
+}
+export async function rdStatus(directory) {
+    const state = await readRdState(directory);
+    if (!state)
+        return { enabled: false, installed: false };
+    let observed;
+    let update;
+    try {
+        observed = JSON.parse(await fs.readFile(path.join(directory, 'rd', 'status.json'), 'utf8'));
+    }
+    catch (error) {
+        if (error.code !== 'ENOENT')
+            throw error;
+    }
+    try {
+        update = JSON.parse(await fs.readFile(path.join(directory, 'rd', 'update-status.json'), 'utf8'));
+    }
+    catch (error) {
+        if (error.code !== 'ENOENT')
+            throw error;
+    }
+    return { enabled: state.enabled, installed: state.installation !== undefined, version: state.artifact?.version, selection: state.session, server: state.server,
+        ...(state.display ? { requestedDisplay: state.display } : {}), ...(state.enabled ? { observed, update } : {}) };
+}

package/dist/workstation/rd/display.js

@@ -0,0 +1,29 @@
+import { captureSamplingModes } from '../desktopControl/captureModes.js';
+export function parseXrandr(text) {
+    const screen = /current (\d+) x (\d+)/.exec(text);
+    const outputs = [...text.matchAll(/^(\S+) connected(?: primary)? (\d+)x(\d+)\+(\d+)\+(\d+).*$/gm)];
+    if (!screen || outputs.length !== 1 || outputs[0][4] !== '0' || outputs[0][5] !== '0' ||
+        screen[1] !== outputs[0][2] || screen[2] !== outputs[0][3])
+        throw new Error('No consistent single-output X11 desktop is available');
+    const output = outputs[0];
+    const section = text.slice(output.index + output[0].length).split(/^\S/m)[0];
+    const modes = [...section.matchAll(/^\s+(\d+)x(\d+)(?:\S*)\s/gm)]
+        .map(match => ({ width: Number(match[1]), height: Number(match[2]) }))
+        .filter(mode => mode.width >= 2 && mode.height >= 2 && mode.width <= 4096 && mode.height <= 4096 && mode.width % 2 === 0 && mode.height % 2 === 0);
+    return { output: output[1], width: Number(output[2]), height: Number(output[3]),
+        modes: modes.filter((mode, index) => modes.findIndex(other => other.width === mode.width && other.height === mode.height) === index) };
+}
+export function desktopDisplayControl(target, actual, managed) {
+    if (target.kind !== 'window' && target.width === actual.width && target.height === actual.height &&
+        target.width % 2 === 0 && target.height % 2 === 0 && !/^rdp\d+$/i.test(actual.output)) {
+        if (managed && /^DUMMY\d+$/i.test(actual.output))
+            return { ...target, overview: true, resize: 'dynamic',
+                resizeRange: { minWidth: 320, minHeight: 320, maxWidth: 4096, maxHeight: 4096 },
+                modes: [{ width: 1280, height: 720 }, { width: 1920, height: 1080 }, { width: 1024, height: 768 }, { width: 720, height: 1280 }] };
+        if (actual.modes.length > 1)
+            return { ...target, overview: true, resize: 'modes', modes: actual.modes };
+    }
+    return { ...target, overview: true, resize: 'dynamic', captureViewport: true, capturePixelScale: 1,
+        resizeRange: { minWidth: 2, minHeight: 2, maxWidth: target.width & ~1, maxHeight: target.height & ~1 },
+        modes: captureSamplingModes(target.width, target.height) };
+}

package/dist/workstation/rd/provider.js

@@ -0,0 +1,222 @@
+import { promises as fs } from 'node:fs';
+import path from 'node:path';
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+import { z } from 'zod';
+import { NativeProvider } from '../desktopControl/nativeProvider.js';
+import { HelperProcess, NativeCommandError } from '../desktopControl/helperProcess.js';
+import { desktopCapabilitiesSchema } from '../desktopControl/protocol.js';
+import { captureTargetLabel } from '../desktopControl/captureTargetLabel.js';
+import { normalizeWorkstationServer } from '../control/serverIdentity.js';
+import { privateDirectory } from '../keepers/kit/paths.js';
+import { verifyRdInstallation } from './artifact.js';
+import { readRdState } from './state.js';
+import { chooseSession, discoverSessions, ensureManagedSession, sessionAlive } from './sessions.js';
+import { desktopDisplayControl, parseXrandr } from './display.js';
+const execute = promisify(execFile);
+const sourceAxis = z.number().int().min(2).max(4096);
+const geometrySchema = z.object({ width: sourceAxis, height: sourceAxis, audio: z.boolean().optional() });
+const windowSchema = z.array(z.object({ id: z.string().regex(/^[a-f0-9]{32}$/), kind: z.literal('window'), label: z.string().max(4096), width: sourceAxis, height: sourceAxis })).max(127);
+export class LinuxDesktopProvider {
+    directory;
+    server;
+    legacy;
+    session;
+    provider;
+    state;
+    runtime = '';
+    revision = 0;
+    geometryIdentity = '';
+    initialization;
+    usingLegacy = false;
+    targetRevisions = new Map();
+    constructor(directory, server, legacy) {
+        this.directory = directory;
+        this.server = server;
+        this.legacy = legacy;
+    }
+    get automaticDpi() {
+        if (this.usingLegacy)
+            return true;
+        const setting = this.session?.environment.AXOM_DESKTOP_AUTO_DPI;
+        if (setting !== undefined)
+            return setting === '1';
+        return this.legacy !== undefined && this.session?.managed === true && this.session.environment.AXOM_DESKTOP_OWNED_DUMMY === '1';
+    }
+    async validate(session = this.session) {
+        const current = await readRdState(this.directory);
+        if (!current?.enabled || !this.state || current.artifact.sha512 !== this.state.artifact.sha512 ||
+            current.session !== this.state.session || current.display !== this.state.display ||
+            normalizeWorkstationServer(current.server) !== normalizeWorkstationServer(this.server) || !session || this.session !== session || !await sessionAlive(session)) {
+            throw new NativeCommandError('unavailable');
+        }
+    }
+    async initialize() {
+        if (this.initialization)
+            return this.initialization;
+        this.initialization = this.initializeCurrent();
+        try {
+            await this.initialization;
+        }
+        finally {
+            this.initialization = undefined;
+        }
+    }
+    async initializeCurrent() {
+        const state = await readRdState(this.directory);
+        this.usingLegacy = state === undefined && this.legacy !== undefined;
+        if (this.usingLegacy) {
+            this.provider = this.legacy;
+            this.state = undefined;
+            return;
+        }
+        if (!state?.enabled) {
+            this.provider = undefined;
+            this.state = undefined;
+            return;
+        }
+        if (normalizeWorkstationServer(state.server) !== normalizeWorkstationServer(this.server))
+            throw new Error('RD belongs to a different workstation server');
+        if (this.provider && this.state?.artifact.sha512 === state.artifact.sha512 && this.state.session === state.session && this.state.display === state.display && this.session && await sessionAlive(this.session))
+            return;
+        this.provider = undefined;
+        this.session = undefined;
+        await verifyRdInstallation(state.installation, state.artifact);
+        const session = chooseSession(await discoverSessions(), state) ?? await ensureManagedSession(this.directory);
+        this.session = session;
+        this.state = state;
+        const runtimeRoot = path.join(session.environment.XDG_RUNTIME_DIR ?? `/run/user/${process.getuid?.()}`, 'axom-rd');
+        await privateDirectory(runtimeRoot);
+        this.runtime = session.managed && session.environment.AXOM_DESKTOP_RUNTIME_DIR && path.isAbsolute(session.environment.AXOM_DESKTOP_RUNTIME_DIR) ?
+            session.environment.AXOM_DESKTOP_RUNTIME_DIR : path.join(runtimeRoot, session.identity);
+        await privateDirectory(this.runtime);
+        const executable = path.join(state.installation, 'bin/axom-desktop-keeper');
+        this.provider = new NativeProvider({ helperPath: executable, runtimeDir: this.runtime,
+            environment: this.environment(), enumerate: () => this.capabilities(), validateSession: () => this.validate(session),
+            sessionHelperFactory: async (binding) => {
+                await this.validate(session);
+                const helper = await HelperProcess.launch(executable, { ...this.environment(), AXOM_KEEPER_TARGET: binding.displayId });
+                return helper;
+            } });
+        process.env.AXOM_QUIC_BINARY = path.join(state.installation, 'bin/axom-quic');
+    }
+    environment() {
+        return { ...process.env, ...this.session.environment, AXOM_DESKTOP_RUNTIME_DIR: this.runtime, AXOM_ACCESS_TOKEN: undefined,
+            ...(this.state.artifact.ipcVersion === 1 ? { XDG_RUNTIME_DIR: this.runtime } : {}),
+            AXOM_DESKTOP_DISPLAY_CONTROL: path.join(this.state.installation, 'bin/axom-display'),
+            AXOM_DESKTOP_PROVIDER_FILE: path.join(this.runtime, 'provider.json'),
+            AXOM_DESKTOP_OWNED_DUMMY: this.session.managed && this.state.artifact.ipcVersion === 2 ? '1' : undefined };
+    }
+    async capabilities() {
+        await this.validate();
+        const executable = path.join(this.state.installation, 'bin/axom-desktop-keeper');
+        const options = { env: this.environment(), timeout: 2000, maxBuffer: 49152 };
+        const { stdout } = await execute(executable, ['--probe'], options);
+        const probe = geometrySchema.parse(JSON.parse(stdout));
+        const geometry = { width: probe.width, height: probe.height };
+        const sharedRuntime = this.state.artifact.ipcVersion === 2;
+        let actual = { output: '', ...geometry, modes: [] };
+        if (sharedRuntime) {
+            try {
+                actual = parseXrandr((await execute('xrandr', ['--current'], options)).stdout);
+            }
+            catch (error) {
+                if (this.session.managed)
+                    throw error;
+            }
+        }
+        let dpi;
+        if (sharedRuntime && this.session.managed) {
+            const resources = (await execute('xrdb', ['-query'], options)).stdout;
+            const value = Number(/^Xft\.dpi:\s*(\d+)\s*$/m.exec(resources)?.[1] ?? 96);
+            dpi = z.number().int().min(64).max(384).parse(value);
+        }
+        const geometryIdentity = `${this.session.identity}:${geometry.width}:${geometry.height}:${dpi ?? ''}`;
+        if (geometryIdentity !== this.geometryIdentity) {
+            this.revision++;
+            this.geometryIdentity = geometryIdentity;
+        }
+        const staging = path.join(this.runtime, '.geometry.json');
+        await fs.writeFile(staging, JSON.stringify({ ...geometry, ...(dpi === undefined ? {} : { dpi }) }), { mode: 0o600 });
+        await fs.rename(staging, path.join(this.runtime, 'geometry.json'));
+        const targets = windowSchema.parse(JSON.parse((await execute(executable, ['--capture-targets'], options)).stdout));
+        const root = { id: '00000000000000000000000000000001', kind: 'display', label: this.session.managed ? 'Virtual desktop' : 'Desktop', ...geometry };
+        const displays = [root, ...targets].map(target => {
+            const identity = `${this.session.identity}:${target.width}:${target.height}`;
+            const previous = this.targetRevisions.get(target.id);
+            const revision = target.id === root.id ? this.revision : previous ? previous.revision + Number(previous.geometry !== identity) : 1;
+            this.targetRevisions.set(target.id, { geometry: identity, revision });
+            const display = desktopDisplayControl({ ...target, label: captureTargetLabel(target.label), revision }, actual, sharedRuntime && this.session.managed);
+            return { ...display, ...(target.id === root.id && dpi !== undefined && display.captureViewport !== true ? {
+                    dpi, maxDpi: 384, appearanceSync: true,
+                } : {}) };
+        });
+        const live = new Set(displays.map(display => display.id));
+        for (const id of this.targetRevisions.keys())
+            if (!live.has(id))
+                this.targetRevisions.delete(id);
+        const failed = await Promise.all(['display-failed', 'input-failed'].map(async (name) => {
+            try {
+                await fs.lstat(path.join(this.runtime, name));
+                return true;
+            }
+            catch (error) {
+                if (error.code !== 'ENOENT')
+                    throw error;
+                return false;
+            }
+        }));
+        const capabilities = desktopCapabilitiesSchema.parse({ protocols: { min: 2, max: probe.audio ? 3 : 2 }, providerId: 'linux-x11-v1', providerVersion: 'axom-linux-2',
+            configured: true, permission: 'granted', health: failed.some(Boolean) ? 'unavailable' : 'ready', reason: failed.some(Boolean) ? 'recovery_unverified' : null,
+            cursorEmbedded: false, formats: ['h264-420-v1'], encoderBackends: [{ id: 'libx264', kind: 'software', formats: [{ format: 'h264-420-v1',
+                            maxWidth: 4096, maxHeight: 4096, maxPixels: 4000000, maxFps: 30, cappedRate: true }] }],
+            input: { pointer: true, physicalKeyboard: true, unicodeText: true, clipboard: true, textPaste: true }, displays });
+        const manifest = path.join(this.runtime, '.provider.json');
+        await fs.writeFile(manifest, JSON.stringify(capabilities), { mode: 0o600 });
+        await fs.rename(manifest, path.join(this.runtime, 'provider.json'));
+        return capabilities;
+    }
+    async probe() {
+        try {
+            await this.initialize();
+            if (!this.provider)
+                return null;
+            if (this.usingLegacy)
+                return this.provider.probe();
+            const capabilities = await this.provider.probe();
+            if (!capabilities)
+                return null;
+            await fs.writeFile(path.join(this.directory, 'rd', 'status.json'), JSON.stringify({ updatedAt: new Date().toISOString(), state: capabilities.health,
+                session: this.session.managed ? 'virtual' : 'existing', display: this.session.display, width: capabilities.displays[0].width, height: capabilities.displays[0].height,
+                resolution: capabilities.displays[0].captureViewport === true ? 'sampling' : capabilities.displays[0].resize,
+                modes: capabilities.displays[0].captureViewport === true ? [] : capabilities.displays[0].modes }), { mode: 0o600 });
+            return capabilities;
+        }
+        catch (error) {
+            await fs.writeFile(path.join(this.directory, 'rd', 'status.json'), JSON.stringify({ updatedAt: new Date().toISOString(), state: 'unavailable', reason: String(error) }), { mode: 0o600 }).catch(() => undefined);
+            throw error;
+        }
+    }
+    async prepare(selection, binding) {
+        await this.initialize();
+        if (!this.provider)
+            throw new NativeCommandError('unavailable');
+        return this.provider.prepare(selection, binding);
+    }
+    async wallpaper(targetId) {
+        await this.initialize();
+        if (!this.usingLegacy)
+            await this.validate();
+        if (!this.provider)
+            throw new NativeCommandError('unavailable');
+        return this.provider.wallpaper(targetId);
+    }
+    async recoverDisplay(binding, reservation) {
+        await this.initialize();
+        if (!this.usingLegacy)
+            await this.validate();
+        if (!this.provider)
+            throw new NativeCommandError('unavailable');
+        return this.provider.recoverDisplay(binding, reservation);
+    }
+}