import ScreenCaptureKit import CoreGraphics import ImageIO import UniformTypeIdentifiers import AppKit // NSScreen only, to read backingScaleFactor as a fallback import Foundation public struct CapturedImage: Sendable { public let pngData: Data public let pixelWidth: Int public let pixelHeight: Int public let scale: CGFloat } public struct ScreenCapturer: Sendable { public init() {} /// Does NOT prompt. Reports the current Screen Recording grant. public static var isScreenRecordingGranted: Bool { CGPreflightScreenCaptureAccess() } /// Captures whatever the given scope points at, resolving it right now. public func capture( _ scope: CaptureScope, savedArea: CaptureRegion? ) async throws -> CapturedImage { guard Self.isScreenRecordingGranted else { throw ShotdeckError.screenRecordingNotGranted } let frontmostPID = NSWorkspace.shared.frontmostApplication?.processIdentifier ?? 0 let target = try CaptureTargetResolver.resolve( scope: scope, savedArea: savedArea, frontmostPID: frontmostPID, candidates: Self.onScreenWindows() ) return try await capture(target) } /// Captures one resolved target. A window is captured window-only (so an overlapping /// window never ends up in a review shot); a region or a display goes through the /// display path. public func capture(_ target: CaptureTarget) async throws -> CapturedImage { guard Self.isScreenRecordingGranted else { throw ShotdeckError.screenRecordingNotGranted } switch target { case .region(let region): return try await capture(region) case .display(let displayID): let bounds = CGDisplayBounds(displayID) return try await capture( CaptureRegion( displayID: displayID, rect: bounds, capturedScale: Self.backingScale(for: displayID))) case .window(let windowID, let frame, let displayID): return try await captureWindow( windowID: windowID, frame: frame, displayID: displayID) } } /// On-screen windows, front-most first, as plain data for the resolver. public static func onScreenWindows() -> [WindowCandidate] { guard let raw = CGWindowListCopyWindowInfo( [.optionOnScreenOnly, .excludeDesktopElements], kCGNullWindowID ) as? [[String: Any]] else { return [] } return raw.compactMap { entry in guard let windowID = (entry[kCGWindowNumber as String] as? NSNumber)?.uint32Value, let ownerPID = (entry[kCGWindowOwnerPID as String] as? NSNumber)?.int32Value, let boundsDict = entry[kCGWindowBounds as String] as? [String: Any], let layer = (entry[kCGWindowLayer as String] as? NSNumber)?.intValue else { return nil } let frame = CGRect( x: boundsDict["X"] as? Double ?? 0, y: boundsDict["Y"] as? Double ?? 0, width: boundsDict["Width"] as? Double ?? 0, height: boundsDict["Height"] as? Double ?? 0 ) return WindowCandidate( windowID: windowID, ownerBundleID: bundleIdentifier(forPID: ownerPID), ownerPID: ownerPID, frame: frame, layer: layer ) } } private static func bundleIdentifier(forPID pid: Int32) -> String? { NSRunningApplication(processIdentifier: pid)?.bundleIdentifier } private static func backingScale(for displayID: UInt32) -> CGFloat { guard let mode = CGDisplayCopyDisplayMode(displayID), mode.width > 0 else { return 2 } return CGFloat(mode.pixelWidth) / CGFloat(mode.width) } /// Captures a single window through ScreenCaptureKit's window filter, at the display's /// backing scale, without the window server compositing anything on top of it. private func captureWindow( windowID: UInt32, frame: CGRect, displayID: UInt32 ) async throws -> CapturedImage { let content: SCShareableContent do { content = try await SCShareableContent.excludingDesktopWindows( false, onScreenWindowsOnly: true) } catch { throw ShotdeckError.captureFailed(underlying: error.localizedDescription) } guard let window = content.windows.first(where: { $0.windowID == windowID }) else { throw ShotdeckError.noFrontWindow } let scale = Self.backingScale(for: displayID) let filter = SCContentFilter(desktopIndependentWindow: window) let configuration = SCStreamConfiguration() configuration.width = Int((frame.width * scale).rounded()) configuration.height = Int((frame.height * scale).rounded()) configuration.showsCursor = false configuration.scalesToFit = false let cgImage: CGImage do { cgImage = try await SCScreenshotManager.captureImage( contentFilter: filter, configuration: configuration) } catch { throw ShotdeckError.captureFailed(underlying: error.localizedDescription) } let data = NSMutableData() guard let dest = CGImageDestinationCreateWithData( data, UTType.png.identifier as CFString, 1, nil ) else { throw ShotdeckError.captureFailed(underlying: "could not create PNG image destination") } CGImageDestinationAddImage(dest, cgImage, nil) guard CGImageDestinationFinalize(dest) else { throw ShotdeckError.captureFailed(underlying: "PNG encoding failed to finalize") } return CapturedImage( pngData: data as Data, pixelWidth: cgImage.width, pixelHeight: cgImage.height, scale: scale ) } /// Captures `region` at the display's true backing scale. Throws /// `.screenRecordingNotGranted` when the grant is absent — never requests it. public func capture(_ region: CaptureRegion) async throws -> CapturedImage { guard Self.isScreenRecordingGranted else { throw ShotdeckError.screenRecordingNotGranted } let content: SCShareableContent do { content = try await SCShareableContent.excludingDesktopWindows( false, onScreenWindowsOnly: true ) } catch { throw ShotdeckError.captureFailed(underlying: error.localizedDescription) } guard let display = content.displays.first(where: { $0.displayID == region.displayID }) else { throw ShotdeckError.displayNoLongerConnected(displayID: region.displayID) } // Bounds/clamp: a resolution change often shrinks the display bounds by a few // points without the region Ben picked being meaningfully wrong; 80% keeps a real // recapture usable while a smaller overlap (e.g. a genuinely different display // swapped in) still throws. let rect: CGRect if display.frame.contains(region.rect) { rect = region.rect } else { let overlap = display.frame.intersection(region.rect) let originalArea = region.rect.width * region.rect.height let overlapArea = overlap.width * overlap.height if originalArea > 0 && overlapArea / originalArea >= 0.8 { rect = overlap } else { throw ShotdeckError.displayNoLongerConnected(displayID: region.displayID) } } let localRect = CGRect( x: rect.minX - display.frame.minX, y: rect.minY - display.frame.minY, width: rect.width, height: rect.height ) guard let mode = CGDisplayCopyDisplayMode(region.displayID) else { throw ShotdeckError.captureFailed( underlying: "no display mode for displayID \(region.displayID)" ) } guard mode.width > 0 else { throw ShotdeckError.captureFailed( underlying: "display mode width is 0 for displayID \(region.displayID)" ) } let scale = CGFloat(mode.pixelWidth) / CGFloat(mode.width) let filter = SCContentFilter(display: display, excludingWindows: []) let configuration = SCStreamConfiguration() configuration.sourceRect = localRect configuration.width = Int((localRect.width * scale).rounded()) configuration.height = Int((localRect.height * scale).rounded()) configuration.scalesToFit = false configuration.showsCursor = false let cgImage: CGImage do { cgImage = try await SCScreenshotManager.captureImage( contentFilter: filter, configuration: configuration ) } catch { throw ShotdeckError.captureFailed(underlying: error.localizedDescription) } let data = NSMutableData() guard let dest = CGImageDestinationCreateWithData( data, UTType.png.identifier as CFString, 1, nil ) else { throw ShotdeckError.captureFailed(underlying: "could not create PNG image destination") } CGImageDestinationAddImage(dest, cgImage, nil) guard CGImageDestinationFinalize(dest) else { throw ShotdeckError.captureFailed(underlying: "PNG encoding failed to finalize") } return CapturedImage( pngData: data as Data, pixelWidth: cgImage.width, pixelHeight: cgImage.height, scale: scale ) } }