anypick 1.0.0

package/dist/tray/native/AccountsPanel.swift

@@ -0,0 +1,434 @@
+import AppKit
+import Foundation
+import SwiftUI
+
+// Module: AccountsPanel.swift — apps routes and hub sources
+
+struct NativeAccountsPanel: View {
+  @ObservedObject var store: TrayStore
+  let openManage: () -> Void
+  let openModelAccounts: () -> Void
+  let openRoutingIssues: () -> Void
+  let openClientModels: (String) -> Void
+  let openHubSetup: () -> Void
+  /// nil = auto-expand when few CLIs (discoverability); user toggle pins state.
+  @State private var showingDirectClients: Bool? = nil
+  @AppStorage(TrayPreferences.Key.onboardingDismissed) private var onboardingDismissed = false
+
+  private var directClientsExpanded: Bool {
+    showingDirectClients ?? (store.nativeSourceIds.count <= 3)
+  }
+
+  private var showOnboarding: Bool {
+    trayShouldShowOnboarding(store: store, dismissed: onboardingDismissed)
+  }
+
+  var body: some View {
+    VStack(alignment: .leading, spacing: TraySpacing.groupGap) {
+      if !store.snapshotReady {
+        NativeSnapshotLoading()
+          .nativeGroup()
+      } else if showOnboarding {
+        NativeOnboardingChecklist(
+          store: store,
+          openAccounts: openManage,
+          openHub: openHubSetup,
+          compact: false
+        )
+        .transition(TrayMotion.panelTransition)
+      }
+
+      if !store.appRouteClients.isEmpty {
+        NativeSectionHeader(
+          title: "Apps",
+          detail: "Where Claude Code & Codex send traffic",
+          action: openManage
+        ) {
+          Text("Accounts…")
+        }
+        VStack(spacing: 0) {
+          ForEach(Array(store.appRouteClients.enumerated()), id: \.element) { index, client in
+            NativeAppRouteRow(
+              client: client,
+              route: store.route(client),
+              actions: store.appActions(client),
+              config: store.modelConfig(client),
+              usage: store.usage(for: client),
+              store: store,
+              customize: { clientId in openClientModels(clientId) }
+            )
+            if index < store.appRouteClients.count - 1 {
+              Divider().padding(.leading, TraySpacing.dividerLeading)
+            }
+          }
+        }
+        .nativeGroup()
+      }
+
+      if let hub = store.proxyHub, store.snapshotReady, !store.isFirstRun {
+        NativeSectionHeader(
+          title: "Proxy Hub",
+          detail: "One local endpoint · many hub sources"
+        ) {
+          openHubSetup()
+        } actionLabel: {
+          Text("Set up…")
+        }
+        NativeHubCard(
+          hub: hub,
+          store: store,
+          openManage: openManage,
+          openModelAccounts: openModelAccounts,
+          openRoutingIssues: openRoutingIssues
+        )
+      }
+
+      if !store.nativeSourceIds.isEmpty {
+        VStack(spacing: 0) {
+          Button {
+            withAnimation(TrayMotion.standard) {
+              showingDirectClients = !directClientsExpanded
+            }
+          } label: {
+            HStack(spacing: 10) {
+              Image(systemName: "terminal")
+                .font(.body.weight(.medium))
+                .foregroundStyle(.secondary)
+                .frame(width: 28, height: 28)
+                .background(
+                  RoundedRectangle(cornerRadius: 7, style: .continuous)
+                    .fill(Color.primary.opacity(0.05))
+                )
+              VStack(alignment: .leading, spacing: 2) {
+                Text("Other CLIs")
+                  .font(.body.weight(.medium))
+                Text(
+                  "\(store.nativeSourceIds.count) direct client\(store.nativeSourceIds.count == 1 ? "" : "s") · account switching only"
+                )
+                .font(.caption)
+                .foregroundStyle(.secondary)
+              }
+              Spacer()
+              Image(systemName: directClientsExpanded ? "chevron.up" : "chevron.down")
+                .font(.caption.weight(.semibold))
+                .foregroundStyle(.tertiary)
+            }
+            .contentShape(Rectangle())
+            .padding(.horizontal, TraySpacing.rowPadding)
+            .padding(.vertical, 10)
+          }
+          .buttonStyle(AnyPickPlainButtonStyle(cornerRadius: 10))
+          .accessibilityLabel("Other CLIs")
+          .accessibilityHint(
+            directClientsExpanded ? "Collapse direct clients" : "Expand direct clients"
+          )
+          .accessibilityValue(
+            "\(store.nativeSourceIds.count) client\(store.nativeSourceIds.count == 1 ? "" : "s")"
+          )
+
+          if directClientsExpanded {
+            Divider().padding(.leading, TraySpacing.dividerLeading)
+            ForEach(Array(store.nativeSourceIds.enumerated()), id: \.element) { index, sourceId in
+              NativeOnlyRouteRow(
+                sourceId: sourceId,
+                actions: store.nativeSourceActions(sourceId),
+                usage: usage(for: sourceId),
+                store: store
+              )
+              if index < store.nativeSourceIds.count - 1 {
+                Divider().padding(.leading, TraySpacing.dividerLeading)
+              }
+            }
+          }
+        }
+        .nativeGroup()
+      }
+
+      // First-run / needs-apps covered by NativeOnboardingChecklist above.
+    }
+  }
+
+  private func usage(for sourceId: String) -> UsageSnapshot? {
+    store.usage(for: sourceId)
+  }
+}
+struct NativeHubCard: View {
+  let hub: ProxySnapshot
+  @ObservedObject var store: TrayStore
+  let openManage: () -> Void
+  let openModelAccounts: () -> Void
+  let openRoutingIssues: () -> Void
+
+  private var hasSources: Bool { (hub.sourceCount ?? 0) > 0 }
+  private var enabledSources: [HubSourceSnapshot] { store.hubSources.filter(\.enabled) }
+  private var issueCount: Int { store.routingIssueCount }
+  private var choiceCount: Int { store.routingChoiceCount }
+
+  private var statusTitle: String {
+    if issueCount > 0 { return "Needs attention" }
+    if choiceCount > 0 { return "Choose a source" }
+    if hub.running { return "Active" }
+    if hasSources { return "Ready" }
+    return "Set up sources"
+  }
+
+  private var statusKind: NativeStatusDot.Kind {
+    if issueCount > 0 { return .warn }
+    if choiceCount > 0 { return .warn }
+    if hub.running { return .on }
+    return hasSources ? .on : .off
+  }
+
+  var body: some View {
+    VStack(alignment: .leading, spacing: 12) {
+      HStack(spacing: 12) {
+        NativeProviderBadge(id: "proxy-hub", size: 36)
+        VStack(alignment: .leading, spacing: 3) {
+          Text("Multi-model routing")
+            .font(.body.weight(.semibold))
+          HStack(spacing: 6) {
+            NativeStatusDot(kind: statusKind, title: statusTitle)
+            Text(
+              "· \(hub.sourceCount ?? 0) accounts · \(hub.modelCount ?? 0) models · \(hub.clientCount ?? 0) apps"
+            )
+            .font(.caption)
+            .foregroundStyle(.secondary)
+            .lineLimit(1)
+          }
+        }
+        Spacer(minLength: 8)
+      }
+
+      Divider()
+
+      if store.hubSources.isEmpty {
+        HStack(spacing: 10) {
+          Image(systemName: "person.crop.circle.badge.plus")
+            .font(.body.weight(.medium))
+            .foregroundStyle(Color.accentColor)
+            .frame(width: 28, height: 28)
+            .background(
+              RoundedRectangle(cornerRadius: 7, style: .continuous)
+                .fill(Color.accentColor.opacity(0.1))
+            )
+          VStack(alignment: .leading, spacing: 2) {
+            Text("No supported accounts yet")
+              .font(.callout.weight(.semibold))
+            Text("Add OpenCode, Gemini, or Grok first.")
+              .font(.caption)
+              .foregroundStyle(.secondary)
+          }
+          Spacer()
+          Button("Add Account", action: openManage)
+            .buttonStyle(.borderedProminent)
+            .controlSize(.small)
+        }
+      } else {
+        HStack(spacing: 10) {
+          HStack(spacing: -6) {
+            ForEach(Array(enabledSources.prefix(3))) { source in
+              NativeProviderBadge(id: source.providerId, size: 26)
+                .overlay(
+                  RoundedRectangle(cornerRadius: 6, style: .continuous)
+                    .stroke(nativeWindowFill, lineWidth: 2)
+                )
+            }
+          }
+          if enabledSources.count > 3 {
+            Text("+\(enabledSources.count - 3)")
+              .font(.caption.weight(.semibold))
+              .foregroundStyle(.secondary)
+          }
+          VStack(alignment: .leading, spacing: 2) {
+            Text(
+              enabledSources.isEmpty
+                ? "No hub sources enabled"
+                : "\(enabledSources.count) hub \(enabledSources.count == 1 ? "source" : "sources") enabled"
+            )
+            .font(.callout.weight(.semibold))
+            Text("Choose which accounts contribute models.")
+              .font(.caption)
+              .foregroundStyle(.secondary)
+          }
+          Spacer(minLength: 6)
+          Button("Sources…", action: openModelAccounts)
+            .buttonStyle(.bordered)
+            .controlSize(.small)
+        }
+      }
+
+      if issueCount > 0 {
+        TrayAttentionCallout(
+          kind: .warning,
+          title: "\(issueCount) routing \(issueCount == 1 ? "issue" : "issues") — pick a source or fix unavailable accounts",
+          actionTitle: "Fix"
+        ) {
+          openRoutingIssues()
+        }
+      } else if choiceCount > 0 {
+        TrayAttentionCallout(
+          kind: .info,
+          title: "Choose \(choiceCount) hub source\(choiceCount == 1 ? "" : "s") for overlapping models",
+          actionTitle: "Choose"
+        ) {
+          openRoutingIssues()
+        }
+      }
+    }
+    .padding(14)
+    .nativeGroup()
+  }
+}
+
+struct NativeHubSourceRow: View {
+  let source: HubSourceSnapshot
+  @ObservedObject var store: TrayStore
+  @State private var optimisticEnabled: Bool?
+
+  private var displayedEnabled: Bool { optimisticEnabled ?? source.enabled }
+
+  var body: some View {
+    HStack(alignment: .top, spacing: 10) {
+      NativeProviderBadge(id: source.providerId, size: 30)
+      VStack(alignment: .leading, spacing: 3) {
+        Text(source.label)
+          .font(.callout.weight(.medium))
+          .lineLimit(1)
+        HStack(spacing: 5) {
+          Text(source.detail).lineLimit(1)
+          if let modelCount = source.modelCount {
+            Text("· \(modelCount) models")
+          }
+        }
+        .font(.caption)
+        .foregroundStyle(.secondary)
+        if let warning = source.warning, !warning.isEmpty {
+          Label(warning, systemImage: "exclamationmark.triangle.fill")
+            .font(.caption)
+            .foregroundStyle(anypickAmber)
+            .lineLimit(2)
+        }
+      }
+      Spacer(minLength: 8)
+      AnyPickSwitch(
+        title: "Enable \(source.label)",
+        isOn: Binding(
+          get: { displayedEnabled },
+          set: { enabled in
+            optimisticEnabled = enabled
+            store.mutate(
+              operation: "hub-source-toggle",
+              name: source.name,
+              providerId: source.providerId,
+              enabled: enabled,
+              activityLabel: "updating \(source.label)"
+            )
+          }
+        ),
+        isEnabled: store.busyRequestId == nil
+      )
+    }
+    .padding(.horizontal, 12)
+    .padding(.vertical, 10)
+    .onChange(of: source.enabled) { _, _ in optimisticEnabled = nil }
+    .onChange(of: store.busyRequestId) { _, requestId in
+      if requestId == nil { optimisticEnabled = nil }
+    }
+  }
+}
+
+enum NativeHubSourceFilter: String, CaseIterable, Identifiable {
+  case all = "All"
+  case enabled = "Enabled"
+
+  var id: String { rawValue }
+}
+
+struct NativeModelAccountsPanel: View {
+  @ObservedObject var store: TrayStore
+  let openManage: () -> Void
+  @State private var search = ""
+  @State private var filter = NativeHubSourceFilter.all
+
+  private var filteredSources: [HubSourceSnapshot] {
+    let query = search.trimmingCharacters(in: .whitespacesAndNewlines)
+    return store.hubSources.filter { source in
+      let matchesFilter = filter == .all || source.enabled
+      let matchesQuery = query.isEmpty ||
+        source.label.localizedCaseInsensitiveContains(query) ||
+        source.detail.localizedCaseInsensitiveContains(query) ||
+        source.providerId.localizedCaseInsensitiveContains(query) ||
+        (source.warning?.localizedCaseInsensitiveContains(query) ?? false)
+      return matchesFilter && matchesQuery
+    }
+    .sorted {
+      if $0.enabled != $1.enabled { return $0.enabled }
+      return $0.label.localizedCaseInsensitiveCompare($1.label) == .orderedAscending
+    }
+  }
+
+  private var providerIds: [String] {
+    Array(Set(filteredSources.map { nativeProviderFamily($0.providerId) }))
+      .sorted {
+        nativeProviderRank($0) == nativeProviderRank($1)
+          ? nativeProviderName($0) < nativeProviderName($1)
+          : nativeProviderRank($0) < nativeProviderRank($1)
+      }
+  }
+
+  var body: some View {
+    VStack(alignment: .leading, spacing: 14) {
+      HStack(spacing: 10) {
+        NativeSearchField(placeholder: "Search hub sources", text: $search)
+        Picker("Filter", selection: $filter) {
+          ForEach(NativeHubSourceFilter.allCases) { item in
+            Text(item.rawValue).tag(item)
+          }
+        }
+        .pickerStyle(.segmented)
+        .labelsHidden()
+        .frame(width: 160)
+      }
+
+      HStack {
+        Text("\(store.hubSources.filter(\.enabled).count) of \(store.hubSources.count) enabled")
+          .font(.caption)
+          .foregroundStyle(.secondary)
+        Spacer()
+        Button("Add Account", action: openManage)
+          .buttonStyle(.bordered)
+          .controlSize(.small)
+      }
+
+      if providerIds.isEmpty {
+        NativeEmptyState(
+          title: store.hubSources.isEmpty ? "No hub sources yet" : "No matching sources",
+          systemImage: store.hubSources.isEmpty
+            ? "person.crop.circle.badge.plus"
+            : "magnifyingglass",
+          description: store.hubSources.isEmpty
+            ? "Add an OpenCode, Gemini, or Grok account under Saved accounts."
+            : "Try another search or show all sources."
+        )
+        .nativeGroup()
+      } else {
+        ForEach(providerIds, id: \.self) { providerId in
+          let sources = filteredSources.filter { nativeProviderFamily($0.providerId) == providerId }
+          NativeSectionHeader(
+            title: nativeProviderName(providerId),
+            detail: "\(sources.filter(\.enabled).count) enabled · \(sources.count) shown"
+          )
+          LazyVStack(spacing: 0) {
+            ForEach(Array(sources.enumerated()), id: \.element.id) { index, source in
+              NativeHubSourceRow(source: source, store: store)
+              if index < sources.count - 1 {
+                Divider().padding(.leading, 52)
+              }
+            }
+          }
+          .nativeGroup()
+        }
+      }
+    }
+  }
+}

package/dist/tray/native/AppEntry.swift

@@ -0,0 +1,229 @@
+import AppKit
+import Foundation
+import SwiftUI
+
+// Module: AppEntry.swift — split from AnyPickTray.swift for maintainability.
+
+@MainActor
+final class AnyPickAppDelegate: NSObject, NSApplicationDelegate, NSWindowDelegate {
+  let store = TrayStore(
+    initialCount: CommandLine.arguments.count > 1 ? Int(CommandLine.arguments[1]) ?? 0 : 0
+  )
+  let navigation = NativeNavigationModel()
+  private var mainWindowController: NSWindowController?
+  /// True while the main window is open as a normal app (Dock + click-outside safe).
+  private var mainWindowPromoted = false
+
+  func applicationDidFinishLaunching(_ notification: Notification) {
+    // Menu-bar only until the user opens the full window.
+    NSApp.setActivationPolicy(.accessory)
+    if ProcessInfo.processInfo.environment["ANYPICK_TRAY_PROTOCOL_SELF_TEST"] == "1" {
+      store.invoke(ActionSnapshot(
+        id: "self-test",
+        clientId: "codex",
+        sourceId: "codex",
+        client: "Codex",
+        label: "self-test",
+        detail: nil,
+        kind: "native",
+        presentation: "app-route",
+        selected: false,
+        enabled: true,
+        disabledReason: nil,
+        routeKind: "direct-account",
+        modelId: nil,
+        upstreamProviderId: nil,
+        upstreamSourceLabel: nil
+      ))
+      DispatchQueue.main.asyncAfter(deadline: .now() + 0.15) { NSApp.terminate(nil) }
+      return
+    }
+    FileHandle.standardInput.readabilityHandler = { [weak self] handle in
+      let data = handle.availableData
+      guard !data.isEmpty else {
+        handle.readabilityHandler = nil
+        DispatchQueue.main.async { NSApp.terminate(nil) }
+        return
+      }
+      DispatchQueue.main.async { self?.store.consume(data) }
+    }
+  }
+
+  func applicationShouldHandleReopen(_ sender: NSApplication, hasVisibleWindows flag: Bool) -> Bool {
+    if !flag {
+      openMainWindow()
+    }
+    return true
+  }
+
+  func openMainWindow(tab: NativeTrayTab = .accounts, clientId: String? = nil) {
+    navigation.show(tab, clientId: clientId)
+    promoteMainWindow()
+
+    if let window = mainWindowController?.window {
+      if !window.isVisible { window.setIsVisible(true) }
+      window.makeKeyAndOrderFront(nil)
+      NSApp.activate(ignoringOtherApps: true)
+      return
+    }
+
+    let rootView = NativeMainWindow(store: store, navigation: navigation)
+    let window = NSWindow(contentViewController: NSHostingController(rootView: rootView))
+    window.title = "AnyPick"
+    // Settings-like utility: resizable (HIG accessibility / logs), with a sensible minimum.
+    window.styleMask = [.titled, .closable, .miniaturizable, .resizable]
+    window.toolbarStyle = .unified
+    window.tabbingMode = .disallowed
+    window.isReleasedWhenClosed = false
+    window.delegate = self
+    window.setFrameAutosaveName("AnyPickMainWindow")
+    let minSize = NSSize(width: 720, height: 480)
+    let defaultSize = NSSize(width: 840, height: 640)
+    window.contentMinSize = minSize
+    // Prefer the user’s last size; first launch gets the default utility size.
+    if !window.setFrameUsingName("AnyPickMainWindow") {
+      window.setContentSize(defaultSize)
+      window.center()
+    }
+
+    let controller = NSWindowController(window: window)
+    mainWindowController = controller
+    controller.showWindow(nil)
+    window.makeKeyAndOrderFront(nil)
+    NSApp.activate(ignoringOtherApps: true)
+  }
+
+  /// Full window behaves like a normal Mac app (survives click-outside, Dock icon).
+  private func promoteMainWindow() {
+    guard !mainWindowPromoted else { return }
+    mainWindowPromoted = true
+    AnyPickAppIcon.applyToApp()
+    NSApp.setActivationPolicy(.regular)
+  }
+
+  /// Closing the last main window returns to menu-bar-only accessory mode.
+  private func demoteIfNoMainWindow() {
+    guard mainWindowPromoted else { return }
+    let mainVisible = mainWindowController?.window?.isVisible == true
+    guard !mainVisible else { return }
+    mainWindowPromoted = false
+    NSApp.setActivationPolicy(.accessory)
+  }
+
+  func windowWillClose(_ notification: Notification) {
+    guard let window = notification.object as? NSWindow,
+          window === mainWindowController?.window else { return }
+    // Defer: isVisible is still true during willClose.
+    DispatchQueue.main.async { [weak self] in
+      self?.demoteIfNoMainWindow()
+    }
+  }
+
+  func windowShouldClose(_ sender: NSWindow) -> Bool {
+    // Hide instead of destroy so frame autosave + state survive; still demotes policy.
+    if sender === mainWindowController?.window {
+      sender.orderOut(nil)
+      demoteIfNoMainWindow()
+      return false
+    }
+    return true
+  }
+
+  /// HIG ⌘W — hide the utility window (same as the close button).
+  func closeMainWindow() {
+    guard let window = mainWindowController?.window, window.isVisible else { return }
+    window.performClose(nil)
+  }
+}
+@main
+struct AnyPickTrayApp: App {
+  @NSApplicationDelegateAdaptor(AnyPickAppDelegate.self) private var delegate
+
+  var body: some Scene {
+    MenuBarExtra {
+      NativeQuickPanel(store: delegate.store) { tab, clientId in
+        delegate.openMainWindow(tab: tab, clientId: clientId)
+      }
+    } label: {
+      StatusLabel(store: delegate.store)
+    }
+    .menuBarExtraStyle(.window)
+    .commands {
+      // Standard macOS app commands while the main window is promoted.
+      CommandGroup(replacing: .appSettings) {
+        Button("Settings…") {
+          delegate.openMainWindow(tab: .settings)
+        }
+        .keyboardShortcut(",", modifiers: .command)
+      }
+      CommandGroup(after: .newItem) {
+        Button("Add Account…") {
+          delegate.openMainWindow(tab: .manage)
+        }
+        .keyboardShortcut("n", modifiers: .command)
+      }
+      CommandGroup(after: .toolbar) {
+        Button("Refresh") {
+          delegate.store.refreshAll()
+        }
+        .keyboardShortcut("r", modifiers: .command)
+        Button("Restart Proxies") {
+          delegate.store.restartProxies()
+        }
+        .keyboardShortcut("r", modifiers: [.command, .shift])
+      }
+      CommandGroup(replacing: .saveItem) {
+        Button("Close") {
+          delegate.closeMainWindow()
+        }
+        .keyboardShortcut("w", modifiers: .command)
+      }
+      CommandMenu("Go") {
+        Button("Apps") { delegate.openMainWindow(tab: .accounts) }
+          .keyboardShortcut("1", modifiers: .command)
+        Button("Accounts") { delegate.openMainWindow(tab: .manage) }
+          .keyboardShortcut("2", modifiers: .command)
+        Button("Proxies") { delegate.openMainWindow(tab: .proxy) }
+          .keyboardShortcut("3", modifiers: .command)
+        Button("Logs") { delegate.openMainWindow(tab: .monitor) }
+          .keyboardShortcut("4", modifiers: .command)
+        Button("Settings") { delegate.openMainWindow(tab: .settings) }
+          .keyboardShortcut("5", modifiers: .command)
+      }
+    }
+  }
+}
+
+/// Menu-bar glyph — template monochrome; attention uses a small status mark (HIG).
+struct StatusLabel: View {
+  @ObservedObject var store: TrayStore
+
+  private var attentionCount: Int { store.attentionCount }
+  private var hasIssues: Bool { store.routingIssueCount > 0 }
+
+  var body: some View {
+    // Template base stays monochrome; colored badge is the only non-template element.
+    ZStack(alignment: .topTrailing) {
+      Image(nsImage: AnyPickTrayIcon.image)
+        .renderingMode(.template)
+      if attentionCount > 0 {
+        Circle()
+          .fill(hasIssues ? Color.orange : Color.accentColor)
+          .frame(width: 6, height: 6)
+          // Hairline ring so the badge stays readable on light/dark menu bars.
+          .overlay(
+            Circle()
+              .strokeBorder(Color.primary.opacity(0.35), lineWidth: 0.5)
+          )
+          .offset(x: 1, y: -1)
+          .accessibilityHidden(true)
+      }
+    }
+    .accessibilityLabel(
+      attentionCount > 0
+        ? "AnyPick, \(attentionCount) \(attentionCount == 1 ? "item needs" : "items need") attention"
+        : "AnyPick"
+    )
+    .accessibilityHint(attentionCount > 0 ? "Open AnyPick to review routing" : "")
+  }
+}