native macOS codings agent orchestrator
Focus notification settings (#154)
* Fix notification settings alert presentation
* Present settings alerts from root view
+63
-37
+4
-28
supacode/Features/App/Reducer/AppFeature.swift
+4
-28
supacode/Features/App/Reducer/AppFeature.swift
···
69
69
enum Alert: Equatable {
70
70
case dismiss
71
71
case confirmQuit
72
-
case openSystemNotificationSettings
73
72
}
74
73
75
74
@Dependency(AnalyticsClient.self) private var analyticsClient
···
540
539
return .none
541
540
542
541
case .systemNotificationsPermissionFailed(let errorMessage):
543
-
let message: String
544
-
if let errorMessage, !errorMessage.isEmpty {
545
-
message =
546
-
"Supacode cannot send system notifications.\n\n"
547
-
+ "Error: \(errorMessage)"
548
-
} else {
549
-
message = "Supacode cannot send system notifications while permission is denied."
550
-
}
551
-
state.alert = AlertState {
552
-
TextState("Enable Notifications in System Settings")
553
-
} actions: {
554
-
ButtonState(action: .openSystemNotificationSettings) {
555
-
TextState("Open System Settings")
556
-
}
557
-
ButtonState(role: .cancel, action: .dismiss) {
558
-
TextState("Cancel")
559
-
}
560
-
} message: {
561
-
TextState(message)
562
-
}
563
-
return .send(.settings(.setSystemNotificationsEnabled(false)))
542
+
return .concatenate(
543
+
.send(.settings(.setSystemNotificationsEnabled(false))),
544
+
.send(.settings(.showNotificationPermissionAlert(errorMessage: errorMessage)))
545
+
)
564
546
565
547
case .alert(.dismiss):
566
548
state.alert = nil
567
549
return .none
568
-
569
-
case .alert(.presented(.openSystemNotificationSettings)):
570
-
state.alert = nil
571
-
return .run { _ in
572
-
await systemNotificationClient.openSettings()
573
-
}
574
550
575
551
case .alert(.presented(.confirmQuit)):
576
552
analyticsClient.capture("app_quit", nil)
+45
supacode/Features/Settings/Reducer/SettingsFeature.swift
+45
supacode/Features/Settings/Reducer/SettingsFeature.swift
···
24
24
var defaultWorktreeBaseDirectoryPath: String
25
25
var selection: SettingsSection? = .general
26
26
var repositorySettings: RepositorySettingsFeature.State?
27
+
@Presents var alert: AlertState<Alert>?
27
28
28
29
init(settings: GlobalSettings = .default) {
29
30
let normalizedDefaultEditorID = OpenWorktreeAction.normalizedDefaultEditorID(settings.defaultEditorID)
···
77
78
case settingsLoaded(GlobalSettings)
78
79
case setSelection(SettingsSection?)
79
80
case setSystemNotificationsEnabled(Bool)
81
+
case showNotificationPermissionAlert(errorMessage: String?)
80
82
case repositorySettings(RepositorySettingsFeature.Action)
83
+
case alert(PresentationAction<Alert>)
81
84
case delegate(Delegate)
82
85
case binding(BindingAction<State>)
83
86
}
84
87
88
+
enum Alert: Equatable {
89
+
case dismiss
90
+
case openSystemNotificationSettings
91
+
}
92
+
85
93
@CasePathable
86
94
enum Delegate: Equatable {
87
95
case settingsChanged(GlobalSettings)
88
96
}
89
97
90
98
@Dependency(AnalyticsClient.self) private var analyticsClient
99
+
@Dependency(SystemNotificationClient.self) private var systemNotificationClient
91
100
92
101
var body: some Reducer<State, Action> {
93
102
BindingReducer()
···
148
157
defaultWorktreeBaseDirectoryPath
149
158
return persist(state)
150
159
160
+
case .showNotificationPermissionAlert(let errorMessage):
161
+
let message: String
162
+
if let errorMessage, !errorMessage.isEmpty {
163
+
message =
164
+
"Supacode cannot send system notifications.\n\n"
165
+
+ "Error: \(errorMessage)"
166
+
} else {
167
+
message = "Supacode cannot send system notifications while permission is denied."
168
+
}
169
+
state.alert = AlertState {
170
+
TextState("Enable Notifications in System Settings")
171
+
} actions: {
172
+
ButtonState(action: .openSystemNotificationSettings) {
173
+
TextState("Open System Settings")
174
+
}
175
+
ButtonState(role: .cancel, action: .dismiss) {
176
+
TextState("Cancel")
177
+
}
178
+
} message: {
179
+
TextState(message)
180
+
}
181
+
return .none
182
+
151
183
case .setSelection(let selection):
152
184
state.selection = selection ?? .general
185
+
return .none
186
+
187
+
case .alert(.dismiss):
188
+
state.alert = nil
189
+
return .none
190
+
191
+
case .alert(.presented(.openSystemNotificationSettings)):
192
+
state.alert = nil
193
+
return .run { _ in
194
+
await systemNotificationClient.openSettings()
195
+
}
196
+
197
+
case .alert:
153
198
return .none
154
199
155
200
case .repositorySettings:
+2
-1
supacode/Features/Settings/Views/SettingsView.swift
+2
-1
supacode/Features/Settings/Views/SettingsView.swift
···
121
121
}
122
122
}
123
123
.navigationSplitViewStyle(.balanced)
124
+
.alert(store: settingsStore.scope(state: \.$alert, action: \.alert))
124
125
.alert(store: store.scope(state: \.$alert, action: \.alert))
125
126
.frame(minWidth: 750, minHeight: 500)
126
127
.background {
127
128
WindowAppearanceSetter(colorScheme: settingsStore.appearanceMode.colorScheme)
128
-
WindowLevelSetter(level: .floating)
129
+
WindowLevelSetter(level: .normal)
129
130
}
130
131
.ignoresSafeArea(.container, edges: .top)
131
132
}
+12
-8
supacodeTests/AppFeatureSystemNotificationTests.swift
+12
-8
supacodeTests/AppFeatureSystemNotificationTests.swift
···
35
35
await store.receive(\.settings.setSystemNotificationsEnabled) {
36
36
$0.settings.systemNotificationsEnabled = false
37
37
}
38
-
39
-
let expectedAlert = AlertState<AppFeature.Alert> {
38
+
let expectedAlert = AlertState<SettingsFeature.Alert> {
40
39
TextState("Enable Notifications in System Settings")
41
40
} actions: {
42
41
ButtonState(action: .openSystemNotificationSettings) {
···
48
47
} message: {
49
48
TextState("Supacode cannot send system notifications.\n\nError: Mock request error")
50
49
}
50
+
await store.receive(\.settings.showNotificationPermissionAlert) {
51
+
$0.settings.alert = expectedAlert
52
+
}
51
53
52
54
#expect(authorizationRequests.value == 1)
53
55
#expect(store.state.settings.systemNotificationsEnabled == false)
54
-
#expect(store.state.alert == expectedAlert)
56
+
#expect(store.state.settings.alert == expectedAlert)
55
57
}
56
58
57
59
@Test(.dependencies) func deniedStatusShowsAlertAndOpensSystemSettings() async {
···
86
88
await store.receive(\.settings.setSystemNotificationsEnabled) {
87
89
$0.settings.systemNotificationsEnabled = false
88
90
}
89
-
90
-
let expectedAlert = AlertState<AppFeature.Alert> {
91
+
let expectedAlert = AlertState<SettingsFeature.Alert> {
91
92
TextState("Enable Notifications in System Settings")
92
93
} actions: {
93
94
ButtonState(action: .openSystemNotificationSettings) {
···
99
100
} message: {
100
101
TextState("Supacode cannot send system notifications.\n\nError: Authorization status is denied.")
101
102
}
103
+
await store.receive(\.settings.showNotificationPermissionAlert) {
104
+
$0.settings.alert = expectedAlert
105
+
}
102
106
103
107
#expect(authorizationRequests.value == 0)
104
108
#expect(store.state.settings.systemNotificationsEnabled == false)
105
-
#expect(store.state.alert == expectedAlert)
109
+
#expect(store.state.settings.alert == expectedAlert)
106
110
107
-
await store.send(.alert(.presented(.openSystemNotificationSettings))) {
108
-
$0.alert = nil
111
+
await store.send(.settings(.alert(.presented(.openSystemNotificationSettings)))) {
112
+
$0.settings.alert = nil
109
113
}
110
114
await store.finish()
111
115
#expect(openedSettings.value == 1)