@platless/axom-cli 0.5.9 → 0.6.52

package/dist/workstation/desktopControl/automationJson.js

@@ -0,0 +1,74 @@
+import { parseDesktopJson } from './protocol.js';
+export function parseAutomationJson(source, limit) {
+    if (typeof source !== 'string' && source.byteLength > limit)
+        throw new Error('invalid_automation_protocol');
+    const text = typeof source === 'string' ? source : new TextDecoder('utf-8', { fatal: true }).decode(source);
+    const value = parseDesktopJson(text, limit, new Set());
+    const numbers = new Map();
+    let offset = 0;
+    const space = () => { while (/[ \t\r\n]/.test(text[offset] ?? '\0'))
+        offset++; };
+    const string = () => {
+        const start = offset++;
+        while (offset < text.length) {
+            const character = text[offset++];
+            if (character === '\\')
+                offset++;
+            else if (character === '"')
+                return JSON.parse(text.slice(start, offset));
+        }
+        throw new Error('invalid_automation_protocol');
+    };
+    const visit = (path) => {
+        space();
+        if (text[offset] === '{') {
+            offset++;
+            space();
+            if (text[offset] === '}') {
+                offset++;
+                return;
+            }
+            do {
+                space();
+                const key = string();
+                space();
+                offset++;
+                visit([...path, key]);
+                space();
+                if (text[offset] !== ',')
+                    break;
+                offset++;
+            } while (true);
+            offset++;
+        }
+        else if (text[offset] === '[') {
+            offset++;
+            space();
+            if (text[offset] === ']') {
+                offset++;
+                return;
+            }
+            let index = 0;
+            do {
+                visit([...path, index++]);
+                space();
+                if (text[offset] !== ',')
+                    break;
+                offset++;
+            } while (true);
+            offset++;
+        }
+        else if (text[offset] === '"')
+            string();
+        else {
+            const start = offset;
+            while (offset < text.length && !/[,\]} \t\r\n]/.test(text[offset]))
+                offset++;
+            const token = text.slice(start, offset);
+            if (/^-?[0-9]/.test(token))
+                numbers.set(JSON.stringify(path), token);
+        }
+    };
+    visit([]);
+    return { value, numbers };
+}

package/dist/workstation/desktopControl/automationLocalState.js

@@ -0,0 +1,23 @@
+import { createHash } from 'node:crypto';
+import { lstat, mkdir } from 'node:fs/promises';
+import { isAbsolute, join } from 'node:path';
+export async function managedAutomationBinding(configDirectory, binding) {
+    const leaseMs = binding.native?.leaseMs;
+    if (!Number.isInteger(leaseMs) || leaseMs < 1 || leaseMs > 30000 || !binding.executionId)
+        throw new Error('trusted_preparation_unavailable');
+    if (!isAbsolute(configDirectory))
+        throw new Error('trusted_storage_unavailable');
+    const directory = join(configDirectory, 'desktop-automation');
+    await mkdir(directory, { mode: 0o700 }).catch(error => { if (error?.code !== 'EEXIST')
+        throw error; });
+    const status = await lstat(directory);
+    if (!status.isDirectory() || status.isSymbolicLink() || status.uid !== process.getuid?.() || (status.mode & 0o077) !== 0)
+        throw new Error('trusted_storage_unavailable');
+    const route = binding.route;
+    const identity = [binding.registrationId ?? 'legacy-single-registration', route.workstation, route.desktopId, route.inputDomainId, route.consumerId, route.deviceGeneration, route.controlGeneration, binding.executionId];
+    if (identity.some(value => value === undefined || value === null))
+        throw new Error('trusted_preparation_unavailable');
+    const key = createHash('sha256').update(JSON.stringify(identity)).digest('hex');
+    const domainKey = createHash('sha256').update(JSON.stringify([route.workstation, route.desktopId, route.inputDomainId])).digest('hex');
+    return { ...binding, native: { waitLockPath: join(directory, `${domainKey}.wait`), ledgerPath: join(directory, `${key}.jsonl`), leaseMs } };
+}

package/dist/workstation/desktopControl/automationProtocol.js

@@ -0,0 +1,253 @@
+import { parseAutomationJson } from './automationJson.js';
+import { automationSchema } from './automationSchema.generated.js';
+export { automationSchema };
+export function decodeAutomationFailureDetail(value) {
+    if (value == null)
+        return null;
+    shape(value, automationSchema.types.FailureDetail);
+    return structuredClone(value);
+}
+const maxJson = 48 * 1024;
+const routeKeys = ['requestId', 'consumerId', 'deviceGeneration', 'controlGeneration', 'inputDomainId'];
+const envelopeKeys = ['automationProtocol', ...routeKeys, 'method', 'payload'];
+function requireValue(value) { if (!value)
+    throw new Error('invalid_automation_protocol'); }
+function object(value) {
+    requireValue(value !== null && typeof value === 'object' && !Array.isArray(value));
+    return value;
+}
+function equal(left, right) {
+    if (left === right)
+        return true;
+    if (left === null || right === null || typeof left !== 'object' || typeof right !== 'object')
+        return false;
+    const keys = Object.keys(left);
+    return keys.length === Object.keys(right).length && keys.every(key => Object.hasOwn(right, key) && equal(left[key], right[key]));
+}
+function integerToken(numbers, path) {
+    if (numbers)
+        requireValue(/^-?(0|[1-9][0-9]*)$/.test(numbers.get(JSON.stringify(path)) ?? ''));
+}
+function shape(value, rule, numbers, path = []) {
+    if (rule.ref) {
+        shape(value, automationSchema.types[rule.ref], numbers, path);
+        semantics(rule.ref, value);
+        return;
+    }
+    if (rule.nullable) {
+        if (value !== null)
+            shape(value, rule.nullable, numbers, path);
+        return;
+    }
+    if (rule.enum) {
+        requireValue(rule.enum.includes(value));
+        if (typeof rule.enum[0] === 'number')
+            integerToken(numbers, path);
+        return;
+    }
+    if (rule.tag) {
+        const data = object(value), variant = rule.variants[data[rule.tag]];
+        requireValue(variant);
+        const fields = { ...data };
+        delete fields[rule.tag];
+        shape(fields, variant, numbers, path);
+        return;
+    }
+    if (rule.fields) {
+        const data = object(value), optional = rule.optional;
+        requireValue(Object.keys(data).every(key => Object.hasOwn(rule.fields, key)));
+        for (const [key, field] of Object.entries(rule.fields)) {
+            if (Object.hasOwn(data, key))
+                shape(data[key], field, numbers, [...path, key]);
+            else
+                requireValue(optional.includes(key));
+        }
+        return;
+    }
+    if (rule.items) {
+        requireValue(Array.isArray(value) && value.length >= rule.min && value.length <= rule.max);
+        if (rule.unique)
+            requireValue(new Set(value.map(item => JSON.stringify(item))).size === value.length);
+        value.forEach((item, index) => shape(item, rule.items, numbers, [...path, index]));
+        return;
+    }
+    if (rule.string) {
+        requireValue(typeof value === 'string' && value.length >= (rule.min ?? 0) && value.length <= rule.max && !value.includes('\u0000'));
+        requireValue(rule.blank || [...value].some(character => !automationSchema.whitespaceRanges.some((range) => character.codePointAt(0) >= range[0] && character.codePointAt(0) <= range[1])));
+        return;
+    }
+    if (rule.boolean) {
+        requireValue(typeof value === 'boolean');
+        return;
+    }
+    requireValue(typeof value === 'number' && Number.isFinite(value));
+    if (rule.integer) {
+        requireValue(Number.isSafeInteger(value));
+        integerToken(numbers, path);
+    }
+    if (rule.min !== undefined)
+        requireValue(value >= rule.min);
+    if (rule.max !== undefined)
+        requireValue(value <= rule.max);
+    if (rule.positive)
+        requireValue(value > 0);
+}
+function semantics(name, value) {
+    if (name === 'Acquisition' && value.type === 'takeover')
+        requireValue((value.expectedDeviceEpoch == null) === (value.expectedDeviceRevision == null));
+    if (name === 'WaitResult') {
+        requireValue((value.status === 'met') === (value.conditionState === 'met'));
+        requireValue(value.conditionState !== 'unavailable' || value.image === null);
+    }
+    if (name === 'Rect')
+        requireValue(Number.isFinite(value.x + value.width) && Number.isFinite(value.y + value.height));
+    if (name === 'Target') {
+        requireValue(Boolean(value.display) !== Boolean(value.window));
+        requireValue((value.selectionReason === 'EXPLICIT_DISPLAY') === Boolean(value.display));
+    }
+    if (name === 'Metadata') {
+        const binding = value.binding, target = value.target, transform = value.coordinates.imageToSourceTransform, rect = value.sourceRect;
+        requireValue(target.id === binding.targetId && target.workstation === binding.workstation && target.desktopId === binding.desktopId && target.inputDomain === binding.inputDomainId);
+        requireValue(Math.abs(transform.originX - rect.x) <= 0.001 && Math.abs(transform.originY - rect.y) <= 0.001 &&
+            Math.abs(value.width * transform.scaleX - rect.width) <= 0.001 && Math.abs(value.height * transform.scaleY - rect.height) <= 0.001);
+    }
+    if (name === 'Transfer') {
+        const header = value.header, metadata = value.metadata, binding = metadata.binding;
+        requireValue(header.consumerId === binding.consumerId && header.deviceGeneration === binding.revisions.deviceGeneration &&
+            header.controlGeneration === binding.revisions.controlGeneration && header.inputDomainId === binding.inputDomainId &&
+            header.captureSerial === binding.captureSerial && header.mimeType === metadata.mimeType);
+    }
+    if (name === 'ActRequest')
+        requireValue(value.actions.reduce((sum, action) => sum + (action.type === 'wait' ? action.durationMs : action.type === 'drag' ? (action.durationMs ?? 500) : 0), 0) <= 10000);
+    if (name === 'ActionResult') {
+        requireValue(value.postImage == null || value.captureError == null);
+        requireValue(value.receipts.length <= (value.actionCount ?? value.receipts.length));
+        value.receipts.forEach((receipt, index) => {
+            requireValue(receipt.index === index && (index === value.receipts.length - 1 || receipt.outcome === 'injected'));
+        });
+    }
+}
+function envelope(value, numbers) {
+    requireValue(equal(Object.keys(value).sort(), [...envelopeKeys].sort()) && value.automationProtocol === 1);
+    shape(value.automationProtocol, { enum: [1] }, numbers, ['automationProtocol']);
+    for (const key of routeKeys)
+        shape(value[key], key === 'controlGeneration' ? { integer: true, min: 0, max: Number.MAX_SAFE_INTEGER } : automationSchema.types.Identity, numbers, [key]);
+    requireValue(typeof value.method === 'string' && Object.hasOwn(automationSchema.requests, value.method));
+}
+export function decodeAutomationRequest(source) {
+    const parsed = parseAutomationJson(source, maxJson), value = object(parsed.value);
+    envelope(value, parsed.numbers);
+    shape(value.payload, automationSchema.requests[value.method], parsed.numbers, ['payload']);
+    if (value.method === 'open')
+        requireValue((value.payload.mode ?? 'observer') === 'controller' || (value.payload.acquisition?.type ?? 'if_free') === 'if_free');
+    if (value.method === 'open' && value.payload.acquisition?.type === 'takeover')
+        requireValue(value.payload.acquisition.expectedDeviceGeneration === value.deviceGeneration);
+    if (value.method === 'act')
+        requireValue(value.payload.request.observationId === value.payload.admission.delivery.binding.observationId);
+    return value;
+}
+export function encodeAutomationRequest(value) {
+    const text = JSON.stringify(value);
+    decodeAutomationRequest(text);
+    return text;
+}
+export function validateAutomationRequestFor(value, route, owner, observation, hostDelivery = false) {
+    decodeAutomationRequest(JSON.stringify(value));
+    requireValue(route && ['consumerId', 'workstation', 'desktopId', 'inputDomainId', 'deviceGeneration', 'controlGeneration'].every(key => route[key] !== undefined));
+    for (const key of ['consumerId', 'deviceGeneration', 'controlGeneration', 'inputDomainId'])
+        requireValue(value[key] === route[key]);
+    const payload = value.payload;
+    if (payload.workstation !== undefined)
+        requireValue(payload.workstation === route.workstation);
+    const handle = payload.handle ?? payload.capture?.handle ?? payload.request?.handle;
+    if (handle)
+        requireValue(owner && equal(owner.handle, handle) && equal(owner.route, route));
+    const binding = value.method === 'act' ? payload.admission.delivery.binding : value.method === 'delivery_ack' ? payload.binding : undefined;
+    if (binding) {
+        requireValue(equal(binding, observation));
+        validateObservationRoute(binding, route);
+        if (value.method === 'act')
+            requireValue(owner?.targetId === binding.targetId && payload.request.observationId === binding.observationId);
+        else
+            requireValue(hostDelivery);
+    }
+}
+function validateObservationRoute(binding, route) {
+    for (const key of ['consumerId', 'workstation', 'desktopId', 'inputDomainId'])
+        requireValue(binding[key] === route[key]);
+    requireValue(binding.revisions.deviceGeneration === route.deviceGeneration && binding.revisions.controlGeneration === route.controlGeneration);
+}
+function transfers(value) {
+    if (value.payload.type !== 'success')
+        return [];
+    if (value.method === 'capture')
+        return [value.payload.data];
+    if (value.method === 'capture_wait_v1' && value.payload.data.image)
+        return [value.payload.data.image];
+    if ((value.method === 'act' || value.method === 'status') && value.payload.data.postImage)
+        return [value.payload.data.postImage];
+    return [];
+}
+export function decodeAutomationResponse(source, request) {
+    decodeAutomationRequest(JSON.stringify(request));
+    const parsed = parseAutomationJson(source, maxJson), value = object(parsed.value);
+    envelope(value, parsed.numbers);
+    for (const key of ['automationProtocol', ...routeKeys, 'method'])
+        requireValue(value[key] === request[key]);
+    if (value.payload?.type === 'failure')
+        shape(value.payload, automationSchema.types.Failure, parsed.numbers, ['payload']);
+    else {
+        requireValue(equal(Object.keys(object(value.payload)).sort(), ['data', 'type']) && value.payload.type === 'success');
+        shape(value.payload.data, automationSchema.responses[value.method], parsed.numbers, ['payload', 'data']);
+        if (value.method === 'open')
+            requireValue(value.payload.data.mode !== 'controller' || value.payload.data.lease !== null);
+    }
+    for (const transfer of transfers(value))
+        for (const key of ['automationProtocol', ...routeKeys])
+            requireValue(transfer.header[key] === request[key]);
+    return value;
+}
+export function acceptsSequence(previous, incoming) {
+    return Number.isSafeInteger(previous) && previous >= 0 && Number.isSafeInteger(incoming) && incoming > previous;
+}
+export function encodeAutomationBinary(header, body) {
+    shape(header, automationSchema.types.Header);
+    requireValue(body.byteLength === header.bytesLength);
+    const text = new TextEncoder().encode(JSON.stringify(header));
+    requireValue(text.length <= maxJson);
+    const frame = new Uint8Array(4 + text.length + body.length);
+    new DataView(frame.buffer).setUint32(0, text.length, false);
+    frame.set(text, 4);
+    frame.set(body, 4 + text.length);
+    return frame;
+}
+export function decodeAutomationBinaryHeader(source) {
+    const parsed = parseAutomationJson(source, maxJson), header = object(parsed.value);
+    shape(header, automationSchema.types.Header, parsed.numbers);
+    return header;
+}
+export class AutomationBinaryReceiver {
+    consumed = false;
+    header;
+    constructor(request, transfer, route) {
+        decodeAutomationRequest(JSON.stringify(request));
+        requireValue(['capture', 'capture_wait_v1', 'act', 'status'].includes(request.method));
+        shape(transfer, automationSchema.types.Transfer);
+        this.header = JSON.parse(JSON.stringify(transfer.header));
+        for (const key of ['automationProtocol', ...routeKeys])
+            requireValue(this.header[key] === request[key]);
+        validateObservationRoute(transfer.metadata.binding, route);
+        for (const key of ['consumerId', 'deviceGeneration', 'controlGeneration', 'inputDomainId'])
+            requireValue(request[key] === route[key]);
+    }
+    accept(frame) {
+        requireValue(!this.consumed && frame.length >= 4 && frame.length <= 4 + maxJson + 8388608);
+        const length = new DataView(frame.buffer, frame.byteOffset, frame.byteLength).getUint32(0, false);
+        requireValue(length > 0 && length <= maxJson && frame.length === 4 + length + this.header.bytesLength);
+        const parsed = parseAutomationJson(frame.subarray(4, 4 + length), maxJson), header = object(parsed.value);
+        shape(header, automationSchema.types.Header, parsed.numbers);
+        requireValue(equal(header, this.header));
+        this.consumed = true;
+        return frame.slice(4 + length);
+    }
+}

package/dist/workstation/desktopControl/automationSchema.generated.js

@@ -0,0 +1 @@
+export const automationSchema = { "whitespaceRanges": [[9, 13], [28, 32], [160, 160], [5760, 5760], [8192, 8202], [8232, 8233], [8239, 8239], [8287, 8287], [12288, 12288]], "types": { "Identity": { "string": true, "max": 256, "blank": false }, "SelectorText": { "string": true, "max": 4096, "blank": false }, "Handle": { "fields": { "id": { "ref": "Identity" } }, "optional": [] }, "Point": { "fields": { "x": { "number": true }, "y": { "number": true } }, "optional": [] }, "Rect": { "fields": { "x": { "number": true }, "y": { "number": true }, "width": { "number": true, "positive": true }, "height": { "number": true, "positive": true } }, "optional": [] }, "Transform": { "fields": { "originX": { "number": true }, "originY": { "number": true }, "scaleX": { "number": true, "positive": true }, "scaleY": { "number": true, "positive": true } }, "optional": [] }, "Revisions": { "fields": { "deviceGeneration": { "ref": "Identity" }, "controlGeneration": { "integer": true, "min": 0, "max": 9007199254740991 }, "targetRevision": { "integer": true, "min": 0, "max": 9007199254740991 }, "geometryRevision": { "integer": true, "min": 0, "max": 9007199254740991 } }, "optional": [] }, "Binding": { "fields": { "consumerId": { "ref": "Identity" }, "workstation": { "ref": "Identity" }, "desktopId": { "ref": "Identity" }, "targetId": { "ref": "Identity" }, "revisions": { "ref": "Revisions" }, "observationId": { "ref": "Identity" }, "captureSerial": { "integer": true, "min": 0, "max": 9007199254740991 }, "captureToken": { "ref": "Identity" }, "inputDomainId": { "ref": "Identity" } }, "optional": [] }, "Delivery": { "fields": { "deliveryId": { "ref": "Identity" }, "binding": { "ref": "Binding" }, "surface": { "enum": ["PROVIDER_REQUEST", "SDK_RETURN"] }, "surfaceRequestId": { "ref": "Identity" } }, "optional": [] }, "Admission": { "fields": { "token": { "ref": "Identity" }, "delivery": { "ref": "Delivery" } }, "optional": [] }, "ApplicationSelector": { "tag": "type", "variants": { "name": { "fields": { "value": { "ref": "SelectorText" } }, "optional": [] }, "bundle_id": { "fields": { "value": { "ref": "SelectorText" } }, "optional": [] }, "path": { "fields": { "value": { "ref": "SelectorText" } }, "optional": [] } } }, "TargetSelector": { "tag": "type", "variants": { "display": { "fields": { "displayId": { "ref": "Identity" } }, "optional": [] }, "window": { "fields": { "windowId": { "ref": "Identity" } }, "optional": [] }, "application": { "fields": { "selector": { "ref": "ApplicationSelector" } }, "optional": [] } } }, "Application": { "fields": { "id": { "ref": "Identity" }, "name": { "ref": "SelectorText" }, "installationPath": { "ref": "SelectorText" }, "bundleId": { "nullable": { "ref": "SelectorText" } }, "desktopEntryId": { "nullable": { "ref": "SelectorText" } } }, "optional": ["bundleId", "desktopEntryId"] }, "Process": { "fields": { "pid": { "integer": true, "min": 1, "max": 9007199254740991 }, "instanceId": { "ref": "Identity" } }, "optional": [] }, "Display": { "fields": { "id": { "ref": "Identity" }, "sourceRect": { "ref": "Rect" } }, "optional": [] }, "Window": { "fields": { "id": { "ref": "Identity" }, "title": { "string": true, "max": 16384, "blank": true }, "applicationId": { "nullable": { "ref": "Identity" } }, "process": { "nullable": { "ref": "Process" } }, "capturable": { "boolean": true }, "focused": { "boolean": true }, "main": { "boolean": true }, "sourceRect": { "nullable": { "ref": "Rect" } } }, "optional": ["sourceRect"] }, "Resolution": { "fields": { "application": { "ref": "Application" }, "state": { "enum": ["INSTALLED", "LAUNCH_PENDING", "RUNNING_WITHOUT_WINDOWS", "RUNNING_WITH_WINDOWS"] }, "processes": { "items": { "ref": "Process" }, "min": 0, "max": 64, "unique": false }, "windows": { "items": { "ref": "Window" }, "min": 0, "max": 64, "unique": false } }, "optional": [] }, "Target": { "fields": { "id": { "ref": "Identity" }, "workstation": { "ref": "Identity" }, "desktopId": { "ref": "Identity" }, "inputDomain": { "ref": "Identity" }, "selectionReason": { "enum": ["EXPLICIT_DISPLAY", "EXPLICIT_WINDOW", "FOCUSED_APPLICATION_WINDOW", "MAIN_APPLICATION_WINDOW", "UNIQUE_CAPTURABLE_WINDOW"] }, "display": { "nullable": { "ref": "Display" } }, "window": { "nullable": { "ref": "Window" } }, "application": { "nullable": { "ref": "Application" } }, "process": { "nullable": { "ref": "Process" } } }, "optional": ["display", "window", "application", "process"] }, "Coordinates": { "fields": { "sourceSpace": { "enum": ["DESKTOP_GLOBAL", "WINDOW_LOCAL"] }, "inputUnit": { "enum": ["NATIVE_PIXEL", "LOGICAL_POINT"] }, "imageToSourceTransform": { "ref": "Transform" }, "sourceToInputTransform": { "ref": "Transform" }, "inputSpace": { "enum": ["DESKTOP_GLOBAL", "WINDOW_LOCAL"] }, "sourceUnit": { "enum": ["NATIVE_PIXEL"] } }, "optional": ["inputSpace", "sourceUnit"] }, "Fidelity": { "fields": { "captureMode": { "enum": ["NATIVE_SURFACE", "VISIBLE_CROP"] }, "stable": { "nullable": { "boolean": true } }, "limitations": { "items": { "enum": ["OCCLUDED", "MINIMIZED", "OTHER_SPACE", "CURSOR_EXCLUDED", "STABILITY_UNKNOWN"] }, "min": 0, "max": 64, "unique": false } }, "optional": [] }, "Metadata": { "fields": { "binding": { "ref": "Binding" }, "mimeType": { "enum": ["image/png", "image/jpeg"] }, "width": { "integer": true, "min": 1, "max": 4096 }, "height": { "integer": true, "min": 1, "max": 4096 }, "sourceRect": { "ref": "Rect" }, "coordinates": { "ref": "Coordinates" }, "capturedAtEpochMs": { "integer": true, "min": 0, "max": 9007199254740991 }, "afterActionId": { "nullable": { "ref": "Identity" } }, "appliedInputSequence": { "nullable": { "integer": true, "min": 0, "max": 9007199254740991 } }, "fidelity": { "ref": "Fidelity" }, "target": { "ref": "Target" }, "parentObservationId": { "nullable": { "ref": "Identity" } }, "cursor": { "nullable": { "fields": { "sourcePosition": { "ref": "Point" }, "includedInImage": { "boolean": true } }, "optional": [] } }, "focus": { "nullable": { "fields": { "windowId": { "nullable": { "ref": "Identity" } }, "applicationId": { "nullable": { "ref": "Identity" } }, "process": { "nullable": { "ref": "Process" } } }, "optional": [] } }, "inputEligible": { "boolean": true } }, "optional": ["parentObservationId", "cursor", "focus", "inputEligible"] }, "Header": { "fields": { "automationProtocol": { "enum": [1] }, "requestId": { "ref": "Identity" }, "consumerId": { "ref": "Identity" }, "deviceGeneration": { "ref": "Identity" }, "controlGeneration": { "integer": true, "min": 0, "max": 9007199254740991 }, "inputDomainId": { "ref": "Identity" }, "transferId": { "ref": "Identity" }, "captureSerial": { "integer": true, "min": 0, "max": 9007199254740991 }, "bytesLength": { "integer": true, "min": 1, "max": 8388608 }, "mimeType": { "enum": ["image/png", "image/jpeg"] } }, "optional": [] }, "Transfer": { "fields": { "header": { "ref": "Header" }, "metadata": { "ref": "Metadata" } }, "optional": [] }, "Acquisition": { "tag": "type", "variants": { "if_free": { "fields": {}, "optional": [] }, "takeover": { "fields": { "expectedOwnershipRevision": { "integer": true, "min": 0, "max": 9007199254740991 }, "expectedDeviceGeneration": { "ref": "Identity" }, "expectedDeviceEpoch": { "ref": "Identity" }, "expectedDeviceRevision": { "integer": true, "min": 0, "max": 9007199254740991 } }, "optional": ["expectedDeviceEpoch", "expectedDeviceRevision"] } } }, "Action": { "tag": "type", "variants": { "move": { "fields": { "point": { "ref": "Point" } }, "optional": [] }, "click": { "fields": { "point": { "ref": "Point" }, "button": { "enum": ["LEFT", "MIDDLE", "RIGHT"] }, "count": { "integer": true, "min": 1, "max": 2 } }, "optional": ["button", "count"] }, "drag": { "fields": { "path": { "items": { "ref": "Point" }, "min": 2, "max": 256, "unique": false }, "button": { "enum": ["LEFT", "MIDDLE", "RIGHT"] }, "durationMs": { "integer": true, "min": 1, "max": 10000 } }, "optional": ["button", "durationMs"] }, "scroll": { "fields": { "deltaX": { "number": true, "min": -10000, "max": 10000 }, "deltaY": { "number": true, "min": -10000, "max": 10000 }, "unit": { "enum": ["PIXEL", "LINE", "PAGE"] }, "point": { "nullable": { "ref": "Point" } } }, "optional": ["point"] }, "key_chord": { "fields": { "keys": { "items": { "string": true, "max": 64, "blank": false }, "min": 1, "max": 8, "unique": true } }, "optional": [] }, "type_text": { "fields": { "text": { "string": true, "max": 16384, "blank": true, "min": 1 }, "mode": { "enum": ["UNICODE", "PASTE"] } }, "optional": ["mode"] }, "focus_window": { "fields": { "windowId": { "ref": "Identity" } }, "optional": [] }, "wait": { "fields": { "durationMs": { "integer": true, "min": 0, "max": 2000 } }, "optional": [] }, "release_all": { "fields": {}, "optional": [] } } }, "ActRequest": { "fields": { "handle": { "ref": "Handle" }, "observationId": { "ref": "Identity" }, "requestId": { "ref": "Identity" }, "actions": { "items": { "ref": "Action" }, "min": 1, "max": 16, "unique": false }, "postObservation": { "boolean": true } }, "optional": ["postObservation"] }, "Controller": { "fields": { "consumerId": { "ref": "Identity" }, "userId": { "nullable": { "ref": "Identity" } }, "ownershipRevision": { "integer": true, "min": 0, "max": 9007199254740991 }, "controlGeneration": { "integer": true, "min": 0, "max": 9007199254740991 } }, "optional": [] }, "Diagnostic": { "fields": { "reason": { "enum": ["capture_timeout", "capture_not_after_action", "too_large", "target_changed", "unsupported_automation_protocol", "delivery_not_acknowledged", "observation_expired", "foreign_handle", "launch_pending", "cancelled", "request_digest_mismatch", "budget_exhausted"] }, "description": { "nullable": { "string": true, "max": 16384, "blank": true } } }, "optional": ["description"] }, "Receipt": { "fields": { "index": { "integer": true, "min": 0, "max": 15 }, "outcome": { "enum": ["accepted", "executing", "injected", "rejected", "unknown"] }, "sequence": { "nullable": { "integer": true, "min": 0, "max": 9007199254740991 } }, "code": { "nullable": { "string": true, "max": 16384, "blank": true } }, "diagnostic": { "nullable": { "ref": "Diagnostic" } } }, "optional": ["diagnostic"] }, "ActionResult": { "fields": { "requestId": { "ref": "Identity" }, "receipts": { "items": { "ref": "Receipt" }, "min": 0, "max": 16, "unique": false }, "postImage": { "nullable": { "ref": "Transfer" } }, "captureError": { "nullable": { "string": true, "max": 16384, "blank": true } }, "captureDiagnostic": { "nullable": { "ref": "Diagnostic" } }, "actionCount": { "integer": true, "min": 0, "max": 16 } }, "optional": ["captureDiagnostic", "actionCount"] }, "LaunchQuery": { "fields": { "workstation": { "ref": "Identity" }, "requestId": { "ref": "Identity" } }, "optional": [] }, "Launch": { "fields": { "identity": { "ref": "LaunchQuery" }, "state": { "enum": ["ACCEPTED", "LAUNCHING", "WINDOW_NOT_READY", "READY", "FAILED", "UNKNOWN", "CANCELLED", "TIMED_OUT"] }, "application": { "nullable": { "ref": "Application" } }, "process": { "nullable": { "ref": "Process" } }, "windows": { "items": { "ref": "Window" }, "min": 0, "max": 64, "unique": false }, "canonicalArgsDigest": { "nullable": { "ref": "Identity" } }, "diagnostic": { "nullable": { "ref": "Diagnostic" } } }, "optional": ["canonicalArgsDigest", "diagnostic"] }, "Candidate": { "tag": "type", "variants": { "display": { "fields": { "display": { "ref": "Display" } }, "optional": [] }, "window": { "fields": { "window": { "ref": "Window" } }, "optional": [] }, "application": { "fields": { "application": { "ref": "Resolution" } }, "optional": [] } } }, "FailureDetail": { "fields": { "diagnostic": { "nullable": { "ref": "Diagnostic" } }, "candidates": { "items": { "ref": "Candidate" }, "min": 0, "max": 64, "unique": false }, "launch": { "nullable": { "ref": "Launch" } }, "controller": { "nullable": { "ref": "Controller" } } }, "optional": ["diagnostic", "candidates", "launch", "controller"] }, "Failure": { "fields": { "type": { "enum": ["failure"] }, "code": { "enum": ["invalid_argument", "forbidden", "unsupported", "not_found", "ambiguous_target", "window_not_ready", "launch_failed", "control_lost", "stale_observation", "outcome_unknown", "resource_limit", "approval_required", "service_unavailable", "conflict", "capture_failed"] }, "message": { "string": true, "max": 16384, "blank": true }, "detail": { "nullable": { "ref": "FailureDetail" } } }, "optional": ["detail"] }, "WaitCondition": { "tag": "type", "variants": { "target_capturable": { "fields": {}, "optional": [] }, "input_applied": { "fields": { "actionId": { "ref": "Identity" } }, "optional": [] }, "changed_from": { "fields": { "observationId": { "ref": "Identity" }, "roi": { "nullable": { "ref": "Rect" } } }, "optional": [] }, "stable": { "fields": { "roi": { "nullable": { "ref": "Rect" } }, "stableMs": { "integer": true, "min": 100, "max": 10000 } }, "optional": [] } } }, "WaitResult": { "fields": { "status": { "enum": ["met", "timeout"] }, "conditionState": { "enum": ["met", "not_met", "unavailable"] }, "elapsedMs": { "integer": true, "min": 0, "max": 60000 }, "image": { "nullable": { "ref": "Transfer" } } }, "optional": [] } }, "requests": { "discover": { "fields": { "workstation": { "ref": "Identity" }, "kinds": { "items": { "enum": ["DISPLAY", "WINDOW", "APPLICATION"] }, "min": 1, "max": 3, "unique": true }, "application": { "nullable": { "ref": "ApplicationSelector" } }, "limit": { "integer": true, "min": 1, "max": 64 }, "cursor": { "nullable": { "string": true, "max": 16384, "blank": true } } }, "optional": ["kinds", "application", "limit", "cursor"] }, "application_resolve": { "fields": { "workstation": { "ref": "Identity" }, "selector": { "ref": "ApplicationSelector" } }, "optional": [] }, "application_ensure": { "fields": { "workstation": { "ref": "Identity" }, "application": { "ref": "Application" }, "requestId": { "ref": "Identity" }, "timeoutMs": { "integer": true, "min": 1, "max": 60000 } }, "optional": ["timeoutMs"] }, "application_status": { "ref": "LaunchQuery" }, "open": { "fields": { "workstation": { "ref": "Identity" }, "target": { "ref": "TargetSelector" }, "mode": { "enum": ["observer", "controller"] }, "acquisition": { "ref": "Acquisition" }, "launchIfNeeded": { "boolean": true }, "requestId": { "ref": "Identity" }, "timeoutMs": { "integer": true, "min": 1, "max": 60000 } }, "optional": ["mode", "acquisition", "launchIfNeeded", "timeoutMs"] }, "capture": { "fields": { "handle": { "ref": "Handle" }, "crop": { "nullable": { "ref": "Rect" } }, "afterActionId": { "nullable": { "ref": "Identity" } }, "timeoutMs": { "integer": true, "min": 1, "max": 60000 }, "maxImageSide": { "integer": true, "min": 1, "max": 4096 }, "maxImageBytes": { "integer": true, "min": 1, "max": 8388608 } }, "optional": ["crop", "afterActionId", "timeoutMs", "maxImageSide", "maxImageBytes"] }, "act": { "fields": { "request": { "ref": "ActRequest" }, "admission": { "ref": "Admission" } }, "optional": [] }, "status": { "fields": { "handle": { "ref": "Handle" }, "requestId": { "ref": "Identity" } }, "optional": [] }, "close": { "fields": { "handle": { "ref": "Handle" } }, "optional": [] }, "delivery_ack": { "ref": "Delivery" }, "capture_wait_v1": { "fields": { "capture": { "fields": { "handle": { "ref": "Handle" }, "crop": { "nullable": { "ref": "Rect" } }, "afterActionId": { "nullable": { "ref": "Identity" } }, "timeoutMs": { "integer": true, "min": 1, "max": 60000 }, "maxImageSide": { "integer": true, "min": 1, "max": 4096 }, "maxImageBytes": { "integer": true, "min": 1, "max": 8388608 } }, "optional": ["crop", "afterActionId", "timeoutMs", "maxImageSide", "maxImageBytes"] }, "condition": { "ref": "WaitCondition" } }, "optional": [] } }, "responses": { "discover": { "fields": { "workstation": { "ref": "Identity" }, "desktopId": { "ref": "Identity" }, "inputDomain": { "ref": "Identity" }, "candidates": { "items": { "ref": "Candidate" }, "min": 0, "max": 64, "unique": false }, "capabilities": { "fields": { "capture": { "boolean": true }, "input": { "boolean": true }, "applicationLaunch": { "boolean": true }, "clipboard": { "boolean": true }, "operations": { "items": { "string": true, "max": 256, "blank": false }, "min": 0, "max": 64, "unique": true } }, "optional": [] }, "controller": { "nullable": { "ref": "Controller" } }, "nextCursor": { "nullable": { "string": true, "max": 16384, "blank": true } }, "deviceOwnership": { "nullable": { "fields": { "deviceEpoch": { "ref": "Identity" }, "revision": { "integer": true, "min": 0, "max": 9007199254740991 }, "state": { "enum": ["free", "draining", "active"] }, "controller": { "nullable": { "fields": { "registrationId": { "ref": "Identity" }, "controllerId": { "ref": "Identity" }, "kind": { "ref": "Identity" } }, "optional": [] } } }, "optional": [] } } }, "optional": ["nextCursor", "deviceOwnership"] }, "application_resolve": { "ref": "Resolution" }, "application_ensure": { "ref": "Launch" }, "application_status": { "ref": "Launch" }, "open": { "fields": { "handle": { "ref": "Handle" }, "target": { "ref": "Target" }, "mode": { "enum": ["observer", "controller"] }, "revisions": { "ref": "Revisions" }, "lease": { "nullable": { "fields": { "id": { "ref": "Identity" }, "expiresAtEpochMs": { "integer": true, "min": 0, "max": 9007199254740991 } }, "optional": [] } } }, "optional": [] }, "capture": { "ref": "Transfer" }, "act": { "ref": "ActionResult" }, "status": { "ref": "ActionResult" }, "close": { "fields": { "handle": { "ref": "Handle" }, "alreadyClosed": { "boolean": true } }, "optional": [] }, "delivery_ack": { "ref": "Admission" }, "capture_wait_v1": { "ref": "WaitResult" } } };

package/dist/workstation/desktopControl/automationSession.js

@@ -0,0 +1,81 @@
+import { randomBytes } from 'node:crypto';
+import { automationSchema } from './automationProtocol.js';
+export class AutomationSession {
+    transport;
+    control;
+    operations;
+    binding;
+    statusRequest;
+    constructor(transport, binding, control) {
+        this.transport = transport;
+        this.control = control;
+        const route = binding.route;
+        if (!['consumerId', 'workstation', 'desktopId', 'inputDomainId', 'deviceGeneration'].every(key => typeof route[key] === 'string' && route[key].length > 0) ||
+            !Number.isSafeInteger(route.controlGeneration) || route.controlGeneration < 0 || !binding.executionId)
+            throw new Error('live_route_unavailable');
+        this.binding = structuredClone(binding);
+        this.operations = [...control.operations];
+    }
+    prepareAttachment(preparation, options) {
+        if (this.statusRequest !== undefined)
+            return Promise.reject(new Error('control_lost'));
+        if (!this.control.prepare)
+            return Promise.reject(new Error('unsupported_automation_attachment'));
+        return this.control.prepare(structuredClone(preparation), options);
+    }
+    controlStatus() {
+        return this.control.status ? this.control.status() : Promise.reject(new Error('unsupported_automation_control_status'));
+    }
+    call(method, payload, options) {
+        if (this.statusRequest !== undefined && (method !== 'application_status' || payload.requestId !== this.statusRequest))
+            return Promise.reject(new Error('control_lost'));
+        if (!Object.hasOwn(automationSchema.requests, method) || !this.operations.includes(method))
+            return Promise.reject(new Error('unsupported'));
+        const route = this.binding.route;
+        return this.transport.request({ automationProtocol: 1, requestId: randomBytes(16).toString('hex'), consumerId: route.consumerId,
+            deviceGeneration: route.deviceGeneration, controlGeneration: route.controlGeneration, inputDomainId: route.inputDomainId, method, payload }, options);
+    }
+    execute(request, options) {
+        if (this.statusRequest !== undefined && (request.method !== 'application_status' || request.payload.requestId !== this.statusRequest))
+            return Promise.reject(new Error('control_lost'));
+        if (!this.operations.includes(request.method))
+            return Promise.reject(new Error('unsupported'));
+        if (['consumerId', 'deviceGeneration', 'controlGeneration', 'inputDomainId'].some(key => request[key] !== this.binding.route[key]))
+            return Promise.reject(new Error('stale_generation'));
+        if (request.method === 'close')
+            this.transport.cancelPending();
+        return this.transport.request(request, options);
+    }
+    discover(payload, options) { return this.call('discover', payload, options); }
+    applicationResolve(payload, options) { return this.call('application_resolve', payload, options); }
+    applicationEnsure(payload, options) { return this.call('application_ensure', payload, options); }
+    applicationStatus(payload, options) { return this.call('application_status', payload, options); }
+    open(payload, options) { return this.call('open', payload, options); }
+    capture(payload, options) { return this.call('capture', payload, options); }
+    act(payload, options) { return this.call('act', payload, options); }
+    status(payload, options) { return this.call('status', payload, options); }
+    close(payload, options) { this.transport.cancelPending(); return this.call('close', payload, options); }
+    deliveryAck(payload, options) { return this.call('delivery_ack', payload, options); }
+    async renewAuthenticatedLease(leaseMs) {
+        if (this.statusRequest !== undefined)
+            return { admitted: true, physical: 'failed' };
+        if (!Number.isInteger(leaseMs) || leaseMs < 1 || leaseMs > 30000)
+            return Promise.reject(new Error('invalid_argument'));
+        return await this.control.renew(leaseMs) ?? { admitted: true, physical: 'pending' };
+    }
+    async dispose() { this.transport.close(); await this.control.close(); }
+    async detachApplicationStatus(requestId, digest) {
+        if (this.statusRequest !== undefined && this.statusRequest !== requestId)
+            throw new Error('conflict');
+        this.statusRequest = requestId;
+        if (!this.control.readControl)
+            throw new Error('unsupported');
+        return this.control.readControl('status_only', { launchRequestId: requestId, canonicalArgsDigest: digest });
+    }
+    async isolate() {
+        this.statusRequest = this.statusRequest ?? '';
+        if (!this.control.readControl)
+            throw new Error('unsupported');
+        return this.control.readControl('isolate', {});
+    }
+}

package/dist/workstation/desktopControl/automationTransport.js

@@ -0,0 +1,138 @@
+import { parseAutomationJson } from './automationJson.js';
+import { AutomationBinaryReceiver, decodeAutomationResponse, decodeAutomationBinaryHeader, encodeAutomationBinary, encodeAutomationRequest } from './automationProtocol.js';
+export class AutomationTransport {
+    send;
+    cancel;
+    pending = new Map();
+    ended = false;
+    imageBytes = 0;
+    constructor(send, cancel = () => { }) {
+        this.send = send;
+        this.cancel = cancel;
+    }
+    pendingCount() { return this.pending.size; }
+    request(value, options = {}) {
+        if (this.ended)
+            return Promise.reject(new Error('closed'));
+        if (this.pending.size >= 64)
+            return Promise.reject(new Error('resource_limit'));
+        if (options.signal?.aborted)
+            return Promise.reject(new Error('cancelled'));
+        const request = structuredClone(value), text = encodeAutomationRequest(request);
+        if (this.pending.has(request.requestId))
+            return Promise.reject(new Error('conflict'));
+        const timeout = options.timeoutMs ?? 65000;
+        if (!Number.isInteger(timeout) || timeout < 1 || timeout > 65000)
+            return Promise.reject(new Error('invalid_argument'));
+        const promise = new Promise((resolve, reject) => {
+            const abort = () => this.retire(request.requestId, 'cancelled');
+            const timer = setTimeout(() => this.retire(request.requestId, 'timed_out'), timeout);
+            this.pending.set(request.requestId, { request, resolve, reject, timer, bytes: 0,
+                detach: () => options.signal?.removeEventListener('abort', abort) });
+            options.signal?.addEventListener('abort', abort, { once: true });
+        });
+        void this.send(text).catch(() => this.retire(request.requestId, 'transport_failed'));
+        return promise;
+    }
+    acceptResponse(text) {
+        try {
+            const raw = parseAutomationJson(text, 49152).value;
+            const pending = this.pending.get(raw.requestId);
+            if (!pending || pending.response)
+                return { ok: false, code: 'unknown_request' };
+            const response = decodeAutomationResponse(text, pending.request);
+            const transfer = response.payload.type === 'success' ? response.method === 'capture' ? response.payload.data :
+                response.method === 'capture_wait_v1' ? response.payload.data.image : ['act', 'status'].includes(response.method) ? response.payload.data.postImage : undefined : undefined;
+            if (transfer) {
+                const size = transfer.header.bytesLength;
+                if (this.imageBytes - pending.bytes + size > 8388608) {
+                    this.retire(raw.requestId, 'resource_limit');
+                    return { ok: false, code: 'resource_limit' };
+                }
+                pending.receiver = new AutomationBinaryReceiver(pending.request, transfer, {
+                    ...pending.request, workstation: transfer.metadata.binding.workstation, desktopId: transfer.metadata.binding.desktopId,
+                });
+                this.imageBytes += size - pending.bytes;
+                pending.bytes = size;
+                pending.response = response;
+                if (pending.early) {
+                    const early = pending.early;
+                    pending.early = undefined;
+                    this.acceptBinary(early);
+                }
+            }
+            else {
+                this.remove(raw.requestId)?.resolve({ response });
+            }
+            return { ok: true };
+        }
+        catch {
+            return { ok: false, code: 'invalid_response' };
+        }
+    }
+    acceptImage(header, bytes) {
+        if (bytes.byteLength !== (header.bytesLength ?? header.byteLength))
+            return { ok: false, code: 'invalid_length' };
+        try {
+            return this.acceptBinary(encodeAutomationBinary(header, bytes));
+        }
+        catch {
+            return { ok: false, code: 'invalid_binary' };
+        }
+    }
+    acceptBinary(frame) {
+        try {
+            if (frame.length < 4 || frame.length > 8388608 + 49156)
+                throw new Error();
+            const length = new DataView(frame.buffer, frame.byteOffset, frame.byteLength).getUint32(0, false);
+            if (length < 1 || length > 49152 || frame.length < 4 + length)
+                throw new Error();
+            const header = decodeAutomationBinaryHeader(frame.subarray(4, 4 + length));
+            const pending = this.pending.get(header.requestId);
+            if (!pending)
+                return { ok: false, code: 'unknown_request' };
+            if (!pending.receiver || !pending.response) {
+                if (!['capture', 'capture_wait_v1', 'act', 'status'].includes(pending.request.method) || frame.length !== 4 + length + header.bytesLength || pending.early ||
+                    ['consumerId', 'deviceGeneration', 'controlGeneration', 'inputDomainId'].some(key => header[key] !== pending.request[key]))
+                    return { ok: false, code: 'invalid_binary' };
+                if (this.imageBytes + header.bytesLength > 8388608)
+                    return { ok: false, code: 'resource_limit' };
+                pending.early = Buffer.from(frame);
+                pending.bytes = header.bytesLength;
+                this.imageBytes += pending.bytes;
+                return { ok: true };
+            }
+            const image = Buffer.from(pending.receiver.accept(frame));
+            this.remove(header.requestId)?.resolve({ response: pending.response, image });
+            return { ok: true };
+        }
+        catch {
+            return { ok: false, code: 'invalid_binary' };
+        }
+    }
+    remove(requestId) {
+        const pending = this.pending.get(requestId);
+        if (pending) {
+            this.pending.delete(requestId);
+            clearTimeout(pending.timer);
+            pending.detach();
+            this.imageBytes -= pending.bytes;
+        }
+        return pending;
+    }
+    retire(requestId, code) {
+        const pending = this.remove(requestId);
+        if (pending) {
+            pending.reject(new Error(code));
+            try {
+                this.cancel(requestId);
+            }
+            catch { }
+        }
+    }
+    invalidateGeneration(_generation) { this.close('stale_generation'); }
+    cancelPending() { for (const requestId of this.pending.keys())
+        this.retire(requestId, 'closed'); }
+    close(code = 'closed') { this.ended = true; for (const requestId of this.pending.keys())
+        this.retire(requestId, code); }
+}