sneakoscope 7.3.0 → 7.6.0

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

@@ -0,0 +1,447 @@
+import Cocoa
+
+extension RemoteTelegramViewController {
+    @objc func acknowledgeDeadLetters() {
+        guard let window = view.window, deadLetterIngressCount > 0 else { return }
+        AlertFactory.confirmSheet(
+            window: window,
+            title: "Acknowledge failed Telegram ingress?",
+            message: "This permanently retires \(deadLetterIngressCount) failed ingress record\(deadLetterIngressCount == 1 ? "" : "s"). It does not claim the Codex effect ran and it does not replay the original text. Keep the Hub stopped, acknowledge, restart it, then resend each failed request from the paired Telegram chat.",
+            destructive: true,
+            actionTitle: "Acknowledge"
+        ) { [weak self] confirmed in
+            guard let self = self, confirmed else { return }
+            self.runMutation(
+                args: [
+                    "telegram", "dead-letters", "acknowledge", "--yes",
+                    "--project-root", AppRuntime.projectRoot,
+                    "--json"
+                ],
+                kind: "telegram-dead-letters-acknowledge",
+                summary: "Acknowledge failed Telegram ingress"
+            )
+        }
+    }
+
+    func checkStatus(refreshConversation: Bool) {
+        guard !busy, !statusInFlight else { return }
+        statusInFlight = true
+        generation += 1
+        let requestGeneration = generation
+        checkButton?.isEnabled = false
+        readinessStatus.stringValue = "Checking Codex App, CLI, Git, Telegram, and Hub state…"
+        if !setupReady {
+            ControlKit.setBadge(setupBadge, text: "Checking Telegram setup…", tone: .busy)
+            setupStatus.stringValue = "Checking Keychain, bot identity, pairing, and dedicated sessions…"
+        }
+        var remote: [String: Any]?
+        var telegram: [String: Any]?
+        var telegramFailure: String?
+        let group = DispatchGroup()
+        group.enter()
+        processClient.run(
+            ["remote", "readiness", "--project-root", AppRuntime.projectRoot, "--json"],
+            timeout: NativeView.statusTimeout
+        ) { [weak self] result in
+            if result.code == 0, !result.truncated {
+                remote = self?.json(result.output)
+            }
+            group.leave()
+        }
+        group.enter()
+        processClient.run(
+            ["telegram", "status", "--project-root", AppRuntime.projectRoot, "--json"],
+            timeout: ProcessClient.telegramStatusTimeout
+        ) { [weak self] result in
+            if !result.timedOut,
+               !result.emptyOutput,
+               !result.truncated,
+               let payload = self?.json(result.output),
+               payload["schema"] as? String == "sks.telegram-status.v1" {
+                telegram = payload
+            } else {
+                telegramFailure = Self.telegramStatusFailureMessage(result)
+            }
+            group.leave()
+        }
+        group.notify(queue: .main) { [weak self] in
+            guard let self = self, self.generation == requestGeneration else { return }
+            self.statusInFlight = false
+            self.render(remote: remote, telegram: telegram)
+            if let telegramFailure = telegramFailure {
+                ControlKit.setBadge(
+                    self.setupReady ? self.connectionBadge : self.setupBadge,
+                    text: "Telegram live status unavailable",
+                    tone: .warning
+                )
+                if self.setupReady {
+                    self.connectionStatus.stringValue = "\(telegramFailure) The linked session and locally loaded conversation remain available."
+                } else {
+                    self.setupStatus.stringValue = telegramFailure
+                }
+            }
+            if !self.hubRunning,
+               let startupFailure = TelegramHubSupervisor.latestStartupFailureMessage {
+                ControlKit.setBadge(self.hubBadge, text: "Telegram Hub startup needs attention", tone: .error)
+                self.hubStatus.stringValue = startupFailure
+            }
+            self.updateButtons()
+            if self.setupReady {
+                if refreshConversation || self.loadedSessionId != self.selectedSessionId {
+                    self.refreshSnapshot(force: true)
+                } else {
+                    self.refreshLive(force: true)
+                }
+            } else {
+                self.clearSnapshot()
+            }
+        }
+    }
+
+    static func telegramStatusFailureMessage(_ result: ProcessResult) -> String {
+        if result.timedOut || result.output.contains("native_process_timeout") {
+            return "Telegram status exceeded its bounded native deadline. Retry after the current probe finishes or check network access to api.telegram.org."
+        }
+        if result.emptyOutput || result.output.contains("native_process_empty_output") {
+            return "Telegram status returned no JSON. Retry, then open Diagnostics if the CLI remains unavailable."
+        }
+        if result.truncated {
+            return "Telegram status exceeded the native output budget. Open Diagnostics and retry."
+        }
+        return "Telegram status returned an invalid response. Retry, then open Diagnostics if it persists."
+    }
+
+    func refreshSnapshot(force: Bool = false) {
+        guard setupReady, !busy, !snapshotInFlight else { return }
+        if !force {
+            guard view.window?.isVisible == true else { return }
+        }
+        liveGeneration += 1
+        liveInFlight = false
+        snapshotInFlight = true
+        snapshotGeneration += 1
+        let requestGeneration = snapshotGeneration
+        let requestSessionId = selectedSessionId
+        let requestCursor = conversationCursor
+        let requestSortDirection = conversationSortDirection
+        updateButtons()
+        ControlKit.setBadge(liveSourceBadge, text: "Refreshing real Codex thread…", tone: .busy)
+        snapshotStatus.stringValue = "Reading the selected App Server thread and bounded live activity…"
+        var args = ["telegram", "center-snapshot", "--project-root", AppRuntime.projectRoot, "--json"]
+        if let selectedSessionId = selectedSessionId {
+            args += ["--session-id", selectedSessionId]
+        }
+        if let conversationCursor = conversationCursor {
+            args += ["--cursor", conversationCursor]
+        }
+        args += ["--sort-direction", conversationSortDirection]
+        processClient.run(
+            args,
+            timeout: 30,
+            maxOutputBytes: 896 * 1024,
+            logOutput: false
+        ) { [weak self] result in
+            guard let self = self,
+                  self.snapshotGeneration == requestGeneration,
+                  self.selectedSessionId == requestSessionId,
+                  self.conversationCursor == requestCursor,
+                  self.conversationSortDirection == requestSortDirection else { return }
+            self.snapshotInFlight = false
+            self.updateButtons()
+            guard result.code == 0,
+                  !result.truncated,
+                  let snapshot = self.json(result.output),
+                  self.validFullSnapshot(snapshot, sessionId: requestSessionId) else {
+                ControlKit.setBadge(self.liveSourceBadge, text: "Conversation refresh unavailable", tone: .warning)
+                self.snapshotStatus.stringValue = result.truncated
+                    ? "The private snapshot exceeded the native output budget. Open Diagnostics and retry after the thread is compacted."
+                    : self.loadedSessionId == nil
+                    ? "The linked conversation could not be loaded. Retry the conversation refresh or open Diagnostics."
+                    : "The last loaded conversation and activity remain visible. Retry the conversation refresh or open Diagnostics."
+                return
+            }
+            self.renderSnapshot(snapshot)
+        }
+    }
+
+    func refreshLive(force: Bool = false) {
+        guard setupReady,
+              !busy,
+              !statusInFlight,
+              !snapshotInFlight,
+              !liveInFlight,
+              isViewingLatestConversationPage else { return }
+        if !force {
+            guard view.window?.isVisible == true else { return }
+        }
+        let requestSourceSignature = centerLiveSourceSignature()
+        let requestWasCatchUp = liveCatchUpInProgress
+        liveSourceFileSignature = requestSourceSignature
+        liveInFlight = true
+        liveGeneration += 1
+        let requestGeneration = liveGeneration
+        let requestSessionId = selectedSessionId
+        var args = ["telegram", "center-live", "--project-root", AppRuntime.projectRoot, "--json"]
+        if let selectedSessionId = selectedSessionId {
+            args += ["--session-id", selectedSessionId]
+        }
+        processClient.run(
+            args,
+            timeout: 10,
+            maxOutputBytes: 320 * 1024,
+            logOutput: false
+        ) { [weak self] result in
+            guard let self = self,
+                  self.liveGeneration == requestGeneration,
+                  self.selectedSessionId == requestSessionId else { return }
+            self.liveInFlight = false
+            guard result.code == 0,
+                  !result.truncated,
+                  let live = self.json(result.output),
+                  self.validLiveSnapshot(live, sessionId: requestSessionId) else {
+                self.liveCatchUpInProgress = false
+                self.renderLiveFailure()
+                return
+            }
+            self.renderLiveSnapshot(live)
+            let completionSourceSignature = self.centerLiveSourceSignature()
+            if Self.shouldRequestImmediateLiveCatchUp(
+                requestSignature: requestSourceSignature,
+                completionSignature: completionSourceSignature,
+                wasCatchUp: requestWasCatchUp
+            ) {
+                self.liveCatchUpInProgress = true
+                self.liveSourceFileSignature = nil
+                self.refreshLive(force: true)
+            } else if completionSourceSignature != requestSourceSignature {
+                self.liveCatchUpInProgress = false
+                self.liveSourceFileSignature = nil
+            } else {
+                self.liveCatchUpInProgress = false
+                self.liveSourceFileSignature = requestSourceSignature
+            }
+            guard let revision = live["conversation_revision"] as? String,
+                  !revision.isEmpty,
+                  revision != self.loadedConversationRevision,
+                  revision != self.liveTriggeredConversationRevision,
+                  self.isCompletedTurn(live["binding"] as? [String: Any]) else { return }
+            self.liveTriggeredConversationRevision = revision
+            self.refreshSnapshot(force: true)
+        }
+    }
+
+    func startLivePolling() {
+        liveTimer?.invalidate()
+        liveSourceFileSignature = nil
+        liveCatchUpInProgress = false
+        liveTimer = Timer.scheduledTimer(withTimeInterval: 2.5, repeats: true) { [weak self] _ in
+            guard let self = self else { return }
+            guard self.view.window?.isVisible == true else {
+                self.liveTimer?.invalidate()
+                self.liveTimer = nil
+                return
+            }
+            guard self.isViewingLatestConversationPage else { return }
+            let sourceSignature = self.centerLiveSourceSignature()
+            guard sourceSignature != self.liveSourceFileSignature else { return }
+            self.refreshLive()
+        }
+        if let liveTimer = liveTimer {
+            RunLoop.main.add(liveTimer, forMode: .common)
+        }
+    }
+
+    func resetConversationPagination() {
+        conversationCursor = nil
+        conversationSortDirection = "desc"
+        isViewingLatestConversationPage = true
+        olderConversationCursor = nil
+        olderConversationSortDirection = "desc"
+        newerConversationCursor = nil
+        newerConversationSortDirection = "asc"
+        updateButtons()
+    }
+
+    func clearSnapshot() {
+        invalidateCenterRequests()
+        clearLoadedCenterState()
+        resetConversationPagination()
+        ControlKit.setBadge(liveSourceBadge, text: "Codex thread not loaded", tone: .neutral)
+        snapshotStatus.stringValue = "Complete Telegram setup to load a linked conversation."
+        renderConversationPlaceholder("Connect Telegram to load a Codex conversation.")
+        renderActivityPlaceholder("Public work activity will appear after a linked Codex turn starts.")
+    }
+
+    func clearLoadedCenterState() {
+        loadedSessionId = nil
+        loadedConversationRevision = nil
+        loadedLiveActivityDigest = nil
+        liveTriggeredConversationRevision = nil
+        loadedTranscriptRows = []
+        loadedHistoryActivityRows = []
+        loadedLiveActivityRows = []
+        loadedThreadId = nil
+        loadedThreadStatus = "unknown"
+        loadedConversationPageTurnCount = 0
+        loadedSnapshotTruncated = false
+        loadedLiveActivityState = "pending"
+        loadedLiveActivityError = nil
+        renderedTranscriptSignature = nil
+        renderedActivitySignature = nil
+        liveSourceFileSignature = nil
+        liveCatchUpInProgress = false
+    }
+
+    func applyConversationPage(_ page: [String: Any]?) {
+        guard let page = page else {
+            resetConversationPagination()
+            return
+        }
+        isViewingLatestConversationPage = page["is_latest"] as? Bool == true
+        olderConversationCursor = page["older_cursor"] as? String
+        olderConversationSortDirection = validConversationSortDirection(
+            page["older_sort_direction"] as? String,
+            fallback: "desc"
+        )
+        newerConversationCursor = page["newer_cursor"] as? String
+        newerConversationSortDirection = validConversationSortDirection(
+            page["newer_sort_direction"] as? String,
+            fallback: "asc"
+        )
+        updateButtons()
+    }
+
+    private func validConversationSortDirection(_ value: String?, fallback: String) -> String {
+        guard let value = value, value == "asc" || value == "desc" else { return fallback }
+        return value
+    }
+
+    private func isCompletedTurn(_ binding: [String: Any]?) -> Bool {
+        guard let status = binding?["last_turn_status"] as? String else { return false }
+        return status == "completed" || status == "failed" || status == "interrupted"
+    }
+
+    private func validFullSnapshot(_ payload: [String: Any], sessionId: String?) -> Bool {
+        guard payload["schema"] as? String == "sks.telegram-center-snapshot.v1",
+              payload["ok"] as? Bool == true,
+              (payload["selected_session_id"] as? String) == sessionId,
+              let state = payload["state"] as? String,
+              ["ready", "awaiting_first_message"].contains(state),
+              payload["conversation_revision"] is String,
+              payload["live_activity_digest"] is String,
+              payload["transcript"] is [[String: Any]],
+              payload["activity"] is [[String: Any]] else { return false }
+        if state == "ready" {
+            return payload["thread"] is [String: Any]
+                && payload["conversation_page"] is [String: Any]
+        }
+        return true
+    }
+
+    private func validLiveSnapshot(_ payload: [String: Any], sessionId: String?) -> Bool {
+        guard payload["schema"] as? String == "sks.telegram-center-live.v1",
+              payload["ok"] as? Bool == true,
+              (payload["selected_session_id"] as? String) == sessionId,
+              let state = payload["state"] as? String,
+              ["ready", "awaiting_first_message"].contains(state),
+              payload["binding"] is [String: Any],
+              payload["conversation_revision"] is String,
+              payload["live_activity_digest"] is String,
+              payload["activity"] is [[String: Any]] else { return false }
+        return true
+    }
+
+    func invalidateCenterRequests() {
+        snapshotGeneration += 1
+        liveGeneration += 1
+        snapshotInFlight = false
+        liveInFlight = false
+        liveCatchUpInProgress = false
+        updateButtons()
+    }
+
+    static func shouldRequestImmediateLiveCatchUp(
+        requestSignature: String,
+        completionSignature: String,
+        wasCatchUp: Bool
+    ) -> Bool {
+        completionSignature != requestSignature && !wasCatchUp
+    }
+
+    func centerLiveSourceSignature() -> String {
+        let remoteRoot = URL(fileURLWithPath: AppRuntime.projectRoot, isDirectory: true)
+            .appendingPathComponent(".sneakoscope", isDirectory: true)
+            .appendingPathComponent("remote", isDirectory: true)
+        let names = [
+            "events.json",
+            "events-health.json",
+            "codex-session-bindings.json"
+        ]
+        return names.map { name in
+            let url = remoteRoot.appendingPathComponent(name)
+            guard let attributes = try? FileManager.default.attributesOfItem(atPath: url.path) else {
+                return "\(name):missing"
+            }
+            let modified = (attributes[.modificationDate] as? Date)?.timeIntervalSince1970 ?? 0
+            let size = (attributes[.size] as? NSNumber)?.uint64Value ?? 0
+            return "\(name):\(modified):\(size)"
+        }.joined(separator: "|")
+    }
+
+    func setupGuidance(
+        token: Bool,
+        botVerified: Bool,
+        longPollReady: Bool,
+        pairing: Bool,
+        sessions: Int,
+        fallback: String?
+    ) -> String {
+        if !token || !botVerified {
+            return "Next: Create or regenerate the bot in @BotFather, send /start in its private chat, then connect the token here."
+        }
+        if !pairing {
+            return "Next: Send /start to the bot from the private Telegram account you want to pair, then reconnect."
+        }
+        if sessions == 0 {
+            return "Next: Reconnect the bot to register a dedicated coding session for this project."
+        }
+        if !longPollReady {
+            return "Next: Remove the bot’s existing webhook, send /start again, then reconnect."
+        }
+        return fallback.map { "Next: \($0)" } ?? "Next: Complete the highlighted setup step, then refresh status."
+    }
+
+    func userFacingThreadStatus(_ status: String) -> String {
+        switch status {
+        case "idle": return "ready"
+        case "active", "inProgress": return "working"
+        case "notLoaded": return "stored history available"
+        case "systemError": return "needs attention"
+        case "awaiting_first_message": return "awaiting first message"
+        case "unknown": return "status unavailable"
+        default: return "thread available"
+        }
+    }
+
+    func setupFailureMessage(_ output: String) -> String {
+        if output.contains("telegram_pairing_start_not_found") {
+            return "No private /start message was found. Open the new bot, send /start from the Telegram account you want to pair, then retry."
+        }
+        if output.contains("telegram_pairing_ambiguous") {
+            return "More than one private /start was pending, so SKS refused to guess the operator. Use only the intended account, send /start again, then retry."
+        }
+        if output.contains("telegram_webhook_conflict") {
+            return "This bot still has a webhook from another service. Remove that webhook there, send /start again, then retry."
+        }
+        if output.contains("telegram_hub_must_be_stopped_before_setup") {
+            return "Stop the Telegram Hub before reconnecting the bot or rotating its token."
+        }
+        if output.contains("telegram_keychain_readback_failed") || output.contains("telegram_keychain_snapshot_failed") {
+            return "The token could not be read back from macOS Keychain for the Hub. Approve the Keychain prompt, then retry."
+        }
+        if output.contains("telegram_bot_auth_failed") || output.contains("\"error_code\":401") || output.contains("Unauthorized") {
+            return "Telegram rejected the token. Copy the current token from @BotFather and try again."
+        }
+        return "Setup failed. Confirm the BotFather token and private /start message, then retry. The token was not written to logs."
+    }
+}