@mindexec/cli 0.2.478 → 0.2.480

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

@@ -1,214 +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)
-        }
-    }
-}
-
+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

@@ -1,80 +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)
-    });
-  }
-}
-
+#!/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)
+    });
+  }
+}
+