mirror of
https://github.com/wu736139669/hapi.git
synced 2026-11-18 03:27:08 +00:00
- Fetch Claude models from the machine catalog, expose the full grouped picker with per-model efforts, and remember launch defaults. - Add directory quick-create, known-directory suggestions, live machine CPU/memory in filters, and the DeepSeek agent icon. - Add the collapsible session status card (goal, tasks, subagents, terminals, team), context-usage meter, and compaction/background/fast/collaboration composer chips without the redundant inline model controls. - Add code block line numbers, wrapping and collapse; per-message share and rewind; a floating session search that does not push the list; and move sign out to the bottom of Settings. via [HAPI](https://hapi.run) Co-Authored-By: HAPI <noreply@hapi.run> Co-Authored-By: Claude Code <noreply@anthropic.com>
1329 lines
50 KiB
Swift
1329 lines
50 KiB
Swift
import Foundation
|
|
import HapiClient
|
|
import HapiProtocol
|
|
import Observation
|
|
|
|
// MARK: - UI models
|
|
|
|
/// One machine row of the picker (Android `MachineOptionUi` port).
|
|
struct MachineOptionUI: Identifiable, Equatable {
|
|
let id: String
|
|
/// `displayName || host || id.prefix(8)` plus ` (platform)` and CLI version.
|
|
let label: String
|
|
/// e.g. `CPU 12% · Mem 45%`; nil when the runner reports no health.
|
|
let healthLabel: String?
|
|
}
|
|
|
|
/// Directory hint under the input (web `directoryStatusMessage` + tone).
|
|
struct DirectoryStatusUI: Equatable {
|
|
let message: String
|
|
let isError: Bool
|
|
}
|
|
|
|
/// Which permission control the current flavor renders (web `PermissionField`).
|
|
enum PermissionUI: Equatable {
|
|
/// Native permission-mode picker (claude, grok, codex-family —
|
|
/// `NewSessionLogic.usesNativePermissionSelect`).
|
|
case nativeSelect([PermissionModeOption])
|
|
/// HAPI YOLO toggle (agy/cursor) with the native mode it maps to.
|
|
case yoloToggle(nativeModeLabel: String?)
|
|
/// Pi: the agent manages its own permissions.
|
|
case managed
|
|
}
|
|
|
|
/// Machine codex-models catalog state (web `useCodexModels`).
|
|
enum CodexModelsState: Equatable {
|
|
case hidden
|
|
case loading
|
|
case loaded([CodexModelSummary])
|
|
/// Runner has no machine RPC (`rpc_target_missing`) — hide the picker.
|
|
case unsupported
|
|
case failed(String)
|
|
}
|
|
|
|
/// Machine Claude-models catalog state (web `useClaudeModels`). The picker
|
|
/// keeps the static presets while loading/failed and replaces them once the
|
|
/// CLI catalog arrives.
|
|
enum ClaudeModelsState: Equatable {
|
|
case hidden
|
|
case loading
|
|
case loaded([ClaudeModelSummary])
|
|
case failed(String)
|
|
}
|
|
|
|
/// Discovered model catalog of the selected non-Claude/Codex agent.
|
|
enum AgentModelsState: Equatable {
|
|
case hidden
|
|
case loading
|
|
case loaded(AgentModelsResponse)
|
|
/// Runner has no catalog RPC (`rpc_target_missing`) — hide the picker.
|
|
case unsupported
|
|
case failed(String)
|
|
}
|
|
|
|
/// What the discovered-model picker fetches: per machine, plus the target
|
|
/// directory for directory-scoped flavors (`AgentModelCatalog.Scope`).
|
|
struct AgentModelsRequest: Hashable {
|
|
let flavor: AgentFlavor
|
|
let machineId: String
|
|
let cwd: String?
|
|
}
|
|
|
|
/// Installed/static-configured Agent catalog for the selected machine.
|
|
enum AgentAvailabilityState: Equatable {
|
|
case loading
|
|
case loaded([AgentAvailabilityEntry])
|
|
case failed(message: String, upgradeRequired: Bool)
|
|
}
|
|
|
|
private struct CachedAgentModels {
|
|
let response: AgentModelsResponse
|
|
let variants: [String: [String]]?
|
|
}
|
|
|
|
// MARK: - Persistence
|
|
|
|
/// Create-form persistence: last-used machine + per-machine recent paths
|
|
/// (web `useRecentPaths`) and the in-progress draft (web
|
|
/// `newSessionFormDraft.ts`) so backing out of the sheet loses nothing.
|
|
/// JSON blobs in `UserDefaults`, keyed per hub (the Android original keys
|
|
/// app-wide; per-hub matches this app's multi-hub stores).
|
|
struct NewSessionLaunchSettings: Codable, Equatable {
|
|
var model: String
|
|
var effort: String
|
|
var modelReasoningEffort: String
|
|
var serviceTier: String
|
|
var permissionMode: String
|
|
var yolo: Bool
|
|
}
|
|
|
|
struct NewSessionPrefsData: Codable, Equatable {
|
|
var lastMachineId: String?
|
|
/// Machine id → most-recent-first spawn directories
|
|
/// (cap `NewSessionLogic.maxRecentPaths`).
|
|
var recentPaths: [String: [String]] = [:]
|
|
var lastAgent: String?
|
|
/// Machine + agent → last launch selections.
|
|
var launchSettings: [String: NewSessionLaunchSettings]?
|
|
}
|
|
|
|
struct NewSessionPrefsStore {
|
|
let hubUrl: String
|
|
var defaults: UserDefaults = .standard
|
|
|
|
private var prefsKey: String { "newSession.prefs.\(hubUrl)" }
|
|
private var draftKey: String { "newSession.draft.\(hubUrl)" }
|
|
|
|
func readPrefs() -> NewSessionPrefsData {
|
|
decode(prefsKey) ?? NewSessionPrefsData()
|
|
}
|
|
|
|
func writePrefs(_ data: NewSessionPrefsData) {
|
|
encode(data, key: prefsKey)
|
|
}
|
|
|
|
/// Nil when no draft is stored (or it fails to decode).
|
|
func readDraft() -> NewSessionForm? {
|
|
decode(draftKey)
|
|
}
|
|
|
|
func writeDraft(_ draft: NewSessionForm) {
|
|
encode(draft, key: draftKey)
|
|
}
|
|
|
|
func clearDraft() {
|
|
defaults.removeObject(forKey: draftKey)
|
|
}
|
|
|
|
private func decode<T: Decodable>(_ key: String) -> T? {
|
|
guard let data = defaults.data(forKey: key) else { return nil }
|
|
return try? HapiJSON.decoder.decode(T.self, from: data)
|
|
}
|
|
|
|
private func encode<T: Encodable>(_ value: T, key: String) {
|
|
guard let data = try? HapiJSON.encoder.encode(value) else { return }
|
|
defaults.set(data, forKey: key)
|
|
}
|
|
}
|
|
|
|
// MARK: - Model
|
|
|
|
/// New-session state machine (A-M3c): machine → directory → agent/options →
|
|
/// spawn — the iOS counterpart of the Android reference's
|
|
/// `NewSessionViewModel` in this app's viewModel-less `@Observable` style.
|
|
/// Pure mapping/validation lives in `NewSessionLogic` (HapiClient, tested);
|
|
/// this model orchestrates debounce, caching, fetches, and persistence.
|
|
/// Web reference: `web/src/components/NewSession/index.tsx`.
|
|
///
|
|
/// Option matrix (web create form):
|
|
/// - model pickers: claude (machine CLI catalog, static presets while it
|
|
/// loads/fails), codex (machine catalog; hidden
|
|
/// when the runner lacks the RPC) and the `AgentModelCatalog` flavors —
|
|
/// agy/cursor/dsh/pi per machine, copilot/grok/kimi/opencode once the
|
|
/// directory exists. Cursor is a flat list of ACP ids (no variant drill-down).
|
|
/// - effort: claude per-model catalog levels (static fallback), grok per-model
|
|
/// efforts, pi thinking
|
|
/// levels; reasoning effort: codex catalog, opencode variants.
|
|
/// - `startingMode` stays unset → the runner spawns `'remote'` (pty deferred).
|
|
@MainActor @Observable
|
|
final class NewSessionModel {
|
|
static let msgWorktreeMissing =
|
|
String(localized: "Worktree sessions require an existing repository directory.")
|
|
static let msgDirectoryMissing =
|
|
String(localized: "Directory does not exist. Creating the session will create it automatically.")
|
|
static let msgDirectoryMissingConfirm =
|
|
String(localized: "Directory does not exist. Tap Create again to create it automatically.")
|
|
static let msgDirectoryOutsideWorkspaceRoots =
|
|
String(localized: "Directory must be inside one of this machine's workspace roots.")
|
|
static let msgDirectoryLookupFailed = String(localized: "Failed to browse directories")
|
|
static let msgDirectoryCheckFailed = String(localized: "Failed to check directory")
|
|
static let msgMachineOffline = String(localized: "Selected machine is offline. Choose an online machine.")
|
|
static let msgAgentAvailabilityFailed = String(localized: "Failed to check installed Agents")
|
|
static let msgRunnerUpgradeRequired =
|
|
String(localized: "Upgrade and restart this machine's HAPI runner before creating sessions.")
|
|
static let msgNoAvailableAgents =
|
|
String(localized: "No supported Agents are installed on this machine.")
|
|
static let msgSelectedAgentUnavailable =
|
|
String(localized: "The selected Agent is not available on this machine.")
|
|
|
|
// MARK: Observable state
|
|
|
|
private(set) var form = NewSessionForm()
|
|
let directoryInput: NewSessionDirectoryModel
|
|
var suggestions: [String] { directoryInput.suggestions }
|
|
private(set) var codexModels: CodexModelsState = .hidden
|
|
private(set) var claudeModels: ClaudeModelsState = .hidden
|
|
private(set) var agentModels: AgentModelsState = .hidden
|
|
/// OpenCode variants keyed `provider/model`; nil until loaded.
|
|
private(set) var opencodeVariants: [String: [String]]?
|
|
private(set) var agentAvailability: AgentAvailabilityState = .loading
|
|
private(set) var isSpawning = false
|
|
private(set) var spawnError: String?
|
|
private(set) var confirmCreateDirectoryArmed = false
|
|
private(set) var machinesSettled = false
|
|
private(set) var prefsData = NewSessionPrefsData()
|
|
let directoryBrowser: RemoteDirectoryBrowserModel
|
|
|
|
// MARK: Wiring
|
|
|
|
private let session: HubSession
|
|
private let prefsStore: NewSessionPrefsStore
|
|
private let initialMachineId: String?
|
|
private let initialDirectory: String?
|
|
/// Fired once with the new session id — navigate-replace to the chat.
|
|
private let onCreated: @MainActor (String) -> Void
|
|
|
|
@ObservationIgnored private var codexTask: Task<Void, Never>?
|
|
@ObservationIgnored private var availabilityTask: Task<Void, Never>?
|
|
@ObservationIgnored private var defaultDirectoryTask: Task<Void, Never>?
|
|
@ObservationIgnored private var codexFetchedForMachine: String?
|
|
@ObservationIgnored private var claudeModelsTask: Task<Void, Never>?
|
|
@ObservationIgnored private var claudeFetchedForMachine: String?
|
|
@ObservationIgnored private var claudeModelsCache: [String: [ClaudeModelSummary]] = [:]
|
|
@ObservationIgnored private var agentModelsTask: Task<Void, Never>?
|
|
@ObservationIgnored private var agentModelsFetched: AgentModelsRequest??
|
|
@ObservationIgnored private var agentModelsCache: [AgentModelsRequest: CachedAgentModels] = [:]
|
|
@ObservationIgnored private var availabilityFetchedForMachine: String?
|
|
@ObservationIgnored private var suppressSuggestions = false
|
|
@ObservationIgnored private var spawnInFlight = false
|
|
@ObservationIgnored private var hasStarted = false
|
|
@ObservationIgnored private var loadedDraft = false
|
|
@ObservationIgnored private var directoryEdited = false
|
|
@ObservationIgnored private var directoryEditVersion = 0
|
|
|
|
init(
|
|
session: HubSession,
|
|
defaults: UserDefaults = .standard,
|
|
initialMachineId: String? = nil,
|
|
initialDirectory: String? = nil,
|
|
onCreated: @escaping @MainActor (String) -> Void
|
|
) {
|
|
self.session = session
|
|
self.prefsStore = NewSessionPrefsStore(hubUrl: session.hubUrl, defaults: defaults)
|
|
self.initialMachineId = initialMachineId
|
|
self.initialDirectory = initialDirectory
|
|
self.onCreated = onCreated
|
|
self.directoryInput = NewSessionDirectoryModel(
|
|
requester: session.api,
|
|
lookupError: Self.msgDirectoryLookupFailed,
|
|
checkError: Self.msgDirectoryCheckFailed
|
|
)
|
|
self.directoryBrowser = RemoteDirectoryBrowserModel(
|
|
requester: session.api,
|
|
fallbackError: Self.msgDirectoryLookupFailed
|
|
)
|
|
}
|
|
|
|
// MARK: - Lifecycle (paired with the sheet's `.task`)
|
|
|
|
/// Restore prefs + sanitized draft, preselect a machine, refresh the
|
|
/// roster. Call once per presentation.
|
|
func start() async {
|
|
if !hasStarted {
|
|
hasStarted = true
|
|
prefsData = prefsStore.readPrefs()
|
|
let draft = prefsStore.readDraft().map(NewSessionLogic.sanitizeDraft)
|
|
if let initialDirectory, !initialDirectory.isEmpty {
|
|
// A directory-header + starts a fresh form at that exact path;
|
|
// it must not inherit an unrelated draft.
|
|
form = NewSessionForm()
|
|
form.machineId = initialMachineId
|
|
form.directory = initialDirectory
|
|
loadedDraft = false
|
|
directoryEdited = true
|
|
} else {
|
|
loadedDraft = draft != nil
|
|
form = draft ?? NewSessionForm()
|
|
directoryEdited = draft != nil
|
|
}
|
|
if !loadedDraft, let raw = prefsData.lastAgent,
|
|
AgentFlavor.creatableFlavors.contains(AgentFlavor(rawValue: raw)) {
|
|
form.agent = AgentFlavor(rawValue: raw)
|
|
}
|
|
suppressSuggestions = true
|
|
}
|
|
reconcileMachineSelection()
|
|
if !loadedDraft {
|
|
applyPreferredLaunchSettings()
|
|
}
|
|
refreshAgentAvailability()
|
|
refreshCodexModelsIfNeeded()
|
|
refreshClaudeModelsIfNeeded()
|
|
refreshAgentModelsIfNeeded()
|
|
scheduleDirectoryWork()
|
|
|
|
do {
|
|
try await session.machineStore.refresh()
|
|
} catch {
|
|
// Snapshot (if any) keeps serving; the picker shows what it has.
|
|
}
|
|
guard !Task.isCancelled else { return }
|
|
machinesSettled = true
|
|
machinesChanged()
|
|
}
|
|
|
|
/// Only an unselected form is auto-selected. Losing a machine must not
|
|
/// move the user's path or pending Create action onto a different host.
|
|
func machinesChanged() {
|
|
guard hasStarted else { return }
|
|
reconcileMachineSelection()
|
|
if selectedMachine == nil {
|
|
cancelDefaultDirectoryResolution()
|
|
directoryBrowser.close()
|
|
availabilityTask?.cancel()
|
|
codexTask?.cancel()
|
|
claudeModelsTask?.cancel()
|
|
availabilityFetchedForMachine = nil
|
|
codexFetchedForMachine = nil
|
|
claudeFetchedForMachine = nil
|
|
claudeModels = .hidden
|
|
} else {
|
|
if directoryBrowser.isPresented,
|
|
directoryBrowser.roots != selectedMachine.map(RemoteDirectoryPath.browseRoots) {
|
|
directoryBrowser.close()
|
|
}
|
|
refreshAgentAvailability()
|
|
refreshCodexModelsIfNeeded()
|
|
refreshClaudeModelsIfNeeded()
|
|
}
|
|
refreshAgentModelsIfNeeded()
|
|
scheduleDirectoryWork()
|
|
}
|
|
|
|
func stopDirectoryWork() {
|
|
cancelDefaultDirectoryResolution()
|
|
directoryInput.stop()
|
|
}
|
|
|
|
private func cancelDefaultDirectoryResolution() {
|
|
directoryEditVersion += 1
|
|
defaultDirectoryTask?.cancel()
|
|
defaultDirectoryTask = nil
|
|
}
|
|
|
|
// MARK: - Derived state
|
|
|
|
var machines: [MachineOptionUI] {
|
|
session.machineStore.machines.map(Self.machineOption)
|
|
}
|
|
|
|
var machinesLoading: Bool {
|
|
session.machineStore.machines.isEmpty && !machinesSettled
|
|
}
|
|
|
|
var machineUnavailable: Bool {
|
|
machinesSettled && form.machineId != nil && selectedMachine == nil
|
|
}
|
|
|
|
var normalizedDirectory: String {
|
|
RemoteDirectoryPath.expandHome(form.directory, homeDirectory: selectedMachine?.metadata?.homeDir)
|
|
}
|
|
|
|
/// `runnerState.lastSpawnError` of the selected machine, formatted
|
|
/// (`web/src/utils/formatRunnerSpawnError.ts`).
|
|
var runnerSpawnError: String? {
|
|
Self.formatRunnerSpawnError(selectedMachine)
|
|
}
|
|
|
|
var recentPaths: [String] {
|
|
recentPaths(for: form.machineId)
|
|
}
|
|
|
|
var directoryStatus: DirectoryStatusUI? {
|
|
if directoryOutsideWorkspaceRoots {
|
|
return DirectoryStatusUI(message: Self.msgDirectoryOutsideWorkspaceRoots, isError: true)
|
|
}
|
|
if missingWorktreeDirectory {
|
|
return DirectoryStatusUI(message: Self.msgWorktreeMissing, isError: true)
|
|
}
|
|
if needsCreationWarning {
|
|
return DirectoryStatusUI(
|
|
message: confirmCreateDirectory
|
|
? Self.msgDirectoryMissingConfirm
|
|
: Self.msgDirectoryMissing,
|
|
isError: false
|
|
)
|
|
}
|
|
if let error = directoryInput.existenceError {
|
|
return DirectoryStatusUI(message: error, isError: true)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
/// Installed creatable flavors, in runner catalog order.
|
|
var agents: [NewSessionOption] {
|
|
availableAgentFlavors.map {
|
|
NewSessionOption(value: $0.rawValue, label: $0.displayLabel)
|
|
}
|
|
}
|
|
|
|
var agentAvailabilityLoading: Bool {
|
|
agentAvailability == .loading
|
|
}
|
|
|
|
var agentAvailabilityError: String? {
|
|
switch agentAvailability {
|
|
case .loading:
|
|
return nil
|
|
case .failed(let message, _):
|
|
return message
|
|
case .loaded:
|
|
return availableAgentFlavors.isEmpty ? Self.msgNoAvailableAgents : nil
|
|
}
|
|
}
|
|
|
|
/// Nil hides the model picker.
|
|
var modelOptions: [NewSessionOption]? {
|
|
switch (form.agent, codexModels) {
|
|
case (.claude, _):
|
|
let catalog: [ClaudeModelSummary]? = {
|
|
if case .loaded(let models) = claudeModels { return models }
|
|
return nil
|
|
}()
|
|
return NewSessionCatalogs.claudeLaunchModelOptions(
|
|
catalog: catalog,
|
|
selectedModel: form.model,
|
|
notListedSuffix: String(localized: "not listed"),
|
|
otherModelsLabel: String(localized: "Other models")
|
|
)
|
|
case (.codex, .loaded(let models)):
|
|
return [NewSessionOption(value: "auto", label: "Default")]
|
|
+ models.map { NewSessionOption(value: $0.id, label: $0.displayName) }
|
|
case (.codex, .loading), (.codex, .failed):
|
|
return [NewSessionOption(value: "auto", label: "Default")]
|
|
case (.codex, _):
|
|
return nil // `.unsupported` (old runner)
|
|
default:
|
|
break
|
|
}
|
|
switch agentModels {
|
|
case .loaded(let response):
|
|
return AgentModelCatalog.newSessionModelOptions(flavor: form.agent, response: response)
|
|
case .loading, .failed:
|
|
return AgentModelCatalog.newSessionModelOptions(
|
|
flavor: form.agent,
|
|
response: AgentModelsResponse(success: true)
|
|
)
|
|
case .hidden, .unsupported:
|
|
return nil
|
|
}
|
|
}
|
|
|
|
var modelsLoading: Bool {
|
|
(form.agent == .codex && codexModels == .loading)
|
|
|| (form.agent == .claude && claudeModels == .loading)
|
|
|| agentModels == .loading
|
|
}
|
|
|
|
var modelsError: String? {
|
|
if case .failed(let message) = codexModels {
|
|
return String(format: String(localized: "Failed to load models: %@"), message)
|
|
}
|
|
if case .failed(let message) = agentModels {
|
|
return String(format: String(localized: "Failed to load models: %@"), message)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
private var loadedAgentModels: AgentModelsResponse? {
|
|
if case .loaded(let response) = agentModels { return response }
|
|
return nil
|
|
}
|
|
|
|
/// Claude effort, grok effort or pi thinking level; nil hides the field.
|
|
var effortOptions: [NewSessionOption]? {
|
|
switch form.agent {
|
|
case .claude:
|
|
let catalog: [ClaudeModelSummary]? = {
|
|
if case .loaded(let models) = claudeModels { return models }
|
|
return nil
|
|
}()
|
|
return NewSessionCatalogs.claudeEffortOptions(
|
|
catalog: catalog,
|
|
model: form.model,
|
|
currentEffort: form.effort
|
|
)
|
|
case .grok: return AgentModelCatalog.grokEffortOptions(response: loadedAgentModels, model: form.model)
|
|
case .pi: return AgentModelCatalog.piEffortOptions(response: loadedAgentModels, model: form.model)
|
|
default: return nil
|
|
}
|
|
}
|
|
|
|
/// Codex reasoning effort or opencode variant; nil hides the field.
|
|
var reasoningEffortOptions: [NewSessionOption]? {
|
|
if form.agent == .opencode {
|
|
return AgentModelCatalog.opencodeReasoningEffortOptions(
|
|
variants: opencodeVariants,
|
|
response: loadedAgentModels,
|
|
model: form.model
|
|
)
|
|
}
|
|
guard form.agent == .codex, codexModels != .unsupported else { return nil }
|
|
if case .loaded(let models) = codexModels,
|
|
let advertised = NewSessionLogic.codexReasoningEfforts(models: models, model: form.model) {
|
|
return [NewSessionOption(value: "default", label: "Default")]
|
|
+ advertised.map {
|
|
NewSessionOption(value: $0, label: NewSessionCatalogs.effortLabel($0))
|
|
}
|
|
}
|
|
return NewSessionCatalogs.codexReasoningEfforts
|
|
}
|
|
|
|
var permission: PermissionUI {
|
|
let agent = form.agent
|
|
if agent == .pi || agent == .dsh {
|
|
return .managed
|
|
}
|
|
if NewSessionLogic.usesNativePermissionSelect(agent) {
|
|
return .nativeSelect(permissionModes.map { PermissionModeOption(mode: $0) })
|
|
}
|
|
return .yoloToggle(nativeModeLabel: NewSessionLogic.hapiYoloNativeMode(for: agent)?.label)
|
|
}
|
|
|
|
/// Grok probes report whether its `auto` mode works in this directory.
|
|
private var permissionModes: [PermissionMode] {
|
|
let modes = form.agent.permissionModes
|
|
guard form.agent == .grok, loadedAgentModels?.autoPermissionModeSupported == false else { return modes }
|
|
return modes.filter { $0 != .auto }
|
|
}
|
|
|
|
/// Machine id whose Claude catalog the form needs, or nil for other
|
|
/// agents / no selected machine.
|
|
var claudeModelsRequest: String? {
|
|
guard form.agent == .claude, let machineId = selectedMachine?.id else { return nil }
|
|
return machineId
|
|
}
|
|
|
|
/// The discovered-model fetch the form needs now; nil when the flavor
|
|
/// has no catalog, no machine is selected, or a directory-scoped catalog
|
|
/// has no existing directory to probe yet.
|
|
var agentModelsRequest: AgentModelsRequest? {
|
|
guard let scope = AgentModelCatalog.scope(for: form.agent),
|
|
let machineId = selectedMachine?.id else { return nil }
|
|
switch scope {
|
|
case .machine:
|
|
return AgentModelsRequest(flavor: form.agent, machineId: machineId, cwd: nil)
|
|
case .directory:
|
|
let cwd = normalizedDirectory.trimmingCharacters(in: .whitespacesAndNewlines)
|
|
guard !cwd.isEmpty, directoryExists == true, !directoryOutsideWorkspaceRoots else { return nil }
|
|
return AgentModelsRequest(flavor: form.agent, machineId: machineId, cwd: cwd)
|
|
}
|
|
}
|
|
|
|
var showCollaborationMode: Bool {
|
|
form.agent == .codex
|
|
}
|
|
|
|
var showCopilotAgentMode: Bool {
|
|
form.agent == .copilot
|
|
}
|
|
|
|
var showFastMode: Bool {
|
|
guard form.agent == .codex, case .loaded(let models) = codexModels else { return false }
|
|
return NewSessionLogic.codexModelAdvertisesFastTier(model: form.model, models: models)
|
|
}
|
|
|
|
var worktreeNameError: String? {
|
|
form.sessionType == .worktree
|
|
? NewSessionLogic.worktreeNameError(form.worktreeName)
|
|
: nil
|
|
}
|
|
|
|
/// Armed after the first Create tap on a missing simple directory.
|
|
var confirmCreateDirectory: Bool {
|
|
confirmCreateDirectoryArmed && needsCreationWarning
|
|
}
|
|
|
|
var canCreate: Bool {
|
|
selectedMachine != nil
|
|
&& !normalizedDirectory.isEmpty
|
|
&& !isSpawning
|
|
&& !missingWorktreeDirectory
|
|
&& !directoryOutsideWorkspaceRoots
|
|
&& selectedAgentAvailable
|
|
&& worktreeNameError == nil
|
|
&& !codexValidationPending
|
|
&& !agentModelsValidationPending
|
|
}
|
|
|
|
private var selectedMachine: Machine? {
|
|
session.machineStore.machines.first { $0.id == form.machineId && $0.active }
|
|
}
|
|
|
|
private var directoryExists: Bool? {
|
|
directoryInput.exists
|
|
}
|
|
|
|
private var directoryOutsideWorkspaceRoots: Bool {
|
|
directoryInput.outsideWorkspaceRoots
|
|
}
|
|
|
|
private var missingWorktreeDirectory: Bool {
|
|
!directoryOutsideWorkspaceRoots && form.sessionType == .worktree && directoryExists == false
|
|
}
|
|
|
|
private var needsCreationWarning: Bool {
|
|
!directoryOutsideWorkspaceRoots && form.sessionType == .simple && directoryExists == false
|
|
}
|
|
|
|
private var availableAgentFlavors: [AgentFlavor] {
|
|
guard case .loaded(let entries) = agentAvailability else { return [] }
|
|
return entries.compactMap { entry in
|
|
guard entry.available, AgentFlavor.creatableFlavors.contains(entry.agent) else { return nil }
|
|
return entry.agent
|
|
}
|
|
}
|
|
|
|
private var selectedAgentAvailable: Bool {
|
|
availableAgentFlavors.contains(form.agent)
|
|
}
|
|
|
|
/// Web `isLaunchPreferenceValidationPending` (codex slice): a restored
|
|
/// codex model/effort must not spawn before the catalog validated it.
|
|
private var codexValidationPending: Bool {
|
|
form.agent == .codex && codexModels == .loading
|
|
&& (form.model != "auto"
|
|
|| form.modelReasoningEffort != "default"
|
|
|| form.serviceTier == .fast)
|
|
}
|
|
|
|
/// A restored non-default model/effort must not spawn before the
|
|
/// discovered catalog validated it (web `isLaunchPreferenceValidationPending`).
|
|
private var agentModelsValidationPending: Bool {
|
|
agentModels == .loading
|
|
&& (form.model != "auto" || form.effort != "auto" || form.modelReasoningEffort != "default")
|
|
}
|
|
|
|
// MARK: - Actions
|
|
|
|
func setMachine(_ machineId: String) {
|
|
guard !isSpawning, machineId != form.machineId,
|
|
session.machineStore.machines.contains(where: { $0.id == machineId && $0.active })
|
|
else { return }
|
|
applyMachineSelection(machineId, resetDirectory: true)
|
|
}
|
|
|
|
func setDirectory(_ value: String) {
|
|
cancelDefaultDirectoryResolution()
|
|
directoryEdited = true
|
|
suppressSuggestions = false
|
|
confirmCreateDirectoryArmed = false
|
|
form.directory = value
|
|
persistDraft()
|
|
scheduleDirectoryWork()
|
|
}
|
|
|
|
func pickSuggestion(_ path: String) {
|
|
pickPath(path)
|
|
}
|
|
|
|
func pickRecentPath(_ path: String) {
|
|
pickPath(path)
|
|
}
|
|
|
|
func openDirectoryBrowser() {
|
|
guard let machine = selectedMachine else { return }
|
|
directoryBrowser.open(
|
|
machineId: machine.id,
|
|
roots: RemoteDirectoryPath.browseRoots(for: machine),
|
|
initialPath: normalizedDirectory,
|
|
defaultPath: RemoteDirectoryPath.defaultDirectory(for: machine)
|
|
)
|
|
}
|
|
|
|
func selectBrowsedDirectory(_ path: String) {
|
|
if !path.isEmpty {
|
|
pickPath(path)
|
|
}
|
|
}
|
|
|
|
func setAgent(_ agent: AgentFlavor) {
|
|
guard agent != form.agent else { return }
|
|
// Web parity: switching agents resets every agent-dependent field
|
|
// (yolo is a cross-flavor preference and survives).
|
|
form.agent = agent
|
|
form.model = "auto"
|
|
form.effort = "auto"
|
|
form.modelReasoningEffort = "default"
|
|
form.permissionMode = .default
|
|
form.serviceTier = .standard
|
|
form.collaborationMode = .default
|
|
form.copilotAgentMode = .interactive
|
|
applyPreferredLaunchSettings()
|
|
captureLaunchSettings()
|
|
persistDraft()
|
|
refreshCodexModelsIfNeeded()
|
|
refreshClaudeModelsIfNeeded()
|
|
refreshAgentModelsIfNeeded()
|
|
}
|
|
|
|
func setModel(_ model: String) {
|
|
form.model = model
|
|
if form.agent == .codex {
|
|
form = reconcileCodexSelections(form)
|
|
}
|
|
if form.agent == .claude {
|
|
form = reconcileClaudeEffort(form)
|
|
}
|
|
form = reconcileAgentModelSelections(form)
|
|
captureLaunchSettings()
|
|
persistDraft()
|
|
}
|
|
|
|
func setEffort(_ effort: String) {
|
|
form.effort = effort
|
|
captureLaunchSettings()
|
|
persistDraft()
|
|
}
|
|
|
|
func setModelReasoningEffort(_ value: String) {
|
|
form.modelReasoningEffort = value
|
|
captureLaunchSettings()
|
|
persistDraft()
|
|
}
|
|
|
|
func setPermissionMode(_ mode: PermissionMode) {
|
|
form.permissionMode = mode
|
|
captureLaunchSettings()
|
|
persistDraft()
|
|
}
|
|
|
|
func setYolo(_ enabled: Bool) {
|
|
form.yolo = enabled
|
|
captureLaunchSettings()
|
|
persistDraft()
|
|
}
|
|
|
|
func setSessionType(_ sessionType: SpawnSessionType) {
|
|
confirmCreateDirectoryArmed = false
|
|
form.sessionType = sessionType
|
|
persistDraft()
|
|
}
|
|
|
|
func setWorktreeName(_ name: String) {
|
|
form.worktreeName = name
|
|
persistDraft()
|
|
}
|
|
|
|
func setServiceTier(_ tier: ServiceTier) {
|
|
form.serviceTier = tier
|
|
captureLaunchSettings()
|
|
persistDraft()
|
|
}
|
|
|
|
func setCollaborationMode(_ mode: CodexCollaborationMode) {
|
|
form.collaborationMode = mode
|
|
persistDraft()
|
|
}
|
|
|
|
func setCopilotAgentMode(_ mode: CopilotAgentMode) {
|
|
form.copilotAgentMode = mode
|
|
persistDraft()
|
|
}
|
|
|
|
func retryModels() {
|
|
codexFetchedForMachine = nil
|
|
claudeFetchedForMachine = nil
|
|
refreshCodexModelsIfNeeded()
|
|
refreshClaudeModelsIfNeeded(force: true)
|
|
refreshAgentModelsIfNeeded(force: true)
|
|
}
|
|
|
|
func retryAgentAvailability() {
|
|
refreshAgentAvailability(force: true)
|
|
}
|
|
|
|
/// Spawn. Directory existence is re-checked server-side first (web
|
|
/// `handleCreate`): a missing worktree base is an error; a missing
|
|
/// simple directory arms a second-tap confirmation, after which the hub
|
|
/// creates it. Success persists prefs, clears the draft, and hands the
|
|
/// new session id to `onCreated`; failure lands in the inline error.
|
|
func create() {
|
|
guard canCreate, !spawnInFlight else { return }
|
|
cancelDefaultDirectoryResolution()
|
|
var current = form
|
|
current.directory = normalizedDirectory
|
|
guard let machineId = current.machineId else { return }
|
|
let directory = current.trimmedDirectory
|
|
guard !directory.isEmpty, !spawnInFlight else { return }
|
|
if current.sessionType == .worktree,
|
|
NewSessionLogic.worktreeNameError(current.worktreeName) != nil {
|
|
return
|
|
}
|
|
guard selectedAgentAvailable else {
|
|
spawnError = agentAvailabilityError ?? Self.msgSelectedAgentUnavailable
|
|
return
|
|
}
|
|
spawnInFlight = true
|
|
isSpawning = true
|
|
spawnError = nil
|
|
Task { [weak self, current] in
|
|
defer {
|
|
self?.spawnInFlight = false
|
|
self?.isSpawning = false
|
|
}
|
|
guard let self else { return }
|
|
let api = self.session.api
|
|
do {
|
|
let pathResult = try await api.machinePathsExist(
|
|
machineId: machineId,
|
|
paths: [directory]
|
|
)
|
|
let exists = pathResult.exists[directory]
|
|
guard self.selectedMachine?.id == machineId else {
|
|
self.spawnError = Self.msgMachineOffline
|
|
return
|
|
}
|
|
self.directoryInput.acceptExistence(pathResult, machineId: machineId, path: directory)
|
|
if pathResult.outsideWorkspaceRoots?.contains(directory) == true {
|
|
self.spawnError = Self.msgDirectoryOutsideWorkspaceRoots
|
|
return
|
|
}
|
|
if current.sessionType == .worktree, exists == false {
|
|
self.spawnError = Self.msgWorktreeMissing
|
|
return
|
|
}
|
|
if current.sessionType == .simple,
|
|
exists == false,
|
|
!self.confirmCreateDirectoryArmed {
|
|
self.confirmCreateDirectoryArmed = true
|
|
return
|
|
}
|
|
|
|
let request = NewSessionLogic.buildSpawnRequest(
|
|
form: current,
|
|
codexFastTierVisible: self.codexFastTierVisible(current)
|
|
)
|
|
switch try await api.spawnSession(machineId: machineId, request) {
|
|
case .success(let sessionId):
|
|
self.persistOnSuccess(machineId: machineId, directory: directory)
|
|
self.onCreated(sessionId)
|
|
case .error(let message, let code, _):
|
|
self.spawnError = Self.spawnErrorMessage(code: code, fallback: message)
|
|
}
|
|
} catch let error as APIError {
|
|
self.spawnError = Self.spawnErrorMessage(
|
|
code: error.code,
|
|
fallback: error.errorDescription
|
|
)
|
|
} catch {
|
|
self.spawnError = (error as? LocalizedError)?.errorDescription
|
|
?? String(localized: "Failed to create session")
|
|
}
|
|
}
|
|
}
|
|
|
|
// MARK: - Internals
|
|
|
|
private func pickPath(_ path: String) {
|
|
cancelDefaultDirectoryResolution()
|
|
directoryEdited = true
|
|
suppressSuggestions = true
|
|
confirmCreateDirectoryArmed = false
|
|
form.directory = path
|
|
persistDraft()
|
|
scheduleDirectoryWork()
|
|
}
|
|
|
|
private func recentPaths(for machineId: String?) -> [String] {
|
|
machineId.flatMap { prefsData.recentPaths[$0] } ?? []
|
|
}
|
|
|
|
/// Recent spawn paths plus directories already used by sessions on this
|
|
/// machine (web `useDirectorySuggestions`), so existing projects are
|
|
/// visible before the user types anything.
|
|
var knownDirectories: [String] {
|
|
guard let machineId = form.machineId else { return recentPaths }
|
|
let recent = recentPaths(for: machineId)
|
|
let recentSet = Set(recent)
|
|
let sessionPaths = session.sessionStore.sessions
|
|
.filter { $0.metadata?.machineId == machineId }
|
|
.flatMap { summary -> [String] in
|
|
[summary.metadata?.path, summary.metadata?.worktree?.basePath].compactMap { $0 }
|
|
}
|
|
.filter { !$0.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty }
|
|
let extras = Set(sessionPaths)
|
|
.subtracting(recentSet)
|
|
.sorted { $0.localizedStandardCompare($1) == .orderedAscending }
|
|
return recent + extras
|
|
}
|
|
|
|
private func reconcileMachineSelection() {
|
|
guard form.machineId == nil else { return }
|
|
let machines = session.machineStore.machines.filter(\.active)
|
|
guard !machines.isEmpty else { return }
|
|
let target = machines.first { $0.id == prefsData.lastMachineId } ?? machines[0]
|
|
applyMachineSelection(target.id, resetDirectory: !directoryEdited && form.trimmedDirectory.isEmpty)
|
|
}
|
|
|
|
private func applyMachineSelection(_ machineId: String, resetDirectory: Bool) {
|
|
directoryBrowser.close()
|
|
cancelDefaultDirectoryResolution()
|
|
directoryInput.stop()
|
|
confirmCreateDirectoryArmed = false
|
|
// The seeded recent path is a pick, not typing — no dropdown.
|
|
suppressSuggestions = true
|
|
form.machineId = machineId
|
|
form.model = "auto"
|
|
if !loadedDraft {
|
|
applyPreferredLaunchSettings()
|
|
}
|
|
if resetDirectory {
|
|
let machine = session.machineStore.machines.first { $0.id == machineId }
|
|
directoryEdited = false
|
|
form.directory = machine.map(RemoteDirectoryPath.defaultDirectory) ?? ""
|
|
}
|
|
persistDraft()
|
|
if resetDirectory {
|
|
resolveDefaultDirectory(machineId: machineId, fallback: form.directory)
|
|
}
|
|
refreshAgentAvailability(force: true)
|
|
refreshCodexModelsIfNeeded()
|
|
refreshAgentModelsIfNeeded()
|
|
scheduleDirectoryWork()
|
|
}
|
|
|
|
private func resolveDefaultDirectory(machineId: String, fallback: String) {
|
|
cancelDefaultDirectoryResolution()
|
|
let editVersion = directoryEditVersion
|
|
let roots = selectedMachine.map(RemoteDirectoryPath.browseRoots)
|
|
let recent = recentPaths(for: machineId)
|
|
guard !recent.isEmpty else { return }
|
|
defaultDirectoryTask = Task { [weak self] in
|
|
guard let self else { return }
|
|
let result: MachinePathsExistsResponse
|
|
do {
|
|
result = try await self.session.api.machinePathsExist(
|
|
machineId: machineId,
|
|
paths: recent
|
|
)
|
|
} catch is CancellationError {
|
|
return
|
|
} catch {
|
|
return
|
|
}
|
|
guard !Task.isCancelled else { return }
|
|
let outside = Set(result.outsideWorkspaceRoots ?? [])
|
|
guard let valid = recent.first(where: {
|
|
result.exists[$0] == true && !outside.contains($0)
|
|
}) else {
|
|
return
|
|
}
|
|
guard self.selectedMachine?.id == machineId,
|
|
self.selectedMachine.map(RemoteDirectoryPath.browseRoots) == roots,
|
|
self.directoryEditVersion == editVersion,
|
|
self.form.directory == fallback else { return }
|
|
self.suppressSuggestions = true
|
|
self.form.directory = valid
|
|
self.persistDraft()
|
|
self.scheduleDirectoryWork()
|
|
}
|
|
}
|
|
|
|
private func scheduleDirectoryWork() {
|
|
directoryInput.update(
|
|
machine: selectedMachine,
|
|
path: form.directory,
|
|
showSuggestions: !suppressSuggestions
|
|
)
|
|
}
|
|
|
|
private func refreshAgentAvailability(force: Bool = false) {
|
|
guard let machineId = selectedMachine?.id else {
|
|
availabilityTask?.cancel()
|
|
availabilityFetchedForMachine = nil
|
|
agentAvailability = .loading
|
|
return
|
|
}
|
|
if !force, availabilityFetchedForMachine == machineId {
|
|
return
|
|
}
|
|
availabilityTask?.cancel()
|
|
availabilityFetchedForMachine = machineId
|
|
agentAvailability = .loading
|
|
availabilityTask = Task { [weak self] in
|
|
guard let self else { return }
|
|
let state: AgentAvailabilityState
|
|
do {
|
|
let response = try await self.session.api.machineAgentAvailability(machineId: machineId)
|
|
state = .loaded(response.agents)
|
|
} catch let error as APIError where error.code == "runner_upgrade_required" {
|
|
state = .failed(message: Self.msgRunnerUpgradeRequired, upgradeRequired: true)
|
|
} catch is CancellationError {
|
|
return
|
|
} catch is APIError {
|
|
state = .failed(message: Self.msgAgentAvailabilityFailed, upgradeRequired: false)
|
|
} catch {
|
|
state = .failed(
|
|
message: (error as? LocalizedError)?.errorDescription
|
|
?? Self.msgAgentAvailabilityFailed,
|
|
upgradeRequired: false
|
|
)
|
|
}
|
|
guard !Task.isCancelled, self.form.machineId == machineId else { return }
|
|
self.agentAvailability = state
|
|
guard case .loaded = state,
|
|
let firstAvailable = self.availableAgentFlavors.first,
|
|
!self.availableAgentFlavors.contains(self.form.agent)
|
|
else {
|
|
return
|
|
}
|
|
self.setAgent(firstAvailable)
|
|
}
|
|
}
|
|
|
|
private func refreshCodexModelsIfNeeded() {
|
|
guard form.agent == .codex else {
|
|
codexTask?.cancel()
|
|
codexFetchedForMachine = nil
|
|
codexModels = .hidden
|
|
return
|
|
}
|
|
guard let machineId = selectedMachine?.id else {
|
|
codexModels = .hidden
|
|
return
|
|
}
|
|
if codexFetchedForMachine == machineId, codexModels != .hidden {
|
|
return
|
|
}
|
|
codexFetchedForMachine = machineId
|
|
codexTask?.cancel()
|
|
codexModels = .loading
|
|
codexTask = Task { [weak self] in
|
|
guard let self else { return }
|
|
let state: CodexModelsState
|
|
do {
|
|
let response = try await self.session.api.machineCodexModels(machineId: machineId)
|
|
state = response.success
|
|
? .loaded(response.models ?? [])
|
|
: .failed(response.error ?? String(localized: "Failed to load Codex models"))
|
|
} catch let error as APIError where error.code == "rpc_target_missing" {
|
|
state = .unsupported
|
|
} catch is CancellationError {
|
|
return
|
|
} catch {
|
|
state = .failed(
|
|
(error as? LocalizedError)?.errorDescription
|
|
?? String(localized: "Failed to load Codex models")
|
|
)
|
|
}
|
|
guard !Task.isCancelled,
|
|
self.form.machineId == machineId,
|
|
self.form.agent == .codex
|
|
else {
|
|
return
|
|
}
|
|
self.codexModels = state
|
|
if case .loaded = state {
|
|
// Reconcile restored selections with the live catalog (web
|
|
// validation effects): unknown model → auto; unsupported
|
|
// effort → default; no fast tier → standard.
|
|
self.form = self.reconcileCodexSelections(self.form)
|
|
self.persistDraft()
|
|
}
|
|
}
|
|
}
|
|
|
|
/// Fetches or reuses the selected machine's Claude model catalog. The
|
|
/// form keeps the static presets while this is loading or fails.
|
|
func refreshClaudeModelsIfNeeded(force: Bool = false) {
|
|
guard form.agent == .claude, let machineId = selectedMachine?.id else {
|
|
claudeModelsTask?.cancel()
|
|
claudeFetchedForMachine = nil
|
|
claudeModels = .hidden
|
|
return
|
|
}
|
|
if !force, let cached = claudeModelsCache[machineId] {
|
|
claudeFetchedForMachine = machineId
|
|
claudeModels = .loaded(cached)
|
|
form = reconcileClaudeEffort(form)
|
|
persistDraft()
|
|
return
|
|
}
|
|
if !force, claudeFetchedForMachine == machineId, claudeModels != .hidden {
|
|
return
|
|
}
|
|
claudeFetchedForMachine = machineId
|
|
claudeModelsTask?.cancel()
|
|
claudeModels = .loading
|
|
claudeModelsTask = Task { [weak self] in
|
|
guard let self else { return }
|
|
let state: ClaudeModelsState
|
|
do {
|
|
let response = try await self.session.api.machineClaudeModels(machineId: machineId)
|
|
state = response.success
|
|
? .loaded(response.availableModels ?? [])
|
|
: .failed(response.error ?? String(localized: "Failed to load Claude models"))
|
|
} catch is CancellationError {
|
|
return
|
|
} catch {
|
|
state = .failed(
|
|
(error as? LocalizedError)?.errorDescription
|
|
?? String(localized: "Failed to load Claude models")
|
|
)
|
|
}
|
|
guard !Task.isCancelled,
|
|
self.form.machineId == machineId,
|
|
self.form.agent == .claude
|
|
else { return }
|
|
self.claudeModels = state
|
|
if case .loaded(let models) = state {
|
|
self.claudeModelsCache[machineId] = models
|
|
self.form = self.reconcileClaudeEffort(self.form)
|
|
self.persistDraft()
|
|
}
|
|
}
|
|
}
|
|
|
|
private func reconcileClaudeEffort(_ current: NewSessionForm) -> NewSessionForm {
|
|
guard case .loaded(let models) = claudeModels else { return current }
|
|
guard let options = NewSessionCatalogs.claudeEffortOptions(
|
|
catalog: models,
|
|
model: current.model,
|
|
currentEffort: current.effort
|
|
) else { return current }
|
|
if !options.contains(where: { $0.value == current.effort }) {
|
|
var next = current
|
|
next.effort = "auto"
|
|
return next
|
|
}
|
|
return current
|
|
}
|
|
|
|
/// Fetches (or reuses) the catalog for ``agentModelsRequest``. The view
|
|
/// calls this whenever the request changes — including when a typed
|
|
/// directory turns out to exist.
|
|
func refreshAgentModelsIfNeeded(force: Bool = false) {
|
|
let request = agentModelsRequest
|
|
guard force || agentModelsFetched != .some(request) else { return }
|
|
agentModelsTask?.cancel()
|
|
agentModelsFetched = .some(request)
|
|
guard let request else {
|
|
agentModels = .hidden
|
|
opencodeVariants = nil
|
|
return
|
|
}
|
|
if !force, let cached = agentModelsCache[request] {
|
|
agentModels = .loaded(cached.response)
|
|
opencodeVariants = cached.variants
|
|
form = reconcileAgentModelSelections(form)
|
|
persistDraft()
|
|
return
|
|
}
|
|
agentModels = .loading
|
|
opencodeVariants = nil
|
|
agentModelsTask = Task { [weak self] in
|
|
guard let self else { return }
|
|
let api = self.session.api
|
|
let state: AgentModelsState
|
|
var variants: [String: [String]]?
|
|
do {
|
|
let response = try await api.machineAgentModels(
|
|
machineId: request.machineId,
|
|
flavor: request.flavor,
|
|
cwd: request.cwd
|
|
)
|
|
// agy pairs `success` with an error for a stale catalog.
|
|
state = response.success
|
|
? .loaded(response)
|
|
: .failed(response.error ?? String(localized: "Failed to load models"))
|
|
if request.flavor == .opencode, response.success, let cwd = request.cwd,
|
|
let answer = try? await api.machineOpencodeModelVariants(machineId: request.machineId, cwd: cwd),
|
|
answer.success {
|
|
variants = answer.variants
|
|
}
|
|
} catch let error as APIError where error.code == "rpc_target_missing" {
|
|
state = .unsupported
|
|
} catch is CancellationError {
|
|
return
|
|
} catch {
|
|
state = .failed(
|
|
(error as? LocalizedError)?.errorDescription ?? String(localized: "Failed to load models")
|
|
)
|
|
}
|
|
guard !Task.isCancelled, self.agentModelsFetched == .some(.some(request)) else { return }
|
|
self.agentModels = state
|
|
self.opencodeVariants = variants
|
|
if case .loaded(let response) = state {
|
|
self.agentModelsCache[request] = CachedAgentModels(response: response, variants: variants)
|
|
self.form = self.reconcileAgentModelSelections(self.form)
|
|
self.persistDraft()
|
|
}
|
|
}
|
|
}
|
|
|
|
private func reconcileAgentModelSelections(_ current: NewSessionForm) -> NewSessionForm {
|
|
guard let response = loadedAgentModels else { return current }
|
|
var next = NewSessionLogic.reconcileAgentModelSelections(current, response: response, variants: opencodeVariants)
|
|
if next.agent == .grok, next.permissionMode == .auto, !permissionModes.contains(.auto) {
|
|
next.permissionMode = .default
|
|
}
|
|
return next
|
|
}
|
|
|
|
private func reconcileCodexSelections(_ current: NewSessionForm) -> NewSessionForm {
|
|
guard case .loaded(let models) = codexModels else { return current }
|
|
var next = current
|
|
if next.model != "auto", !models.contains(where: { $0.id == next.model }) {
|
|
next.model = "auto"
|
|
}
|
|
if next.modelReasoningEffort != "default",
|
|
let supported = NewSessionLogic.codexReasoningEfforts(models: models, model: next.model),
|
|
!supported.contains(next.modelReasoningEffort) {
|
|
next.modelReasoningEffort = "default"
|
|
}
|
|
if next.serviceTier != .standard,
|
|
!NewSessionLogic.codexModelAdvertisesFastTier(model: next.model, models: models) {
|
|
next.serviceTier = .standard
|
|
}
|
|
return next
|
|
}
|
|
|
|
private func codexFastTierVisible(_ current: NewSessionForm) -> Bool {
|
|
guard current.agent == .codex, case .loaded(let models) = codexModels else { return false }
|
|
return NewSessionLogic.codexModelAdvertisesFastTier(model: current.model, models: models)
|
|
}
|
|
|
|
private func launchSettingsKey(machineId: String, agent: AgentFlavor) -> String {
|
|
"\(machineId)|\(agent.rawValue)"
|
|
}
|
|
|
|
private func applyPreferredLaunchSettings() {
|
|
guard let machineId = form.machineId,
|
|
let settings = prefsData.launchSettings?[
|
|
launchSettingsKey(machineId: machineId, agent: form.agent)
|
|
] else { return }
|
|
form.model = settings.model
|
|
form.effort = settings.effort
|
|
form.modelReasoningEffort = settings.modelReasoningEffort
|
|
if let tier = ServiceTier(rawValue: settings.serviceTier) {
|
|
form.serviceTier = tier
|
|
}
|
|
if let mode = PermissionMode(rawValue: settings.permissionMode),
|
|
form.agent.permissionModes.contains(mode) {
|
|
form.permissionMode = mode
|
|
}
|
|
form.yolo = settings.yolo
|
|
}
|
|
|
|
private func captureLaunchSettings() {
|
|
guard let machineId = form.machineId else { return }
|
|
prefsData.lastMachineId = machineId
|
|
prefsData.lastAgent = form.agent.rawValue
|
|
var settings = prefsData.launchSettings ?? [:]
|
|
settings[launchSettingsKey(machineId: machineId, agent: form.agent)] = NewSessionLaunchSettings(
|
|
model: form.model,
|
|
effort: form.effort,
|
|
modelReasoningEffort: form.modelReasoningEffort,
|
|
serviceTier: form.serviceTier.rawValue,
|
|
permissionMode: form.permissionMode.rawValue,
|
|
yolo: form.yolo
|
|
)
|
|
prefsData.launchSettings = settings
|
|
prefsStore.writePrefs(prefsData)
|
|
}
|
|
|
|
private func persistDraft() {
|
|
prefsStore.writeDraft(form)
|
|
}
|
|
|
|
private func persistOnSuccess(machineId: String, directory: String) {
|
|
prefsData.lastMachineId = machineId
|
|
prefsData.recentPaths[machineId] = NewSessionLogic.pushRecent(
|
|
prefsData.recentPaths[machineId] ?? [],
|
|
path: directory
|
|
)
|
|
prefsStore.writePrefs(prefsData)
|
|
prefsStore.clearDraft()
|
|
}
|
|
|
|
private static func spawnErrorMessage(code: String?, fallback: String?) -> String {
|
|
switch code {
|
|
case "runner_upgrade_required":
|
|
return msgRunnerUpgradeRequired
|
|
case "agent_unavailable":
|
|
return msgSelectedAgentUnavailable
|
|
case "outside_workspace_roots":
|
|
return msgDirectoryOutsideWorkspaceRoots
|
|
default:
|
|
let trimmed = fallback?.trimmingCharacters(in: .whitespacesAndNewlines) ?? ""
|
|
return trimmed.isEmpty ? String(localized: "Failed to create session") : trimmed
|
|
}
|
|
}
|
|
|
|
// MARK: - Formatting (Android `NewSessionViewModel` companion ports)
|
|
|
|
/// `getMachineOptionLabel` (web `MachineSelector`), minus capability-skew
|
|
/// (TODO with the machine detail screen).
|
|
static func machineOption(_ machine: Machine) -> MachineOptionUI {
|
|
let metadata = machine.metadata
|
|
let title = metadata?.displayName.flatMap { name in
|
|
name.trimmingCharacters(in: .whitespaces).isEmpty ? nil : name
|
|
}
|
|
?? metadata?.host
|
|
?? String(machine.id.prefix(8))
|
|
let platform = metadata.map { " (\($0.platform))" } ?? ""
|
|
let version = metadata.map { " · CLI \($0.happyCliVersion)" } ?? ""
|
|
let healthParts: [String] = [
|
|
machine.health?.cpuPercent.map { "CPU \(Int($0))%" },
|
|
machine.health?.memoryPercent.map { "Mem \(Int($0))%" },
|
|
].compactMap { $0 }
|
|
return MachineOptionUI(
|
|
id: machine.id,
|
|
label: "\(title)\(platform)\(version)",
|
|
healthLabel: healthParts.isEmpty ? nil : healthParts.joined(separator: " · ")
|
|
)
|
|
}
|
|
|
|
/// `formatRunnerSpawnError` (`web/src/utils/formatRunnerSpawnError.ts`).
|
|
static func formatRunnerSpawnError(_ machine: Machine?) -> String? {
|
|
guard case .object(let error)? = machine?.runnerState?.lastSpawnError else { return nil }
|
|
guard case .string(let message)? = error["message"], !message.isEmpty else { return nil }
|
|
if case .number(let at)? = error["at"] {
|
|
let date = Date(timeIntervalSince1970: at / 1000)
|
|
return "\(message) (\(date.formatted(date: .abbreviated, time: .shortened)))"
|
|
}
|
|
return message
|
|
}
|
|
}
|