npm - @phystack/screen-phyos - Versions diffs - 4.3.40-dev - Mend

@phystack/screen-phyos 4.3.40-dev

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (15) hide show

package/README.md ADDED Viewed

	@@ -0,0 +1 @@
1	+ Physcreen

package/bin/index.js ADDED Viewed

	@@ -0,0 +1,2 @@
1	+ #!/usr/bin/env node
2	+ require('../dist/index.js');

package/dist/browser.js ADDED Viewed

@@ -0,0 +1,117 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setup = exports.reload = exports.open = exports.restart = void 0;
+const child_process_1 = __importDefault(require("child_process"));
+const ws_1 = __importDefault(require("ws"));
+const node_fetch_1 = __importDefault(require("node-fetch"));
+const phy_logger_1 = require("@phystack/phy-logger");
+const delay = (n) => new Promise((resolve) => setTimeout(resolve, n));
+const CHROME_PORT = 3000;
+const logger = new phy_logger_1.PhyLogger({
+    logToFile: false,
+    logToConsole: true,
+    includeTrace: true,
+    namespace: 'screen-phyos-browser',
+});
+const restart = async () => {
+    for (let counter = 0; counter < 3; counter++) {
+        try {
+            child_process_1.default.execSync('killall chromium');
+            return;
+        }
+        catch (e) {
+            await delay(10000);
+        }
+    }
+};
+exports.restart = restart;
+const fetchTargets = async () => {
+    const response = await (0, node_fetch_1.default)(`http://localhost:${CHROME_PORT}/json`);
+    const targets = await response.json();
+    logger.debug('Available targets', { targets });
+    return targets;
+};
+const getWebSocketDebuggerUrl = async () => {
+    const targets = await fetchTargets();
+    // Filter targets to find the page you want
+    const pageTarget = targets.find((target) => {
+        const url = new URL(target.url);
+        return (target.type === 'page' &&
+            (url.protocol === 'http:' || url.protocol === 'https:' || url.protocol === 'file:'));
+    });
+    if (!pageTarget) {
+        throw new Error('No suitable page target found');
+    }
+    return pageTarget.webSocketDebuggerUrl;
+};
+const sendCmd = async (cmd) => {
+    const webSocketDebuggerUrl = await getWebSocketDebuggerUrl();
+    const ws = new ws_1.default(webSocketDebuggerUrl);
+    return new Promise((resolve, reject) => {
+        ws.on('open', () => {
+            logger.debug('WebSocket connection opened');
+            ws.send(JSON.stringify(cmd));
+        });
+        ws.on('message', (data) => {
+            logger.debug('WebSocket message received', { data });
+            resolve(data);
+            ws.close();
+        });
+        ws.on('error', (err) => {
+            logger.error('WebSocket error', { error: err });
+            reject(err);
+        });
+        ws.on('close', () => {
+            logger.debug('WebSocket connection closed');
+        });
+    });
+};
+const open = async (url) => {
+    logger.info('Opening URL', { url });
+    for (let i = 0; i < 5; i++) {
+        try {
+            const cmd = {
+                id: 1,
+                method: 'Page.navigate',
+                params: { url },
+            };
+            await sendCmd(cmd);
+            return true;
+        }
+        catch (e) {
+            logger.error('Cannot send message, restarting browser', { error: e.toString() });
+            await (0, exports.restart)();
+            await delay(1000);
+        }
+    }
+    logger.error('Cannot reach the browser, giving up');
+    return false;
+};
+exports.open = open;
+const reload = async () => {
+    const cmd = {
+        id: 1,
+        method: 'Page.reload',
+        params: {},
+    };
+    await sendCmd(cmd);
+};
+exports.reload = reload;
+const setup = async () => {
+    const cmd = {
+        id: 1,
+        method: 'Page.setDeviceMetricsOverride',
+        params: {
+            width: 1280,
+            height: 720,
+            deviceScaleFactor: 0,
+            mobile: false,
+        },
+    };
+    await sendCmd(cmd);
+};
+exports.setup = setup;
+exports.default = { restart: exports.restart, open: exports.open, reload: exports.reload, setup: exports.setup };

package/dist/index.js ADDED Viewed

@@ -0,0 +1,394 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+require("./version.js");
+require("./proxy-settings.js");
+// import { connect, Module } from '@ombori/ga-module';
+const hub_client_1 = require("@phystack/hub-client");
+const phy_logger_1 = require("@phystack/phy-logger");
+const child_process_1 = __importDefault(require("child_process"));
+// import net from 'net';
+const fs_1 = __importDefault(require("fs"));
+// import { Settings } from './schema.js';
+const screenshot_js_1 = require("./screenshot.js");
+const sway_js_1 = require("./sway.js");
+const sound = __importStar(require("./sound.js"));
+const udev_js_1 = __importDefault(require("./udev.js"));
+const browser_js_1 = __importDefault(require("./browser.js"));
+const proxy_js_1 = __importDefault(require("./proxy.js"));
+const twin_types_1 = require("./types/twin.types");
+const logger = new phy_logger_1.PhyLogger({
+    logToFile: false,
+    logToConsole: true,
+    includeTrace: true,
+    namespace: 'screen-phyos',
+});
+(async () => {
+    const { PHYSCREEN_DEBUG = "0" } = process.env;
+    if (parseInt(PHYSCREEN_DEBUG, 10) === 1) {
+        logger.info('Starting in PHYSCREEN_DEBUG mode');
+        return;
+    }
+    proxy_js_1.default.start({
+        port: 1234,
+        dport: 3000,
+    });
+    const NO_SETTINGS_URL = 'file:///var/physcreen/index.html#no-settings';
+    const client = await (0, hub_client_1.connectPhyClient)();
+    const deviceInstance = await client.getDeviceInstance();
+    const screenInstance = await client.getInstance();
+    const { properties } = screenInstance;
+    logger.info('Device Instance retrieved', {
+        spaceId: deviceInstance.twin.properties.desired.spaceId,
+        env: deviceInstance.twin.properties.desired.env,
+        displayName: deviceInstance.twin.properties.desired.displayName,
+        deviceSerial: deviceInstance.twin.properties.desired.deviceSerial,
+        accessKey: deviceInstance.twin.properties.desired.accessKey
+    });
+    logger.info('Screen Instance retrieved', {
+        screenId: screenInstance.id,
+        desiredProperties: screenInstance.properties.desired
+    });
+    if (properties.desired && properties.desired.url) {
+        const cachedUrl = properties.desired.url || NO_SETTINGS_URL;
+        logger.info('Opening cached URL', { url: cachedUrl });
+        await browser_js_1.default.open(cachedUrl);
+    }
+    const HEARTBEAT_PATH = '/tmp/physcreen-heartbeat';
+    setInterval(() => {
+        fs_1.default.writeFileSync(HEARTBEAT_PATH, new Date().toISOString());
+    }, 1000);
+    const emitReportedProperties = async (data, status) => {
+        const payload = {
+            twinId: screenInstance.id,
+            data,
+            ...(status && { status }),
+        };
+        logger.info('Reporting properties', { payload });
+        await client.setScreenInstanceReportedProperties(payload);
+    };
+    let crashes = 0;
+    await emitReportedProperties({ crash: { count: crashes } }, twin_types_1.TwinStatusEnum.Online);
+    let lastHeartbeat = 0;
+    // module.subscribe('App.Heartbeat', () => {
+    //   if (!lastHeartbeat) console.log('Heartbeat: an initial heartbeat is received');
+    //   lastHeartbeat = new Date().getTime();
+    // });
+    async function onSupervisorUrlUpdated() {
+        const url = properties.desired.url;
+        if (url === activeUrl)
+            return;
+        activeUrl = url || NO_SETTINGS_URL;
+        logger.info('URL changed', { newUrl: activeUrl });
+        await browser_js_1.default.open(activeUrl);
+    }
+    const delay = (n) => new Promise((resolve) => setTimeout(resolve, n));
+    let activeUrl = properties.desired.url || NO_SETTINGS_URL;
+    logger.info('Opening initial URL', { url: activeUrl });
+    await browser_js_1.default.open(activeUrl);
+    if (!properties.desired.screenResolution)
+        properties.desired.screenResolution = 'default';
+    if (!properties.desired.screenOrientation)
+        properties.desired.screenOrientation = 'landscape';
+    if (!properties.desired.soundOutput)
+        properties.desired.soundOutput = 'hdmi1';
+    if (!properties.desired.soundInput)
+        properties.desired.soundInput = 'default';
+    if (!properties.desired.scale)
+        properties.desired.scale = '1.0';
+    logger.info('Desired settings retrieved', { desiredSettings: properties.desired });
+    logger.info('Setting up config file for wayland composer');
+    await (0, sway_js_1.setupSwayConfig)({
+        orientation: properties.desired.screenOrientation,
+        resolution: properties.desired.screenResolution,
+        scale: properties.desired.scale,
+        headless: !(0, sway_js_1.isDrmAvailable)(),
+    });
+    sound.onDevices((devices) => {
+        const sound = devices.reduce((prev, { device, card, name }) => ({
+            ...prev,
+            [`${card}:${device}`]: name,
+        }), {});
+        emitReportedProperties({ sound });
+    });
+    logger.info('Setting up sound output');
+    await sound.setup(properties.desired.soundOutput, properties.desired.soundInput);
+    // const onIoUpdated = async ({ inputs, outputs }: { inputs: any[]; outputs: any[] }) => {
+    //   await mirror.activate(
+    //     ScreenTransforms(module.settings.screen_orientation),
+    //     module.settings.screen_resolution,
+    //   );
+    //   console.log(`Found ${inputs.length} inputs`);
+    //   for (const inp of inputs) console.log(` ${inp.name} ${inp.type}`);
+    //   console.log(`Found ${outputs.length} outputs`);
+    //   for (const oup of outputs)
+    //     console.log(` ${oup.name} ${oup.model} ${oup.serial} ${oup.current_mode}`);
+    //   if (outputs.length === 0) {
+    //     module.updateTelemetry({ output: null });
+    //   } else {
+    //     const {
+    //       name,
+    //       current_mode: { width, height } = { width: 0, height: 0 },
+    //       model,
+    //       serial,
+    //       make,
+    //     } = outputs[0];
+    //     module.updateTelemetry({
+    //       output: {
+    //         name,
+    //         mode: `${width}x${height}`,
+    //         model: `${make} ${model}`,
+    //         serial,
+    //       },
+    //     });
+    //   }
+    // };
+    // const checkPortOpen = (port: number) =>
+    //   new Promise<boolean>((resolve) => {
+    //     const conn = net.createConnection({ port, timeout: 10000 });
+    //     conn.on('connect', () => {
+    //       resolve(true);
+    //       conn.end();
+    //     });
+    //     conn.on('error', () => {
+    //       resolve(false);
+    //     });
+    //   });
+    // module.onStream('debug', async (ws: any) => module.proxyTcp(ws, 1234));
+    // module.onMethod('open', async (data: any) => {
+    //   const { url } = data;
+    //   await browser.open(url);
+    //   return 'Opened';
+    // });
+    // module.onMethod('kill', async () => {
+    //   console.log('Kill command received, killing browser');
+    //   browser.restart();
+    //   return 'Killing browser';
+    // });
+    // module.onMethod('reload', async () => {
+    //   console.log('Reloading browser');
+    //   browser.reload();
+    //   return 'Reloading';
+    // });
+    // module.onMethod('setup', async () => {
+    //   console.log('Opening setup screen');
+    //   browser.setup();
+    //   return 'Toggling setup';
+    // });
+    // module.onMethod('inputs', () => swayMsg('-t get_inputs'));
+    // module.onMethod('outputs', () => swayMsg('-t get_outputs'));
+    // module.onMethod('screenshot', async () => {
+    //   try {
+    //     console.log('Taking screenshot');
+    //     const data = await takeScreenshot();
+    //     const [allWhite, allBlack] = await analyzeScreenshot(data);
+    //     const resized = await resizeScreenshot(data);
+    //     const token = await getScreenshotToken({accessKey: `${GRID_DEVICE_ID}`, browserId: `${GRID_DEVICE_ACCESS_KEY}`}); // TODO: renew
+    //     if (!token) throw new Error('Screenshot: cannot upload, invalid token');
+    //     const url = await uploadScreenshot(resized, token);
+    //     return { url, allWhite, allBlack };
+    //   } catch (error) {
+    //     console.error('Error during screenshot process:', error);
+    //     throw new Error('Failed to process screenshot');
+    //   }
+    // });
+    // module.onMethod('screenshot', async () => {
+    //   try {
+    //     // Take the screenshot
+    //     const data = await takeScreenshot();
+    //     // Analyze the screenshot
+    //     const [allWhite, allBlack] = await analyzeScreenshot(data);
+    //     // Resize the screenshot
+    //     const resized = await resizeScreenshot(data);
+    //     // Emit the screenshot data
+    //     await module.emit('uplink', {
+    //       type: 'Screen.Screenshot',
+    //       uuid: GRID_DEVICE_ID,
+    //       image: resized.toString('base64'),
+    //     });
+    //     // Construct the URL
+    //     const url = `https://gridhealth.blob.core.windows.net/screens/${GRID_DEVICE_ID}.jpg`;
+    //     // Return the result
+    //     return { url, allWhite, allBlack };
+    //   } catch (error) {
+    //     console.error('Error during screenshot process:', error);
+    //     throw new Error('Failed to process screenshot');
+    //   }
+    // });
+    // module.onMethod('sound_test', async (params) => {
+    //   const { output = module.settings.sound_output } = params;
+    //   const success = await sound.test(output);
+    //   return success ? 'Success' : 'Failed';
+    // });
+    const checkHeartbeats = async () => {
+        while (true) {
+            await delay(60 * 1000);
+            if (!lastHeartbeat)
+                continue; // no heartbeats ever received
+            const now = new Date().getTime();
+            if (now - lastHeartbeat <= 60000)
+                continue;
+            logger.error('Heartbeat not registered for 60 seconds, restarting app');
+            lastHeartbeat = 0;
+            // await sendCrashReport('no_heartbeat');
+            await browser_js_1.default.restart();
+        }
+    };
+    let prevUrl = '';
+    const takeScreenshots = async () => {
+        let whiteColorCount = 0;
+        let blackColorCount = 0;
+        await delay(20 * 1000); // Initial delay before starting the loop
+        while (true) {
+            const { restartIfAllWhite = true, restartIfAllBlack = true } = properties.desired;
+            let data = null;
+            try {
+                data = await (0, screenshot_js_1.takeScreenshot)();
+            }
+            catch (e) {
+                logger.error('Error taking screenshot', { error: e.toString() });
+                (0, sway_js_1.restartSway)();
+                continue;
+            }
+            if (!data) {
+                logger.error('Screenshot data is not a buffer');
+                throw new Error('Screenshot: not a buffer');
+            }
+            try {
+                const [allWhite, allBlack] = await (0, screenshot_js_1.analyzeScreenshot)(data);
+                const resized = await (0, screenshot_js_1.resizeScreenshot)(data);
+                let url = `https://gridhealth.blob.core.windows.net/screens/${deviceInstance.twin.deviceId}.jpg`;
+                try {
+                    logger.info('Starting new screenshot upload');
+                    const token = await (0, screenshot_js_1.getScreenshotToken)({
+                        browserId: deviceInstance.twin.deviceId,
+                        accessKey: deviceInstance.twin.properties.desired.accessKey
+                    });
+                    logger.debug('Screenshot token retrieved', { token });
+                    if (!token)
+                        throw new Error('Screenshot: cannot upload, invalid token');
+                    url = await (0, screenshot_js_1.uploadScreenshot)(resized, token);
+                }
+                catch (e) {
+                    logger.error('Error during screenshot upload', { error: e.toString() });
+                    throw new Error('Failed to upload screenshot');
+                }
+                try {
+                    if (url !== prevUrl) {
+                        prevUrl = url;
+                        await emitReportedProperties({ screenshot: url });
+                    }
+                }
+                catch (e) {
+                    logger.error('Error during screenshot telemetry', { error: e.toString() });
+                    throw new Error('Failed to screenshot telemetry');
+                }
+                whiteColorCount = allWhite && restartIfAllWhite ? whiteColorCount + 1 : 0;
+                blackColorCount = allBlack && restartIfAllBlack ? blackColorCount + 1 : 0;
+                if (whiteColorCount)
+                    logger.warn(`Screenshot: all white (${whiteColorCount} try)`);
+                if (blackColorCount)
+                    logger.warn(`Screenshot: all black (${blackColorCount} try)`);
+                if (whiteColorCount > 2) {
+                    logger.error('Screen detected as all white, restarting browser');
+                    await emitReportedProperties({ crash: { reason: 'screen_all_white' } });
+                    browser_js_1.default.restart();
+                    whiteColorCount = 0;
+                }
+                if (blackColorCount > 2) {
+                    logger.error('Screen detected as all black, restarting browser');
+                    await emitReportedProperties({ crash: { reason: 'screen_all_black' } });
+                    browser_js_1.default.restart();
+                    blackColorCount = 0;
+                }
+                // Wait time adjustments based on screen status
+                await delay(whiteColorCount + blackColorCount ? 5 * 1000 : 60 * 1000);
+            }
+            catch (e) {
+                logger.error('Error processing screenshot', { error: e.toString() });
+                // Continue the loop even if there is an error during processing
+                await delay(5 * 1000); // Shorter delay after an error
+            }
+        }
+    };
+    const isTouchConnected = (info) => info.driver === 'hid-multitouch' && info.action === 'bind';
+    const isMouseLikeConnected = (info) => info.action === 'add' &&
+        info.subsystem === 'input' &&
+        /^\/dev\/input\/mouse[0-9]/.test(info.devname);
+    udev_js_1.default.monitor(async (info) => {
+        try {
+            if (!info)
+                return;
+            if (info.subsystem === 'bdi')
+                return; // ignore zfs mounts
+            // when the screen is connected for the 1st time
+            if (info.action === 'add' &&
+                info.subsystem === 'graphics' &&
+                info.devname === '/dev/fb0') {
+                const inputs = await (0, sway_js_1.swayMsg)(`-t get_outputs`);
+                if (inputs && inputs.every((input) => /^HEADLESS-/.test(input.name))) {
+                    logger.info('Udev: Screen is connected for the 1st time, restarting module');
+                    browser_js_1.default.restart();
+                    return;
+                }
+            }
+            if (info.action === 'change' &&
+                info.subsystem === 'drm' &&
+                info.devname === '/dev/dri/card0') {
+                const inputs = await (0, sway_js_1.swayMsg)(`-t get_outputs`);
+                if (inputs && inputs.every((input) => /^HEADLESS-/.test(input.name))) {
+                    logger.info('Udev: Screen is connected, restarting module');
+                    browser_js_1.default.restart();
+                }
+            }
+            // logger.debug('Udev ignored', { info });
+        }
+        catch (e) {
+            logger.error('Cannot process udev event', { error: e });
+        }
+    });
+    checkHeartbeats();
+    takeScreenshots();
+    process.on('SIGTERM', async () => {
+        logger.info('Received SIGTERM, exiting');
+        try {
+            await emitReportedProperties({}, twin_types_1.TwinStatusEnum.Exited);
+            fs_1.default.unlinkSync(HEARTBEAT_PATH); // Remove heartbeat file only on clean shutdown
+            await new Promise((resolve) => child_process_1.default.exec('killall -9 sway', resolve));
+            await delay(500);
+        }
+        catch (e) {
+            logger.error('Error during shutdown', { error: e.toString() });
+        }
+        process.exit(1);
+    });
+    // module.restartHandler = async () => {
+    //   console.log('onrestart handler');
+    //   await new Promise((resolve) => cp.exec('killall -9 sway', resolve));
+    // };
+})();

package/dist/mirror.js ADDED Viewed

@@ -0,0 +1,127 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const child_process_1 = __importDefault(require("child_process"));
+const sway_js_1 = require("./sway.js");
+const walk = (data, parent) => {
+    if (!data)
+        return [];
+    data.parent = parent;
+    const result = [data];
+    for (const child of data.nodes) {
+        for (const i of walk(child, data))
+            result.push(i);
+    }
+    return result;
+};
+const MIRROR_TITLE = 'wlr dmabuf output mirror';
+async function main(orientation, resolution) {
+    const res = await (0, sway_js_1.swayMsg)('-t get_tree');
+    const data = walk(res);
+    //  data.forEach(a => console.log(a.type));
+    const outputs = data.filter((a) => a.type === 'output' && a.active);
+    console.log(`Found ${outputs.length} outputs`);
+    // if (outputs.length <= 1) return;
+    const windows = data.filter((a) => a.type === 'con');
+    const primaryWindow = windows.filter((win) => win.name !== MIRROR_TITLE).pop();
+    if (!primaryWindow)
+        throw new Error('primary window not found');
+    console.log('Found a primary window');
+    if (!primaryWindow.parent)
+        throw new Error('primary window got no parent');
+    if (!primaryWindow.parent.parent)
+        throw new Error('primary window got no output');
+    const primaryOutput = primaryWindow.parent.parent;
+    if (outputs.length && resolution !== 'default') {
+        console.log('Fixing resolution');
+        await (0, sway_js_1.swayMsg)(`'output * mode ${resolution}'`);
+    }
+    for (const out of outputs) {
+        if (out === primaryOutput && orientation) {
+            console.log('Fixing rotation for primary output', out.name);
+            await (0, sway_js_1.swayMsg)(`output ${out.name} transform ${orientation}`);
+            continue;
+        }
+        //    console.log(out);
+        if (out.transform === 'normal')
+            continue;
+        console.log('Fixing rotation for output', out.name);
+        await (0, sway_js_1.swayMsg)(`output ${out.name} transform 0`);
+    }
+    console.log(`Found ${windows.length} windows`);
+    if (windows.length > outputs.length) {
+        console.log('Found too many windows, killing all mirrors');
+        windows.forEach((win) => console.log(`title: ${win.name}`));
+        try {
+            child_process_1.default.execSync('killall wdomirror');
+        }
+        catch (e) { }
+        return false;
+    }
+    if (windows.length < outputs.length) {
+        // FIXME: implement a proper display search
+        const template = `Mirrorable output: ${primaryOutput.make} Model: ${primaryOutput.model}: ID: `;
+        console.log(primaryOutput.name, primaryOutput.serial, primaryOutput.model);
+        const lines = child_process_1.default
+            .execSync('wdomirror 2>&1 || true', {
+            env: { ...process.env },
+        })
+            .toString()
+            .trim()
+            .split('\n');
+        const found = lines.filter((line) => line.includes(template));
+        const ids = (found.length ? found : lines)
+            .map((line) => /ID: ([0-9]+)$/.exec(line))
+            .filter((a) => a)
+            .map(([, id]) => id);
+        if (!ids.length)
+            throw new Error('Unable to find screen id');
+        const id = ids[0];
+        for (let i = windows.length; i < outputs.length; i++) {
+            console.log('Creating a mirror process');
+            child_process_1.default.exec(`wdomirror ${id} &`, {
+                env: { ...process.env },
+            });
+        }
+        await new Promise((resolve) => setInterval(resolve, 1000));
+        return false;
+    }
+    const workspaces = data.filter((a) => a.type === 'workspace' && a.output);
+    for (const ws of workspaces) {
+        const children = ws.nodes.filter((ch) => ch.type === 'con');
+        if (children.length <= 1)
+            continue;
+        for (const ch of children) {
+            if (ch.name !== MIRROR_TITLE)
+                continue;
+            console.log('moving window to a different workspace', ch.id);
+            await (0, sway_js_1.swayMsg)(`'[con_id=${ch.id}] focus'`);
+            await (0, sway_js_1.swayMsg)(`move container to workspace next`);
+            return false;
+        }
+    }
+    for (const con of data.filter((a) => a.type === 'con' && a.fullscreen_mode === 0)) {
+        await (0, sway_js_1.swayMsg)(`'[con_id=${con.id}] focus'`);
+        await (0, sway_js_1.swayMsg)(`'[con_id=${con.id}] fullscreen on'`);
+        await (0, sway_js_1.swayMsg)(`'[con_id=${con.id}] fullscreen off'`);
+        await (0, sway_js_1.swayMsg)(`'[con_id=${con.id}] border none'`);
+        console.log(`window ${con.id} is fullscreen now`);
+    }
+    console.log('All good');
+    return true;
+}
+async function activate(orientation, resolution) {
+    for (let i = 0; i < 20; i++) {
+        try {
+            if (await main(orientation, resolution))
+                return;
+        }
+        catch (e) {
+            console.error(e);
+            await new Promise((resolve) => setTimeout(resolve, 1000));
+        }
+    }
+}
+exports.default = { activate };

package/dist/proxy-settings.js ADDED Viewed

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const global_agent_1 = require("global-agent");
+const { HTTP_PROXY, HTTPS_PROXY, NO_PROXY } = process.env;
+process.env.GLOBAL_AGENT_FORCE_GLOBAL_AGENT = 'false';
+if (HTTP_PROXY)
+    process.env.GLOBAL_AGENT_HTTP_PROXY = HTTP_PROXY.replace(/\"/g, '');
+if (HTTPS_PROXY)
+    process.env.GLOBAL_AGENT_HTTPS_PROXY = HTTPS_PROXY.replace(/\"/g, '');
+if (NO_PROXY)
+    process.env.GLOBAL_AGENT_NO_PROXY = NO_PROXY.replace(/\"/g, '');
+(0, global_agent_1.bootstrap)();

package/dist/proxy.js ADDED Viewed

@@ -0,0 +1,52 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const http_proxy_1 = __importDefault(require("http-proxy"));
+const http_1 = __importDefault(require("http"));
+const phy_logger_1 = require("@phystack/phy-logger");
+const logger = new phy_logger_1.PhyLogger({
+    logToFile: false,
+    logToConsole: true,
+    includeTrace: true,
+    namespace: 'screen-phyos-proxy',
+});
+// As chromium does not support remote debugging, we need to manually proxy all http/ws requests to it
+const start = ({ port, dport }) => {
+    // const proxy = httpProxy.createProxy({
+    //   ws: true
+    // });
+    // const target = `localhost:${dport}`;
+    // const server = http.createServer((req: any, res: any) => {
+    //   console.log('>', req.url);
+    //   proxy.web(req, res, { target: { host: 'localhost', port: dport } }, (e: any) => {
+    //     if (e) {
+    //       console.error(e.message);
+    //     }
+    //   });
+    // })
+    // server.on('upgrade', (req: any, res: any) => {
+    //   console.log('up', req.url);
+    //   proxy.ws(req, res, { target: 'ws://localhost:3000' }, undefined, (e: any) => {
+    //     if (e) {
+    //       console.error(e.message);
+    //     }
+    //   });
+    // })
+    //
+    // Setup our server to proxy standard HTTP requests
+    // @ts-ignore
+    var proxy = new http_proxy_1.default.createProxyServer({
+        target: {
+            host: 'localhost',
+            port: dport
+        }
+    });
+    var proxyServer = http_1.default.createServer((req, res) => proxy.web(req, res));
+    proxyServer.on('upgrade', (req, socket, head) => proxy.ws(req, socket, head));
+    proxyServer.listen(port, '127.0.0.1');
+    // server.listen(port);
+    logger.info('Debugger proxy started', { port, targetPort: dport });
+};
+exports.default = { start };

package/dist/schema.js ADDED Viewed

	@@ -0,0 +1,2 @@
1	+ "use strict";
2	+ Object.defineProperty(exports, "__esModule", { value: true });

package/dist/screenshot.js ADDED Viewed

@@ -0,0 +1,202 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getScreenshotToken = exports.uploadScreenshot = exports.analyzeScreenshot = exports.takeScreenshot = exports.resizeScreenshot = void 0;
+const child_process_1 = __importDefault(require("child_process"));
+const child_process_2 = require("child_process");
+const fs_1 = __importDefault(require("fs"));
+const util_1 = __importDefault(require("util"));
+const get_image_colors_1 = __importDefault(require("get-image-colors"));
+const storage_blob_1 = require("@azure/storage-blob");
+const axios_proxy_1 = __importDefault(require("@phystack/axios-proxy"));
+const phy_logger_1 = require("@phystack/phy-logger");
+const execPromise = util_1.default.promisify(child_process_2.exec);
+// import { Token } from './browser.js';
+const SCREENSHOT_TIMEOUT = 60000; // 1min
+const logger = new phy_logger_1.PhyLogger({
+    logToFile: false,
+    logToConsole: true,
+    includeTrace: true,
+    namespace: 'screen-phyos-screenshot',
+});
+const takeScreenshot = async () => {
+    let result = [];
+    const timeout = setTimeout(() => {
+        logger.error("takeScreenshot(): Timeout when creating a screenshot, probably sway is not working correctly, exiting now");
+        process.exit(1);
+    }, SCREENSHOT_TIMEOUT);
+    const code = await new Promise((resolve) => {
+        const child = child_process_1.default.spawn("grim", ["-"], {
+            stdio: ["inherit", "pipe", "inherit"],
+            env: { ...process.env },
+        });
+        child.stdout.on("data", (data) => result.push(data));
+        child.on("close", resolve);
+    });
+    clearTimeout(timeout);
+    if (code !== 0) {
+        throw new Error("takeScreenshot(): Error encountered when creating a screenshot");
+    }
+    if (result.length === 0)
+        throw new Error("takeScreenshot(): Cannot create screenshot, zero size");
+    logger.info("takeScreenshot(): Screenshot done");
+    return Buffer.concat(result);
+};
+exports.takeScreenshot = takeScreenshot;
+const resizeScreenshot = async (data) => {
+    try {
+        // Write the data to a temporary file
+        const tempInputFile = "/tmp/screenshot.png";
+        const tempOutputFile = "/tmp/screenshot_resized.jpg";
+        await fs_1.default.promises.writeFile(tempInputFile, data);
+        // Run the convert command
+        const command = `/usr/bin/convert ${tempInputFile} -strip -interlace Plane -gaussian-blur 0.05 -quality 45% -thumbnail 600x600 ${tempOutputFile}`;
+        await execPromise(command);
+        // Read the resized image from the output file
+        const resizedData = await fs_1.default.promises.readFile(tempOutputFile);
+        // Cleanup temporary files
+        await fs_1.default.promises.unlink(tempInputFile);
+        await fs_1.default.promises.unlink(tempOutputFile);
+        return resizedData;
+    }
+    catch (error) {
+        logger.error("resizeScreenshot(): Error during image resizing", { error });
+        throw new Error("Cannot convert screenshot");
+    }
+};
+exports.resizeScreenshot = resizeScreenshot;
+async function getScreenshotToken(creds) {
+    logger.info("getScreenshotToken(): getScreenshotToken function started");
+    // Use the correct endpoint for QA and DEV
+    let url = "https://api.omborigrid.com/devices/healthcheck-config";
+    const proxy = process.env.HTTPS_PROXY;
+    logger.debug("Environment proxy", { proxy });
+    if (proxy?.toLowerCase().includes("portal-dev")) {
+        url = "https://api.griddeveloper.com/devices/healthcheck-config";
+        logger.info("getScreenshotToken(): Using DEV environment endpoint");
+    }
+    else if (proxy?.toLowerCase().includes("portal-qa")) {
+        url = "https://api-qa.omborigrid.com/devices/healthcheck-config";
+        logger.info("getScreenshotToken(): Using QA environment endpoint");
+    }
+    else {
+        logger.info("getScreenshotToken(): Using PROD environment endpoint");
+    }
+    logger.info("getScreenshotToken(): Using following parameters", {
+        url,
+        creds,
+        proxy,
+    });
+    logger.info("getScreenshotToken(): Making axios request", { url, requestBody: creds });
+    try {
+        // Get axios instance with proxy support
+        const axiosWithProxy = await (0, axios_proxy_1.default)();
+        // Make the request with timeout
+        const response = await axiosWithProxy.post(url, creds, {
+            timeout: 60000,
+            headers: {
+                "content-type": "application/json",
+            },
+        });
+        logger.info("getScreenshotToken(): Axios request completed", {
+            status: response.status,
+            statusText: response.statusText,
+            headers: response.headers
+        });
+        if (response.status > 299) {
+            logger.error("getScreenshotToken(): Cannot acquire upload token", {
+                statusText: response.statusText,
+                status: response.status,
+                responseBody: response.data
+            });
+            return undefined;
+        }
+        logger.info("getScreenshotToken(): Request successful", { responseData: response.data });
+        logger.info("getScreenshotToken(): Function completed successfully");
+        return response.data;
+    }
+    catch (error) {
+        logger.error("getScreenshotToken(): Axios request failed", { error });
+        if (error.response) {
+            // The request was made and the server responded with a status code
+            logger.error("getScreenshotToken(): Error response details", {
+                status: error.response.status,
+                data: error.response.data,
+                headers: error.response.headers
+            });
+        }
+        else if (error.request) {
+            // The request was made but no response was received
+            logger.error("getScreenshotToken(): No response received", { request: error.request });
+        }
+        else {
+            // Something happened in setting up the request
+            logger.error("getScreenshotToken(): Error setting up request", { message: error.message });
+        }
+        return undefined;
+    }
+}
+exports.getScreenshotToken = getScreenshotToken;
+const uploadScreenshot = async (data, { sas_token, sas_token_subject }) => {
+    console.log("uploadScreenshot(): Upload screenshot method started");
+    console.log("uploadScreenshot(): About to upload", data.length, "bytes");
+    console.log("uploadScreenshot(): SAS token subject:", sas_token_subject);
+    console.log("uploadScreenshot(): SAS token length:", sas_token.length);
+    const [proto, , hostname, container, file] = sas_token_subject.split("/");
+    console.log("uploadScreenshot(): Parsed components:", {
+        proto,
+        hostname,
+        container,
+        file,
+    });
+    const account = hostname.split(".")[0];
+    console.log("uploadScreenshot(): Account name:", account);
+    const target = `https://${account}.blob.core.windows.net?${sas_token}`;
+    console.log("uploadScreenshot(): Target URL (without token):", `https://${account}.blob.core.windows.net`);
+    try {
+        console.log("uploadScreenshot(): Creating BlobServiceClient...");
+        const blobServiceClient = new storage_blob_1.BlobServiceClient(target);
+        console.log("uploadScreenshot(): Getting container client for:", container);
+        const containerClient = blobServiceClient.getContainerClient(container);
+        console.log("uploadScreenshot(): Getting block blob client for:", file);
+        const blockBlobClient = containerClient.getBlockBlobClient(file);
+        console.log("uploadScreenshot(): Starting upload...");
+        const uploadBlobResponse = await blockBlobClient.upload(data, data.length, {
+            blobHTTPHeaders: { blobContentType: "image/jpeg" },
+        });
+        console.log(`uploadScreenshot(): Upload block blob ${file} successfully`, uploadBlobResponse.requestId);
+        console.log("uploadScreenshot(): Upload response details:", {
+            requestId: uploadBlobResponse.requestId,
+            version: uploadBlobResponse.version,
+            date: uploadBlobResponse.date,
+            etag: uploadBlobResponse.etag,
+        });
+        return sas_token_subject;
+    }
+    catch (error) {
+        console.error("uploadScreenshot(): Upload failed with error:", error);
+        console.error("uploadScreenshot(): Error details:", {
+            message: error instanceof Error ? error.message : "Unknown error",
+            stack: error instanceof Error ? error.stack : undefined,
+        });
+        throw error;
+    }
+};
+exports.uploadScreenshot = uploadScreenshot;
+const analyzeScreenshot = async (data) => {
+    try {
+        const cl = await (0, get_image_colors_1.default)(data, "image/png");
+        if (!cl)
+            return [false, false];
+        const allWhite = cl.every((c) => c.rgb().every((color) => color > 250));
+        const allBlack = cl.every((c) => c.rgb().every((color) => color < 5));
+        return [allWhite, allBlack];
+    }
+    catch (e) {
+        console.log("error", e.toString());
+        return [false, false];
+    }
+};
+exports.analyzeScreenshot = analyzeScreenshot;

package/dist/sound.js ADDED Viewed

@@ -0,0 +1,83 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.test = exports.onDevices = exports.setup = void 0;
+const fs_1 = __importDefault(require("fs"));
+const child_process_1 = __importDefault(require("child_process"));
+let onDevicesHandler = () => { };
+async function setup(output, input) {
+    let cardId = 0;
+    let deviceId = 0;
+    const devices = child_process_1.default.execSync("aplay -l")
+        .toString().trim().split("\n")
+        .map(line => /^card ([0-9]+): .+, device ([0-9]+): (.+) \[(.+)\]$/.exec(line))
+        .filter(info => info)
+        .map(([_, card, device, name, displayName]) => ({
+        card: parseInt(card, 10),
+        device: parseInt(device, 10),
+        name,
+        displayName,
+    }));
+    onDevicesHandler(devices);
+    let device = null;
+    if (output === 'default') {
+        cardId = 0;
+        deviceId = 0;
+    }
+    else if (output === 'hdmi1') {
+        device = devices.find(({ name }) => name === 'HDMI 0')
+            || devices.find(({ displayName }) => displayName === 'HDMI 0')
+            || devices.find(({ name }) => name.indexOf('HDMI 0') >= 0)
+            || devices.find(({ name }) => name.indexOf('HDMI') >= 0);
+    }
+    else if (output === 'hdmi2') {
+        device = devices.find(({ name }) => name === 'HDMI 1')
+            || devices.find(({ displayName }) => displayName === 'HDMI 1')
+            || devices.find(({ name }) => /HDMI 1/i.test(name))
+            || devices.find(({ name }) => /HDMI/i.test(name));
+    }
+    else if (output === 'jack') {
+        device = devices.find(({ name }) => /headphones/i.test(name));
+    }
+    if (device) {
+        cardId = device.card;
+        deviceId = device.device;
+    }
+    const inputDeviceId = input === 'default' ? '0,0' : '1,0';
+    const cfg = [
+        `defaults.pcm.card ${cardId}`,
+        `defaults.pcm.device ${deviceId}`,
+        `defaults.ctl.card ${cardId}`,
+        `pcm.!default {`,
+        `  type asym`,
+        `  playback.pcm`,
+        `  {`,
+        `    type plug`,
+        `    slave.pcm "plughw:${cardId},${deviceId}"`,
+        `  }`,
+        `  capture.pcm`,
+        `  {`,
+        `    type plug`,
+        `    slave.pcm "plughw:${inputDeviceId}"`,
+        `  }`,
+        `}`,
+    ].join('\n');
+    await fs_1.default.promises.writeFile("/etc/asound.conf", cfg);
+}
+exports.setup = setup;
+const onDevices = (handler) => { onDevicesHandler = handler; };
+exports.onDevices = onDevices;
+const test = async (output) => {
+    let out = output;
+    if (out === "jack")
+        out = "front";
+    if (/^hdmi[0-9]/.test(out))
+        out = 'hdmi';
+    const code = await new Promise(resolve => child_process_1.default
+        .spawn("speaker-test", ["-D", `plug:${out} `, "-c2", "-l", "1", "-t", "wav"], { stdio: 'inherit' })
+        .on('exit', resolve));
+    return code === 0;
+};
+exports.test = test;

package/dist/sway.js ADDED Viewed

@@ -0,0 +1,163 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.swayMsg = exports.isDrmAvailable = exports.restartSway = exports.setupSwayConfig = exports.ScreenTransforms = exports.getPanelRotation = void 0;
+const fs_1 = __importDefault(require("fs"));
+const child_process_1 = __importDefault(require("child_process"));
+const path_1 = __importDefault(require("path"));
+const phy_logger_1 = require("@phystack/phy-logger");
+const logger = new phy_logger_1.PhyLogger({
+    logToFile: false,
+    logToConsole: true,
+    includeTrace: true,
+    namespace: 'screen-phyos-sway',
+});
+let panelWithRotation = 0;
+// TRICKY: rotation of DSI touch panels on rockchip is not applied correctly, so we're fixing it manually
+if (process.arch === 'arm64') {
+    const baseDir = '/sys/firmware/devicetree/base';
+    let present = [];
+    try {
+        const entries = fs_1.default.readdirSync(baseDir);
+        for (const entry of entries) {
+            if (entry.startsWith('dsi@')) {
+                const rotationPath = path_1.default.join(baseDir, entry, 'panel@0', 'rotation');
+                if (fs_1.default.existsSync(rotationPath)) {
+                    present.push(rotationPath);
+                }
+            }
+        }
+    }
+    catch (error) {
+        logger.error('Error accessing device tree', { error });
+    }
+    if (present.length > 0) {
+        const rotationBuffer = fs_1.default.readFileSync(present[0]);
+        const rotation = rotationBuffer.readInt32BE();
+        logger.info('Found DSI panel with rotation', { rotation });
+        panelWithRotation = rotation;
+    }
+}
+const getPanelRotation = () => panelWithRotation;
+exports.getPanelRotation = getPanelRotation;
+const transforms = {
+    landscape: 0 + panelWithRotation,
+    portrait: 90 + panelWithRotation,
+    'portrait-left': 270 + panelWithRotation,
+    'landscape-inverted': 180 + panelWithRotation,
+};
+const matrices = {
+    landscape: '1 0 0 0 1 0',
+    portrait: '0 1 0 -1 0 1',
+    'portrait-left': '0 -1 1 1 0 0',
+    'landscape-inverted': '-1 0 1 0 -1 1',
+};
+const getTouchRotationCmd = (orientation) => {
+    const mtx = matrices[orientation];
+    if (mtx)
+        return `calibration_matrix ${mtx}`;
+    return `map_to_output *`;
+};
+const ScreenTransforms = (orientation) => {
+    let val = transforms[orientation];
+    while (val < 0)
+        val += 360;
+    while (val >= 360)
+        val -= 360;
+    if (val % 90 !== 0) {
+        logger.error('Weird screen rotation', { rotation: val });
+        return 'default';
+    }
+    if (val === 0)
+        return 'normal';
+    return val.toString(10);
+};
+exports.ScreenTransforms = ScreenTransforms;
+const call = (cmd) => new Promise((resolve, reject) => child_process_1.default.exec(cmd, (err, out) => (err ? reject(err) : resolve(out))));
+const swayMsg = async (msg) => {
+    logger.debug('Sway: sending message', { message: msg });
+    const SWAY_SOCK = '/tmp/sway.sock';
+    const res = await call(`swaymsg --raw -s ${SWAY_SOCK} ${msg}`);
+    return JSON.parse(res);
+};
+exports.swayMsg = swayMsg;
+const detectPhantomOutputs = async () => {
+    const outputs = await swayMsg('-t get_outputs');
+    // Find outputs with higher resolutions
+    const highResOutputs = outputs.filter((output) => output.rect.width > 1024);
+    // Find outputs with 1024x768 resolution
+    const lowResOutputs = outputs.filter((output) => output.rect.width <= 1024);
+    // If there's at least one higher resolution output and exactly one low resolution output
+    let phantomOutputs = [];
+    if (highResOutputs.length > 0 && lowResOutputs.length > 0) {
+        phantomOutputs = lowResOutputs;
+    }
+    return phantomOutputs;
+};
+async function setupSwayConfig({ resolution, orientation, headless, scale, }) {
+    console.log('Setting up sway config');
+    // for headless sway, we should specify resolution explicitly
+    let res = resolution === 'default' && headless ? '1920x1080' : resolution;
+    if (process.arch === 'arm64') {
+        if (res === 'default')
+            res = '1920x1080'; // on arm platform we limit max resolution to fullhd
+    }
+    const parsedScale = parseFloat(scale) || '1.0';
+    let config = `
+output * bg /var/physcreen/ombori-logo.png center #000000
+output * scale ${parsedScale}
+output * transform ${(0, exports.ScreenTransforms)(orientation)}
+seat * hide_cursor 5000
+bindsym F2 exec chvt 2
+bindsym F1 exec chvt 1
+output * mode ${res}
+# Touchscreen settings
+input type:touch {
+    tap enabled
+    natural_scroll enabled
+    ${getTouchRotationCmd(orientation)}
+}
+`;
+    const phantomOutputs = await detectPhantomOutputs();
+    console.log({ phantomOutputs });
+    for (const output of phantomOutputs) {
+        console.log(`Disabling phantom output: ${output.name}`);
+        config += `\noutput ${output.name} disable\n`;
+    }
+    console.log('Writing sway config', config);
+    await fs_1.default.promises.writeFile('/etc/sway/config', config);
+    await swayMsg('reload');
+}
+exports.setupSwayConfig = setupSwayConfig;
+const restartSway = () => {
+    try {
+        child_process_1.default.execSync('killall sway');
+    }
+    catch (e) {
+        console.error(e.toString());
+    }
+};
+exports.restartSway = restartSway;
+const isNoDrms = () => {
+    return fs_1.default.readdirSync('/sys/class/drm').join(' ') === 'version';
+};
+const isDrmAvailable = () => {
+    try {
+        for (const file of fs_1.default.readdirSync('/sys/class/drm')) {
+            const statusFile = `/sys/class/drm/${file}/status`;
+            if (!fs_1.default.existsSync(statusFile))
+                continue;
+            const status = fs_1.default.readFileSync(statusFile).toString().trim();
+            if (status === 'connected')
+                return true;
+        }
+    }
+    catch (e) {
+        console.log('err', e.toString());
+        return false;
+    }
+};
+exports.isDrmAvailable = isDrmAvailable;

package/dist/types/twin.types.js ADDED Viewed

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TwinStatusEnum = exports.TwinTypeEnum = void 0;
+var TwinTypeEnum;
+(function (TwinTypeEnum) {
+    TwinTypeEnum["Screen"] = "Screen";
+})(TwinTypeEnum = exports.TwinTypeEnum || (exports.TwinTypeEnum = {}));
+var TwinStatusEnum;
+(function (TwinStatusEnum) {
+    TwinStatusEnum["Offline"] = "Offline";
+    TwinStatusEnum["Online"] = "Online";
+    TwinStatusEnum["Starting"] = "Starting";
+    TwinStatusEnum["Exited"] = "Exited";
+    TwinStatusEnum["ImageNotFound"] = "ImageNotFound";
+})(TwinStatusEnum = exports.TwinStatusEnum || (exports.TwinStatusEnum = {}));

package/dist/udev.js ADDED Viewed

@@ -0,0 +1,44 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const child_process_1 = __importDefault(require("child_process"));
+const phy_logger_1 = require("@phystack/phy-logger");
+const logger = new phy_logger_1.PhyLogger({
+    logToFile: false,
+    logToConsole: true,
+    includeTrace: true,
+    namespace: 'screen-phyos-udev',
+});
+async function monitorProcess(cb) {
+    await new Promise(resolve => {
+        const monitor = child_process_1.default.spawn("udevadm", ["monitor", "--kernel", "--property"], { stdio: 'pipe' });
+        monitor.stderr.on('data', (data) => logger.error('Udev monitor error', { error: data.toString().trim() }));
+        monitor.stdout.on('data', (line) => cb(line.toString().trim()));
+        monitor.on('exit', () => resolve());
+    });
+}
+async function monitor(onChange) {
+    while (true) {
+        let result = {};
+        logger.info('Udev: monitoring devices');
+        await monitorProcess(line => {
+            `${line}\n`.split('\n').map(chunk => chunk.trim()).forEach(chunk => {
+                if (chunk === "") {
+                    onChange(result);
+                    result = {};
+                    return;
+                }
+                const info = /^([A-Z0-9]+)=(.+)$/.exec(chunk);
+                if (!info)
+                    return;
+                const [, name, value] = info;
+                result[name.toLowerCase()] = value;
+            });
+        });
+        logger.info('Udev: monitor exited, restarting');
+        await new Promise(resolve => setTimeout(resolve, 5 * 1000));
+    }
+}
+exports.default = { monitor };

package/dist/version.js ADDED Viewed

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs_1 = require("fs");
+const path_1 = require("path");
+if (process.argv[2] === '--version' || process.argv[2] === '-v') {
+    const packagePath = (0, path_1.join)(__dirname, '../package.json');
+    const packageData = JSON.parse((0, fs_1.readFileSync)(packagePath, 'utf8'));
+    console.log(`physcreen-manager v${packageData.version}`);
+    process.exit(0);
+}

package/package.json ADDED Viewed

@@ -0,0 +1,63 @@
+{
+  "name": "@phystack/screen-phyos",
+  "version": "4.3.40-dev",
+  "description": "PhyOS Screen",
+  "license": "UNLICENSED",
+  "publishConfig": {
+    "access": "public"
+  },
+  "engines": {
+    "node": ">=20.0.0"
+  },
+  "dependencies": {
+    "@azure/storage-blob": "^12.23.0",
+    "@phystack/axios-proxy": "4.3.40-dev",
+    "@phystack/hub-client": "4.3.40-dev",
+    "@phystack/phy-logger": "4.3.40-dev",
+    "@vercel/ncc": "^0.38.1",
+    "get-image-colors": "^4.0.0",
+    "global-agent": "^3.0.0",
+    "http-proxy": "^1.18.1",
+    "node-fetch": "^2.6.1",
+    "pkg": "^5.8.1",
+    "ws": "^7.4.4"
+  },
+  "devDependencies": {
+    "@babel/preset-react": "^7.18.6",
+    "@babel/preset-typescript": "^7.21.0",
+    "@types/get-image-colors": "^2.0.0",
+    "@types/global-agent": "^2.1.1",
+    "@types/http-proxy": "^1.17.8",
+    "@types/node-fetch": "^2.6.11",
+    "@types/react": "^18.0.30",
+    "@types/react-dom": "^18.0.11",
+    "@types/styled-components": "^5.1.26",
+    "@types/ws": "^7.4.1",
+    "antd": "^5.3.3",
+    "babel-loader": "^9.1.2",
+    "css-loader": "^6.7.3",
+    "qrcode.react": "^3.1.0",
+    "react": "^18.2.0",
+    "react-dom": "^18.2.0",
+    "react-simple-keyboard": "^3.5.47",
+    "rimraf": "^3.0.2",
+    "style-loader": "^3.3.2",
+    "styled-components": "^5.3.9",
+    "ts-loader": "^9.4.2",
+    "typescript": "^4.2.3",
+    "uuid": "^8.3.2"
+  },
+  "bin": {
+    "physcreen-manager": "./bin/index.js"
+  },
+  "files": [
+    "bin/**/*",
+    "dist/**/*"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "lint": "eslint --ext .js,.ts src",
+    "lint-fix": "tsc --noEmit && eslint --ext .js,.ts src --fix && prettier --write ."
+  },
+  "gitHead": "53c505b3ecad47ebd4f38819c07b0ec1227214a6"
+}