@hearthlog/native 0.0.0-stage → 0.1.1

package/swift/macOS/DevTools.swift

@@ -0,0 +1,85 @@
+#if STOR_DEV
+import AppKit
+import WebKit
+
+/// Debugging aids for builds made with `--dev` (never in a release build). Set in the environment:
+///   STOR_ORIGIN           open this origin instead of the site's, for example http://127.0.0.1:5180
+///   STOR_DEV_DELAY        seconds to wait for the page before the steps below (default 6)
+///   STOR_DEV_EVAL         body of an async JavaScript function; its returned string is printed as `EVAL <value>`
+///   STOR_DEV_EVAL_FILE    the same, read from a file
+///   STOR_DEV_NAVIGATE     a route to open through the shell, as the Go menu does
+///   STOR_ACCESS_HOST      treat this host as the Cloudflare Access login
+///   STOR_DEV_CLICK        "x,y;x,y" window points (from the top left) to send a mouse-down to, after the eval
+///   STOR_DEV_LEGACY_PAGE=1   do not define window.storShell, as a page that predates the shell sees it
+///   STOR_DEV_DOWNLOAD_DIR save downloads here without a panel
+///   STOR_DEV_ALLOW_POPUPS=1  let scripts call window.open without a user gesture
+///   STOR_DEV_NO_NOTIFICATIONS=1  do not schedule reminders (that asks for permission); log them instead
+///   STOR_DEV_SETTLE       seconds to wait after the eval before the screenshot (default 0)
+///   STOR_DEV_SCREENSHOT   write a PNG of the window, with its window controls and glass
+///   STOR_DEV_EXIT=1       quit afterwards
+@MainActor
+enum DevTools {
+    static let environment = ProcessInfo.processInfo.environment
+
+    static func log(_ message: String) {
+        print("LOG", message)
+    }
+
+    static func schedule(for controller: MainWindowController) {
+        let environment = Self.environment
+        guard environment["STOR_DEV_EVAL"] != nil || environment["STOR_DEV_EVAL_FILE"] != nil || environment["STOR_DEV_SCREENSHOT"] != nil || environment["STOR_DEV_NAVIGATE"] != nil else { return }
+        let delay = Double(environment["STOR_DEV_DELAY"] ?? "") ?? 6
+        DispatchQueue.main.asyncAfter(deadline: .now() + delay) {
+            Task { @MainActor in
+                if let path = environment["STOR_DEV_NAVIGATE"] {
+                    controller.host.navigate(to: path)
+                    try? await Task.sleep(for: .seconds(1))
+                }
+                let script = environment["STOR_DEV_EVAL"] ?? environment["STOR_DEV_EVAL_FILE"].flatMap { try? String(contentsOfFile: $0, encoding: .utf8) }
+                if let body = script {
+                    do {
+                        let value = try await controller.host.webView.callAsyncJavaScript(body, contentWorld: .page)
+                        print("EVAL", value ?? "nil")
+                    } catch {
+                        print("EVAL error:", error.localizedDescription)
+                    }
+                }
+                if let clicks = environment["STOR_DEV_CLICK"], let window = controller.window {
+                    for (index, spec) in clicks.split(separator: ";").enumerated() {
+                        let parts = spec.split(separator: ",").compactMap { Double($0) }
+                        guard parts.count == 2,
+                              let event = NSEvent.mouseEvent(with: .leftMouseDown, location: NSPoint(x: parts[0], y: window.frame.height - parts[1]), modifierFlags: [], timestamp: ProcessInfo.processInfo.systemUptime, windowNumber: window.windowNumber, context: nil, eventNumber: index + 1, clickCount: 1, pressure: 1)
+                        else { continue }
+                        log("click \(spec)")
+                        window.sendEvent(event)
+                    }
+                }
+                try? await Task.sleep(for: .seconds(Double(environment["STOR_DEV_SETTLE"] ?? "") ?? 0))
+                if let window = controller.window, let close = window.standardWindowButton(.closeButton) {
+                    var chain: [String] = []
+                    var view: NSView? = close
+                    while let current = view { chain.append("\(type(of: current)) \(current.frame)"); view = current.superview }
+                    print("TITLEBAR", chain.joined(separator: " < "))
+                }
+                if let window = controller.window {
+                    let buttons = [NSWindow.ButtonType.closeButton, .miniaturizeButton, .zoomButton].compactMap { window.standardWindowButton($0)?.frame }
+                    print("STATE badge=\(NSApp.dockTile.badgeLabel ?? "none") menus=\((NSApp.delegate as? AppDelegate)?.menuSummary ?? "")")
+                    print("WINDOW key=\(window.isKeyWindow) visible=\(window.isVisible) occluded=\(!window.occlusionState.contains(.visible)) appActive=\(NSApp.isActive) frame=\(window.frame) buttons=\(buttons.map { "\($0.origin.x),\($0.origin.y)" })")
+                }
+                if let path = environment["STOR_DEV_SCREENSHOT"], let window = controller.window {
+                    print("SCREENSHOT", capture(window, to: path) ? path : "failed")
+                }
+                if environment["STOR_DEV_EXIT"] == "1" { exit(0) }
+            }
+        }
+    }
+
+    private static func capture(_ window: NSWindow, to path: String) -> Bool {
+        let options: CGWindowImageOption = [.boundsIgnoreFraming, .bestResolution]
+        guard let image = CGWindowListCreateImage(.null, .optionIncludingWindow, CGWindowID(window.windowNumber), options),
+              let png = NSBitmapImageRep(cgImage: image).representation(using: .png, properties: [:])
+        else { return false }
+        return (try? png.write(to: URL(fileURLWithPath: path))) != nil
+    }
+}
+#endif

package/swift/macOS/MainWindowController.swift

@@ -0,0 +1,206 @@
+import AppKit
+import WebKit
+
+/// One window onto the site. The title bar is hidden and the content runs under it: the page draws
+/// the sidebar, the window's glass shows through it, and the standard window buttons sit on the
+/// sidebar's brand row.
+@MainActor
+final class MainWindowController: NSWindowController, NSWindowDelegate, StorWebHostDelegate {
+    let host: StorWebHost
+    private(set) var pendingUploads = 0
+
+    private unowned let app: AppDelegate
+    private let lights: TrafficLights
+    private var signIn: SignInWindowController?
+    private var titleObservation: NSKeyValueObservation?
+
+    /// Smaller than this the page would switch to its phone layout, which a Mac window never shows.
+    static let minimumSize = NSSize(width: 860, height: 560)
+
+    init(site: SiteConfig, app: AppDelegate, inspectable: Bool, restoresFrame: Bool) {
+        self.app = app
+        let window = StorWindow(
+            contentRect: NSRect(x: 0, y: 0, width: 1280, height: 820),
+            styleMask: [.titled, .closable, .miniaturizable, .resizable, .fullSizeContentView],
+            backing: .buffered,
+            defer: false
+        )
+        window.title = site.title
+        window.titleVisibility = .hidden
+        window.titlebarAppearsTransparent = true
+        window.tabbingMode = .disallowed
+        window.isReleasedWhenClosed = false
+        window.contentMinSize = Self.minimumSize
+
+        host = StorWebHost(site: site, kind: .mac, inspectable: inspectable, lightsWidth: TrafficLights.extent(of: window))
+        lights = TrafficLights(window: window)
+
+        // The glass behind the page, with one canvas tint across the window and a translucent sidebar.
+        let glass = NSVisualEffectView()
+        glass.material = .sidebar
+        glass.blendingMode = .behindWindow
+        glass.state = .followsWindowActiveState
+        host.webView.frame = glass.bounds
+        host.webView.autoresizingMask = [.width, .height]
+        glass.addSubview(host.webView)
+        window.contentView = glass
+        window.pageView = host.webView
+
+        window.center()
+        if restoresFrame { window.setFrameAutosaveName("StorWindow.\(site.id)") }
+
+        super.init(window: window)
+        window.delegate = self
+        host.delegate = self
+        titleObservation = host.webView.observe(\.title, options: [.new]) { [weak window] webView, _ in
+            if let title = webView.title, !title.isEmpty { window?.title = title }
+        }
+    }
+
+    required init?(coder: NSCoder) { fatalError("init(coder:) is not used") }
+
+    override func showWindow(_ sender: Any?) {
+        super.showWindow(sender)
+        lights.apply()
+    }
+
+    // MARK: Window
+
+    func windowDidBecomeKey(_ notification: Notification) { host.setAttribute("data-stor-inactive", false) }
+    func windowDidResignKey(_ notification: Notification) { host.setAttribute("data-stor-inactive", true) }
+    func windowWillEnterFullScreen(_ notification: Notification) { host.setAttribute("data-stor-fullscreen", true) }
+    func windowDidExitFullScreen(_ notification: Notification) {
+        host.setAttribute("data-stor-fullscreen", false)
+        lights.apply()
+    }
+    func windowWillClose(_ notification: Notification) { app.windowClosed(self) }
+
+    // MARK: StorWebHostDelegate
+
+    func host(_ host: StorWebHost, received message: ShellMessage) {
+        switch message {
+        case .lights(let x, let y): lights.move(to: CGPoint(x: x, y: y))
+        case .backgroundHover(let on): (window as? StorWindow)?.backgroundHover = on
+        case .outbox(let pending): pendingUploads = pending
+        case .haptic, .drag: break
+        case .appearance, .badge, .reminders, .menu: app.handle(message)
+        }
+    }
+
+    func host(_ host: StorWebHost, openWindowFor configuration: WKWebViewConfiguration, url: URL) -> WKWebView? {
+        app.openPopup(configuration: configuration, host: host)
+    }
+
+    func host(_ host: StorWebHost, showSignIn url: URL) {
+        #if STOR_DEV
+        DevTools.log("sign-in window for \(url)")
+        #endif
+        if let signIn {
+            signIn.showWindow(nil)
+            return
+        }
+        let controller = SignInWindowController(site: host.site, policy: host.policy, dataStore: host.dataStore, url: url) { [weak self] success in
+            guard let self else { return }
+            self.signIn = nil
+            #if STOR_DEV
+            DevTools.log("sign-in finished success=\(success)")
+            #endif
+            if success { self.host.reloadAfterSignIn() }
+        }
+        signIn = controller
+        controller.showWindow(nil)
+    }
+
+    func host(_ host: StorWebHost, openExternally url: URL) {
+        NSWorkspace.shared.open(url)
+    }
+
+    func host(_ host: StorWebHost, chooseDestinationFor suggestedFilename: String) async -> URL? {
+        #if STOR_DEV
+        // No panel for automated runs.
+        if let directory = DevTools.environment["STOR_DEV_DOWNLOAD_DIR"] {
+            DevTools.log("download \(suggestedFilename)")
+            return URL(fileURLWithPath: directory).appendingPathComponent(suggestedFilename)
+        }
+        #endif
+        let panel = NSSavePanel()
+        panel.nameFieldStringValue = suggestedFilename
+        panel.canCreateDirectories = true
+        return await run(panel) == .OK ? panel.url : nil
+    }
+
+    func host(_ host: StorWebHost, savedDownload url: URL) {
+        #if STOR_DEV
+        DevTools.log("download saved \(url.lastPathComponent)")
+        #endif
+    }
+
+    func host(_ host: StorWebHost, chooseFilesFor parameters: WKOpenPanelParameters) async -> [URL]? {
+        let panel = NSOpenPanel()
+        panel.allowsMultipleSelection = parameters.allowsMultipleSelection
+        panel.canChooseDirectories = parameters.allowsDirectories
+        panel.canChooseFiles = true
+        return await run(panel) == .OK ? panel.urls : nil
+    }
+
+    func host(_ host: StorWebHost, present dialog: JSDialog) async -> JSDialogResult {
+        let alert = NSAlert()
+        alert.messageText = host.site.title
+        var field: NSTextField?
+        switch dialog {
+        case .alert(let message):
+            alert.informativeText = message
+            alert.addButton(withTitle: "OK")
+        case .confirm(let message):
+            alert.informativeText = message
+            alert.addButton(withTitle: "OK")
+            alert.addButton(withTitle: "Cancel")
+        case .prompt(let message, let defaultText):
+            alert.informativeText = message
+            alert.addButton(withTitle: "OK")
+            alert.addButton(withTitle: "Cancel")
+            let input = NSTextField(frame: NSRect(x: 0, y: 0, width: 260, height: 24))
+            input.stringValue = defaultText ?? ""
+            alert.accessoryView = input
+            field = input
+        }
+        let response: NSApplication.ModalResponse
+        if let window { response = await alert.beginSheetModal(for: window) } else { response = alert.runModal() }
+        return response == .alertFirstButtonReturn ? .ok(field?.stringValue) : .cancel
+    }
+
+    /// Shows a save or open panel as a sheet on this window.
+    private func run(_ panel: NSSavePanel) async -> NSApplication.ModalResponse {
+        if let window { return await panel.beginSheetModal(for: window) }
+        return await panel.begin()
+    }
+}
+
+/// A window the page opened itself, such as a PDF in its own viewer. It shares the site's data store
+/// and follows the same navigation rules as the main window.
+@MainActor
+final class PopupWindowController: NSWindowController, NSWindowDelegate {
+    private let onClose: (PopupWindowController) -> Void
+
+    init(webView: WKWebView, title: String, onClose: @escaping (PopupWindowController) -> Void) {
+        self.onClose = onClose
+        let window = NSWindow(
+            contentRect: NSRect(x: 0, y: 0, width: 920, height: 1040),
+            styleMask: [.titled, .closable, .miniaturizable, .resizable],
+            backing: .buffered,
+            defer: false
+        )
+        window.title = title
+        window.isReleasedWhenClosed = false
+        webView.frame = NSRect(origin: .zero, size: window.contentLayoutRect.size)
+        webView.autoresizingMask = [.width, .height]
+        window.contentView = webView
+        window.center()
+        super.init(window: window)
+        window.delegate = self
+    }
+
+    required init?(coder: NSCoder) { fatalError("init(coder:) is not used") }
+
+    func windowWillClose(_ notification: Notification) { onClose(self) }
+}

package/swift/macOS/SignInWindowController.swift

@@ -0,0 +1,60 @@
+import AppKit
+import WebKit
+
+/// The Cloudflare Access login, in its own window. It shares the app's data store, so the session
+/// cookie Access sets is the one the app's web view sends. The window closes itself as soon as
+/// Access sends the person back to the app.
+@MainActor
+final class SignInWindowController: NSWindowController, NSWindowDelegate, WKNavigationDelegate {
+    private let policy: NavigationPolicy
+    private let webView: WKWebView
+    private let onFinished: (Bool) -> Void
+    private var finished = false
+
+    init(site: SiteConfig, policy: NavigationPolicy, dataStore: WKWebsiteDataStore, url: URL, onFinished: @escaping (Bool) -> Void) {
+        self.policy = policy
+        self.onFinished = onFinished
+
+        let configuration = WKWebViewConfiguration()
+        configuration.websiteDataStore = dataStore
+        webView = WKWebView(frame: .zero, configuration: configuration)
+
+        let window = NSWindow(
+            contentRect: NSRect(x: 0, y: 0, width: 480, height: 700),
+            styleMask: [.titled, .closable, .miniaturizable],
+            backing: .buffered,
+            defer: false
+        )
+        window.title = "Sign in to \(site.title)"
+        window.isReleasedWhenClosed = false
+        window.contentView = webView
+        window.center()
+        super.init(window: window)
+
+        window.delegate = self
+        webView.navigationDelegate = self
+        webView.load(URLRequest(url: url))
+    }
+
+    required init?(coder: NSCoder) { fatalError("init(coder:) is not used") }
+
+    func webView(_ webView: WKWebView, decidePolicyFor navigationAction: WKNavigationAction) async -> WKNavigationActionPolicy {
+        let url = navigationAction.request.url
+        if policy.finishesSignIn(url) {
+            finish(success: true)
+            return .cancel
+        }
+        return policy.allowsSignIn(url) ? .allow : .cancel
+    }
+
+    func windowWillClose(_ notification: Notification) {
+        finish(success: false)
+    }
+
+    private func finish(success: Bool) {
+        guard !finished else { return }
+        finished = true
+        onFinished(success)
+        if success { close() }
+    }
+}

package/swift/macOS/StorWindow.swift

@@ -0,0 +1,48 @@
+import AppKit
+
+/// The Mac window. A click on a background of the page (the shell's script reports when the pointer is
+/// over one) moves the window. The mouse-down has to be handled here, before any view sees it and with
+/// the very event that started it: a drag started later, from a message, is not reliable.
+@MainActor
+final class StorWindow: NSWindow {
+    /// Set from the page: the pointer is over something that is not a control, text or a graphic.
+    var backgroundHover = false
+    /// The web view; only clicks that land inside it can be background clicks, so the window buttons
+    /// and the native title bar strip keep behaving as they do in any Mac window.
+    weak var pageView: NSView?
+
+    override func sendEvent(_ event: NSEvent) {
+        if event.type == .leftMouseDown, backgroundHover, startsBackgroundDrag(event) { return }
+        super.sendEvent(event)
+    }
+
+    private func startsBackgroundDrag(_ event: NSEvent) -> Bool {
+        #if STOR_DEV
+        if let frameView = contentView?.superview {
+            let hit = frameView.hitTest(event.locationInWindow)
+            var chain: [String] = []
+            var view = hit
+            while let current = view, chain.count < 8 { chain.append(String(describing: type(of: current))); view = current.superview }
+            DevTools.log("hit \(chain.joined(separator: " < ")) inPage=\(hit?.isDescendant(of: pageView ?? frameView) == true) frameView=\(type(of: frameView))")
+        }
+        #endif
+        // Modified clicks are the page's (selection, context menus).
+        guard event.modifierFlags.intersection([.control, .option, .command, .shift]).isEmpty,
+              let pageView, let frameView = contentView?.superview,
+              frameView.hitTest(event.locationInWindow)?.isDescendant(of: pageView) == true
+        else { return false }
+        #if STOR_DEV
+        DevTools.log("background mouse-down clickCount=\(event.clickCount)")
+        #endif
+        if event.clickCount >= 2 {
+            switch UserDefaults.standard.string(forKey: "AppleActionOnDoubleClick") {
+            case "Minimize": miniaturize(nil)
+            case "None": break
+            default: zoom(nil)
+            }
+        } else {
+            performDrag(with: event)
+        }
+        return true
+    }
+}

package/swift/macOS/TrafficLights.swift

@@ -0,0 +1,115 @@
+import AppKit
+
+/// Places the standard window buttons where the page's sidebar reserved room for them. The page
+/// reports that spot (`[data-stor-lights]`), so the layout decides it and it follows the sidebar.
+@MainActor
+final class TrafficLights {
+    /// Before the page reports: the expanded sidebar's brand row.
+    static let fallback = CGPoint(x: 26, y: 38)
+
+    private weak var window: NSWindow?
+    private var anchor = TrafficLights.fallback
+    private let buttonSpacing: CGFloat
+    private var observers: [NSObjectProtocol] = []
+    private var applyScheduled = false
+    private var isApplying = false
+
+    init(window: NSWindow) {
+        self.window = window
+        // Keep AppKit's original spacing: a frame notification may arrive while only one button
+        // has been reset, so measuring the partly updated group would give the wrong spacing.
+        if let close = window.standardWindowButton(.closeButton),
+           let miniaturize = window.standardWindowButton(.miniaturizeButton) {
+            buttonSpacing = miniaturize.frame.minX - close.frame.minX
+        } else {
+            buttonSpacing = 20
+        }
+        let center = NotificationCenter.default
+        // AppKit lays the buttons out again on these, so put them back each time.
+        for name in [NSWindow.didResizeNotification, NSWindow.didEndLiveResizeNotification,
+                     NSWindow.didExitFullScreenNotification, NSWindow.didBecomeKeyNotification,
+                     NSWindow.didResignKeyNotification] {
+            observers.append(center.addObserver(forName: name, object: window, queue: .main) { [weak self] _ in
+                MainActor.assumeIsolated {
+                    if name == NSWindow.didResizeNotification {
+                        // AppKit has finished this resize's layout. Restore the group before it
+                        // is displayed; queued work can wait until the mouse is released.
+                        self?.apply()
+                    } else {
+                        self?.scheduleApply()
+                    }
+                }
+            })
+        }
+        let close = window.standardWindowButton(.closeButton)
+        // Focus changes can reset just the buttons without changing their container's frame.
+        let views: [NSView?] = [close, window.standardWindowButton(.miniaturizeButton),
+                               window.standardWindowButton(.zoomButton), close?.superview,
+                               close?.superview?.superview]
+        for view in views.compactMap({ $0 }) {
+            view.postsFrameChangedNotifications = true
+            observers.append(center.addObserver(forName: NSView.frameDidChangeNotification, object: view, queue: .main) { [weak self] _ in
+                MainActor.assumeIsolated { self?.scheduleApply() }
+            })
+        }
+    }
+
+    deinit {
+        observers.forEach(NotificationCenter.default.removeObserver)
+    }
+
+    /// Width the three buttons take, so the page can leave exactly that much room. Spacing differs between macOS versions.
+    static func extent(of window: NSWindow) -> CGFloat {
+        guard let close = window.standardWindowButton(.closeButton),
+              let zoom = window.standardWindowButton(.zoomButton)
+        else { return 62 }
+        let width = zoom.frame.maxX - close.frame.minX
+        return width >= 40 ? ceil(width) : 62
+    }
+
+    func move(to anchor: CGPoint) {
+        self.anchor = anchor
+        apply()
+    }
+
+    private func scheduleApply() {
+        guard !isApplying, !applyScheduled else { return }
+        applyScheduled = true
+        // Finish the current AppKit layout before moving the group; never move one button back
+        // synchronously while AppKit is still resetting the others.
+        DispatchQueue.main.async { [weak self] in
+            guard let self else { return }
+            self.applyScheduled = false
+            self.apply()
+        }
+    }
+
+    func apply() {
+        guard !isApplying, let window, !window.styleMask.contains(.fullScreen),
+              let close = window.standardWindowButton(.closeButton),
+              let miniaturize = window.standardWindowButton(.miniaturizeButton),
+              let zoom = window.standardWindowButton(.zoomButton),
+              let container = close.superview
+        else { return }
+        isApplying = true
+        defer { isApplying = false }
+        let step = buttonSpacing
+        // macOS only hit-tests a view inside its container, so a button moved below the title bar would stop
+        // working. Grow the title bar container to hold them, and only as wide as they are, so the page's
+        // own controls along the top edge stay reachable.
+        if let titlebarView = close.superview, let titlebarContainer = titlebarView.superview, titlebarContainer !== window.contentView?.superview {
+            let height = ceil(anchor.y + close.frame.height)
+            let width = ceil(anchor.x + 2 * step + close.frame.width + 12)
+            let frame = NSRect(x: 0, y: window.frame.height - height, width: width, height: height)
+            if titlebarContainer.frame != frame { titlebarContainer.frame = frame }
+            if titlebarView.frame != titlebarContainer.bounds { titlebarView.frame = titlebarContainer.bounds }
+        }
+        // The page measures from the window's top; window coordinates start at the bottom.
+        let centerY = window.frame.height - anchor.y
+        for (index, button) in [close, miniaturize, zoom].enumerated() {
+            let point = container.convert(NSPoint(x: anchor.x + CGFloat(index) * step, y: centerY), from: nil)
+            let origin = NSPoint(x: point.x, y: point.y - button.frame.height / 2)
+            if button.frame.origin != origin { button.setFrameOrigin(origin) }
+        }
+    }
+}

package/swift/macOS/main.swift

@@ -0,0 +1,9 @@
+import AppKit
+
+MainActor.assumeIsolated {
+    let application = NSApplication.shared
+    let delegate = AppDelegate()
+    application.delegate = delegate
+    application.setActivationPolicy(.regular)
+    application.run()
+}

package/README.md

@@ -1,3 +0,0 @@
-# Temporary Holding Version
-
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.