sneakoscope 8.1.2 → 8.2.0

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

@@ -20,6 +20,114 @@ enum OperationState: String, Codable {
     case queued, running, waitingForConfirmation, succeeded, failed, cancelled, terminalUncertain
 }
 
+/// Diagnostic commands can complete successfully while reporting that runtime
+/// readiness is not satisfied. This metadata deliberately excludes request
+/// bodies, credentials, endpoint query strings, and secret fingerprints.
+struct DiagnosticOperationMetadata: Codable, Equatable {
+    let schema: String
+    let executionOK: Bool
+    let reportGenerated: Bool
+    let requestedLevel: String
+    let levelSatisfied: Bool
+    let fullFeatureVerified: Bool
+    let reportId: String
+    let correlationId: String
+    let attemptId: Int
+    let catalogGeneration: String?
+
+    enum CodingKeys: String, CodingKey { case schema
+        case executionOK = "execution_ok", reportGenerated = "report_generated"
+        case requestedLevel = "requested_level", levelSatisfied = "level_satisfied"
+        case fullFeatureVerified = "full_feature_verified", reportId = "report_id"
+        case correlationId = "correlation_id", attemptId = "attempt_id"
+        case catalogGeneration = "catalog_generation"
+    }
+}
+struct ProviderResponseIdentity: Equatable {
+    let requestGeneration: Int
+    let reportId: String
+    let correlationId: String
+    let attemptId: Int
+    let checkedAt: Date
+    let catalogGeneration: String?
+}
+struct ProviderResponseGate {
+    private(set) var activeRequestGeneration = 0
+    private(set) var accepted: ProviderResponseIdentity?
+    mutating func begin() -> Int { activeRequestGeneration += 1; return activeRequestGeneration }
+    mutating func accept(_ candidate: ProviderResponseIdentity) -> Bool {
+        guard candidate.requestGeneration == activeRequestGeneration else { return false }
+        if let previous = accepted {
+            guard candidate.checkedAt > previous.checkedAt
+                    || candidate.checkedAt == previous.checkedAt && candidate.attemptId >= previous.attemptId else { return false }
+        }
+        accepted = candidate
+        return true
+    }
+    func statusMayMerge(checkedAt: Date, catalogGeneration: String?) -> Bool {
+        guard let accepted = accepted else { return true }
+        // Ambient status can advance only the explicitly verified generation.
+        guard catalogGeneration == accepted.catalogGeneration else { return false }
+        return checkedAt >= accepted.checkedAt
+    }
+}
+
+enum ProviderRecoveryAction: String, CaseIterable {
+    case repairBridgeService = "repair_bridge_service"
+    case restartBridgeAndRetry = "restart_bridge_and_retry"
+    case inspectBridgeLogs = "inspect_bridge_logs_and_retry_transport"
+    case updateBridgeProtocol = "update_bridge_or_codex_protocol"
+    case configureCodexLb = "configure_codex_lb_credential"
+    case rotateCodexLb = "rotate_codex_lb_credential"
+    case configureOpenRouter = "configure_openrouter_credential"
+    case rotateOpenRouter = "rotate_openrouter_credential"
+    case retryCatalog = "retry_catalog_sync"
+    case resolveConflict = "resolve_catalog_route_conflict"
+    case refreshCatalog = "refresh_catalog_or_select_supported_model"
+    case runDeep = "run_deep_verification"
+    case updateMenubar = "update_sks_and_rebuild_menubar"
+    case reviewConfig = "review_config_manually"
+
+    var buttonTitle: String {
+        switch self {
+        case .repairBridgeService, .restartBridgeAndRetry: return "Repair Bridge"
+        case .inspectBridgeLogs: return "Open Diagnostics"
+        case .updateBridgeProtocol, .updateMenubar: return "Check for Updates"
+        case .configureCodexLb, .rotateCodexLb: return "Configure Codex-LB"
+        case .configureOpenRouter, .rotateOpenRouter: return "Configure OpenRouter"
+        case .retryCatalog, .resolveConflict, .refreshCatalog: return "Refresh Catalog"
+        case .runDeep: return "Verify Deep"
+        case .reviewConfig: return "Review Config"
+        }
+    }
+}
+enum ProviderSecretRedactor {
+    private static let patterns = [
+        (#"(?i)(authorization\s*:\s*bearer\s+)[^\s,;]+"#, "$1[REDACTED]"),
+        (#"(?i)(x-codex-lb-api-key\s*[:=]\s*)[^\s,;]+"#, "$1[REDACTED]"),
+        (#"\bsk-(?:clb|or|proj)?-[A-Za-z0-9_-]{6,}\b"#, "[REDACTED]"),
+        (#"(?i)(api[_-]?key\s*[:=]\s*)[^\s,;]+"#, "$1[REDACTED]")
+    ]
+
+    static func redact(_ value: String) -> String {
+        patterns.reduce(value) { output, entry in
+            let (pattern, replacement) = entry
+            guard let regex = try? NSRegularExpression(pattern: pattern) else { return output }
+            return regex.stringByReplacingMatches(in: output, range: NSRange(output.startIndex..., in: output), withTemplate: replacement)
+        }
+    }
+
+    static func redactEndpoint(_ value: String) -> String {
+        let cleaned = redact(value)
+        guard var components = URLComponents(string: cleaned), components.scheme != nil else { return cleaned }
+        components.user = nil
+        components.password = nil
+        components.query = nil
+        components.fragment = nil
+        return components.string ?? "[REDACTED ENDPOINT]"
+    }
+}
+
 enum OperationProgressSignal: String, Codable, CaseIterable {
     case evidence, fileChange, testResult, modelResponse, toolResponse, none
 }
@@ -299,6 +407,7 @@ struct OperationSnapshot: Codable {
     let registry: String?
     let recovery: OperationRecoveryStatus?
     let providerApply: ProviderApplyProjection?
+    let diagnostic: DiagnosticOperationMetadata?
 
     init(
         schema: String,
@@ -316,7 +425,8 @@ struct OperationSnapshot: Codable {
         projectRoot: String?,
         registry: String?,
         recovery: OperationRecoveryStatus? = nil,
-        providerApply: ProviderApplyProjection? = nil
+        providerApply: ProviderApplyProjection? = nil,
+        diagnostic: DiagnosticOperationMetadata? = nil
     ) {
         self.schema = schema
         self.id = id
@@ -334,6 +444,7 @@ struct OperationSnapshot: Codable {
         self.registry = registry
         self.recovery = recovery
         self.providerApply = providerApply
+        self.diagnostic = diagnostic
     }
 }
 
@@ -386,4 +497,3 @@ struct UpdateOperationReceiptSnapshot: Codable {
         case receiptPath = "receipt_path"
     }
 }
-

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

@@ -0,0 +1,21 @@
+import Foundation
+
+struct ProviderRouteExplanation: Equatable {
+    let providerId: String
+    let upstreamModel: String
+    let fallback: String
+
+    static func decode(from commandEnvelope: [String: Any]) -> ProviderRouteExplanation? {
+        guard let result = commandEnvelope["result"] as? [String: Any],
+              let explanation = result["explanation"] as? [String: Any],
+              let route = explanation["route"] as? [String: Any],
+              let providerId = route["provider_id"] as? String,
+              let upstreamModel = route["upstream_model"] as? String,
+              let fallback = explanation["fallback"] as? String else { return nil }
+        return ProviderRouteExplanation(
+            providerId: providerId,
+            upstreamModel: upstreamModel,
+            fallback: fallback
+        )
+    }
+}

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

@@ -0,0 +1,140 @@
+import Cocoa
+
+extension ProvidersViewController {
+    func makeCombinedCatalogCard() -> NSBox {
+        let refresh = NativeView.button("Refresh", target: self, action: #selector(refreshCombinedCatalog))
+        let report = NativeView.button("Open Report", target: self, action: #selector(openCatalogReport))
+        registerProviderAction(refresh, id: "sks-provider-refresh-catalog")
+        registerProviderAction(report, id: "sks-provider-open-catalog-report")
+        actionButtons += [refresh, report]
+        let card = NativeView.card(title: "Combined Model Catalog", subtitle: "Codex-LB and OpenRouter catalogs activate atomically with one explicit route index. A failed build keeps the prior verified generation.", views: [catalogSyncStatus, ControlKit.actionRow([refresh, report])])
+        card.setAccessibilityIdentifier("sks-provider-card-combined-catalog")
+        return card
+    }
+
+    func makeRoutesCard() -> NSBox {
+        let explain = NativeView.button("Explain Route", target: self, action: #selector(explainRoute))
+        registerProviderAction(explain, id: "sks-provider-route-explain")
+        actionButtons.append(explain)
+        let card = NativeView.card(title: "Routes", subtitle: "Routes come only from the canonical model index or a validated session pin. Fallback is always none.", views: [routesStatus, NativeView.row([routeModelField, explain])])
+        card.setAccessibilityIdentifier("sks-provider-card-routes")
+        return card
+    }
+
+    func renderCombinedCatalog(_ json: [String: Any]) {
+        let catalog = json["catalog_sync"] as? [String: Any]
+        guard catalog?["schema"] as? String == "sks.combined-catalog-sync.v1",
+              let data = try? JSONSerialization.data(withJSONObject: catalog as Any),
+              let decoded = try? JSONDecoder().decode(CombinedCatalogSyncStatusV1.self, from: data),
+              decoded.providers["codex-lb"]?.schema == "sks.catalog-sync-state.v2",
+              decoded.providers["openrouter"]?.schema == "sks.catalog-sync-state.v2" else {
+            catalogSyncStatus.stringValue = "Capability schema invalid · catalog_sync missing · capability_schema_invalid"
+            catalogSyncStatus.textColor = .systemRed
+            return
+        }
+        renderCatalogStatus(decoded)
+    }
+
+    func renderCatalogStatus(_ catalog: CombinedCatalogSyncStatusV1) {
+        func providerText(_ id: String) -> String {
+            guard let state = catalog.providers[id] else { return "invalid" }
+            return state.modelCount.map(String.init) ?? state.state
+        }
+        let modelText = catalog.modelCount.map { " · \($0) models" } ?? ""
+        let routeText = catalog.routeCount.map { " · \($0) routes" } ?? ""
+        let conflictText = catalog.conflictCount > 0 ? " · \(catalog.conflictCount) conflicts" : ""
+        let cause = catalog.blockers.first.map { " · \(ProviderSecretRedactor.redact($0))" } ?? ""
+        let recovery = catalog.recoveryAction.flatMap(ProviderRecoveryAction.init(rawValue:)).map { " · recovery \($0.buttonTitle)" } ?? ""
+        catalogSyncStatus.stringValue = "Combined catalog · \(catalog.state)\(modelText)\(routeText) · Codex-LB \(providerText("codex-lb")) / OpenRouter \(providerText("openrouter"))\(conflictText)\(cause)\(recovery)"
+        switch catalog.state {
+        case "verified": catalogSyncStatus.textColor = .systemGreen
+        case "failed": catalogSyncStatus.textColor = .systemRed
+        default: catalogSyncStatus.textColor = .systemOrange
+        }
+    }
+
+    func renderRoutes(_ json: [String: Any]) {
+        guard let routing = json["routing"] as? [String: Any],
+              let policy = routing["policy"] as? [String: Any],
+              policy["schema"] as? String == "sks.bridge-routing-policy.v1",
+              policy["fallback"] as? String == "none" else {
+            routesStatus.stringValue = "Routes · schema invalid or fallback is not none"
+            routesStatus.textColor = .systemRed
+            return
+        }
+        let provider = policy["default_provider_id"] as? String ?? "none"
+        let generation = policy["policy_generation"] as? String ?? "unreported"
+        let catalogGeneration = policy["catalog_generation"] as? String ?? "unreported"
+        let pin = routing["session_pin"] as? [String: Any]
+        let pinText = pin.map { "\($0["provider_id"] as? String ?? "invalid") / \($0["public_model"] as? String ?? "invalid")" } ?? "none"
+        let selected = routing["selected_route"] as? [String: Any]
+        let selectedModel = routing["selected_model"] as? String ?? "unknown"
+        let selectedText = selected.map { "\(selectedModel) → \($0["provider_id"] as? String ?? "unknown")" } ?? "none"
+        routesStatus.stringValue = "Default provider: \(provider) · selected model: \(selectedText) · session pin: \(pinText) · fallback: none · policy \(generation) · catalog \(catalogGeneration)"
+        routesStatus.textColor = .secondaryLabelColor
+    }
+
+    @objc func refreshCombinedCatalog() {
+        runCatalogCommand(["bridge", "catalog", "sync", "--json"], title: "Refresh combined catalog", mutationGroup: "codex-config")
+    }
+
+    @objc func openCatalogReport() {
+        runCatalogCommand(["bridge", "catalog", "status", "--json"], title: "Load combined catalog report", mutationGroup: nil)
+    }
+
+    private func runCatalogCommand(_ args: [String], title: String, mutationGroup: String?) {
+        guard !catalogRefreshInFlight, let snapshot = operations.begin(kind: "bridge-catalog", mutationGroup: mutationGroup, summary: title) else { return }
+        catalogRefreshInFlight = true
+        catalogSyncStatus.stringValue = "Combined catalog · syncing"
+        _ = operations.update(snapshot, state: .running, stage: "catalog_sync", progress: nil, summary: title)
+        processClient.run(args, timeout: NativeView.mutationTimeout) { [weak self] result in
+            guard let self = self else { return }
+            self.catalogRefreshInFlight = false
+            guard let json = self.json(result.output) else {
+                _ = self.operations.update(snapshot, state: .failed, stage: "complete", progress: 1, summary: "Catalog report schema invalid")
+                self.catalogSyncStatus.stringValue = "Capability schema invalid · catalog_sync missing · capability_schema_invalid"
+                self.catalogSyncStatus.textColor = .systemRed
+                return
+            }
+            guard json["schema"] as? String == "sks.desktop-bridge-command-result.v1",
+                  ["catalog.sync", "catalog.status"].contains(json["operation"] as? String ?? ""),
+                  let statusJSON = json["status"] as? [String: Any],
+                  let status = try? DesktopBridgeStatusV3Truth.decode(from: statusJSON) else {
+                _ = self.operations.update(snapshot, state: .failed, stage: "complete", progress: 1, summary: "Catalog command envelope invalid")
+                self.catalogSyncStatus.stringValue = "Capability schema invalid · current Desktop Bridge status missing"
+                self.catalogSyncStatus.textColor = .systemRed
+                return
+            }
+            self.renderCombinedCatalog(status.raw)
+            let valid = !self.catalogSyncStatus.stringValue.contains("schema invalid")
+            _ = self.operations.update(snapshot, state: valid ? .succeeded : .failed, stage: "complete", progress: 1, summary: valid ? "Catalog report generated" : "Catalog report schema invalid")
+            self.refresh()
+        }
+    }
+
+    @objc func explainRoute() {
+        let model = routeModelField.stringValue.trimmingCharacters(in: .whitespacesAndNewlines)
+        guard !model.isEmpty, let snapshot = operations.begin(kind: "bridge-route-explain", mutationGroup: nil, summary: "Explain model route") else {
+            routesStatus.stringValue = "Route explain blocked · choose an exact model from the combined catalog."
+            routesStatus.textColor = .systemOrange
+            return
+        }
+        routesStatus.stringValue = "Explaining \(model) through the explicit route index…"
+        _ = operations.update(snapshot, state: .running, stage: "model_route", progress: nil, summary: "Explain model route")
+        processClient.run(["bridge", "route", "explain", model, "--json"], timeout: NativeView.statusTimeout) { [weak self] result in
+            guard let self = self else { return }
+            let json = self.json(result.output)
+            let explanation = json.flatMap(ProviderRouteExplanation.decode(from:))
+            let explainedRoute = explanation.flatMap { explanation in
+                explanation.fallback == "none"
+                    ? "\(model) → \(explanation.providerId) / \(explanation.upstreamModel) · fallback none"
+                    : nil
+            }
+            let valid = explainedRoute != nil
+            _ = self.operations.update(snapshot, state: valid ? .succeeded : .failed, stage: "complete", progress: 1, summary: valid ? "Route explained" : "Route unavailable")
+            self.routesStatus.stringValue = explainedRoute
+                ?? "\(model) · route missing or ambiguous · no fallback · \(self.structuredPublicDetail(json, fallback: result.output, fallbackNext: "Refresh catalog or choose a supported model"))"
+            self.routesStatus.textColor = valid ? .systemGreen : .systemRed
+        }
+    }
+}