mirror of
https://github.com/wu736139669/hapi.git
synced 2026-10-08 19:19:42 +00:00
weishu
eed3dddb94
Interaction layer turning the read-only chat into a working remote control,
mirroring the merged Android B-M3ab feature-for-feature (web authority where
the ports disagreed):
- ChatInteractor (HapiClient, fully swift-test covered): optimistic composer
sends (appendOptimistic -> POST -> status settle), queue-by-default with a
long-press Send&Steer intent while a turn is active, tap-to-retry on failed
rows (steer retries degrade to queue), per-session drafts
(UserDefaultsChatDrafts, hub-scoped keys, debounced + flushed on close).
- session_inactive (409) recovery: one POST /resume (current permissionMode)
then retry; a superseding session id seeds the new window
(MessageWindowControllers.seed), migrates the draft, retargets the
optimistic row and emits sessionSuperseded -- ChatView/HomeView replace the
navigation entry in place.
- Queued bar: uninvoked sends in web sort order with Cancel (optimistic
DELETE; invoked-race ingests the authoritative row as sent), Edit
(cancel + composer prefill, newer-draft guard) and Steer (invoked answers
reconcile a missed consume); single-flight per-row op guard.
reconcileQueuedState now runs on chat open and on session-pipe gap.
- Permission actions: flavor-exact bodies mirroring PermissionFooter.tsx --
claude {} / allowTools (Bash(cmd)) / mode:acceptEdits, codex-family
decision approved / approved_for_session / abort via deny -- plus
AskUserQuestion flat answers (option cards, Other free text, no-questions
fallback, cursor stable ids) and request_user_input nested answers
(user_note suffix, required validation); optimistic Resolving /
AlreadyHandled (404/409) overrides settled by the agentState patch.
ChatPipeline now re-attaches the window row's client status so failed
user rows actually render the retry affordance (web normalize.ts parity;
the Android reference misses this overlay).
- Session config sheet (toolbar gear): catalog-driven permission-mode picker
with tones, claude static model/effort catalogs (ModelCatalog port), codex
models via new GET /sessions/:id/codex-models endpoint + wire types with
per-model reasoning efforts; optimistic detail updates
(SessionListStore.updateDetailLocal, new) rolled forward to server truth
on error.
- Lifecycle: VisibilityReporter posts POST /api/visibility per tracked
handshake subscriptionId on scene-phase flips (404 prunes); ChatSession
exposes its subscriptionId and feeds the reporter; the global SSE pipe was
already HubSession-lifetime on iOS.
- Tests: ChatInteractorTests transcribes the Android interaction suite
against the real APIClient/AuthManager/SessionListStore/window registry
with only HTTP scripted -- canonical JSON bodies asserted byte-for-byte
(send/approve/deny/config), optimistic send happy/fail/retry, 409 resume
both id paths, cancel invoked-race, steer reconcile, edit prefill,
override lifecycle, config optimistic + rollback, drafts, abort.
64 lines
2.2 KiB
Swift
64 lines
2.2 KiB
Swift
import Foundation
|
|
|
|
/// Per-session composer draft persistence (A-M3ab — the Android `ChatDrafts`
|
|
/// twin). Production backing is `UserDefaults`, keys scoped by hub; tests use
|
|
/// an in-memory map. All access happens on the main actor (the composer's
|
|
/// isolation), so implementations may be plain synchronous stores.
|
|
@MainActor
|
|
public protocol ChatDrafts: AnyObject {
|
|
/// The saved draft, or nil when none.
|
|
func load(sessionId: String) -> String?
|
|
|
|
/// Persist `text`; blank clears the key.
|
|
func save(sessionId: String, text: String)
|
|
|
|
func clear(sessionId: String)
|
|
|
|
/// Resume/reopen returned a different id: carry the draft across —
|
|
/// never clobbering a draft already typed in the target session.
|
|
func move(fromSessionId: String, toSessionId: String)
|
|
}
|
|
|
|
/// `UserDefaults`-backed drafts, keyed `chat-draft:<scope>:<sessionId>`
|
|
/// (scope = normalized hub origin, so multi-hub drafts never collide).
|
|
public final class UserDefaultsChatDrafts: ChatDrafts {
|
|
private let defaults: UserDefaults
|
|
private let scope: String
|
|
|
|
public init(scope: String, defaults: UserDefaults = .standard) {
|
|
self.scope = scope
|
|
self.defaults = defaults
|
|
}
|
|
|
|
private func key(_ sessionId: String) -> String {
|
|
"chat-draft:\(scope):\(sessionId)"
|
|
}
|
|
|
|
public func load(sessionId: String) -> String? {
|
|
let value = defaults.string(forKey: key(sessionId))
|
|
guard let value, !value.isEmpty else { return nil }
|
|
return value
|
|
}
|
|
|
|
public func save(sessionId: String, text: String) {
|
|
if text.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty {
|
|
defaults.removeObject(forKey: key(sessionId))
|
|
} else {
|
|
defaults.set(text, forKey: key(sessionId))
|
|
}
|
|
}
|
|
|
|
public func clear(sessionId: String) {
|
|
defaults.removeObject(forKey: key(sessionId))
|
|
}
|
|
|
|
public func move(fromSessionId: String, toSessionId: String) {
|
|
guard fromSessionId != toSessionId else { return }
|
|
guard let draft = load(sessionId: fromSessionId) else { return }
|
|
defaults.removeObject(forKey: key(fromSessionId))
|
|
if load(sessionId: toSessionId)?.isEmpty != false {
|
|
defaults.set(draft, forKey: key(toSessionId))
|
|
}
|
|
}
|
|
}
|