@elizaos/plugin-vision 1.2.1 → 2.0.0-alpha.2

package/dist/workers/screen-capture-worker.js

@@ -1,427 +1,359 @@
-"use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __toESM = (mod, isNodeMode, target) => {
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: () => mod[key],
+        enumerable: true
+      });
+  return to;
 };
-var __generator = (this && this.__generator) || function (thisArg, body) {
-    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
-    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
-    function verb(n) { return function (v) { return step([n, v]); }; }
-    function step(op) {
-        if (f) throw new TypeError("Generator is already executing.");
-        while (g && (g = 0, op[0] && (_ = 0)), _) try {
-            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
-            if (y = 0, t) op = [op[0] & 2, t.value];
-            switch (op[0]) {
-                case 0: case 1: t = op; break;
-                case 4: _.label++; return { value: op[1], done: false };
-                case 5: _.label++; y = op[1]; op = [0]; continue;
-                case 7: op = _.ops.pop(); _.trys.pop(); continue;
-                default:
-                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
-                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
-                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
-                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
-                    if (t[2]) _.ops.pop();
-                    _.trys.pop(); continue;
-            }
-            op = body.call(thisArg, _);
-        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
-        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
-    }
+var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
 };
-Object.defineProperty(exports, "__esModule", { value: true });
-var worker_threads_1 = require("worker_threads");
-var child_process_1 = require("child_process");
-var util_1 = require("util");
-var fs = require("fs/promises");
-var path = require("path");
-var sharp_1 = require("sharp");
-var worker_logger_1 = require("./worker-logger");
-var execAsync = (0, util_1.promisify)(child_process_1.exec);
-var ScreenCaptureWorker = /** @class */ (function () {
-    function ScreenCaptureWorker(config, sharedBuffer) {
-        this.isRunning = true;
-        this.frameCount = 0;
-        this.lastFPSReport = Date.now();
-        this.displays = [];
-        this.currentDisplayIndex = 0;
-        // Atomic indices
-        this.FRAME_ID_INDEX = 0;
-        this.WRITE_LOCK_INDEX = 1;
-        this.WIDTH_INDEX = 2;
-        this.HEIGHT_INDEX = 3;
-        this.DISPLAY_INDEX = 4;
-        this.TIMESTAMP_INDEX = 5;
-        this.DATA_OFFSET = 24; // 6 * 4 bytes for metadata
-        this.config = config;
-        this.sharedBuffer = sharedBuffer;
-        this.dataView = new DataView(sharedBuffer);
-        this.atomicState = new Int32Array(sharedBuffer, 0, 6);
-    }
-    ScreenCaptureWorker.prototype.initialize = function () {
-        return __awaiter(this, void 0, void 0, function () {
-            var _a;
-            return __generator(this, function (_b) {
-                switch (_b.label) {
-                    case 0:
-                        // Get display information
-                        _a = this;
-                        return [4 /*yield*/, this.getDisplays()];
-                    case 1:
-                        // Get display information
-                        _a.displays = _b.sent();
-                        if (this.displays.length === 0) {
-                            throw new Error('No displays found');
-                        }
-                        // Set initial display
-                        if (this.config.displayIndex !== undefined && this.config.displayIndex < this.displays.length) {
-                            this.currentDisplayIndex = this.config.displayIndex;
-                        }
-                        worker_logger_1.logger.info("[ScreenCaptureWorker] Initialized with ".concat(this.displays.length, " displays"));
-                        this.displays.forEach(function (d, i) {
-                            worker_logger_1.logger.info("  Display ".concat(i, ": ").concat(d.name, " (").concat(d.width, "x").concat(d.height, ") ").concat(d.isPrimary ? '[PRIMARY]' : ''));
-                        });
-                        return [2 /*return*/];
-                }
-            });
-        });
+
+// src/workers/screen-capture-worker.ts
+var import_node_child_process = require("node:child_process");
+var fs = __toESM(require("node:fs/promises"));
+var path = __toESM(require("node:path"));
+var import_node_util = require("node:util");
+var import_node_worker_threads2 = require("node:worker_threads");
+var import_sharp = __toESM(require("sharp"));
+
+// src/workers/worker-logger.ts
+var import_node_worker_threads = require("node:worker_threads");
+var logger = {
+  info: (message, ...args) => {
+    const logMessage = {
+      type: "log",
+      level: "info",
+      message,
+      args,
+      timestamp: new Date().toISOString()
     };
-    ScreenCaptureWorker.prototype.getDisplays = function () {
-        return __awaiter(this, void 0, void 0, function () {
-            var platform, stdout, data, displays_1, gpuInfo, items, stdout, displays, lines, _i, lines_1, line, match, stdout, displays_2, lines, error_1;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        platform = process.platform;
-                        _a.label = 1;
-                    case 1:
-                        _a.trys.push([1, 8, , 9]);
-                        if (!(platform === 'darwin')) return [3 /*break*/, 3];
-                        return [4 /*yield*/, execAsync('system_profiler SPDisplaysDataType -json')];
-                    case 2:
-                        stdout = (_a.sent()).stdout;
-                        data = JSON.parse(stdout);
-                        displays_1 = [];
-                        if (data.SPDisplaysDataType && data.SPDisplaysDataType[0]) {
-                            gpuInfo = data.SPDisplaysDataType[0];
-                            items = gpuInfo._items || [];
-                            items.forEach(function (item, index) {
-                                var resolution = item.native_resolution;
-                                if (resolution) {
-                                    var match = resolution.match(/(\d+) x (\d+)/);
-                                    if (match) {
-                                        displays_1.push({
-                                            id: "display-".concat(index),
-                                            name: item._name || "Display ".concat(index + 1),
-                                            width: parseInt(match[1], 10),
-                                            height: parseInt(match[2], 10),
-                                            x: 0,
-                                            y: 0,
-                                            isPrimary: index === 0,
-                                        });
-                                    }
-                                }
-                            });
-                        }
-                        return [2 /*return*/, displays_1];
-                    case 3:
-                        if (!(platform === 'linux')) return [3 /*break*/, 5];
-                        return [4 /*yield*/, execAsync('xrandr --query')];
-                    case 4:
-                        stdout = (_a.sent()).stdout;
-                        displays = [];
-                        lines = stdout.split('\n');
-                        for (_i = 0, lines_1 = lines; _i < lines_1.length; _i++) {
-                            line = lines_1[_i];
-                            if (line.includes(' connected')) {
-                                match = line.match(/^(\S+) connected (?:primary )?(\d+)x(\d+)\+(\d+)\+(\d+)/);
-                                if (match) {
-                                    displays.push({
-                                        id: match[1],
-                                        name: match[1],
-                                        width: parseInt(match[2], 10),
-                                        height: parseInt(match[3], 10),
-                                        x: parseInt(match[4], 10),
-                                        y: parseInt(match[5], 10),
-                                        isPrimary: line.includes('primary'),
-                                    });
-                                }
-                            }
-                        }
-                        return [2 /*return*/, displays];
-                    case 5:
-                        if (!(platform === 'win32')) return [3 /*break*/, 7];
-                        return [4 /*yield*/, execAsync('wmic path Win32_DesktopMonitor get DeviceID,ScreenWidth,ScreenHeight /format:csv')];
-                    case 6:
-                        stdout = (_a.sent()).stdout;
-                        displays_2 = [];
-                        lines = stdout.trim().split('\n').slice(2);
-                        lines.forEach(function (line, index) {
-                            var parts = line.split(',');
-                            if (parts.length >= 4) {
-                                var width = parseInt(parts[2], 10);
-                                var height = parseInt(parts[3], 10);
-                                if (!isNaN(width) && !isNaN(height)) {
-                                    displays_2.push({
-                                        id: parts[1],
-                                        name: parts[1] || "Display ".concat(index + 1),
-                                        width: width,
-                                        height: height,
-                                        x: 0,
-                                        y: 0,
-                                        isPrimary: index === 0,
-                                    });
-                                }
-                            }
-                        });
-                        return [2 /*return*/, displays_2.length > 0
-                                ? displays_2
-                                : [
-                                    {
-                                        id: 'primary',
-                                        name: 'Primary Display',
-                                        width: 1920,
-                                        height: 1080,
-                                        x: 0,
-                                        y: 0,
-                                        isPrimary: true,
-                                    },
-                                ]];
-                    case 7: return [3 /*break*/, 9];
-                    case 8:
-                        error_1 = _a.sent();
-                        worker_logger_1.logger.error('[ScreenCaptureWorker] Failed to get display info:', error_1);
-                        return [3 /*break*/, 9];
-                    case 9: 
-                    // Fallback
-                    return [2 /*return*/, [
-                            {
-                                id: 'default',
-                                name: 'Default Display',
-                                width: 1920,
-                                height: 1080,
-                                x: 0,
-                                y: 0,
-                                isPrimary: true,
-                            },
-                        ]];
-                }
-            });
-        });
+    if (import_node_worker_threads.parentPort) {
+      import_node_worker_threads.parentPort.postMessage(logMessage);
+    } else {
+      console.log(`[INFO] ${message}`, ...args);
+    }
+  },
+  warn: (message, ...args) => {
+    const logMessage = {
+      type: "log",
+      level: "warn",
+      message,
+      args,
+      timestamp: new Date().toISOString()
     };
-    ScreenCaptureWorker.prototype.run = function () {
-        return __awaiter(this, void 0, void 0, function () {
-            var _loop_1, this_1;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.initialize()];
-                    case 1:
-                        _a.sent();
-                        worker_logger_1.logger.info('[ScreenCaptureWorker] Starting capture loop...');
-                        _loop_1 = function () {
-                            var startTime, now, fps, frameTime_1, elapsed_1, error_2;
-                            return __generator(this, function (_b) {
-                                switch (_b.label) {
-                                    case 0:
-                                        startTime = Date.now();
-                                        _b.label = 1;
-                                    case 1:
-                                        _b.trys.push([1, 5, , 7]);
-                                        return [4 /*yield*/, this_1.captureFrame()];
-                                    case 2:
-                                        _b.sent();
-                                        this_1.frameCount++;
-                                        now = Date.now();
-                                        if (now - this_1.lastFPSReport >= 1000) {
-                                            fps = this_1.frameCount / ((now - this_1.lastFPSReport) / 1000);
-                                            worker_logger_1.logger.info("[ScreenCaptureWorker] FPS: ".concat(fps.toFixed(2), ", Display: ").concat(this_1.currentDisplayIndex));
-                                            worker_threads_1.parentPort === null || worker_threads_1.parentPort === void 0 ? void 0 : worker_threads_1.parentPort.postMessage({
-                                                type: 'fps',
-                                                fps: fps,
-                                                frameCount: this_1.frameCount,
-                                                displayIndex: this_1.currentDisplayIndex,
-                                            });
-                                            this_1.frameCount = 0;
-                                            this_1.lastFPSReport = now;
-                                        }
-                                        // Cycle through displays if configured
-                                        if (this_1.config.captureAllDisplays && this_1.displays.length > 1) {
-                                            this_1.currentDisplayIndex = (this_1.currentDisplayIndex + 1) % this_1.displays.length;
-                                        }
-                                        if (!this_1.config.targetFPS) return [3 /*break*/, 4];
-                                        frameTime_1 = 1000 / this_1.config.targetFPS;
-                                        elapsed_1 = Date.now() - startTime;
-                                        if (!(elapsed_1 < frameTime_1)) return [3 /*break*/, 4];
-                                        return [4 /*yield*/, new Promise(function (resolve) { return setTimeout(resolve, frameTime_1 - elapsed_1); })];
-                                    case 3:
-                                        _b.sent();
-                                        _b.label = 4;
-                                    case 4: return [3 /*break*/, 7];
-                                    case 5:
-                                        error_2 = _b.sent();
-                                        worker_logger_1.logger.error('[ScreenCaptureWorker] Capture error:', error_2);
-                                        return [4 /*yield*/, new Promise(function (resolve) { return setTimeout(resolve, 100); })];
-                                    case 6:
-                                        _b.sent(); // Brief pause on error
-                                        return [3 /*break*/, 7];
-                                    case 7: return [2 /*return*/];
-                                }
-                            });
-                        };
-                        this_1 = this;
-                        _a.label = 2;
-                    case 2:
-                        if (!this.isRunning) return [3 /*break*/, 4];
-                        return [5 /*yield**/, _loop_1()];
-                    case 3:
-                        _a.sent();
-                        return [3 /*break*/, 2];
-                    case 4: return [2 /*return*/];
-                }
-            });
-        });
+    if (import_node_worker_threads.parentPort) {
+      import_node_worker_threads.parentPort.postMessage(logMessage);
+    } else {
+      console.warn(`[WARN] ${message}`, ...args);
+    }
+  },
+  error: (message, ...args) => {
+    const logMessage = {
+      type: "log",
+      level: "error",
+      message,
+      args,
+      timestamp: new Date().toISOString()
     };
-    ScreenCaptureWorker.prototype.captureFrame = function () {
-        return __awaiter(this, void 0, void 0, function () {
-            var display, tempFile, imageBuffer, image, metadata, width, height, rawData, maxDataSize, dataSize, i, error_3;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        display = this.displays[this.currentDisplayIndex];
-                        tempFile = path.join(process.cwd(), "temp_screen_".concat(Date.now(), "_").concat(this.currentDisplayIndex, ".png"));
-                        _a.label = 1;
-                    case 1:
-                        _a.trys.push([1, 7, , 9]);
-                        // Capture the screen
-                        return [4 /*yield*/, this.captureScreenToFile(tempFile, display)];
-                    case 2:
-                        // Capture the screen
-                        _a.sent();
-                        return [4 /*yield*/, fs.readFile(tempFile)];
-                    case 3:
-                        imageBuffer = _a.sent();
-                        image = (0, sharp_1.default)(imageBuffer);
-                        return [4 /*yield*/, image.metadata()];
-                    case 4:
-                        metadata = _a.sent();
-                        width = metadata.width || display.width;
-                        height = metadata.height || display.height;
-                        return [4 /*yield*/, image.ensureAlpha().raw().toBuffer()];
-                    case 5:
-                        rawData = _a.sent();
-                        // Wait for write lock
-                        while (Atomics.compareExchange(this.atomicState, this.WRITE_LOCK_INDEX, 0, 1) !== 0) {
-                            // Spin wait - in practice this should be very brief
-                        }
-                        try {
-                            // Write metadata
-                            Atomics.store(this.atomicState, this.WIDTH_INDEX, width);
-                            Atomics.store(this.atomicState, this.HEIGHT_INDEX, height);
-                            Atomics.store(this.atomicState, this.DISPLAY_INDEX, this.currentDisplayIndex);
-                            Atomics.store(this.atomicState, this.TIMESTAMP_INDEX, Date.now());
-                            maxDataSize = this.sharedBuffer.byteLength - this.DATA_OFFSET;
-                            dataSize = Math.min(rawData.length, maxDataSize);
-                            for (i = 0; i < dataSize; i++) {
-                                this.dataView.setUint8(this.DATA_OFFSET + i, rawData[i]);
-                            }
-                            // Update frame ID (signals new frame available)
-                            Atomics.add(this.atomicState, this.FRAME_ID_INDEX, 1);
-                        }
-                        finally {
-                            // Release write lock
-                            Atomics.store(this.atomicState, this.WRITE_LOCK_INDEX, 0);
-                        }
-                        // Clean up temp file
-                        return [4 /*yield*/, fs.unlink(tempFile).catch(function () { })];
-                    case 6:
-                        // Clean up temp file
-                        _a.sent();
-                        return [3 /*break*/, 9];
-                    case 7:
-                        error_3 = _a.sent();
-                        // Clean up temp file on error
-                        return [4 /*yield*/, fs.unlink(tempFile).catch(function () { })];
-                    case 8:
-                        // Clean up temp file on error
-                        _a.sent();
-                        throw error_3;
-                    case 9: return [2 /*return*/];
-                }
-            });
-        });
+    if (import_node_worker_threads.parentPort) {
+      import_node_worker_threads.parentPort.postMessage(logMessage);
+    } else {
+      console.error(`[ERROR] ${message}`, ...args);
+    }
+  },
+  debug: (message, ...args) => {
+    const logMessage = {
+      type: "log",
+      level: "debug",
+      message,
+      args,
+      timestamp: new Date().toISOString()
     };
-    ScreenCaptureWorker.prototype.captureScreenToFile = function (outputPath, display) {
-        return __awaiter(this, void 0, void 0, function () {
-            var platform, displayArg, script, error_4;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        platform = process.platform;
-                        _a.label = 1;
-                    case 1:
-                        _a.trys.push([1, 11, , 12]);
-                        if (!(platform === 'darwin')) return [3 /*break*/, 3];
-                        displayArg = this.currentDisplayIndex > 0 ? "-D ".concat(this.currentDisplayIndex + 1) : '';
-                        return [4 /*yield*/, execAsync("screencapture -x ".concat(displayArg, " \"").concat(outputPath, "\""))];
-                    case 2:
-                        _a.sent();
-                        return [3 /*break*/, 10];
-                    case 3:
-                        if (!(platform === 'linux')) return [3 /*break*/, 8];
-                        if (!(display.x !== 0 || display.y !== 0)) return [3 /*break*/, 5];
-                        // Multi-monitor setup
-                        return [4 /*yield*/, execAsync("scrot -a ".concat(display.x, ",").concat(display.y, ",").concat(display.width, ",").concat(display.height, " \"").concat(outputPath, "\""))];
-                    case 4:
-                        // Multi-monitor setup
-                        _a.sent();
-                        return [3 /*break*/, 7];
-                    case 5: return [4 /*yield*/, execAsync("scrot \"".concat(outputPath, "\""))];
-                    case 6:
-                        _a.sent();
-                        _a.label = 7;
-                    case 7: return [3 /*break*/, 10];
-                    case 8:
-                        if (!(platform === 'win32')) return [3 /*break*/, 10];
-                        script = "\n          Add-Type -AssemblyName System.Windows.Forms;\n          Add-Type -AssemblyName System.Drawing;\n          $screens = [System.Windows.Forms.Screen]::AllScreens;\n          $screen = $screens[".concat(this.currentDisplayIndex, "];\n          $bounds = $screen.Bounds;\n          $bitmap = New-Object System.Drawing.Bitmap $bounds.Width, $bounds.Height;\n          $graphics = [System.Drawing.Graphics]::FromImage($bitmap);\n          $graphics.CopyFromScreen($bounds.Location, [System.Drawing.Point]::Empty, $bounds.Size);\n          $bitmap.Save('").concat(outputPath.replace(/\\/g, '\\\\'), "');\n          $graphics.Dispose();\n          $bitmap.Dispose();\n        ");
-                        return [4 /*yield*/, execAsync("powershell -Command \"".concat(script.replace(/\n/g, ' '), "\""))];
-                    case 9:
-                        _a.sent();
-                        _a.label = 10;
-                    case 10: return [3 /*break*/, 12];
-                    case 11:
-                        error_4 = _a.sent();
-                        throw new Error("Screen capture failed: ".concat(error_4.message));
-                    case 12: return [2 /*return*/];
-                }
-            });
+    if (import_node_worker_threads.parentPort) {
+      import_node_worker_threads.parentPort.postMessage(logMessage);
+    } else {
+      console.debug(`[DEBUG] ${message}`, ...args);
+    }
+  }
+};
+
+// src/workers/screen-capture-worker.ts
+var execAsync = import_node_util.promisify(import_node_child_process.exec);
+
+class ScreenCaptureWorker {
+  config;
+  sharedBuffer;
+  dataView;
+  atomicState;
+  isRunning = true;
+  frameCount = 0;
+  lastFPSReport = Date.now();
+  displays = [];
+  currentDisplayIndex = 0;
+  FRAME_ID_INDEX = 0;
+  WRITE_LOCK_INDEX = 1;
+  WIDTH_INDEX = 2;
+  HEIGHT_INDEX = 3;
+  DISPLAY_INDEX = 4;
+  TIMESTAMP_INDEX = 5;
+  DATA_OFFSET = 24;
+  constructor(config, sharedBuffer) {
+    this.config = config;
+    this.sharedBuffer = sharedBuffer;
+    this.dataView = new DataView(sharedBuffer);
+    this.atomicState = new Int32Array(sharedBuffer, 0, 6);
+  }
+  async initialize() {
+    this.displays = await this.getDisplays();
+    if (this.displays.length === 0) {
+      throw new Error("No displays found");
+    }
+    if (this.config.displayIndex !== undefined && this.config.displayIndex < this.displays.length) {
+      this.currentDisplayIndex = this.config.displayIndex;
+    }
+    logger.info(`[ScreenCaptureWorker] Initialized with ${this.displays.length} displays`);
+    this.displays.forEach((d, i) => {
+      logger.info(`  Display ${i}: ${d.name} (${d.width}x${d.height}) ${d.isPrimary ? "[PRIMARY]" : ""}`);
+    });
+  }
+  async getDisplays() {
+    const platform = process.platform;
+    try {
+      if (platform === "darwin") {
+        const { stdout } = await execAsync("system_profiler SPDisplaysDataType -json");
+        const data = JSON.parse(stdout);
+        const displays = [];
+        if (data.SPDisplaysDataType?.[0]) {
+          const gpuInfo = data.SPDisplaysDataType[0];
+          const items = gpuInfo._items || [];
+          items.forEach((item, index) => {
+            const resolution = item.native_resolution;
+            if (resolution) {
+              const match = resolution.match(/(\d+) x (\d+)/);
+              if (match) {
+                displays.push({
+                  id: `display-${index}`,
+                  name: item._name || `Display ${index + 1}`,
+                  width: parseInt(match[1], 10),
+                  height: parseInt(match[2], 10),
+                  x: 0,
+                  y: 0,
+                  isPrimary: index === 0
+                });
+              }
+            }
+          });
+        }
+        return displays;
+      } else if (platform === "linux") {
+        const { stdout } = await execAsync("xrandr --query");
+        const displays = [];
+        const lines = stdout.split(`
+`);
+        for (const line of lines) {
+          if (line.includes(" connected")) {
+            const match = line.match(/^(\S+) connected (?:primary )?(\d+)x(\d+)\+(\d+)\+(\d+)/);
+            if (match) {
+              displays.push({
+                id: match[1],
+                name: match[1],
+                width: parseInt(match[2], 10),
+                height: parseInt(match[3], 10),
+                x: parseInt(match[4], 10),
+                y: parseInt(match[5], 10),
+                isPrimary: line.includes("primary")
+              });
+            }
+          }
+        }
+        return displays;
+      } else if (platform === "win32") {
+        const { stdout } = await execAsync("wmic path Win32_DesktopMonitor get DeviceID,ScreenWidth,ScreenHeight /format:csv");
+        const displays = [];
+        const lines = stdout.trim().split(`
+`).slice(2);
+        lines.forEach((line, index) => {
+          const parts = line.split(",");
+          if (parts.length >= 4) {
+            const width = parseInt(parts[2], 10);
+            const height = parseInt(parts[3], 10);
+            if (!Number.isNaN(width) && !Number.isNaN(height)) {
+              displays.push({
+                id: parts[1],
+                name: parts[1] || `Display ${index + 1}`,
+                width,
+                height,
+                x: 0,
+                y: 0,
+                isPrimary: index === 0
+              });
+            }
+          }
         });
-    };
-    ScreenCaptureWorker.prototype.stop = function () {
-        this.isRunning = false;
-    };
-    return ScreenCaptureWorker;
-}());
-// Worker entry point
-if (worker_threads_1.parentPort) {
-    var config = worker_threads_1.workerData.config, sharedBuffer = worker_threads_1.workerData.sharedBuffer;
-    var worker_1 = new ScreenCaptureWorker(config, sharedBuffer);
-    // Handle messages from main thread
-    worker_threads_1.parentPort.on('message', function (msg) {
-        if (msg.type === 'stop') {
-            worker_1.stop();
+        return displays.length > 0 ? displays : [
+          {
+            id: "primary",
+            name: "Primary Display",
+            width: 1920,
+            height: 1080,
+            x: 0,
+            y: 0,
+            isPrimary: true
+          }
+        ];
+      }
+    } catch (error) {
+      logger.error("[ScreenCaptureWorker] Failed to get display info:", error);
+    }
+    return [
+      {
+        id: "default",
+        name: "Default Display",
+        width: 1920,
+        height: 1080,
+        x: 0,
+        y: 0,
+        isPrimary: true
+      }
+    ];
+  }
+  async run() {
+    await this.initialize();
+    logger.info("[ScreenCaptureWorker] Starting capture loop...");
+    while (this.isRunning) {
+      const startTime = Date.now();
+      try {
+        await this.captureFrame();
+        this.frameCount++;
+        const now = Date.now();
+        if (now - this.lastFPSReport >= 1000) {
+          const fps = this.frameCount / ((now - this.lastFPSReport) / 1000);
+          logger.info(`[ScreenCaptureWorker] FPS: ${fps.toFixed(2)}, Display: ${this.currentDisplayIndex}`);
+          import_node_worker_threads2.parentPort?.postMessage({
+            type: "fps",
+            fps,
+            frameCount: this.frameCount,
+            displayIndex: this.currentDisplayIndex
+          });
+          this.frameCount = 0;
+          this.lastFPSReport = now;
         }
-    });
-    // Run the worker
-    worker_1.run().catch(function (error) {
-        worker_logger_1.logger.error('[ScreenCaptureWorker] Fatal error:', error);
-        worker_threads_1.parentPort === null || worker_threads_1.parentPort === void 0 ? void 0 : worker_threads_1.parentPort.postMessage({ type: 'error', error: error.message });
-        process.exit(1);
-    });
+        if (this.config.captureAllDisplays && this.displays.length > 1) {
+          this.currentDisplayIndex = (this.currentDisplayIndex + 1) % this.displays.length;
+        }
+        if (this.config.targetFPS) {
+          const frameTime = 1000 / this.config.targetFPS;
+          const elapsed = Date.now() - startTime;
+          if (elapsed < frameTime) {
+            await new Promise((resolve) => setTimeout(resolve, frameTime - elapsed));
+          }
+        }
+      } catch (error) {
+        logger.error("[ScreenCaptureWorker] Capture error:", error);
+        await new Promise((resolve) => setTimeout(resolve, 100));
+      }
+    }
+  }
+  async captureFrame() {
+    const display = this.displays[this.currentDisplayIndex];
+    const tempFile = path.join(process.cwd(), `temp_screen_${Date.now()}_${this.currentDisplayIndex}.png`);
+    try {
+      await this.captureScreenToFile(tempFile, display);
+      const imageBuffer = await fs.readFile(tempFile);
+      const image = import_sharp.default(imageBuffer);
+      const metadata = await image.metadata();
+      const width = metadata.width || display.width;
+      const height = metadata.height || display.height;
+      const rawData = await image.ensureAlpha().raw().toBuffer();
+      while (Atomics.compareExchange(this.atomicState, this.WRITE_LOCK_INDEX, 0, 1) !== 0) {}
+      try {
+        Atomics.store(this.atomicState, this.WIDTH_INDEX, width);
+        Atomics.store(this.atomicState, this.HEIGHT_INDEX, height);
+        Atomics.store(this.atomicState, this.DISPLAY_INDEX, this.currentDisplayIndex);
+        Atomics.store(this.atomicState, this.TIMESTAMP_INDEX, Date.now());
+        const maxDataSize = this.sharedBuffer.byteLength - this.DATA_OFFSET;
+        const dataSize = Math.min(rawData.length, maxDataSize);
+        for (let i = 0;i < dataSize; i++) {
+          this.dataView.setUint8(this.DATA_OFFSET + i, rawData[i]);
+        }
+        Atomics.add(this.atomicState, this.FRAME_ID_INDEX, 1);
+      } finally {
+        Atomics.store(this.atomicState, this.WRITE_LOCK_INDEX, 0);
+      }
+      await fs.unlink(tempFile).catch(() => {});
+    } catch (error) {
+      await fs.unlink(tempFile).catch(() => {});
+      throw error;
+    }
+  }
+  async captureScreenToFile(outputPath, display) {
+    const platform = process.platform;
+    try {
+      if (platform === "darwin") {
+        const displayArg = this.currentDisplayIndex > 0 ? `-D ${this.currentDisplayIndex + 1}` : "";
+        await execAsync(`screencapture -x ${displayArg} "${outputPath}"`);
+      } else if (platform === "linux") {
+        if (display.x !== 0 || display.y !== 0) {
+          await execAsync(`scrot -a ${display.x},${display.y},${display.width},${display.height} "${outputPath}"`);
+        } else {
+          await execAsync(`scrot "${outputPath}"`);
+        }
+      } else if (platform === "win32") {
+        const script = `
+          Add-Type -AssemblyName System.Windows.Forms;
+          Add-Type -AssemblyName System.Drawing;
+          $screens = [System.Windows.Forms.Screen]::AllScreens;
+          $screen = $screens[${this.currentDisplayIndex}];
+          $bounds = $screen.Bounds;
+          $bitmap = New-Object System.Drawing.Bitmap $bounds.Width, $bounds.Height;
+          $graphics = [System.Drawing.Graphics]::FromImage($bitmap);
+          $graphics.CopyFromScreen($bounds.Location, [System.Drawing.Point]::Empty, $bounds.Size);
+          $bitmap.Save('${outputPath.replace(/\\/g, "\\\\")}');
+          $graphics.Dispose();
+          $bitmap.Dispose();
+        `;
+        await execAsync(`powershell -Command "${script.replace(/\n/g, " ")}"`);
+      }
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      throw new Error(`Screen capture failed: ${errorMessage}`);
+    }
+  }
+  stop() {
+    this.isRunning = false;
+  }
+}
+if (import_node_worker_threads2.parentPort) {
+  const { config, sharedBuffer } = import_node_worker_threads2.workerData;
+  const worker = new ScreenCaptureWorker(config, sharedBuffer);
+  import_node_worker_threads2.parentPort.on("message", (msg) => {
+    if (msg.type === "stop") {
+      worker.stop();
+    }
+  });
+  worker.run().catch((error) => {
+    logger.error("[ScreenCaptureWorker] Fatal error:", error);
+    import_node_worker_threads2.parentPort?.postMessage({ type: "error", error: error.message });
+    process.exit(1);
+  });
 }
-//# sourceMappingURL=screen-capture-worker.js.map
+
+//# debugId=91B84423455CE7E564756E2164756E21
+//# sourceMappingURL=screen-capture-worker.js.map