@mindexec/cli 0.2.441 → 0.2.443

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mindexec/cli",
-  "version": "0.2.441",
+  "version": "0.2.443",
   "description": "MindExec local runtime and bridge CLI",
   "main": "server.js",
   "type": "module",

package/remote-fast/osx-arm64/MacScreenCaptureKitH264.swift

@@ -0,0 +1,339 @@
+import CoreFoundation
+import CoreGraphics
+import CoreMedia
+import CoreVideo
+import Foundation
+import IOSurface
+import ScreenCaptureKit
+import VideoToolbox
+
+@available(macOS 12.3, *)
+final class LiveDeskScreenCaptureKitEncoder: NSObject, SCStreamOutput, SCStreamDelegate {
+    private let displayIndex: Int
+    private let width: Int
+    private let height: Int
+    private let fps: Int
+    private let bitrateKbps: Int
+    private let queue = DispatchQueue(label: "dev.livedesk.screencapturekit.frames", qos: .userInteractive)
+    private let writeLock = NSLock()
+    private var stream: SCStream?
+    private var compressionSession: VTCompressionSession?
+    private var sampleCount: Int = 0
+    private var frameCount: Int = 0
+    private var skippedCount: Int = 0
+    private var encodedCount: Int = 0
+    private var encodedKeyCount: Int = 0
+    private var encodedDeltaCount: Int = 0
+    private var loggedInputSurface = false
+
+    init(displayIndex: Int, width: Int, height: Int, fps: Int, bitrateKbps: Int) {
+        self.displayIndex = max(0, displayIndex)
+        self.width = max(2, width)
+        self.height = max(2, height)
+        self.fps = max(1, fps)
+        self.bitrateKbps = max(500, bitrateKbps)
+        super.init()
+    }
+
+    func start() async throws {
+        try createCompressionSession()
+
+        let shareableContent = try await SCShareableContent.excludingDesktopWindows(false, onScreenWindowsOnly: true)
+        guard !shareableContent.displays.isEmpty else {
+            throw LiveDeskSCKError.noDisplays
+        }
+
+        let mainDisplayID = CGMainDisplayID()
+        let orderedDisplays = shareableContent.displays.sorted { left, right in
+            let leftIsMain = left.displayID == mainDisplayID
+            let rightIsMain = right.displayID == mainDisplayID
+            if leftIsMain != rightIsMain {
+                return leftIsMain
+            }
+            return left.displayID < right.displayID
+        }
+        let display = orderedDisplays[min(displayIndex, orderedDisplays.count - 1)]
+        let filter = SCContentFilter(display: display, excludingWindows: [])
+        let configuration = SCStreamConfiguration()
+        configuration.width = width
+        configuration.height = height
+        configuration.minimumFrameInterval = CMTime(value: 1, timescale: CMTimeScale(fps))
+        configuration.queueDepth = 3
+        configuration.showsCursor = false
+        configuration.pixelFormat = kCVPixelFormatType_420YpCbCr8BiPlanarVideoRange
+
+        let stream = SCStream(filter: filter, configuration: configuration, delegate: self)
+        try stream.addStreamOutput(self, type: .screen, sampleHandlerQueue: queue)
+        self.stream = stream
+        try await stream.startCapture()
+
+        fputs("LiveDeskSCK started displayIndex=\(displayIndex) displayID=\(display.displayID) size=\(width)x\(height) fps=\(fps) bitrateKbps=\(bitrateKbps)\n", stderr)
+        while !Task.isCancelled {
+            try await Task.sleep(nanoseconds: 1_000_000_000)
+        }
+    }
+
+    private func createCompressionSession() throws {
+        var session: VTCompressionSession?
+        let encoderSpecification: [CFString: Any] = [
+            kVTVideoEncoderSpecification_EnableHardwareAcceleratedVideoEncoder: true
+        ]
+        let imageBufferAttributes: [CFString: Any] = [
+            kCVPixelBufferPixelFormatTypeKey: NSNumber(value: kCVPixelFormatType_420YpCbCr8BiPlanarVideoRange),
+            kCVPixelBufferWidthKey: NSNumber(value: width),
+            kCVPixelBufferHeightKey: NSNumber(value: height),
+            kCVPixelBufferMetalCompatibilityKey: true,
+            kCVPixelBufferIOSurfacePropertiesKey: [:] as CFDictionary
+        ]
+        let status = VTCompressionSessionCreate(
+            allocator: kCFAllocatorDefault,
+            width: Int32(width),
+            height: Int32(height),
+            codecType: kCMVideoCodecType_H264,
+            encoderSpecification: encoderSpecification as CFDictionary,
+            imageBufferAttributes: imageBufferAttributes as CFDictionary,
+            compressedDataAllocator: nil,
+            outputCallback: Self.compressionCallback,
+            refcon: UnsafeMutableRawPointer(Unmanaged.passUnretained(self).toOpaque()),
+            compressionSessionOut: &session)
+
+        guard status == noErr, let session else {
+            throw LiveDeskSCKError.encoderCreate(status)
+        }
+
+        VTSessionSetProperty(session, key: kVTCompressionPropertyKey_RealTime, value: kCFBooleanTrue)
+        VTSessionSetProperty(session, key: kVTCompressionPropertyKey_PrioritizeEncodingSpeedOverQuality, value: kCFBooleanTrue)
+        VTSessionSetProperty(session, key: kVTCompressionPropertyKey_AllowTemporalCompression, value: kCFBooleanTrue)
+        VTSessionSetProperty(session, key: kVTCompressionPropertyKey_AllowFrameReordering, value: kCFBooleanFalse)
+        VTSessionSetProperty(session, key: kVTCompressionPropertyKey_MaxFrameDelayCount, value: NSNumber(value: 0))
+        VTSessionSetProperty(session, key: kVTCompressionPropertyKey_ProfileLevel, value: kVTProfileLevel_H264_Baseline_AutoLevel)
+        let recoveryKeyInterval = max(1, fps / 2)
+        VTSessionSetProperty(session, key: kVTCompressionPropertyKey_MaxKeyFrameInterval, value: NSNumber(value: recoveryKeyInterval))
+        VTSessionSetProperty(session, key: kVTCompressionPropertyKey_MaxKeyFrameIntervalDuration, value: NSNumber(value: 0.5))
+        VTSessionSetProperty(session, key: kVTCompressionPropertyKey_ExpectedFrameRate, value: NSNumber(value: fps))
+        VTSessionSetProperty(session, key: kVTCompressionPropertyKey_AverageBitRate, value: NSNumber(value: bitrateKbps * 1000))
+        VTCompressionSessionPrepareToEncodeFrames(session)
+        compressionSession = session
+    }
+
+    private static let compressionCallback: VTCompressionOutputCallback = { refCon, _, status, _, sampleBuffer in
+        guard status == noErr,
+              let refCon,
+              let sampleBuffer,
+              CMSampleBufferDataIsReady(sampleBuffer) else {
+            return
+        }
+
+        let encoder = Unmanaged<LiveDeskScreenCaptureKitEncoder>.fromOpaque(refCon).takeUnretainedValue()
+        encoder.writeEncodedSampleBuffer(sampleBuffer)
+    }
+
+    func stream(_ stream: SCStream, didOutputSampleBuffer sampleBuffer: CMSampleBuffer, of type: SCStreamOutputType) {
+        guard type == .screen,
+              CMSampleBufferDataIsReady(sampleBuffer),
+              let imageBuffer = CMSampleBufferGetImageBuffer(sampleBuffer),
+              let session = compressionSession else {
+            return
+        }
+
+        sampleCount += 1
+        guard isEncodableFrame(sampleBuffer) else {
+            skippedCount += 1
+            logCaptureProgressIfNeeded()
+            return
+        }
+
+        frameCount += 1
+        if !loggedInputSurface {
+            loggedInputSurface = true
+            let pixelFormat = CVPixelBufferGetPixelFormatType(imageBuffer)
+            let hasIOSurface = CVPixelBufferGetIOSurface(imageBuffer) != nil
+            fputs("LiveDeskSCK input pixelFormat=\(pixelFormat) iosurface=\(hasIOSurface ? 1 : 0) queueDepth=3 zeroCopyCandidate=\(hasIOSurface ? 1 : 0)\n", stderr)
+        }
+        let pts = CMSampleBufferGetPresentationTimeStamp(sampleBuffer)
+        let duration = CMTime(value: 1, timescale: CMTimeScale(fps))
+        var frameProperties: CFDictionary?
+        if frameCount == 1 {
+            let properties = NSMutableDictionary()
+            properties[kVTEncodeFrameOptionKey_ForceKeyFrame] = kCFBooleanTrue
+            frameProperties = properties
+        }
+
+        let status = VTCompressionSessionEncodeFrame(
+            session,
+            imageBuffer: imageBuffer,
+            presentationTimeStamp: pts,
+            duration: duration,
+            frameProperties: frameProperties,
+            sourceFrameRefcon: nil,
+            infoFlagsOut: nil)
+
+        if status != noErr && (frameCount == 1 || frameCount % 120 == 0) {
+            fputs("LiveDeskSCK encode status=\(status) frames=\(frameCount)\n", stderr)
+        }
+        logCaptureProgressIfNeeded()
+    }
+
+    func stream(_ stream: SCStream, didStopWithError error: Error) {
+        fputs("LiveDeskSCK stream stopped: \(error)\n", stderr)
+        exit(3)
+    }
+
+    private func isEncodableFrame(_ sampleBuffer: CMSampleBuffer) -> Bool {
+        guard let attachments = CMSampleBufferGetSampleAttachmentsArray(sampleBuffer, createIfNecessary: false) as NSArray?,
+              let first = attachments.firstObject as? NSDictionary,
+              let rawStatus = first[SCStreamFrameInfo.status] as? Int else {
+            return true
+        }
+        return rawStatus == SCFrameStatus.complete.rawValue
+            || rawStatus == SCFrameStatus.idle.rawValue
+    }
+
+    private func logCaptureProgressIfNeeded() {
+        let interval = max(1, fps * 5)
+        if sampleCount == 1 || sampleCount % interval == 0 {
+            fputs("LiveDeskSCK capture samples=\(sampleCount) complete=\(frameCount) skipped=\(skippedCount)\n", stderr)
+        }
+    }
+
+    private func writeEncodedSampleBuffer(_ sampleBuffer: CMSampleBuffer) {
+        guard let blockBuffer = CMSampleBufferGetDataBuffer(sampleBuffer) else {
+            return
+        }
+
+        let keyFrame = isKeyFrame(sampleBuffer)
+        var output = Data()
+        appendAccessUnitDelimiter(to: &output)
+        if keyFrame, let formatDescription = CMSampleBufferGetFormatDescription(sampleBuffer) {
+            appendParameterSet(formatDescription, index: 0, to: &output)
+            appendParameterSet(formatDescription, index: 1, to: &output)
+        }
+
+        var lengthAtOffset = 0
+        var totalLength = 0
+        var dataPointer: UnsafeMutablePointer<Int8>?
+        let status = CMBlockBufferGetDataPointer(
+            blockBuffer,
+            atOffset: 0,
+            lengthAtOffsetOut: &lengthAtOffset,
+            totalLengthOut: &totalLength,
+            dataPointerOut: &dataPointer)
+
+        guard status == noErr, let dataPointer, totalLength > 4 else {
+            return
+        }
+
+        var offset = 0
+        while offset + 4 <= totalLength {
+            var nalLength: UInt32 = 0
+            memcpy(&nalLength, dataPointer.advanced(by: offset), 4)
+            nalLength = CFSwapInt32BigToHost(nalLength)
+            let length = Int(nalLength)
+            if length <= 0 || offset + 4 + length > totalLength {
+                break
+            }
+
+            appendStartCode(to: &output)
+            output.append(UnsafeRawPointer(dataPointer.advanced(by: offset + 4)).assumingMemoryBound(to: UInt8.self), count: length)
+            offset += 4 + length
+        }
+
+        guard !output.isEmpty else {
+            return
+        }
+
+        writeLock.lock()
+        FileHandle.standardOutput.write(output)
+        writeLock.unlock()
+
+        encodedCount += 1
+        if keyFrame {
+            encodedKeyCount += 1
+        } else {
+            encodedDeltaCount += 1
+        }
+        if encodedCount == 1 || encodedCount % max(1, fps * 5) == 0 {
+            fputs("LiveDeskSCK encoded frames=\(encodedCount) key=\(encodedKeyCount) delta=\(encodedDeltaCount) bytes=\(output.count)\n", stderr)
+        }
+    }
+
+    private func isKeyFrame(_ sampleBuffer: CMSampleBuffer) -> Bool {
+        guard let attachments = CMSampleBufferGetSampleAttachmentsArray(sampleBuffer, createIfNecessary: false) as NSArray?,
+              let first = attachments.firstObject as? NSDictionary else {
+            return true
+        }
+        return !(first[kCMSampleAttachmentKey_NotSync] as? Bool ?? false)
+    }
+
+    private func appendParameterSet(_ formatDescription: CMFormatDescription, index: Int, to output: inout Data) {
+        var pointer: UnsafePointer<UInt8>?
+        var size = 0
+        var count = 0
+        var nalHeaderLength: Int32 = 0
+        let status = CMVideoFormatDescriptionGetH264ParameterSetAtIndex(
+            formatDescription,
+            parameterSetIndex: index,
+            parameterSetPointerOut: &pointer,
+            parameterSetSizeOut: &size,
+            parameterSetCountOut: &count,
+            nalUnitHeaderLengthOut: &nalHeaderLength)
+
+        guard status == noErr, let pointer, size > 0 else {
+            return
+        }
+
+        appendStartCode(to: &output)
+        output.append(pointer, count: size)
+    }
+
+    private func appendStartCode(to output: inout Data) {
+        output.append(contentsOf: [0, 0, 0, 1])
+    }
+
+    private func appendAccessUnitDelimiter(to output: inout Data) {
+        appendStartCode(to: &output)
+        output.append(contentsOf: [0x09, 0xF0])
+    }
+}
+
+enum LiveDeskSCKError: Error {
+    case noDisplays
+    case encoderCreate(OSStatus)
+}
+
+func intArg(_ name: String, default defaultValue: Int) -> Int {
+    let args = CommandLine.arguments
+    guard let index = args.firstIndex(of: name), index + 1 < args.count else {
+        return defaultValue
+    }
+    return Int(args[index + 1]) ?? defaultValue
+}
+
+@main
+struct LiveDeskSCKMain {
+    static func main() async {
+        guard #available(macOS 12.3, *) else {
+            fputs("LiveDeskSCK requires macOS 12.3 or later.\n", stderr)
+            exit(2)
+        }
+        guard CGPreflightScreenCaptureAccess() else {
+            fputs("LiveDeskSCK screen recording permission is not granted.\n", stderr)
+            exit(10)
+        }
+
+        let displayIndex = intArg("--display-index", default: 0)
+        let width = intArg("--width", default: 960)
+        let height = intArg("--height", default: 540)
+        let fps = intArg("--fps", default: 30)
+        let bitrateKbps = intArg("--bitrate-kbps", default: max(3500, width * height * fps / 4000))
+
+        do {
+            let encoder = LiveDeskScreenCaptureKitEncoder(displayIndex: displayIndex, width: width, height: height, fps: fps, bitrateKbps: bitrateKbps)
+            try await encoder.start()
+        } catch {
+            fputs("LiveDeskSCK failed: \(error)\n", stderr)
+            exit(1)
+        }
+    }
+}
+

package/remote-fast/osx-arm64/MacSystemAudioCapture.swift

@@ -0,0 +1,214 @@
+import AudioToolbox
+import AVFAudio
+import CoreGraphics
+import CoreMedia
+import Foundation
+import ScreenCaptureKit
+
+@available(macOS 13.0, *)
+final class LiveDeskSystemAudioCapture: NSObject, SCStreamOutput, SCStreamDelegate {
+    private let sampleRate: Int
+    private let channelCount: Int
+    private let queue = DispatchQueue(label: "dev.livedesk.screencapturekit.audio", qos: .userInteractive)
+    private let writeLock = NSLock()
+    private var stream: SCStream?
+    private var audioFrameCount = 0
+    private var loggedFormat = false
+
+    init(sampleRate: Int, channelCount: Int) {
+        self.sampleRate = max(8_000, min(192_000, sampleRate))
+        self.channelCount = max(1, min(2, channelCount))
+        super.init()
+    }
+
+    func start() async throws {
+        let content = try await SCShareableContent.excludingDesktopWindows(false, onScreenWindowsOnly: true)
+        guard !content.displays.isEmpty else {
+            throw LiveDeskSystemAudioError.noDisplays
+        }
+
+        let mainDisplayID = CGMainDisplayID()
+        let display = content.displays.sorted { left, right in
+            let leftIsMain = left.displayID == mainDisplayID
+            let rightIsMain = right.displayID == mainDisplayID
+            if leftIsMain != rightIsMain {
+                return leftIsMain
+            }
+            return left.displayID < right.displayID
+        }[0]
+
+        let configuration = SCStreamConfiguration()
+        configuration.width = 2
+        configuration.height = 2
+        configuration.minimumFrameInterval = CMTime(value: 1, timescale: 1)
+        configuration.queueDepth = 8
+        configuration.capturesAudio = true
+        configuration.sampleRate = sampleRate
+        configuration.channelCount = channelCount
+        configuration.excludesCurrentProcessAudio = true
+
+        let stream = SCStream(filter: SCContentFilter(display: display, excludingWindows: []), configuration: configuration, delegate: self)
+        try stream.addStreamOutput(self, type: .audio, sampleHandlerQueue: queue)
+        self.stream = stream
+        try await stream.startCapture()
+        fputs("LiveDeskSCKAudio started displayID=\(display.displayID) sampleRate=\(sampleRate) channels=\(channelCount)\n", stderr)
+
+        while !Task.isCancelled {
+            try await Task.sleep(nanoseconds: 1_000_000_000)
+        }
+    }
+
+    func stream(_ stream: SCStream, didOutputSampleBuffer sampleBuffer: CMSampleBuffer, of type: SCStreamOutputType) {
+        guard type == .audio, sampleBuffer.isValid, CMSampleBufferDataIsReady(sampleBuffer) else {
+            return
+        }
+        writePcm(sampleBuffer)
+    }
+
+    func stream(_ stream: SCStream, didStopWithError error: Error) {
+        fputs("LiveDeskSCKAudio stream stopped: \(error)\n", stderr)
+        exit(3)
+    }
+
+    private func writePcm(_ sampleBuffer: CMSampleBuffer) {
+        guard let description = sampleBuffer.formatDescription?.audioStreamBasicDescription else {
+            return
+        }
+
+        let channels = Int(description.mChannelsPerFrame)
+        let frames = Int(CMSampleBufferGetNumSamples(sampleBuffer))
+        let isFloat32 = description.mFormatID == kAudioFormatLinearPCM
+            && description.mBitsPerChannel == 32
+            && (description.mFormatFlags & kAudioFormatFlagIsFloat) != 0
+        let isInterleaved = (description.mFormatFlags & kAudioFormatFlagIsNonInterleaved) == 0
+        guard isFloat32, frames > 0, channels > 0, channels <= 8 else {
+            if !loggedFormat {
+                loggedFormat = true
+                fputs("LiveDeskSCKAudio unsupported PCM format id=\(description.mFormatID) flags=\(description.mFormatFlags) bits=\(description.mBitsPerChannel) channels=\(channels)\n", stderr)
+            }
+            return
+        }
+
+        do {
+            try sampleBuffer.withAudioBufferList { audioBufferList, _ in
+                let bytesPerSample = MemoryLayout<Float>.size
+                let bytesPerChannel = frames * bytesPerSample
+                let outputBytes = bytesPerChannel * channels
+                guard audioBufferList.count > 0, outputBytes > 0 else {
+                    return
+                }
+
+                let output: Data
+                if isInterleaved {
+                    let sourceBuffer = audioBufferList[0]
+                    guard let source = sourceBuffer.mData, Int(sourceBuffer.mDataByteSize) >= outputBytes else {
+                        return
+                    }
+                    output = Data(bytes: source, count: outputBytes)
+                } else {
+                    guard audioBufferList.count >= channels else {
+                        return
+                    }
+                    var interleaved = Data(count: outputBytes)
+                    var copied = true
+                    interleaved.withUnsafeMutableBytes { rawBuffer in
+                        guard let destination = rawBuffer.baseAddress?.assumingMemoryBound(to: Float.self) else {
+                            copied = false
+                            return
+                        }
+                        for channelIndex in 0..<channels {
+                            let sourceBuffer = audioBufferList[channelIndex]
+                            guard let source = sourceBuffer.mData,
+                                  Int(sourceBuffer.mDataByteSize) >= bytesPerChannel else {
+                                copied = false
+                                return
+                            }
+                            let sourceSamples = source.assumingMemoryBound(to: Float.self)
+                            for frameIndex in 0..<frames {
+                                destination[frameIndex * channels + channelIndex] = sourceSamples[frameIndex]
+                            }
+                        }
+                    }
+                    guard copied else {
+                        return
+                    }
+                    output = interleaved
+                }
+
+                if !loggedFormat {
+                    loggedFormat = true
+                    fputs("LiveDeskSCKAudio format sampleRate=\(Int(description.mSampleRate.rounded())) channels=\(channels) frames=\(frames) interleaved=\(isInterleaved ? 1 : 0)\n", stderr)
+                }
+                writePacket(output, sampleRate: Int(description.mSampleRate.rounded()), channels: channels)
+                audioFrameCount += 1
+                if audioFrameCount == 1 || audioFrameCount % 250 == 0 {
+                    fputs("LiveDeskSCKAudio frames=\(audioFrameCount) bytes=\(output.count)\n", stderr)
+                }
+            }
+        } catch {
+            fputs("LiveDeskSCKAudio audio buffer error: \(error)\n", stderr)
+        }
+    }
+
+    private func writePacket(_ pcm: Data, sampleRate: Int, channels: Int) {
+        guard sampleRate > 0, channels > 0, pcm.count <= Int(UInt32.max) else {
+            return
+        }
+        var packet = Data()
+        packet.reserveCapacity(16 + pcm.count)
+        packet.append(contentsOf: [0x4c, 0x44, 0x41, 0x55])
+        appendLittleEndian(UInt16(1), to: &packet)
+        appendLittleEndian(UInt16(min(channels, Int(UInt16.max))), to: &packet)
+        appendLittleEndian(UInt32(min(sampleRate, Int(UInt32.max))), to: &packet)
+        appendLittleEndian(UInt32(pcm.count), to: &packet)
+        packet.append(pcm)
+
+        writeLock.lock()
+        FileHandle.standardOutput.write(packet)
+        writeLock.unlock()
+    }
+
+    private func appendLittleEndian<T: FixedWidthInteger>(_ value: T, to data: inout Data) {
+        var littleEndian = value.littleEndian
+        withUnsafeBytes(of: &littleEndian) { bytes in
+            data.append(contentsOf: bytes)
+        }
+    }
+}
+
+enum LiveDeskSystemAudioError: Error {
+    case noDisplays
+}
+
+func intArg(_ name: String, default defaultValue: Int) -> Int {
+    let args = CommandLine.arguments
+    guard let index = args.firstIndex(of: name), index + 1 < args.count else {
+        return defaultValue
+    }
+    return Int(args[index + 1]) ?? defaultValue
+}
+
+@main
+struct LiveDeskSystemAudioMain {
+    static func main() async {
+        guard #available(macOS 13.0, *) else {
+            fputs("LiveDeskSCKAudio requires macOS 13 or later.\n", stderr)
+            exit(2)
+        }
+        guard CGPreflightScreenCaptureAccess() else {
+            fputs("LiveDeskSCKAudio Screen & System Audio Recording permission is not granted.\n", stderr)
+            exit(10)
+        }
+
+        let sampleRate = intArg("--sample-rate", default: 48_000)
+        let channels = intArg("--channels", default: 2)
+        do {
+            let capture = LiveDeskSystemAudioCapture(sampleRate: sampleRate, channelCount: channels)
+            try await capture.start()
+        } catch {
+            fputs("LiveDeskSCKAudio failed: \(error)\n", stderr)
+            exit(1)
+        }
+    }
+}
+

package/remote-fast/osx-arm64/UnixRawCaptureHelper.mjs

@@ -0,0 +1,80 @@
+#!/usr/bin/env node
+
+import readline from 'node:readline';
+import { convertRgbaToRgb565 } from './livedesk-raw-capture-resampler.mjs';
+
+const screenshotModule = await import('node-screenshots');
+const Monitor = screenshotModule.Monitor || screenshotModule.default?.Monitor;
+if (!Monitor?.all) {
+  throw new Error('node-screenshots Monitor API is unavailable.');
+}
+
+function clampInteger(value, min, max, fallback) {
+  const number = Number(value);
+  if (!Number.isFinite(number)) return fallback;
+  return Math.max(min, Math.min(max, Math.round(number)));
+}
+
+function pickMonitor(index) {
+  const monitors = Monitor.all();
+  if (!monitors.length) {
+    throw new Error('No capturable desktop monitor was found.');
+  }
+  const selectedIndex = clampInteger(index, 0, monitors.length - 1, 0);
+  const monitor = monitors[selectedIndex]
+    || monitors.find(item => item?.isPrimary?.() === true)
+    || monitors[0];
+  return { monitor, selectedIndex, monitorCount: monitors.length };
+}
+
+function writeResponse(metadata, payload = Buffer.alloc(0)) {
+  const header = Buffer.from(JSON.stringify(metadata), 'utf8');
+  const prefix = Buffer.allocUnsafe(8);
+  prefix.writeUInt32BE(header.length, 0);
+  prefix.writeUInt32BE(payload.length, 4);
+  process.stdout.write(prefix);
+  process.stdout.write(header);
+  if (payload.length > 0) process.stdout.write(payload);
+}
+
+const input = readline.createInterface({ input: process.stdin, crlfDelay: Infinity });
+for await (const line of input) {
+  if (!line.trim()) continue;
+  let request;
+  try {
+    request = JSON.parse(line);
+    const id = Number.isSafeInteger(Number(request.id)) ? Number(request.id) : 0;
+    const maxWidth = clampInteger(request.maxWidth, 1, 480, 320);
+    const maxHeight = clampInteger(request.maxHeight, 1, 270, 180);
+    const { monitor, selectedIndex, monitorCount } = pickMonitor(request.monitorIndex);
+    const captureStartedAt = performance.now();
+    const image = await monitor.captureImage();
+    const raw = await image.toRaw(false);
+    const captureMs = Math.max(0, performance.now() - captureStartedAt);
+    const sourceWidth = Number(image.width || monitor.width?.() || 0);
+    const sourceHeight = Number(image.height || monitor.height?.() || 0);
+    const convertStartedAt = performance.now();
+    const converted = convertRgbaToRgb565(raw, sourceWidth, sourceHeight, maxWidth, maxHeight);
+    const convertMs = Math.max(0, performance.now() - convertStartedAt);
+    writeResponse({
+      ok: true,
+      id,
+      width: converted.width,
+      height: converted.height,
+      sourceWidth,
+      sourceHeight,
+      monitorIndex: selectedIndex,
+      monitorCount,
+      captureMs: Math.round(captureMs),
+      convertMs: Math.round(convertMs),
+      resizeFilter: converted.filter
+    }, converted.output);
+  } catch (error) {
+    writeResponse({
+      ok: false,
+      id: Number.isSafeInteger(Number(request?.id)) ? Number(request.id) : 0,
+      error: String(error?.message || error || 'capture failed').slice(0, 1000)
+    });
+  }
+}
+