@modelprofile.com/flexharness 6.1.0 → 7.0.1

package/dist_ts_kvm/classes.browserkvm.js

@@ -0,0 +1,271 @@
+import * as plugins from './plugins.js';
+const defaultViewerSelector = 'video, canvas';
+export class BrowserKvm {
+    kind;
+    options;
+    browser;
+    page;
+    constructor(options) {
+        this.options = options;
+        this.kind = options.kind ?? 'generic';
+    }
+    async connect() {
+        if (this.browser && this.page) {
+            return;
+        }
+        const timeoutMs = this.options.timeoutMs ?? 30000;
+        const args = [];
+        if (process.env.CI || process.getuid?.() === 0) {
+            args.push('--no-sandbox', '--disable-setuid-sandbox');
+        }
+        this.browser = await plugins.puppeteer.launch({
+            args,
+            acceptInsecureCerts: this.options.ignoreHttpsErrors ?? false,
+            defaultViewport: null,
+            executablePath: this.options.executablePath,
+            headless: this.options.headless ?? true,
+            timeout: timeoutMs,
+            userDataDir: this.options.userDataDir,
+        });
+        this.page = await this.browser.newPage();
+        this.page.setDefaultTimeout(timeoutMs);
+        this.page.setDefaultNavigationTimeout(timeoutMs);
+        await this.page.goto(this.options.url, {
+            waitUntil: 'domcontentloaded',
+            timeout: timeoutMs,
+        });
+        await this.tryGenericLogin();
+        await this.waitForViewerReady();
+        await this.focusViewer();
+    }
+    async disconnect() {
+        const browser = this.browser;
+        this.page = undefined;
+        this.browser = undefined;
+        if (browser) {
+            await browser.close();
+        }
+    }
+    async focusViewer() {
+        const page = this.requirePage();
+        const viewerSelector = this.getViewerSelector();
+        const viewerElement = await page.$(viewerSelector);
+        if (!viewerElement) {
+            throw new Error(`KVM viewer selector missing: ${viewerSelector}`);
+        }
+        await viewerElement.click();
+    }
+    async captureFrame() {
+        const page = this.requirePage();
+        const captureSelector = this.getCaptureSelector();
+        const captureElement = await page.$(captureSelector);
+        if (!captureElement) {
+            throw new Error(`KVM capture selector missing: ${captureSelector}`);
+        }
+        const mediaResult = await page.evaluate((selector) => {
+            const rootElement = document.querySelector(selector);
+            if (!rootElement) {
+                return {
+                    captured: false,
+                    error: `KVM capture selector missing: ${selector}`,
+                };
+            }
+            const mediaElement = (rootElement.matches('video, canvas')
+                ? rootElement
+                : rootElement.querySelector('video, canvas'));
+            if (!mediaElement) {
+                return {
+                    captured: false,
+                    hasMediaElement: false,
+                };
+            }
+            let width = 0;
+            let height = 0;
+            if (mediaElement instanceof HTMLVideoElement) {
+                width = mediaElement.videoWidth;
+                height = mediaElement.videoHeight;
+            }
+            else if (mediaElement instanceof HTMLCanvasElement) {
+                width = mediaElement.width;
+                height = mediaElement.height;
+            }
+            if (width <= 0 || height <= 0) {
+                return {
+                    captured: false,
+                    hasMediaElement: true,
+                    mediaHasFrame: false,
+                };
+            }
+            try {
+                const canvasElement = document.createElement('canvas');
+                canvasElement.width = width;
+                canvasElement.height = height;
+                const context = canvasElement.getContext('2d');
+                if (!context) {
+                    return {
+                        captured: false,
+                        hasMediaElement: true,
+                        mediaHasFrame: true,
+                        error: 'Could not create canvas 2D context for KVM frame capture.',
+                    };
+                }
+                context.drawImage(mediaElement, 0, 0, width, height);
+                const dataUrl = canvasElement.toDataURL('image/png');
+                return {
+                    captured: true,
+                    width,
+                    height,
+                    dataBase64: dataUrl.slice(dataUrl.indexOf(',') + 1),
+                };
+            }
+            catch (error) {
+                return {
+                    captured: false,
+                    hasMediaElement: true,
+                    mediaHasFrame: true,
+                    error: error instanceof Error ? error.message : String(error),
+                };
+            }
+        }, captureSelector);
+        if (mediaResult.captured) {
+            return {
+                timestamp: Date.now(),
+                width: mediaResult.width ?? 0,
+                height: mediaResult.height ?? 0,
+                mimeType: 'image/png',
+                dataBase64: mediaResult.dataBase64 ?? '',
+            };
+        }
+        if (mediaResult.error?.startsWith('KVM capture selector missing')) {
+            throw new Error(mediaResult.error);
+        }
+        if (mediaResult.hasMediaElement && mediaResult.mediaHasFrame === false) {
+            throw new Error(`KVM media element has no frame: ${captureSelector}`);
+        }
+        const boundingBox = await captureElement.boundingBox();
+        if (!boundingBox || boundingBox.width <= 0 || boundingBox.height <= 0) {
+            throw new Error(`KVM capture selector has no visible frame: ${captureSelector}`);
+        }
+        const screenshot = await captureElement.screenshot({
+            type: 'png',
+        });
+        return {
+            timestamp: Date.now(),
+            width: Math.round(boundingBox.width),
+            height: Math.round(boundingBox.height),
+            mimeType: 'image/png',
+            dataBase64: Buffer.from(screenshot).toString('base64'),
+        };
+    }
+    async typeText(text, options) {
+        const page = this.requirePage();
+        await this.focusViewer();
+        await page.keyboard.type(text, {
+            delay: options?.delayMs,
+        });
+    }
+    async pressKey(key) {
+        const page = this.requirePage();
+        await this.focusViewer();
+        await page.keyboard.press(key);
+    }
+    async pressShortcut(keys) {
+        const page = this.requirePage();
+        await this.focusViewer();
+        const pressedKeys = [];
+        try {
+            for (const key of keys) {
+                await page.keyboard.down(key);
+                pressedKeys.push(key);
+            }
+        }
+        finally {
+            for (const key of pressedKeys.reverse()) {
+                await page.keyboard.up(key);
+            }
+        }
+    }
+    async wait(milliseconds) {
+        await new Promise((resolve) => setTimeout(resolve, milliseconds));
+    }
+    async tryGenericLogin() {
+        if (!this.options.username || !this.options.password) {
+            return;
+        }
+        const page = this.requirePage();
+        const usernameElement = await this.findFirstElement([
+            'input[name="username"]',
+            'input[autocomplete="username"]',
+            'input[type="email"]',
+            'input[type="text"]',
+        ]);
+        const passwordElement = await this.findFirstElement([
+            'input[name="password"]',
+            'input[autocomplete="current-password"]',
+            'input[type="password"]',
+        ]);
+        if (!usernameElement || !passwordElement) {
+            return;
+        }
+        await usernameElement.click({ clickCount: 3 });
+        await usernameElement.type(this.options.username);
+        await passwordElement.click({ clickCount: 3 });
+        await passwordElement.type(this.options.password);
+        await passwordElement.press('Enter');
+        await Promise.race([
+            page
+                .waitForNavigation({
+                waitUntil: 'domcontentloaded',
+                timeout: Math.min(this.options.timeoutMs ?? 30000, 10000),
+            })
+                .catch(() => undefined),
+            this.wait(1000),
+        ]);
+    }
+    async waitForViewerReady() {
+        const page = this.requirePage();
+        const viewerSelector = this.getViewerSelector();
+        await page.waitForFunction((selector) => {
+            const rootElement = document.querySelector(selector);
+            if (!rootElement) {
+                return false;
+            }
+            const mediaElement = (rootElement.matches('video, canvas')
+                ? rootElement
+                : rootElement.querySelector('video, canvas'));
+            if (mediaElement instanceof HTMLVideoElement) {
+                return mediaElement.videoWidth > 0 && mediaElement.videoHeight > 0;
+            }
+            if (mediaElement instanceof HTMLCanvasElement) {
+                return mediaElement.width > 0 && mediaElement.height > 0;
+            }
+            const boundingRect = rootElement.getBoundingClientRect();
+            return boundingRect.width > 0 && boundingRect.height > 0;
+        }, {
+            timeout: this.options.timeoutMs ?? 30000,
+        }, viewerSelector);
+    }
+    async findFirstElement(selectors) {
+        const page = this.requirePage();
+        for (const selector of selectors) {
+            const element = await page.$(selector);
+            if (element) {
+                return element;
+            }
+        }
+        return null;
+    }
+    getViewerSelector() {
+        return this.options.viewerSelector ?? defaultViewerSelector;
+    }
+    getCaptureSelector() {
+        return this.options.captureSelector ?? this.options.viewerSelector ?? defaultViewerSelector;
+    }
+    requirePage() {
+        if (!this.page) {
+            throw new Error('BrowserKvm is not connected. Call connect() first.');
+        }
+        return this.page;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.browserkvm.js","sourceRoot":"","sources":["../ts_kvm/classes.browserkvm.ts"],"names":[],"mappings":"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"}

package/dist_ts_kvm/classes.kvmterminal.d.ts

@@ -0,0 +1,8 @@
+import type { IKvmTerminalCommandResult, IKvmTerminalOptions } from './interfaces.js';
+export declare class KvmTerminal {
+    private options;
+    constructor(options: IKvmTerminalOptions);
+    bootstrap(): Promise<void>;
+    runCommand(command: string): Promise<IKvmTerminalCommandResult>;
+    observeText(): Promise<string>;
+}

package/dist_ts_kvm/classes.kvmterminal.js

@@ -0,0 +1,88 @@
+import { createWrappedKvmCommand, parseWrappedKvmCommandOutput } from './commandwrappers.js';
+export class KvmTerminal {
+    options;
+    constructor(options) {
+        this.options = options;
+    }
+    async bootstrap() {
+        const osHint = this.options.osHint ?? 'unknown';
+        switch (osHint) {
+            case 'windows':
+                await this.options.kvm.pressShortcut(['Meta', 'R']);
+                await this.options.kvm.wait(500);
+                await this.options.kvm.typeText('powershell -NoLogo');
+                await this.options.kvm.pressKey('Enter');
+                await this.options.kvm.wait(1500);
+                break;
+            case 'macos':
+                await this.options.kvm.pressShortcut(['Meta', 'Space']);
+                await this.options.kvm.wait(500);
+                await this.options.kvm.typeText('Terminal');
+                await this.options.kvm.pressKey('Enter');
+                await this.options.kvm.wait(1500);
+                break;
+            case 'linux':
+                await this.options.kvm.pressShortcut(['Control', 'Alt', 'T']);
+                await this.options.kvm.wait(1500);
+                break;
+            case 'unknown':
+            default:
+                break;
+        }
+    }
+    async runCommand(command) {
+        const wrappedCommand = createWrappedKvmCommand(command, this.options.shellHint ?? 'unknown');
+        const commandTimeoutMs = this.options.commandTimeoutMs ?? 30000;
+        const ocrPollIntervalMs = this.options.ocrPollIntervalMs ?? 500;
+        const startedAt = Date.now();
+        let rawOcrText = '';
+        let attempts = 0;
+        await this.options.kvm.focusViewer();
+        await this.options.kvm.typeText(wrappedCommand.textToType);
+        await this.options.kvm.pressKey('Enter');
+        while (true) {
+            attempts++;
+            rawOcrText = await this.observeText();
+            const parsedResult = parseWrappedKvmCommandOutput({
+                commandId: wrappedCommand.commandId,
+                startMarker: wrappedCommand.startMarker,
+                endMarkerPrefix: wrappedCommand.endMarkerPrefix,
+                rawText: rawOcrText,
+            });
+            if (parsedResult.completed) {
+                return {
+                    commandId: wrappedCommand.commandId,
+                    command,
+                    completed: true,
+                    timedOut: false,
+                    exitCode: parsedResult.exitCode,
+                    combinedText: parsedResult.combinedText,
+                    rawOcrText,
+                };
+            }
+            const reachedMaxAttempts = typeof this.options.ocrMaxAttempts === 'number' && attempts >= this.options.ocrMaxAttempts;
+            const reachedTimeout = Date.now() - startedAt >= commandTimeoutMs;
+            if (reachedMaxAttempts || reachedTimeout) {
+                return {
+                    commandId: wrappedCommand.commandId,
+                    command,
+                    completed: false,
+                    timedOut: true,
+                    combinedText: rawOcrText,
+                    rawOcrText,
+                };
+            }
+            const remainingTimeMs = commandTimeoutMs - (Date.now() - startedAt);
+            await this.options.kvm.wait(Math.min(ocrPollIntervalMs, Math.max(remainingTimeMs, 0)));
+        }
+    }
+    async observeText() {
+        const frame = await this.options.kvm.captureFrame();
+        const result = await this.options.ocrEngine.recognize(frame, {
+            crop: this.options.ocrCrop,
+            language: 'eng',
+        });
+        return result.text;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2xhc3Nlcy5rdm10ZXJtaW5hbC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3RzX2t2bS9jbGFzc2VzLmt2bXRlcm1pbmFsLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSx1QkFBdUIsRUFBRSw0QkFBNEIsRUFBRSxNQUFNLHNCQUFzQixDQUFDO0FBTTdGLE1BQU0sT0FBTyxXQUFXO0lBQ2QsT0FBTyxDQUFzQjtJQUVyQyxZQUFZLE9BQTRCO1FBQ3RDLElBQUksQ0FBQyxPQUFPLEdBQUcsT0FBTyxDQUFDO0lBQ3pCLENBQUM7SUFFTSxLQUFLLENBQUMsU0FBUztRQUNwQixNQUFNLE1BQU0sR0FBRyxJQUFJLENBQUMsT0FBTyxDQUFDLE1BQU0sSUFBSSxTQUFTLENBQUM7UUFFaEQsUUFBUSxNQUFNLEVBQUUsQ0FBQztZQUNmLEtBQUssU0FBUztnQkFDWixNQUFNLElBQUksQ0FBQyxPQUFPLENBQUMsR0FBRyxDQUFDLGFBQWEsQ0FBQyxDQUFDLE1BQU0sRUFBRSxHQUFHLENBQUMsQ0FBQyxDQUFDO2dCQUNwRCxNQUFNLElBQUksQ0FBQyxPQUFPLENBQUMsR0FBRyxDQUFDLElBQUksQ0FBQyxHQUFHLENBQUMsQ0FBQztnQkFDakMsTUFBTSxJQUFJLENBQUMsT0FBTyxDQUFDLEdBQUcsQ0FBQyxRQUFRLENBQUMsb0JBQW9CLENBQUMsQ0FBQztnQkFDdEQsTUFBTSxJQUFJLENBQUMsT0FBTyxDQUFDLEdBQUcsQ0FBQyxRQUFRLENBQUMsT0FBTyxDQUFDLENBQUM7Z0JBQ3pDLE1BQU0sSUFBSSxDQUFDLE9BQU8sQ0FBQyxHQUFHLENBQUMsSUFBSSxDQUFDLElBQUksQ0FBQyxDQUFDO2dCQUNsQyxNQUFNO1lBQ1IsS0FBSyxPQUFPO2dCQUNWLE1BQU0sSUFBSSxDQUFDLE9BQU8sQ0FBQyxHQUFHLENBQUMsYUFBYSxDQUFDLENBQUMsTUFBTSxFQUFFLE9BQU8sQ0FBQyxDQUFDLENBQUM7Z0JBQ3hELE1BQU0sSUFBSSxDQUFDLE9BQU8sQ0FBQyxHQUFHLENBQUMsSUFBSSxDQUFDLEdBQUcsQ0FBQyxDQUFDO2dCQUNqQyxNQUFNLElBQUksQ0FBQyxPQUFPLENBQUMsR0FBRyxDQUFDLFFBQVEsQ0FBQyxVQUFVLENBQUMsQ0FBQztnQkFDNUMsTUFBTSxJQUFJLENBQUMsT0FBTyxDQUFDLEdBQUcsQ0FBQyxRQUFRLENBQUMsT0FBTyxDQUFDLENBQUM7Z0JBQ3pDLE1BQU0sSUFBSSxDQUFDLE9BQU8sQ0FBQyxHQUFHLENBQUMsSUFBSSxDQUFDLElBQUksQ0FBQyxDQUFDO2dCQUNsQyxNQUFNO1lBQ1IsS0FBSyxPQUFPO2dCQUNWLE1BQU0sSUFBSSxDQUFDLE9BQU8sQ0FBQyxHQUFHLENBQUMsYUFBYSxDQUFDLENBQUMsU0FBUyxFQUFFLEtBQUssRUFBRSxHQUFHLENBQUMsQ0FBQyxDQUFDO2dCQUM5RCxNQUFNLElBQUksQ0FBQyxPQUFPLENBQUMsR0FBRyxDQUFDLElBQUksQ0FBQyxJQUFJLENBQUMsQ0FBQztnQkFDbEMsTUFBTTtZQUNSLEtBQUssU0FBUyxDQUFDO1lBQ2Y7Z0JBQ0UsTUFBTTtRQUNWLENBQUM7SUFDSCxDQUFDO0lBRU0sS0FBSyxDQUFDLFVBQVUsQ0FBQyxPQUFlO1FBQ3JDLE1BQU0sY0FBYyxHQUFHLHVCQUF1QixDQUFDLE9BQU8sRUFBRSxJQUFJLENBQUMsT0FBTyxDQUFDLFNBQVMsSUFBSSxTQUFTLENBQUMsQ0FBQztRQUM3RixNQUFNLGdCQUFnQixHQUFHLElBQUksQ0FBQyxPQUFPLENBQUMsZ0JBQWdCLElBQUksS0FBSyxDQUFDO1FBQ2hFLE1BQU0saUJBQWlCLEdBQUcsSUFBSSxDQUFDLE9BQU8sQ0FBQyxpQkFBaUIsSUFBSSxHQUFHLENBQUM7UUFDaEUsTUFBTSxTQUFTLEdBQUcsSUFBSSxDQUFDLEdBQUcsRUFBRSxDQUFDO1FBQzdCLElBQUksVUFBVSxHQUFHLEVBQUUsQ0FBQztRQUNwQixJQUFJLFFBQVEsR0FBRyxDQUFDLENBQUM7UUFFakIsTUFBTSxJQUFJLENBQUMsT0FBTyxDQUFDLEdBQUcsQ0FBQyxXQUFXLEVBQUUsQ0FBQztRQUNyQyxNQUFNLElBQUksQ0FBQyxPQUFPLENBQUMsR0FBRyxDQUFDLFFBQVEsQ0FBQyxjQUFjLENBQUMsVUFBVSxDQUFDLENBQUM7UUFDM0QsTUFBTSxJQUFJLENBQUMsT0FBTyxDQUFDLEdBQUcsQ0FBQyxRQUFRLENBQUMsT0FBTyxDQUFDLENBQUM7UUFFekMsT0FBTyxJQUFJLEVBQUUsQ0FBQztZQUNaLFFBQVEsRUFBRSxDQUFDO1lBQ1gsVUFBVSxHQUFHLE1BQU0sSUFBSSxDQUFDLFdBQVcsRUFBRSxDQUFDO1lBQ3RDLE1BQU0sWUFBWSxHQUFHLDRCQUE0QixDQUFDO2dCQUNoRCxTQUFTLEVBQUUsY0FBYyxDQUFDLFNBQVM7Z0JBQ25DLFdBQVcsRUFBRSxjQUFjLENBQUMsV0FBVztnQkFDdkMsZUFBZSxFQUFFLGNBQWMsQ0FBQyxlQUFlO2dCQUMvQyxPQUFPLEVBQUUsVUFBVTthQUNwQixDQUFDLENBQUM7WUFFSCxJQUFJLFlBQVksQ0FBQyxTQUFTLEVBQUUsQ0FBQztnQkFDM0IsT0FBTztvQkFDTCxTQUFTLEVBQUUsY0FBYyxDQUFDLFNBQVM7b0JBQ25DLE9BQU87b0JBQ1AsU0FBUyxFQUFFLElBQUk7b0JBQ2YsUUFBUSxFQUFFLEtBQUs7b0JBQ2YsUUFBUSxFQUFFLFlBQVksQ0FBQyxRQUFRO29CQUMvQixZQUFZLEVBQUUsWUFBWSxDQUFDLFlBQVk7b0JBQ3ZDLFVBQVU7aUJBQ1gsQ0FBQztZQUNKLENBQUM7WUFFRCxNQUFNLGtCQUFrQixHQUN0QixPQUFPLElBQUksQ0FBQyxPQUFPLENBQUMsY0FBYyxLQUFLLFFBQVEsSUFBSSxRQUFRLElBQUksSUFBSSxDQUFDLE9BQU8sQ0FBQyxjQUFjLENBQUM7WUFDN0YsTUFBTSxjQUFjLEdBQUcsSUFBSSxDQUFDLEdBQUcsRUFBRSxHQUFHLFNBQVMsSUFBSSxnQkFBZ0IsQ0FBQztZQUNsRSxJQUFJLGtCQUFrQixJQUFJLGNBQWMsRUFBRSxDQUFDO2dCQUN6QyxPQUFPO29CQUNMLFNBQVMsRUFBRSxjQUFjLENBQUMsU0FBUztvQkFDbkMsT0FBTztvQkFDUCxTQUFTLEVBQUUsS0FBSztvQkFDaEIsUUFBUSxFQUFFLElBQUk7b0JBQ2QsWUFBWSxFQUFFLFVBQVU7b0JBQ3hCLFVBQVU7aUJBQ1gsQ0FBQztZQUNKLENBQUM7WUFFRCxNQUFNLGVBQWUsR0FBRyxnQkFBZ0IsR0FBRyxDQUFDLElBQUksQ0FBQyxHQUFHLEVBQUUsR0FBRyxTQUFTLENBQUMsQ0FBQztZQUNwRSxNQUFNLElBQUksQ0FBQyxPQUFPLENBQUMsR0FBRyxDQUFDLElBQUksQ0FBQyxJQUFJLENBQUMsR0FBRyxDQUFDLGlCQUFpQixFQUFFLElBQUksQ0FBQyxHQUFHLENBQUMsZUFBZSxFQUFFLENBQUMsQ0FBQyxDQUFDLENBQUMsQ0FBQztRQUN6RixDQUFDO0lBQ0gsQ0FBQztJQUVNLEtBQUssQ0FBQyxXQUFXO1FBQ3RCLE1BQU0sS0FBSyxHQUFHLE1BQU0sSUFBSSxDQUFDLE9BQU8sQ0FBQyxHQUFHLENBQUMsWUFBWSxFQUFFLENBQUM7UUFDcEQsTUFBTSxNQUFNLEdBQUcsTUFBTSxJQUFJLENBQUMsT0FBTyxDQUFDLFNBQVMsQ0FBQyxTQUFTLENBQUMsS0FBSyxFQUFFO1lBQzNELElBQUksRUFBRSxJQUFJLENBQUMsT0FBTyxDQUFDLE9BQU87WUFDMUIsUUFBUSxFQUFFLEtBQUs7U0FDaEIsQ0FBQyxDQUFDO1FBQ0gsT0FBTyxNQUFNLENBQUMsSUFBSSxDQUFDO0lBQ3JCLENBQUM7Q0FDRiJ9

package/dist_ts_kvm/commandwrappers.d.ts

@@ -0,0 +1,14 @@
+import type { IWrappedKvmCommand, TKvmShellHint } from './interfaces.js';
+export interface IParseWrappedKvmCommandOutputOptions {
+    commandId: string;
+    startMarker: string;
+    endMarkerPrefix: string;
+    rawText: string;
+}
+export interface IParseWrappedKvmCommandOutputResult {
+    completed: boolean;
+    exitCode?: number;
+    combinedText: string;
+}
+export declare const createWrappedKvmCommand: (command: string, shellHint: TKvmShellHint) => IWrappedKvmCommand;
+export declare const parseWrappedKvmCommandOutput: (options: IParseWrappedKvmCommandOutputOptions) => IParseWrappedKvmCommandOutputResult;

package/dist_ts_kvm/commandwrappers.js

@@ -0,0 +1,58 @@
+import * as plugins from './plugins.js';
+export const createWrappedKvmCommand = (command, shellHint) => {
+    const commandId = plugins.crypto.randomUUID().replace(/-/g, '');
+    const startMarker = `SMARTKVM_START_${commandId}`;
+    const endMarkerPrefix = `SMARTKVM_END_${commandId}_`;
+    let textToType;
+    switch (shellHint) {
+        case 'powershell':
+            textToType = `$__smartkvm_id = "${commandId}"; Write-Output "${startMarker}"; $__smartkvm_status = 0; try { ${command}; if ($null -ne $LASTEXITCODE) { $__smartkvm_status = $LASTEXITCODE } } catch { Write-Output $_; $__smartkvm_status = 1 }; Write-Output "${endMarkerPrefix}$__smartkvm_status"`;
+            break;
+        case 'cmd':
+            textToType = `echo ${startMarker} & ${command} & echo ${endMarkerPrefix}%ERRORLEVEL%`;
+            break;
+        case 'bash':
+        case 'zsh':
+        case 'sh':
+        case 'unknown':
+        default:
+            textToType = `printf '\n${startMarker}\n'; ${command}; __smartkvm_status=$?; printf '\n${endMarkerPrefix}%s\n' "$__smartkvm_status"`;
+            break;
+    }
+    return {
+        commandId,
+        shellHint,
+        command,
+        textToType,
+        startMarker,
+        endMarkerPrefix,
+    };
+};
+export const parseWrappedKvmCommandOutput = (options) => {
+    const normalizedRawText = options.rawText.replace(/\r\n/g, '\n').replace(/\r/g, '\n');
+    const startIndex = normalizedRawText.indexOf(options.startMarker);
+    if (startIndex === -1) {
+        return {
+            completed: false,
+            combinedText: normalizedRawText,
+        };
+    }
+    const contentStartIndex = startIndex + options.startMarker.length;
+    const endIndex = normalizedRawText.indexOf(options.endMarkerPrefix, contentStartIndex);
+    if (endIndex === -1) {
+        return {
+            completed: false,
+            combinedText: normalizedRawText,
+        };
+    }
+    const endMarkerValueStartIndex = endIndex + options.endMarkerPrefix.length;
+    const endMarkerLine = normalizedRawText.slice(endMarkerValueStartIndex).split('\n')[0].trim();
+    const exitCodeMatch = endMarkerLine.match(/^-?\d+/);
+    const exitCode = exitCodeMatch ? Number.parseInt(exitCodeMatch[0], 10) : undefined;
+    return {
+        completed: true,
+        exitCode,
+        combinedText: normalizedRawText.slice(contentStartIndex, endIndex).trim(),
+    };
+};
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts_kvm/index.d.ts

@@ -0,0 +1,6 @@
+export * from './interfaces.js';
+export * from './classes.browserkvm.js';
+export * from './classes.kvmterminal.js';
+export * from './commandwrappers.js';
+export * from './tools.js';
+export * from './ocr.js';

package/dist_ts_kvm/index.js

@@ -0,0 +1,7 @@
+export * from './interfaces.js';
+export * from './classes.browserkvm.js';
+export * from './classes.kvmterminal.js';
+export * from './commandwrappers.js';
+export * from './tools.js';
+export * from './ocr.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90c19rdm0vaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxpQkFBaUIsQ0FBQztBQUNoQyxjQUFjLHlCQUF5QixDQUFDO0FBQ3hDLGNBQWMsMEJBQTBCLENBQUM7QUFDekMsY0FBYyxzQkFBc0IsQ0FBQztBQUNyQyxjQUFjLFlBQVksQ0FBQztBQUMzQixjQUFjLFVBQVUsQ0FBQyJ9

package/dist_ts_kvm/interfaces.d.ts

@@ -0,0 +1,106 @@
+export type TKvmKind = 'jetkvm' | 'glinet' | 'pikvm' | 'tinypilot' | 'generic';
+export type TKvmFrameMimeType = 'image/png' | 'image/jpeg';
+export type TKvmOsHint = 'windows' | 'macos' | 'linux' | 'unknown';
+export type TKvmShellHint = 'powershell' | 'cmd' | 'bash' | 'zsh' | 'sh' | 'unknown';
+export type TKvmKey = 'Enter' | 'Escape' | 'Tab' | 'Backspace' | 'Delete' | 'ArrowUp' | 'ArrowDown' | 'ArrowLeft' | 'ArrowRight' | 'Home' | 'End' | 'PageUp' | 'PageDown' | 'Space' | 'Meta' | 'Control' | 'Alt' | 'Shift' | 'F1' | 'F2' | 'F3' | 'F4' | 'F5' | 'F6' | 'F7' | 'F8' | 'F9' | 'F10' | 'F11' | 'F12' | string;
+export interface IKvmFrame {
+    timestamp: number;
+    width: number;
+    height: number;
+    mimeType: TKvmFrameMimeType;
+    dataBase64: string;
+}
+export interface IBrowserKvmOptions {
+    url: string;
+    kind?: TKvmKind;
+    username?: string;
+    password?: string;
+    headless?: boolean;
+    /**
+     * Main element that should receive keyboard focus.
+     * Usually video, canvas, or a wrapper around the KVM viewer.
+     */
+    viewerSelector?: string;
+    /**
+     * Element used for frame capture.
+     * Defaults to video, then canvas, then viewer screenshot fallback.
+     */
+    captureSelector?: string;
+    /**
+     * Useful for self-signed KVM certificates.
+     */
+    ignoreHttpsErrors?: boolean;
+    /**
+     * Persist browser session cookies/login state.
+     */
+    userDataDir?: string;
+    /**
+     * Optional browser executable path.
+     */
+    executablePath?: string;
+    /**
+     * Optional timeout for initial load and viewer detection.
+     */
+    timeoutMs?: number;
+}
+export interface IKvmTypeTextOptions {
+    delayMs?: number;
+}
+export interface IKvmDriver {
+    readonly kind: TKvmKind;
+    connect: () => Promise<void>;
+    disconnect: () => Promise<void>;
+    focusViewer: () => Promise<void>;
+    captureFrame: () => Promise<IKvmFrame>;
+    typeText: (text: string, options?: IKvmTypeTextOptions) => Promise<void>;
+    pressKey: (key: TKvmKey) => Promise<void>;
+    pressShortcut: (keys: TKvmKey[]) => Promise<void>;
+    wait: (milliseconds: number) => Promise<void>;
+}
+export interface IOcrCrop {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+export interface IOcrRecognizeOptions {
+    crop?: IOcrCrop;
+    language?: string;
+}
+export interface IOcrResult {
+    text: string;
+    confidence?: number;
+}
+export interface IOcrEngine {
+    recognize: (frame: IKvmFrame, options?: IOcrRecognizeOptions) => Promise<IOcrResult>;
+}
+export interface IKvmTerminalOptions {
+    kvm: IKvmDriver;
+    ocrEngine: IOcrEngine;
+    osHint?: TKvmOsHint;
+    shellHint?: TKvmShellHint;
+    commandTimeoutMs?: number;
+    ocrPollIntervalMs?: number;
+    ocrMaxAttempts?: number;
+    /**
+     * Optional OCR crop to limit recognition to terminal area.
+     */
+    ocrCrop?: IOcrCrop;
+}
+export interface IKvmTerminalCommandResult {
+    commandId: string;
+    command: string;
+    completed: boolean;
+    timedOut: boolean;
+    exitCode?: number;
+    combinedText: string;
+    rawOcrText: string;
+}
+export interface IWrappedKvmCommand {
+    commandId: string;
+    shellHint: TKvmShellHint;
+    command: string;
+    textToType: string;
+    startMarker: string;
+    endMarkerPrefix: string;
+}

package/dist_ts_kvm/interfaces.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW50ZXJmYWNlcy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3RzX2t2bS9pbnRlcmZhY2VzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIifQ==

package/dist_ts_kvm/ocr.d.ts

@@ -0,0 +1,14 @@
+import * as plugins from './plugins.js';
+import type { IOcrEngine } from './interfaces.js';
+export interface IKvmMistralOcrEngineOptions {
+    apiKey?: string;
+    model?: string;
+    endpointUrl?: string;
+    transport?: plugins.ocr.ISmartAiMistralOcrTransport;
+    includeImageBase64?: boolean;
+    tableFormat?: plugins.ocr.TSmartAiMistralOcrTableFormat;
+    extractHeader?: boolean;
+    extractFooter?: boolean;
+    confidenceScoresGranularity?: plugins.ocr.TSmartAiMistralOcrConfidenceScoresGranularity;
+}
+export declare const createMistralKvmOcrEngine: (options?: IKvmMistralOcrEngineOptions) => IOcrEngine;

package/dist_ts_kvm/ocr.js

@@ -0,0 +1,23 @@
+import * as plugins from './plugins.js';
+export const createMistralKvmOcrEngine = (options = {}) => {
+    const ocrEngine = plugins.ocr.createMistralOcrEngine({
+        ...options,
+        confidenceScoresGranularity: options.confidenceScoresGranularity ?? 'page',
+    });
+    return {
+        recognize: async (frame, recognizeOptions = {}) => {
+            if (recognizeOptions.crop) {
+                throw new Error('Mistral KVM OCR does not support crop options yet.');
+            }
+            const result = await ocrEngine.recognizeImage({
+                dataBase64: frame.dataBase64,
+                mimeType: frame.mimeType,
+            });
+            return {
+                text: result.text,
+                confidence: result.confidence,
+            };
+        },
+    };
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoib2NyLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vdHNfa3ZtL29jci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEtBQUssT0FBTyxNQUFNLGNBQWMsQ0FBQztBQWV4QyxNQUFNLENBQUMsTUFBTSx5QkFBeUIsR0FBRyxDQUN2QyxVQUF1QyxFQUFFLEVBQzdCLEVBQUU7SUFDZCxNQUFNLFNBQVMsR0FBRyxPQUFPLENBQUMsR0FBRyxDQUFDLHNCQUFzQixDQUFDO1FBQ25ELEdBQUcsT0FBTztRQUNWLDJCQUEyQixFQUFFLE9BQU8sQ0FBQywyQkFBMkIsSUFBSSxNQUFNO0tBQzNFLENBQUMsQ0FBQztJQUVILE9BQU87UUFDTCxTQUFTLEVBQUUsS0FBSyxFQUFFLEtBQUssRUFBRSxnQkFBZ0IsR0FBRyxFQUFFLEVBQXVCLEVBQUU7WUFDckUsSUFBSSxnQkFBZ0IsQ0FBQyxJQUFJLEVBQUUsQ0FBQztnQkFDMUIsTUFBTSxJQUFJLEtBQUssQ0FBQyxvREFBb0QsQ0FBQyxDQUFDO1lBQ3hFLENBQUM7WUFFRCxNQUFNLE1BQU0sR0FBRyxNQUFNLFNBQVMsQ0FBQyxjQUFjLENBQUM7Z0JBQzVDLFVBQVUsRUFBRSxLQUFLLENBQUMsVUFBVTtnQkFDNUIsUUFBUSxFQUFFLEtBQUssQ0FBQyxRQUFRO2FBQ3pCLENBQUMsQ0FBQztZQUVILE9BQU87Z0JBQ0wsSUFBSSxFQUFFLE1BQU0sQ0FBQyxJQUFJO2dCQUNqQixVQUFVLEVBQUUsTUFBTSxDQUFDLFVBQVU7YUFDOUIsQ0FBQztRQUNKLENBQUM7S0FDRixDQUFDO0FBQ0osQ0FBQyxDQUFDIn0=

package/dist_ts_kvm/plugins.d.ts

@@ -0,0 +1,6 @@
+import * as crypto from 'node:crypto';
+export { crypto };
+import puppeteer from 'puppeteer';
+export { puppeteer };
+import * as ocr from '@modelprofile.com/flexharness/ocr';
+export { ocr };

package/dist_ts_kvm/plugins.js

@@ -0,0 +1,10 @@
+// node native scope
+import * as crypto from 'node:crypto';
+export { crypto };
+// third party scope
+import puppeteer from 'puppeteer';
+export { puppeteer };
+// FlexHarness OCR
+import * as ocr from '@modelprofile.com/flexharness/ocr';
+export { ocr };
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGx1Z2lucy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3RzX2t2bS9wbHVnaW5zLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLG9CQUFvQjtBQUNwQixPQUFPLEtBQUssTUFBTSxNQUFNLGFBQWEsQ0FBQztBQUV0QyxPQUFPLEVBQUUsTUFBTSxFQUFFLENBQUM7QUFFbEIsb0JBQW9CO0FBQ3BCLE9BQU8sU0FBUyxNQUFNLFdBQVcsQ0FBQztBQUVsQyxPQUFPLEVBQUUsU0FBUyxFQUFFLENBQUM7QUFFckIsa0JBQWtCO0FBQ2xCLE9BQU8sS0FBSyxHQUFHLE1BQU0sbUNBQW1DLENBQUM7QUFDekQsT0FBTyxFQUFFLEdBQUcsRUFBRSxDQUFDIn0=