@livedesk/client 0.1.118 → 0.1.120

package/bin/client-version.js

@@ -0,0 +1,27 @@
+import { readFileSync } from 'node:fs';
+import { dirname, join, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const packageRoot = resolve(__dirname, '..');
+
+export function readClientPackageVersion() {
+    try {
+        const packageInfo = JSON.parse(readFileSync(join(packageRoot, 'package.json'), 'utf8'));
+        return String(packageInfo.version || '0.0.0');
+    } catch {
+        return '0.0.0';
+    }
+}
+
+export function formatClientVersionBanner(env = process.env) {
+    const clientPackage = `@livedesk/client@${readClientPackageVersion()}`;
+    const launcherName = String(env.LIVEDESK_NPM_LAUNCHER_NAME || '').trim();
+    const launcherVersion = String(env.LIVEDESK_NPM_LAUNCHER_VERSION || '').trim();
+
+    if (launcherName && launcherVersion) {
+        return `[LiveDesk Client] npm packages: ${launcherName}@${launcherVersion} -> ${clientPackage}`;
+    }
+
+    return `[LiveDesk Client] npm package: ${clientPackage}`;
+}

package/bin/livedesk-client.js

@@ -8,6 +8,7 @@ import { createServer } from 'node:http';
 import { createRequire } from 'node:module';
 import net from 'node:net';
 import os from 'node:os';
+import { formatClientVersionBanner, readClientPackageVersion } from './client-version.js';
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const require = createRequire(import.meta.url);
@@ -74,12 +75,7 @@ Enable Windows auto-start from the connection page when this client signs in.
 }
 
 function readPackageVersion() {
-    try {
-        const packageInfo = JSON.parse(readFileSync(join(packageRoot, 'package.json'), 'utf8'));
-        return packageInfo.version || '0.0.0';
-    } catch {
-        return '0.0.0';
-    }
+    return readClientPackageVersion();
 }
 
 function isTruthy(value) {
@@ -2727,6 +2723,8 @@ async function main() {
         return;
     }
 
+    console.log(formatClientVersionBanner());
+
     let connectionPage = null;
     while (true) {
         const prepared = await prepareLoginConnection(parsed, connectionPage);

package/fast/osx-arm64/MindExec.RemoteAgent.Fast/MacSystemAudioCapture.swift

@@ -0,0 +1,213 @@
+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/fast/osx-x64/MindExec.RemoteAgent.Fast/MacSystemAudioCapture.swift

@@ -0,0 +1,213 @@
+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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@livedesk/client",
-  "version": "0.1.118",
+  "version": "0.1.120",
   "description": "LiveDesk local remote client",
   "type": "module",
   "bin": {
@@ -16,7 +16,8 @@
     "THIRD_PARTY_NOTICES.md"
   ],
   "scripts": {
-    "check": "node --check bin/livedesk-client.js && node --check bin/livedesk-client-node.js && node --check bin/livedesk-client-fast.js",
+    "check": "node --check bin/client-version.js && node --check bin/livedesk-client.js && node --check bin/livedesk-client-node.js && node --check bin/livedesk-client-fast.js",
+    "test:version": "node --test tests/client-version.test.mjs",
     "pack:dry": "npm pack --dry-run"
   },
   "keywords": [