}

}

private var healthCard: some View {

let snapshot = self.healthStore.snapshot

return VStack(alignment: .leading, spacing: 6) {

HStack(spacing: 8) {

Circle()

.fill(self.healthStore.state.tint)

.frame(width: 10, height: 10)

Text(self.healthStore.summaryLine)

.font(.callout.weight(.semibold))

}

if let snap = snapshot {

let linkId = snap.channelOrder?.first(where: {

if let summary = snap.channels[$0] { return summary.linked != nil }

return false

}) ?? snap.channels.keys.first(where: {

if let summary = snap.channels[$0] { return summary.linked != nil }

return false

})

let linkLabel =

linkId.flatMap { snap.channelLabels?[$0] } ??

linkId?.capitalized ??

"Link channel"

let linkAge = linkId.flatMap { snap.channels[$0]?.authAgeMs }

Text("\(linkLabel) auth age: \(healthAgeString(linkAge))")

.font(.caption)

.foregroundStyle(.secondary)

Text("Session store: \(snap.sessions.path) (\(snap.sessions.count) entries)")

.font(.caption)

.foregroundStyle(.secondary)

if let recent = snap.sessions.recent.first {

let lastActivity = recent.updatedAt != nil

? relativeAge(from: Date(timeIntervalSince1970: (recent.updatedAt ?? 0) / 1000))

: "unknown"

Text("Last activity: \(recent.key) \(lastActivity)")

.font(.caption)

.foregroundStyle(.secondary)

}

Text("Last check: \(relativeAge(from: self.healthStore.lastSuccess))")

.font(.caption)

.foregroundStyle(.secondary)

} else if let error = self.healthStore.lastError {

Text(error)

.font(.caption)

.foregroundStyle(.red)

} else {

Text("Health check pending…")

.font(.caption)

.foregroundStyle(.secondary)

}

HStack(spacing: 12) {

Button {

Task { await self.healthStore.refresh(onDemand: true) }

} label: {

if self.healthStore.isRefreshing {

ProgressView().controlSize(.small)

} else {

Label("Run Health Check", systemImage: "arrow.clockwise")

}

}

.disabled(self.healthStore.isRefreshing)

Divider().frame(height: 18)

Button {

self.revealLogs()

} label: {

Label("Reveal Logs", systemImage: "doc.text.magnifyingglass")

}

}

}

.padding(12)

.background(Color.gray.opacity(0.08))

.cornerRadius(10)

}

}

private enum RemoteStatus: Equatable {

}

}

private func healthAgeString(_ ms: Double?) -> String {

guard let ms else { return "unknown" }

return msToAge(ms)

}

#if DEBUG

struct GeneralSettings_Previews: PreviewProvider {

static var previews: some View {

}

}

private func decodeAndApplyPresenceData(_ data: Data) {

do {

let decoded = try JSONDecoder().decode([PresenceEntry].self, from: data)

self.applyPresence(decoded)

} catch {

self.logger.error("presence decode from event failed: \(error.localizedDescription, privacy: .public)")

self.lastError = error.localizedDescription

}

}

func handlePresenceEventPayload(_ payload: OpenClawProtocol.AnyCodable) {

do {

let wrapper = try GatewayPayloadDecoding.decode(payload, as: PresenceEventPayload.self)

private let gatewayManager = GatewayProcessManager.shared

private let controlChannel = ControlChannel.shared

private let activityStore = WorkActivityStore.shared

private let connectivityCoordinator = GatewayConnectivityCoordinator.shared

@State private var statusItem: NSStatusItem?

@State private var isMenuPresented = false

@State private var isPanelVisible = false

init() {

OpenClawLogging.bootstrapIfNeeded()

GatewayConnectivityCoordinator.shared.start()

Self.applyAttachOnlyOverrideIfNeeded()

_state = State(initialValue: AppStateStore.shared)

return item

}

private func formatVersionLabel(_ version: String) -> String {

let trimmed = version.trimmingCharacters(in: .whitespacesAndNewlines)

guard !trimmed.isEmpty else { return version }

if trimmed.hasPrefix("v") { return trimmed }

if let first = trimmed.unicodeScalars.first, CharacterSet.decimalDigits.contains(first) {

return "v\(trimmed)"

}

return trimmed

}

@objc

private func patchThinking(_ sender: NSMenuItem) {

guard let dict = sender.representedObject as? [String: Any],

}

}

extension [String] {

fileprivate func dedupedPreserveOrder() -> [String] {

var seen = Set<String>()

var result: [String] = []

for item in self where !seen.contains(item) {

seen.insert(item)

result.append(item)

}

return result

}

}

enum SessionLoadError: LocalizedError {

case gatewayUnavailable(String)

case decodeFailed(String)

@State private var meterStartupTask: Task<Void, Never>?

@State private var availableLocales: [Locale] = []

@State private var triggerEntries: [TriggerEntry] = []

private let fieldLabelWidth: CGFloat = 140

private let controlWidth: CGFloat = 240

private let isPreview = ProcessInfo.processInfo.isPreview

}

}

private func holdUntilSilence(onUpdate: @escaping @Sendable (VoiceWakeTestState) -> Void) {

Task { [weak self] in

guard let self else { return }

let detectedAt = Date()

let hardStop = detectedAt.addingTimeInterval(6) // cap overall listen after trigger

while !self.isStopping {

let now = Date()

if now >= hardStop { break }

if let last = self.lastHeard, now.timeIntervalSince(last) >= silenceWindow {

break

}

try? await Task.sleep(nanoseconds: 200_000_000)

}

if !self.isStopping {

self.stop()

await MainActor.run { AppStateStore.shared.stopVoiceEars() }

if let detectedText {

self.logger.info("voice wake hold finished; len=\(detectedText.count)")

Task { @MainActor in onUpdate(.detected(detectedText)) }

}

}

}

}

private func scheduleSilenceCheck(

triggers: [String],

onUpdate: @escaping @Sendable (VoiceWakeTestState) -> Void)