anypick 1.0.0

package/dist/tray/native/MonitorPanel.swift

@@ -0,0 +1,375 @@
+import AppKit
+import Foundation
+import SwiftUI
+
+// Module: MonitorPanel.swift — live logs + recent activity.
+
+struct NativeMonitorPanel: View {
+  @ObservedObject var store: TrayStore
+  @State private var stickToBottom = true
+
+  private var selectedSource: LogSourceSnapshot? {
+    store.logSources.first { $0.id == store.selectedLogSourceId } ?? store.logSources.first
+  }
+
+  private var hubHealthColor: Color {
+    if store.routingIssueCount > 0 { return anypickAmber }
+    if store.routingChoiceCount > 0 { return Color.accentColor }
+    return anypickSuccess
+  }
+
+  private var hubHealthSymbol: String {
+    if store.routingIssueCount > 0 { return "exclamationmark.triangle.fill" }
+    if store.routingChoiceCount > 0 { return "person.crop.circle.badge.questionmark" }
+    return "checkmark.shield"
+  }
+
+  var body: some View {
+    VStack(alignment: .leading, spacing: 12) {
+      NativeSectionHeader(title: "Live Logs", detail: "Local services · auto-refresh while open")
+
+      if let source = selectedSource {
+        VStack(alignment: .leading, spacing: 10) {
+          HStack(spacing: 10) {
+            NativeProviderBadge(id: source.providerId, size: 30)
+            Picker(
+              "Log source",
+              selection: Binding(
+                get: { source.id },
+                set: { store.selectLogSource($0) }
+              )
+            ) {
+              ForEach(store.logSources) { item in
+                Text(item.label).tag(item.id)
+              }
+            }
+            .labelsHidden()
+            .pickerStyle(.menu)
+            .frame(maxWidth: 280, alignment: .leading)
+            .accessibilityLabel("Log source")
+            Text(source.detail)
+              .font(.caption)
+              .foregroundStyle(.secondary)
+              .lineLimit(1)
+            Spacer(minLength: 8)
+            if store.loadingLogSourceId == source.id {
+              ProgressView()
+                .controlSize(.small)
+                .accessibilityLabel("Loading logs")
+            } else {
+              Text("Live")
+                .font(.caption.weight(.medium))
+                .foregroundStyle(anypickSuccess)
+                .accessibilityLabel("Live updates")
+            }
+            Button("Refresh") {
+              store.requestLogs(source)
+            }
+            .help("Refresh this log stream")
+            .disabled(store.loadingLogSourceId != nil)
+            Button("Copy") {
+              store.copyLogs(for: source.id)
+            }
+            .help("Copy visible logs")
+            .disabled(!canCopyLogs(source))
+          }
+          .buttonStyle(.bordered)
+          .controlSize(.small)
+
+          NativeLogViewer(
+            text: logText(for: source),
+            isPlaceholder: isPlaceholder(source),
+            stickToBottom: $stickToBottom
+          )
+          .frame(maxWidth: .infinity, maxHeight: .infinity, alignment: .topLeading)
+        }
+        .padding(12)
+        .frame(maxWidth: .infinity, maxHeight: .infinity, alignment: .topLeading)
+        .nativeGroup()
+      } else {
+        NativeEmptyState(
+          title: "No log sources available",
+          systemImage: "doc.text.magnifyingglass",
+          description: "Start a proxy service to inspect its local logs."
+        )
+        .frame(maxWidth: .infinity, maxHeight: .infinity)
+        .nativeGroup()
+      }
+
+      if let hub = store.proxyHub, let actionId = hub.testActionId {
+        HStack(spacing: 12) {
+          Image(systemName: hubHealthSymbol)
+            .font(.title3.weight(.medium))
+            .foregroundStyle(hubHealthColor)
+            .frame(width: 28, height: 28)
+            .background(
+              RoundedRectangle(cornerRadius: 8, style: .continuous)
+                .fill(hubHealthColor.opacity(0.1))
+            )
+          VStack(alignment: .leading, spacing: 2) {
+            Text("Routing health")
+              .font(.callout.weight(.semibold))
+            Text(
+              store.routingIssueCount > 0
+                ? "Resolve routing issues, then verify catalogs and the listener."
+                : store.routingChoiceCount > 0
+                  ? "Choose the hub source, then run the routing check."
+                  : hub.running
+                    ? "Refresh provider models and verify the owned listener."
+                    : "Contacts providers and starts the listener if needed."
+            )
+            .font(.caption)
+            .foregroundStyle(.secondary)
+            .lineLimit(2)
+          }
+          Spacer(minLength: 8)
+          Button("Run Check") {
+            store.invoke(actionId: actionId, label: "routing check")
+          }
+          .buttonStyle(.borderedProminent)
+          .controlSize(.small)
+          .disabled(store.busyRequestId != nil)
+          .help("Verify hub routing and refresh provider catalogs")
+        }
+        .padding(.horizontal, 12)
+        .padding(.vertical, 10)
+        .nativeGroup()
+      }
+
+      VStack(alignment: .leading, spacing: 6) {
+        NativeSectionHeader(
+          title: "Recent activity",
+          detail: "Switches, account changes, and proxy actions"
+        )
+        if store.activity.isEmpty {
+          Text("Switches, account changes, and proxy actions appear here.")
+            .font(.callout)
+            .foregroundStyle(.secondary)
+            .frame(maxWidth: .infinity, alignment: .leading)
+            .padding(.vertical, 12)
+            .padding(.horizontal, 12)
+            .nativeGroup()
+        } else {
+          VStack(spacing: 0) {
+            let events = Array(store.activity.prefix(6))
+            ForEach(Array(events.enumerated()), id: \.element.id) { index, event in
+              NativeActivityEventRow(event: event)
+              if index < events.count - 1 {
+                Divider().padding(.leading, 52)
+              }
+            }
+          }
+          .nativeGroup()
+        }
+      }
+    }
+    .frame(maxWidth: .infinity, maxHeight: .infinity, alignment: .topLeading)
+    .onAppear {
+      selectDefaultLogSource(load: true)
+      if let source = selectedSource {
+        store.startLogPolling(for: source.id)
+      }
+    }
+    .onDisappear {
+      store.stopLogPolling()
+    }
+    .onChange(of: store.logSources.map(\.id)) { _, _ in
+      selectDefaultLogSource(load: false)
+      if let source = selectedSource {
+        store.startLogPolling(for: source.id)
+      }
+    }
+    .onChange(of: store.selectedLogSourceId) { _, sourceId in
+      stickToBottom = true
+      loadSelectedSourceIfNeeded()
+      if !sourceId.isEmpty {
+        store.startLogPolling(for: sourceId)
+      }
+    }
+    .onChange(of: store.loadingLogSourceId) { _, sourceId in
+      if sourceId == nil { loadSelectedSourceIfNeeded() }
+    }
+  }
+
+  private func selectDefaultLogSource(load: Bool) {
+    if !store.logSources.contains(where: { $0.id == store.selectedLogSourceId }),
+       let first = store.logSources.first {
+      store.selectLogSource(first.id)
+    }
+    if load, let source = selectedSource { store.requestLogs(source) }
+  }
+
+  private func loadSelectedSourceIfNeeded() {
+    guard let source = selectedSource, store.logsBySource[source.id] == nil else { return }
+    store.requestLogs(source)
+  }
+
+  private func logText(for source: LogSourceSnapshot) -> String {
+    if store.loadingLogSourceId == source.id, store.logsBySource[source.id] == nil {
+      return "Loading \(source.label) logs…"
+    }
+    let text = store.logsBySource[source.id] ?? ""
+    switch store.logStatesBySource[source.id] {
+    case "not-running": return "Service is not running."
+    case "error": return text.isEmpty ? "Could not load logs." : text
+    case "empty": return "No log entries yet."
+    case "ready": return text.isEmpty ? "No log entries yet." : text
+    default: return text.isEmpty ? "No log entries yet." : text
+    }
+  }
+
+  private func isPlaceholder(_ source: LogSourceSnapshot) -> Bool {
+    let state = store.logStatesBySource[source.id]
+    if store.loadingLogSourceId == source.id, store.logsBySource[source.id] == nil {
+      return true
+    }
+    if state == "not-running" || state == "empty" { return true }
+    let text = store.logsBySource[source.id] ?? ""
+    return text.isEmpty
+  }
+
+  private func canCopyLogs(_ source: LogSourceSnapshot) -> Bool {
+    guard store.logsBySource[source.id]?.isEmpty == false else { return false }
+    let state = store.logStatesBySource[source.id]
+    return state == nil || state == "ready"
+  }
+}
+
+// MARK: - Log viewer
+
+struct NativeLogViewer: View {
+  let text: String
+  let isPlaceholder: Bool
+  @Binding var stickToBottom: Bool
+
+  private var lines: [String] {
+    if text.isEmpty { return [""] }
+    return text.split(separator: "\n", omittingEmptySubsequences: false).map(String.init)
+  }
+
+  var body: some View {
+    Group {
+      if isPlaceholder {
+        // No ScrollView — short status must stay top-leading (ScrollView centers).
+        Text(text)
+          .font(.system(size: 11.5, weight: .regular, design: .monospaced))
+          .foregroundStyle(Color.secondary)
+          .multilineTextAlignment(.leading)
+          .frame(maxWidth: .infinity, maxHeight: .infinity, alignment: .topLeading)
+          .padding(12)
+      } else {
+        // Bare ScrollView centers undersized children — pin content to topLeading
+        // by giving it at least the full viewport size.
+        GeometryReader { geo in
+          let viewportW = max(geo.size.width, 1)
+          let viewportH = max(geo.size.height, 1)
+          ScrollViewReader { proxy in
+            ScrollView([.vertical, .horizontal], showsIndicators: false) {
+              VStack(alignment: .leading, spacing: 1) {
+                ForEach(Array(lines.enumerated()), id: \.offset) { index, line in
+                  Text(line.isEmpty ? " " : line)
+                    .font(.system(size: 11.5, weight: .regular, design: .monospaced))
+                    .foregroundStyle(logLineColor(line))
+                    .multilineTextAlignment(.leading)
+                    .frame(maxWidth: .infinity, alignment: .leading)
+                    .textSelection(.enabled)
+                    .id(index)
+                }
+              }
+              .padding(12)
+              .frame(
+                minWidth: viewportW,
+                maxWidth: .infinity,
+                minHeight: viewportH,
+                alignment: .topLeading
+              )
+              .id("log-bottom-\(lines.count)")
+            }
+            .onChange(of: text) { _, _ in
+              guard stickToBottom else { return }
+              DispatchQueue.main.async {
+                proxy.scrollTo(lines.count - 1, anchor: .bottom)
+              }
+            }
+            .onAppear {
+              if stickToBottom {
+                proxy.scrollTo(lines.count - 1, anchor: .bottom)
+              }
+            }
+          }
+        }
+      }
+    }
+    .frame(maxWidth: .infinity, maxHeight: .infinity, alignment: .topLeading)
+    .background(
+      RoundedRectangle(cornerRadius: 8, style: .continuous)
+        .fill(Color.black.opacity(0.78))
+    )
+    .overlay(
+      RoundedRectangle(cornerRadius: 8, style: .continuous)
+        .stroke(nativeStroke.opacity(0.7), lineWidth: 0.5)
+    )
+    .clipShape(RoundedRectangle(cornerRadius: 8, style: .continuous))
+  }
+
+  private func logLineColor(_ line: String) -> Color {
+    let lower = line.lowercased()
+    if lower.contains("error")
+      || lower.contains("fatal")
+      || lower.contains("exception")
+      || lower.contains("traceback")
+      || lower.contains(" failed")
+      || lower.contains("✗")
+      || lower.hasPrefix("e ") {
+      return anypickRed
+    }
+    if lower.contains("warn")
+      || lower.contains("attention")
+      || lower.contains("timeout")
+      || lower.contains("retry") {
+      return anypickAmber
+    }
+    if lower.contains("started")
+      || lower.contains("success")
+      || lower.contains("ready")
+      || lower.contains("listening")
+      || lower.contains("✓")
+      || lower.contains(" ← ") {
+      return anypickSuccess.opacity(0.92)
+    }
+    // Terminal-style body text (Tauri log-viewer green tint).
+    return Color(red: 0.55, green: 0.90, blue: 0.68).opacity(0.92)
+  }
+}
+
+struct NativeActivityEventRow: View {
+  let event: ActivityEvent
+
+  var body: some View {
+    HStack(alignment: .firstTextBaseline, spacing: 10) {
+      Text(event.date, style: .time)
+        .font(.caption.monospaced())
+        .foregroundStyle(.secondary)
+        .frame(width: 60, alignment: .leading)
+      Image(systemName: event.isError ? "exclamationmark.circle.fill" : activitySymbol(event.kind))
+        .foregroundStyle(event.isError ? anypickRed : anypickSuccess)
+      Text(event.message)
+        .font(.callout)
+        .lineLimit(2)
+      Spacer()
+    }
+    .padding(12)
+  }
+
+  private func activitySymbol(_ kind: String) -> String {
+    switch kind {
+    case "switch": return "arrow.left.arrow.right.circle.fill"
+    case "account": return "person.crop.circle.fill"
+    case "gateway": return "network"
+    case "proxy": return "bolt.circle.fill"
+    case "quota": return "arrow.triangle.2.circlepath.circle.fill"
+    case "settings": return "gearshape.fill"
+    default: return "checkmark.circle.fill"
+    }
+  }
+}

package/dist/tray/native/ProxyPanel.swift

@@ -0,0 +1,326 @@
+import AppKit
+import Foundation
+import SwiftUI
+
+// Module: ProxyPanel.swift — proxy services + hub setup.
+
+struct NativeProxyPanel: View {
+  @ObservedObject var store: TrayStore
+  let openManage: () -> Void
+  let openMonitor: () -> Void
+  var openHubSetup: () -> Void = {}
+  var openModelAccounts: () -> Void = {}
+
+  var body: some View {
+    VStack(alignment: .leading, spacing: 14) {
+      NativeSectionHeader(
+        title: "Proxy services",
+        detail: "\(store.proxies.filter(\.running).count) active · loopback only"
+      )
+
+      if store.proxies.isEmpty {
+        NativeEmptyState(
+          title: "No proxy services configured",
+          systemImage: "network.slash",
+          description: "Add a proxy-capable native account from Accounts.",
+          actionTitle: "Accounts",
+          action: openManage
+        )
+        .nativeGroup()
+      } else {
+        VStack(spacing: 0) {
+          ForEach(Array(store.proxies.enumerated()), id: \.element.id) { index, proxy in
+            NativeProxyRow(
+              proxy: proxy,
+              store: store,
+              openMonitor: openMonitor,
+              openHubSetup: openHubSetup,
+              openModelAccounts: openModelAccounts
+            )
+            if index < store.proxies.count - 1 {
+              Divider().padding(.leading, TraySpacing.dividerLeading)
+            }
+          }
+        }
+        .nativeGroup()
+      }
+    }
+  }
+}
+
+struct NativeProxyRow: View {
+  let proxy: ProxySnapshot
+  @ObservedObject var store: TrayStore
+  let openMonitor: () -> Void
+  var openHubSetup: () -> Void = {}
+  var openModelAccounts: () -> Void = {}
+  @State private var optimisticRunning: Bool?
+
+  private var isHub: Bool { proxy.providerId == "proxy-hub" }
+  private var displayedRunning: Bool { optimisticRunning ?? proxy.running }
+
+  var body: some View {
+    // Settings list: badge | title+detail | ⋯ | switch
+    HStack(alignment: .center, spacing: 10) {
+      NativeProviderBadge(id: proxy.providerId, size: 28)
+      VStack(alignment: .leading, spacing: 2) {
+        Text(proxy.label)
+          .font(.body.weight(.medium))
+          .lineLimit(1)
+        HStack(spacing: 6) {
+          NativeStatusDot(
+            kind: displayedRunning ? .on : .off,
+            title: displayedRunning ? "Running" : "Stopped"
+          )
+          if let address = proxy.address {
+            Text(address)
+              .font(.caption.monospaced())
+              .foregroundStyle(.secondary)
+              .lineLimit(1)
+              .textSelection(.enabled)
+          } else {
+            Text(proxy.detail)
+              .font(.caption)
+              .foregroundStyle(.secondary)
+              .lineLimit(1)
+          }
+        }
+      }
+      .frame(maxWidth: .infinity, alignment: .leading)
+
+      if let address = proxy.address {
+        Button {
+          store.copyAddress(address)
+        } label: {
+          Image(systemName: "doc.on.doc")
+            .font(.caption.weight(.medium))
+            .foregroundStyle(.secondary)
+            .frame(width: 28, height: 28)
+            .contentShape(Rectangle())
+        }
+        .buttonStyle(AnyPickPlainButtonStyle(cornerRadius: 6))
+        .help("Copy proxy address")
+        .accessibilityLabel("Copy proxy address")
+      }
+
+      Menu {
+        if isHub {
+          Button("Set up…", action: openHubSetup)
+          Button("Hub sources…", action: openModelAccounts)
+        }
+        if displayedRunning {
+          Button("Restart") {
+            store.invoke(actionId: proxy.restartActionId, label: "Restart \(proxy.label)")
+          }
+          .disabled(store.busyRequestId != nil)
+        }
+        if proxy.logsAvailable != false {
+          Button("View logs") {
+            store.selectLogSource(proxy.id)
+            store.requestLogs(proxy)
+            openMonitor()
+          }
+        }
+        Divider()
+        Button(displayedRunning ? "Stop" : "Start") {
+          optimisticRunning = !displayedRunning
+          if store.invoke(actionId: proxy.toggleActionId, label: proxy.label) == nil {
+            optimisticRunning = nil
+          }
+        }
+        .disabled(store.busyRequestId != nil)
+      } label: {
+        TrayOverflowMenuLabel()
+      }
+      .trayMenuLabel()
+      .help("\(proxy.label) actions")
+      .accessibilityLabel("\(proxy.label) actions")
+
+      AnyPickSwitch(
+        title: "Enable \(proxy.label)",
+        isOn: Binding(
+          get: { displayedRunning },
+          set: { enabled in
+            guard enabled != displayedRunning else { return }
+            optimisticRunning = enabled
+            if store.invoke(actionId: proxy.toggleActionId, label: proxy.label) == nil {
+              optimisticRunning = nil
+            }
+          }
+        ),
+        isEnabled: store.busyRequestId == nil
+      )
+    }
+    .padding(.horizontal, TraySpacing.rowPadding)
+    .padding(.vertical, 10)
+    .onChange(of: proxy.running) { _, _ in optimisticRunning = nil }
+    .onChange(of: store.busyRequestId) { _, requestId in
+      if requestId == nil { optimisticRunning = nil }
+    }
+    .onChange(of: store.lastResult?.requestId) { _, _ in
+      if store.lastResult?.status == "error" { optimisticRunning = nil }
+    }
+  }
+}
+
+/// Numbered Hub DX: sources → listener → assign apps (detail under Proxies).
+struct NativeHubSetupPanel: View {
+  @ObservedObject var store: TrayStore
+  let openSources: () -> Void
+  let openRouting: () -> Void
+  let openAccounts: () -> Void
+  let openManage: () -> Void
+
+  private var hub: ProxySnapshot? { store.proxyHub }
+  private var enabledSources: Int { store.hubSources.filter(\.enabled).count }
+  private var totalSources: Int { store.hubSources.count }
+  private var appsOffHub: [String] {
+    store.appRouteClients.filter { client in
+      !(store.appActions(client).first(where: \.selected)?.routeKind == "hub")
+    }
+  }
+
+  var body: some View {
+    VStack(alignment: .leading, spacing: 16) {
+      NativeSectionHeader(
+        title: "Configure Proxy Hub",
+        detail: "Sources → start listener → point apps at the Hub"
+      )
+
+      VStack(spacing: 0) {
+        hubStep(
+          number: "1",
+          done: enabledSources > 0,
+          title: "Enable hub sources",
+          detail: totalSources == 0
+            ? "Add OpenCode, Gemini, or Grok accounts first."
+            : "\(enabledSources) of \(totalSources) enabled · choose which accounts contribute models."
+        ) {
+          if totalSources == 0 {
+            Button("Add Account", action: openManage)
+              .buttonStyle(.borderedProminent)
+              .controlSize(.small)
+          } else {
+            Button("Edit sources…", action: openSources)
+              .buttonStyle(.bordered)
+              .controlSize(.small)
+          }
+        }
+        Divider().padding(.leading, 44)
+        hubStep(
+          number: "2",
+          done: hub?.running == true,
+          title: "Start the listener",
+          detail: hub?.address.map { "Loopback OpenAI-compatible endpoint · \($0)" }
+            ?? "One local endpoint for all enabled Hub models."
+        ) {
+          if let hub {
+            NativeHubListenerSwitch(hub: hub, store: store, isEnabled: enabledSources > 0)
+          }
+        }
+        Divider().padding(.leading, 44)
+        hubStep(
+          number: "3",
+          done: !store.appRouteClients.isEmpty && appsOffHub.isEmpty,
+          title: "Point apps at the Hub",
+          detail: appsOffHub.isEmpty
+            ? (store.appRouteClients.isEmpty
+              ? "No switchable apps detected yet."
+              : "All apps are already routed via Proxy Hub.")
+            : "Per-app route · not automatic. \(appsOffHub.count) app\(appsOffHub.count == 1 ? "" : "s") still on a direct account or gateway."
+        ) {
+          Button("Apps", action: openAccounts)
+            .buttonStyle(.bordered)
+            .controlSize(.small)
+        }
+      }
+      .nativeGroup()
+
+      if store.routingIssueCount + store.routingChoiceCount > 0 {
+        NativeSectionHeader(
+          title: "Routing health",
+          detail: "Resolve before every model ID is usable"
+        )
+        TrayAttentionCallout(
+          kind: store.routingIssueCount > 0 ? .warning : .info,
+          title: store.routingIssueCount > 0
+            ? "\(store.routingIssueCount) routing issue\(store.routingIssueCount == 1 ? "" : "s") — pick a source or fix unavailable accounts"
+            : "Choose \(store.routingChoiceCount) hub source\(store.routingChoiceCount == 1 ? "" : "s") for overlapping models",
+          actionTitle: "Fix"
+        ) {
+          openRouting()
+        }
+      }
+    }
+  }
+
+  @ViewBuilder
+  private func hubStep<Actions: View>(
+    number: String,
+    done: Bool,
+    title: String,
+    detail: String,
+    @ViewBuilder actions: () -> Actions
+  ) -> some View {
+    HStack(alignment: .top, spacing: 12) {
+      ZStack {
+        Circle()
+          .fill(done ? anypickSuccess.opacity(0.15) : Color.primary.opacity(0.06))
+          .frame(width: 26, height: 26)
+        if done {
+          Image(systemName: "checkmark")
+            .font(.caption.weight(.bold))
+            .foregroundStyle(anypickSuccess)
+        } else {
+          Text(number)
+            .font(.caption.weight(.semibold))
+            .foregroundStyle(.secondary)
+        }
+      }
+      VStack(alignment: .leading, spacing: 8) {
+        Text(title)
+          .font(.body.weight(.semibold))
+        Text(detail)
+          .font(.callout)
+          .foregroundStyle(.secondary)
+          .fixedSize(horizontal: false, vertical: true)
+        actions()
+      }
+      Spacer(minLength: 0)
+    }
+    .padding(14)
+  }
+}
+
+private struct NativeHubListenerSwitch: View {
+  let hub: ProxySnapshot
+  @ObservedObject var store: TrayStore
+  var isEnabled: Bool
+  @State private var optimisticRunning: Bool?
+
+  private var displayedRunning: Bool { optimisticRunning ?? hub.running }
+
+  var body: some View {
+    AnyPickSwitch(
+      title: "Enable Proxy Hub",
+      isOn: Binding(
+        get: { displayedRunning },
+        set: { enabled in
+          guard enabled != displayedRunning else { return }
+          optimisticRunning = enabled
+          if store.invoke(actionId: hub.toggleActionId, label: hub.label) == nil {
+            optimisticRunning = nil
+          }
+        }
+      ),
+      isEnabled: store.busyRequestId == nil && isEnabled
+    )
+    .onChange(of: hub.running) { _, _ in optimisticRunning = nil }
+    .onChange(of: store.busyRequestId) { _, requestId in
+      if requestId == nil { optimisticRunning = nil }
+    }
+    .onChange(of: store.lastResult?.requestId) { _, _ in
+      if store.lastResult?.status == "error" { optimisticRunning = nil }
+    }
+  }
+}