sneakoscope 7.3.0 → 7.6.0

package/dist/native/sks-menubar/Sources/TelegramHubSupervisor.swift

@@ -0,0 +1,469 @@
+import Cocoa
+import Darwin
+
+struct TelegramHubServiceSnapshot: Equatable {
+    let running: Bool
+    let receiveReady: Bool
+    let mode: String?
+    let pid: Int32?
+
+    var verifiedDirectPID: Int32? {
+        guard running, mode == "direct" else { return nil }
+        return pid
+    }
+}
+
+final class TelegramHubSupervisor {
+    private static let failureStore = TelegramHubStartupFailureStore()
+
+    static var latestStartupFailureMessage: String? {
+        failureStore.message
+    }
+
+    private let processClient: ProcessClient
+    private let actionScript: String
+    private let projectRoot: String
+    private var process: Process?
+    private var generation = 0
+    private var intentionalStop = false
+    private var startupReady = false
+    private var startupRetryCount = 0
+    private var startupTerminationReason: String?
+    private var unexpectedRestartCount = 0
+    private let predecessorWaitDelays: [TimeInterval] = [0.25, 0.5, 1, 1, 2, 2]
+    private let startupProbeDelays: [TimeInterval] = [0.25, 0.5, 1, 1, 2, 2, 3, 3]
+    private let startupRetryDelays: [TimeInterval] = [0.5, 1.5, 3]
+    private let restartDelays: [TimeInterval] = [1, 5, 15]
+
+    init(processClient: ProcessClient, actionScript: String, projectRoot: String) {
+        self.processClient = processClient
+        self.actionScript = actionScript
+        self.projectRoot = projectRoot
+    }
+
+    func startIfConfigured() {
+        let environment = ProcessInfo.processInfo.environment
+        let home = FileManager.default.homeDirectoryForCurrentUser
+        let globalRoot = environment["SKS_GLOBAL_ROOT"].map { URL(fileURLWithPath: $0, isDirectory: true) }
+            ?? home.appendingPathComponent(".sneakoscope-global", isDirectory: true)
+        let config = globalRoot
+            .appendingPathComponent("telegram", isDirectory: true)
+            .appendingPathComponent("config.json")
+        guard FileManager.default.fileExists(atPath: config.path) else { return }
+        start()
+    }
+
+    func start(completion: ((Bool) -> Void)? = nil) {
+        onMain {
+            self.unexpectedRestartCount = 0
+            self.startupRetryCount = 0
+            self.beginStart(completion: completion)
+        }
+    }
+
+    func stop(completion: ((Bool) -> Void)? = nil) {
+        onMain {
+            self.generation += 1
+            self.intentionalStop = true
+            self.startupReady = false
+            self.startupTerminationReason = nil
+            Self.failureStore.message = nil
+            let requestGeneration = self.generation
+            self.terminateOwnedProcess { ownedStopped in
+                guard self.generation == requestGeneration else { return }
+                self.stopLaunchAgent { result in
+                    guard self.generation == requestGeneration else { return }
+                    self.intentionalStop = false
+                    completion?(ownedStopped && result.stopped)
+                }
+            }
+        }
+    }
+
+    func restart(completion: ((Bool) -> Void)? = nil) {
+        stop { [weak self] stopped in
+            guard let self = self, stopped else {
+                completion?(false)
+                return
+            }
+            self.start(completion: completion)
+        }
+    }
+
+    func shutdown() {
+        onMain {
+            self.generation += 1
+            self.intentionalStop = true
+            self.startupReady = false
+            self.startupTerminationReason = nil
+            guard let process = self.process, process.isRunning else { return }
+            let pid = process.processIdentifier
+            process.terminate()
+            DispatchQueue.global(qos: .utility).asyncAfter(deadline: .now() + 2) {
+                if process.isRunning { Darwin.kill(pid, SIGKILL) }
+            }
+        }
+    }
+
+    private func beginStart(completion: ((Bool) -> Void)?) {
+        if process?.isRunning == true {
+            completion?(startupReady)
+            return
+        }
+        generation += 1
+        intentionalStop = false
+        startupReady = false
+        startupTerminationReason = nil
+        let requestGeneration = generation
+        stopLaunchAgent { [weak self] result in
+            guard let self = self, self.generation == requestGeneration else { return }
+            if result.stopped {
+                self.waitForVerifiedPredecessorRelease(
+                    generation: requestGeneration,
+                    attempt: 0,
+                    completion: completion
+                )
+                return
+            }
+            if result.snapshot?.verifiedDirectPID != nil {
+                self.waitForVerifiedPredecessorRelease(
+                    generation: requestGeneration,
+                    attempt: 0,
+                    completion: completion
+                )
+                return
+            }
+            self.finishStartupFailure("telegram_hub_launch_agent_stop_failed", completion: completion)
+        }
+    }
+
+    private func waitForVerifiedPredecessorRelease(
+        generation requestGeneration: Int,
+        attempt: Int,
+        completion: ((Bool) -> Void)?
+    ) {
+        hubStatus { [weak self] _, snapshot in
+            guard let self = self, self.generation == requestGeneration else { return }
+            guard snapshot?.verifiedDirectPID != nil else {
+                self.launchDirect(generation: requestGeneration, completion: completion)
+                return
+            }
+            guard attempt < self.predecessorWaitDelays.count else {
+                self.finishStartupFailure("telegram_hub_predecessor_handoff_timeout", completion: completion)
+                return
+            }
+            let delay = self.predecessorWaitDelays[attempt]
+            DispatchQueue.main.asyncAfter(deadline: .now() + delay) { [weak self] in
+                guard let self = self,
+                      self.generation == requestGeneration,
+                      !self.intentionalStop else { return }
+                self.waitForVerifiedPredecessorRelease(
+                    generation: requestGeneration,
+                    attempt: attempt + 1,
+                    completion: completion
+                )
+            }
+        }
+    }
+
+    private func launchDirect(generation requestGeneration: Int, completion: ((Bool) -> Void)?) {
+        let process = Process()
+        let output = Pipe()
+        process.executableURL = URL(fileURLWithPath: actionScript)
+        process.arguments = [
+            "telegram", "hub", "run",
+            "--project-root", projectRoot,
+            "--center-supervised",
+            "--center-supervisor-pid", String(getpid()),
+            "--json"
+        ]
+        process.currentDirectoryURL = FileManager.default.homeDirectoryForCurrentUser
+        process.standardInput = FileHandle.nullDevice
+        process.standardOutput = output
+        process.standardError = output
+        process.terminationHandler = { [weak self, weak process] _ in
+            DispatchQueue.global(qos: .utility).async {
+                let data = output.fileHandleForReading.readDataToEndOfFile()
+                let bounded = Data(data.suffix(32 * 1024))
+                let text = String(data: bounded, encoding: .utf8) ?? ""
+                DispatchQueue.main.async {
+                    guard let self = self,
+                          let process = process,
+                          self.process === process,
+                          self.generation == requestGeneration else { return }
+                    self.handleDirectTermination(
+                        output: text,
+                        generation: requestGeneration,
+                        completion: completion
+                    )
+                }
+            }
+        }
+        do {
+            try process.run()
+            output.fileHandleForWriting.closeFile()
+            self.process = process
+            pollStartupReadiness(
+                for: process,
+                generation: requestGeneration,
+                attempt: 0,
+                completion: completion
+            )
+        } catch {
+            finishOrRetryStartup(
+                reason: "telegram_hub_process_launch_failed",
+                generation: requestGeneration,
+                completion: completion
+            )
+        }
+    }
+
+    private func pollStartupReadiness(
+        for process: Process,
+        generation requestGeneration: Int,
+        attempt: Int,
+        completion: ((Bool) -> Void)?
+    ) {
+        guard self.process === process, process.isRunning else { return }
+        hubStatus { [weak self, weak process] _, snapshot in
+            guard let self = self,
+                  let process = process,
+                  self.process === process,
+                  self.generation == requestGeneration,
+                  process.isRunning else { return }
+            if snapshot?.running == true,
+               snapshot?.receiveReady == true,
+               snapshot?.mode == "direct",
+               snapshot?.pid == process.processIdentifier {
+                self.startupReady = true
+                self.startupRetryCount = 0
+                Self.failureStore.message = nil
+                completion?(true)
+                DispatchQueue.main.asyncAfter(deadline: .now() + 60) { [weak self, weak process] in
+                    guard let self = self,
+                          let process = process,
+                          self.process === process,
+                          process.isRunning else { return }
+                    self.unexpectedRestartCount = 0
+                }
+                return
+            }
+            guard attempt < self.startupProbeDelays.count else {
+                self.startupTerminationReason = "telegram_hub_startup_timeout"
+                self.terminateOwnedStartupProcess(process)
+                return
+            }
+            let delay = self.startupProbeDelays[attempt]
+            DispatchQueue.main.asyncAfter(deadline: .now() + delay) { [weak self, weak process] in
+                guard let self = self,
+                      let process = process,
+                      self.process === process,
+                      self.generation == requestGeneration,
+                      process.isRunning else { return }
+                self.pollStartupReadiness(
+                    for: process,
+                    generation: requestGeneration,
+                    attempt: attempt + 1,
+                    completion: completion
+                )
+            }
+        }
+    }
+
+    private func handleDirectTermination(
+        output: String,
+        generation requestGeneration: Int,
+        completion: ((Bool) -> Void)?
+    ) {
+        process = nil
+        let wasReady = startupReady
+        startupReady = false
+        let forcedReason = startupTerminationReason
+        startupTerminationReason = nil
+        guard !intentionalStop else { return }
+        if wasReady {
+            scheduleUnexpectedRestart(after: requestGeneration)
+            return
+        }
+        let reason = forcedReason ?? Self.startupFailureReason(output: output)
+        finishOrRetryStartup(reason: reason, generation: requestGeneration, completion: completion)
+    }
+
+    private func finishOrRetryStartup(
+        reason: String,
+        generation requestGeneration: Int,
+        completion: ((Bool) -> Void)?
+    ) {
+        guard Self.retryableStartupFailure(reason),
+              startupRetryCount < startupRetryDelays.count else {
+            finishStartupFailure(reason, completion: completion)
+            return
+        }
+        let delay = startupRetryDelays[startupRetryCount]
+        startupRetryCount += 1
+        DispatchQueue.main.asyncAfter(deadline: .now() + delay) { [weak self] in
+            guard let self = self,
+                  self.generation == requestGeneration,
+                  !self.intentionalStop,
+                  self.process?.isRunning != true else { return }
+            self.beginStart(completion: completion)
+        }
+    }
+
+    private func finishStartupFailure(_ reason: String, completion: ((Bool) -> Void)?) {
+        Self.failureStore.message = Self.startupFailureMessage(for: reason)
+        completion?(false)
+    }
+
+    private func scheduleUnexpectedRestart(after requestGeneration: Int) {
+        guard unexpectedRestartCount < restartDelays.count else {
+            finishStartupFailure("telegram_hub_unexpected_exit", completion: nil)
+            return
+        }
+        let delay = restartDelays[unexpectedRestartCount]
+        unexpectedRestartCount += 1
+        DispatchQueue.main.asyncAfter(deadline: .now() + delay) { [weak self] in
+            guard let self = self,
+                  self.generation == requestGeneration,
+                  !self.intentionalStop,
+                  self.process?.isRunning != true else { return }
+            self.startupRetryCount = 0
+            self.beginStart(completion: nil)
+        }
+    }
+
+    private func terminateOwnedStartupProcess(_ process: Process) {
+        guard self.process === process, process.isRunning else { return }
+        let pid = process.processIdentifier
+        process.terminate()
+        DispatchQueue.global(qos: .utility).asyncAfter(deadline: .now() + 2) {
+            if process.isRunning { Darwin.kill(pid, SIGKILL) }
+        }
+    }
+
+    private func terminateOwnedProcess(completion: @escaping (Bool) -> Void) {
+        guard let process = process, process.isRunning else {
+            self.process = nil
+            completion(true)
+            return
+        }
+        self.process = nil
+        let pid = process.processIdentifier
+        process.terminationHandler = { _ in DispatchQueue.main.async { completion(true) } }
+        process.terminate()
+        DispatchQueue.global(qos: .utility).asyncAfter(deadline: .now() + 2) {
+            if process.isRunning { Darwin.kill(pid, SIGKILL) }
+        }
+    }
+
+    private func stopLaunchAgent(completion: @escaping (TelegramHubStopResult) -> Void) {
+        processClient.run(
+            ["telegram", "hub", "stop", "--project-root", projectRoot, "--json"],
+            timeout: 12,
+            maxOutputBytes: 32 * 1024,
+            logOutput: false
+        ) { result in
+            completion(TelegramHubStopResult(
+                stopped: result.code == 0,
+                snapshot: Self.serviceSnapshot(from: result.output)
+            ))
+        }
+    }
+
+    private func hubStatus(completion: @escaping (ProcessResult, TelegramHubServiceSnapshot?) -> Void) {
+        processClient.run(
+            ["telegram", "hub", "status", "--project-root", projectRoot, "--json"],
+            timeout: 5,
+            maxOutputBytes: 32 * 1024,
+            logOutput: false
+        ) { result in
+            completion(result, Self.serviceSnapshot(from: result.output))
+        }
+    }
+
+    static func serviceSnapshot(from output: String) -> TelegramHubServiceSnapshot? {
+        guard let data = output.data(using: .utf8),
+              let value = try? JSONSerialization.jsonObject(with: data) as? [String: Any],
+              value["schema"] as? String == "sks.telegram-hub-service.v1" else { return nil }
+        let pid = (value["pid"] as? NSNumber)?.int32Value
+        return TelegramHubServiceSnapshot(
+            running: value["running"] as? Bool == true,
+            receiveReady: value["receive_ready"] as? Bool == true,
+            mode: value["mode"] as? String,
+            pid: pid.flatMap { $0 > 0 ? $0 : nil }
+        )
+    }
+
+    static func startupFailureReason(output: String) -> String {
+        if output.contains("telegram_owner_conflict") { return "telegram_hub_owner_conflict" }
+        if output.contains("telegram_409_conflict") { return "telegram_hub_external_poller_conflict" }
+        if output.contains("telegram_api_timeout")
+            || output.contains("telegram_api_transport_failed")
+            || output.contains("telegram_poll_failed") {
+            return "telegram_hub_network_unavailable"
+        }
+        if output.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty {
+            return "telegram_hub_empty_startup_output"
+        }
+        return "telegram_hub_startup_failed"
+    }
+
+    static func retryableStartupFailure(_ reason: String) -> Bool {
+        [
+            "telegram_hub_owner_conflict",
+            "telegram_hub_external_poller_conflict",
+            "telegram_hub_network_unavailable",
+            "telegram_hub_startup_timeout",
+            "telegram_hub_empty_startup_output"
+        ].contains(reason)
+    }
+
+    static func startupFailureMessage(for reason: String) -> String {
+        switch reason {
+        case "telegram_hub_predecessor_handoff_timeout":
+            return "The previous Center-supervised Telegram Hub is still shutting down. Wait a few seconds, then retry. Center did not terminate an unverified owner."
+        case "telegram_hub_owner_conflict":
+            return "Another Telegram Hub still owns this bot. Stop that Hub, then retry. Center did not terminate the other owner."
+        case "telegram_hub_external_poller_conflict":
+            return "Telegram reports another active poller for this bot. Stop the other poller, then retry."
+        case "telegram_hub_network_unavailable":
+            return "Telegram Hub could not reach the Telegram API after bounded retries. Check the network, then retry."
+        case "telegram_hub_startup_timeout":
+            return "Telegram Hub did not become ready before the bounded startup deadline. Check Telegram connectivity, then retry."
+        case "telegram_hub_launch_agent_stop_failed":
+            return "The legacy Telegram Hub service could not be stopped safely. Open Diagnostics, resolve the service error, then retry."
+        case "telegram_hub_process_launch_failed":
+            return "Telegram Hub could not launch. Open Diagnostics, confirm the SKS runtime is available, then retry."
+        default:
+            return "Telegram Hub startup failed. Open Diagnostics, resolve the reported Telegram error, then retry."
+        }
+    }
+
+    private func onMain(_ work: @escaping () -> Void) {
+        if Thread.isMainThread { work() }
+        else { DispatchQueue.main.async(execute: work) }
+    }
+}
+
+private struct TelegramHubStopResult {
+    let stopped: Bool
+    let snapshot: TelegramHubServiceSnapshot?
+}
+
+private final class TelegramHubStartupFailureStore: @unchecked Sendable {
+    private let lock = NSLock()
+    private var value: String?
+
+    var message: String? {
+        get {
+            lock.lock()
+            defer { lock.unlock() }
+            return value
+        }
+        set {
+            lock.lock()
+            value = newValue
+            lock.unlock()
+        }
+    }
+}

package/dist/native/sks-menubar/Sources/UpdatesViewController.swift

@@ -34,7 +34,7 @@ final class UpdatesViewController: NSViewController, ControlCenterPage {
         checkButton = NativeView.button("Check Now", target: self, action: #selector(checkNow))
         codexUpdateButton = NativeView.button("Update Codex CLI", target: self, action: #selector(updateCodexCLI))
         codexUpdateButton.setAccessibilityHelp("Update the operator Codex CLI using its verified installation method.")
-        reviewButton = ControlKit.primaryButton("Review and Update", target: self, action: #selector(reviewAndUpdate))
+        reviewButton = ControlKit.primaryButton("Review and Update", target: self, action: #selector(reviewAndUpdate), isDefault: true)
         reviewButton.setAccessibilityHelp("Review the staged update first, then confirm before anything is installed.")
         codexUpdateStatus.setAccessibilityLabel("Codex CLI update result")
         let buttons = NSStackView(views: [checkButton, codexUpdateButton, reviewButton, progress])
@@ -46,17 +46,12 @@ final class UpdatesViewController: NSViewController, ControlCenterPage {
             NativeView.card(title: "Progress", subtitle: "Authoritative stage checklist from the update receipt.", views: [stageStatus]),
             NativeView.card(title: "Recovery", subtitle: "Rollback guidance and the previous Menu Bar app remain available if final verification fails. The update receipt records the exact recovery command and stage state.", views: [remediation])
         ])
-        loadCached()
     }
 
     deinit { receiptTimer?.invalidate() }
 
     func refreshOnAppear() { reloadSnapshot() }
 
-    private func loadCached() {
-        reloadSnapshot()
-    }
-
     private func setBusy(_ value: Bool) {
         busy = value
         checkButton?.isEnabled = !value

package/dist/native/sks-menubar/Tests/AppRuntimeTestSupport.swift

@@ -0,0 +1,12 @@
+#if SKS_NATIVE_TESTING
+enum AppRuntime {
+    static let actionScript = "/tmp/sks-menubar-action.sh"
+    static let projectRoot = "/tmp/sks-menubar-project"
+    static let buildStampPath = "/tmp/sks-menubar-build-stamp.json"
+    static let configPath = "/tmp/sks-menubar-config.json"
+    static let lastActionLogPath = "/tmp/sks-menubar-last-action.log"
+    static let operationDirectory = "/tmp/sks-menubar-operations"
+    static let codexBundleId: String? = nil
+    static let packageVersion = "test"
+}
+#endif

package/dist/native/sks-menubar/Tests/NativeTelegramRegressionRunner.swift

@@ -0,0 +1,55 @@
+#if SKS_NATIVE_TEST_RUNNER
+import Cocoa
+import Darwin
+
+@main
+struct NativeTelegramRegressionRunner {
+    static func main() {
+        precondition(
+            ProcessClient.alignedTimeout(
+                arguments: ["telegram", "status", "--json"],
+                requested: 8
+            ) == 12
+        )
+        precondition(
+            TelegramHubSupervisor.serviceSnapshot(
+                from: #"{"schema":"sks.telegram-hub-service.v1","running":true,"receive_ready":false,"mode":"direct","pid":4242}"#
+            )?.verifiedDirectPID == 4242
+        )
+        precondition(
+            TelegramHubSupervisor.serviceSnapshot(
+                from: #"{"schema":"sks.telegram-hub-service.v1","running":false,"receive_ready":false,"mode":null,"pid":null}"#
+            )?.verifiedDirectPID == nil
+        )
+        precondition(TelegramHubSupervisor.retryableStartupFailure("telegram_hub_owner_conflict"))
+        precondition(TelegramHubSupervisor.retryableStartupFailure("telegram_hub_network_unavailable"))
+
+        let temp = FileManager.default.temporaryDirectory
+            .appendingPathComponent("sks-native-telegram-regression-\(UUID().uuidString)", isDirectory: true)
+        try! FileManager.default.createDirectory(at: temp, withIntermediateDirectories: true)
+        let client = ProcessClient(
+            actionScript: "/bin/sh",
+            logPath: temp.appendingPathComponent("process.log").path,
+            projectRoot: temp.path
+        )
+        client.run(["-c", "sleep 30"], timeout: 0.2, logOutput: false) { timeoutResult in
+            precondition(timeoutResult.code == -2)
+            precondition(timeoutResult.timedOut)
+            precondition(!timeoutResult.emptyOutput)
+            precondition(timeoutResult.output.contains("native_process_timeout"))
+            client.run(["-c", "exit 0"], timeout: 2, logOutput: false) { emptyResult in
+                precondition(emptyResult.code == -3)
+                precondition(!emptyResult.timedOut)
+                precondition(emptyResult.emptyOutput)
+                precondition(emptyResult.output.contains("native_process_empty_output"))
+                let message = RemoteTelegramViewController.telegramStatusFailureMessage(emptyResult)
+                precondition(message.contains("returned no JSON"))
+                try? FileManager.default.removeItem(at: temp)
+                print("native-telegram-regressions-ok")
+                Darwin.exit(0)
+            }
+        }
+        dispatchMain()
+    }
+}
+#endif

package/dist/native/sks-menubar/Tests/ProcessClientTests.swift

@@ -0,0 +1,33 @@
+#if canImport(XCTest)
+import XCTest
+
+final class ProcessClientTests: XCTestCase {
+    func testTelegramStatusTimeoutLeavesRoomForInnerProbeBudget() {
+        XCTAssertEqual(
+            ProcessClient.alignedTimeout(
+                arguments: ["telegram", "status", "--json"],
+                requested: 8
+            ),
+            12
+        )
+        XCTAssertEqual(
+            ProcessClient.alignedTimeout(
+                arguments: ["remote", "readiness", "--json"],
+                requested: 8
+            ),
+            8
+        )
+    }
+
+    func testNativeTimeoutAndEmptyOutputAreStablePublicErrors() {
+        XCTAssertEqual(
+            ProcessClient.nativeFailureOutput("native_process_timeout"),
+            #"{"schema":"sks.native-process-error.v1","ok":false,"error":"native_process_timeout"}"#
+        )
+        XCTAssertEqual(
+            ProcessClient.nativeFailureOutput("native_process_empty_output"),
+            #"{"schema":"sks.native-process-error.v1","ok":false,"error":"native_process_empty_output"}"#
+        )
+    }
+}
+#endif