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.
58 lines
2.6 KiB
Swift
58 lines
2.6 KiB
Swift
import Foundation
|
|
import HapiProtocol
|
|
|
|
/// `POST /api/visibility` reporting (A-M3ab — the Android `VisibilityReporter`
|
|
/// twin): tracks the hub-minted subscription id of every live SSE pipe (fed
|
|
/// by ``onHandshake(key:subscriptionId:)`` from each pipe's handshake) and
|
|
/// reports foreground/background flips so the hub can suppress redundant push
|
|
/// notifications while the app is visibly connected.
|
|
///
|
|
/// Connect-time visibility already rides the SSE URL (`SSEClient` sends
|
|
/// `visibility=visible`), so only *transitions after connect* need a POST. A
|
|
/// `404` means the subscription died server-side — the entry is dropped (the
|
|
/// reconnect handshake re-registers a fresh id). Entries for closed pipes
|
|
/// self-heal the same way: the next flip 404s and prunes them.
|
|
@MainActor
|
|
public final class VisibilityReporter {
|
|
private let setVisibility: @Sendable (String, VisibilityState) async throws -> Void
|
|
private var subscriptionIds: [String: String] = [:]
|
|
private var foreground = true
|
|
|
|
public init(setVisibility: @escaping @Sendable (String, VisibilityState) async throws -> Void) {
|
|
self.setVisibility = setVisibility
|
|
}
|
|
|
|
/// Handshake hook: remember `subscriptionId` for the pipe identified by
|
|
/// `key` (e.g. `"global"`, `"session:<id>"`). Nil ids (older hubs) are
|
|
/// ignored.
|
|
public func onHandshake(key: String, subscriptionId: String?) {
|
|
guard let subscriptionId else { return }
|
|
subscriptionIds[key] = subscriptionId
|
|
}
|
|
|
|
/// Lifecycle input: report the flip to every tracked live subscription.
|
|
public func setForeground(_ isForeground: Bool) {
|
|
guard foreground != isForeground else { return }
|
|
foreground = isForeground
|
|
let visibility: VisibilityState = isForeground ? .visible : .hidden
|
|
let snapshot = subscriptionIds
|
|
let post = setVisibility
|
|
Task { [weak self] in
|
|
for (key, subscriptionId) in snapshot {
|
|
do {
|
|
try await post(subscriptionId, visibility)
|
|
} catch let error as APIError where error.status == 404 {
|
|
// Dead subscription — forget it unless a reconnect
|
|
// already stored a fresh id under the same key.
|
|
if let self, self.subscriptionIds[key] == subscriptionId {
|
|
self.subscriptionIds.removeValue(forKey: key)
|
|
}
|
|
} catch {
|
|
// Transient/offline — the next flip retries, and the
|
|
// reconnect handshake re-syncs connect-time visibility.
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|