Import apps/android/src/state/connection-actions.ts

This commit is contained in:
QQ 2026-11-14 14:19:18 +08:00
parent 50285b0b4c
commit 9803501891
1 changed files with 348 additions and 0 deletions

View File

@ -0,0 +1,348 @@
import { browseScope, useBrowseMemory } from '../services/browse-memory'
import { friendlyError, isSessionAuthError } from '../lib/errors'
import { initialProbeTransports } from '../lib/network-route'
import { strings as zhCN } from '../locales/i18n'
import { resolveAutomaticPreferredTransports } from '../services/network-route'
import { serverSession } from '../services/server-session'
import { saveLastConnectedDeviceId } from '../services/storage'
import type { SessionAccess } from './session-runtime'
import type { AppState } from './store-state'
import { disconnected } from './store-state'
/** Connection actions use the store's single connection/session runtime. */
const RELAY_DOWNGRADE_MS = 10 * 60_000
export function createConnectionActions({ get, set, runtime }: SessionAccess): Pick<AppState,
'connectDevice' | 'reconnect' | 'resumeConnection' | 'refreshConnectionNetworkDetails' | 'disconnect' | 'setOffline'> {
return {
async connectDevice(device, options = {}) {
const { config, identity } = get()
if (config === undefined || identity === undefined) return false
const generation = ++runtime.connectionGeneration
++runtime.sessionLoadGeneration
runtime.sessionReadAbort?.abort()
const memory = useBrowseMemory.getState()
const scope = browseScope({...get(), selectedDevice: device})
const cached = device.trusted ? memory.catalogs[scope] : undefined
const sameHost = get().selectedDevice?.deviceId === device.deviceId
if (!sameHost) runtime.webRtcFallbackStreak = 0
// reconnect() marks recovery before delegating here. A direct connect starts
// a new usage lifecycle even when choosing the same Host again.
const recovering = sameHost && get().connection.phase === 'reconnecting'
// In-memory catalogs belong to one Host; keep them only across its reconnect.
set(state => ({
...(!recovering ? { currentWorkSessionIds: [] } : {}),
...(!sameHost ? { selectedSession: undefined, messages: {}, feedbackBySession: {}, relayOnlyUntil: undefined } : {}),
sessionLifecycles: {},
sessionProjectionSeqs: {},
permissionSelecting: false,
modelSelecting: false,
busyAction: undefined,
codexReadySessionId: undefined,
selectedDevice: device,
connection: { phase: 'connecting', stats: { mode: 'Disconnected', connected: false } },
connectionStage: 'authenticating',
connectionProbeOrder: [],
connectionNetworkDetails: undefined,
hostDescriptor: undefined,
codexAvailable: false,
cursorAvailable: false,
antigravityAvailable: false,
piAvailable: false,
opencodeAvailable: false,
claudeAvailable: false,
hermesAvailable: false,
workspaceCatalog: undefined,
workspaces: sameHost ? state.workspaces : cached?.workspaces ?? [],
sessions: sameHost ? state.sessions : cached?.sessions ?? [],
archivedSessionIds: sameHost ? state.archivedSessionIds : [],
pinnedSessionIds: sameHost ? state.pinnedSessionIds : [],
sessionModels: undefined,
error: undefined,
}))
try {
await runtime.connection.prepareConnection(recovering)
if (generation !== runtime.connectionGeneration) return false
await runtime.closeActiveCodexStream(false)
await runtime.closeActiveCursorStream(false)
const { api, credentials } = await serverSession.authenticate(config.baseUrl, identity)
const preference = get().transportPreference
const relayOnlyActive = (get().relayOnlyUntil ?? 0) > Date.now()
const forceRelay = options.forceRelay === true || preference === 'relay' || relayOnlyActive
const preferredTransports = forceRelay
? ['relay'] as const
: preference === 'turn'
? ['turn', 'relay'] as const
: await resolveAutomaticPreferredTransports()
if (generation !== runtime.connectionGeneration) return false
set({ connectionStage: 'transport', connectionProbeOrder: initialProbeTransports(preferredTransports) })
await runtime.connection.connect(
config.baseUrl,
identity,
device,
credentials.accessToken,
frame => runtime.enqueueMuxFrame(generation, frame),
{
refreshAccessToken: async () => (await serverSession.authenticate(config.baseUrl, identity)).credentials.accessToken,
fetchIceServers: async connectionId => api.turnCredentials(connectionId),
preferredTransports: [...preferredTransports],
forceRelay,
onWebRtcFallback: () => {
if (generation !== runtime.connectionGeneration) return
// Repeated negotiation failures on this host: remember to go
// straight to the relay data plane for a while.
runtime.webRtcFallbackStreak += 1
if (runtime.webRtcFallbackStreak >= 2) {
set({ relayOnlyUntil: Date.now() + RELAY_DOWNGRADE_MS })
}
},
onOpencodeArchived: nativeId => {
if (generation !== runtime.connectionGeneration) return
const sessionId = `opencode:${nativeId}`
set(state => ({
sessions: state.sessions.filter(item => item.sessionId !== sessionId),
workspaces: state.workspaces.map(workspace => ({ ...workspace, sessionIds: workspace.sessionIds.filter(id => id !== sessionId) })),
}))
if (get().workspaceCatalog?.backend === 'opencode') void get().refreshWorkspaces('opencode')
},
onSecureHandshake: () => {
if (generation !== runtime.connectionGeneration) return
set(state => ({
connectionStage: 'secure', connection: {
...state.connection, stats: runtime.connection.getStats() ?? state.connection.stats,
}
}))
},
onClose: closeOptions => {
if (generation !== runtime.connectionGeneration) return
// Drop local stream handles so reconnect opens a fresh stream.
void runtime.closeActiveCodexStream(false)
void runtime.closeActiveCursorStream(false)
if (get().connection.phase !== 'disconnected') {
++runtime.connectionGeneration
++runtime.sessionLoadGeneration
// An established P2P/LAN/TURN path dropping is the unstable
// network case: remember relay-only for a while so recovery
// reconnects instantly over the relay instead of re-climbing
// LAN -> P2P -> TURN every time.
if (closeOptions?.lastTransport === 'lan' || closeOptions?.lastTransport === 'p2p' || closeOptions?.lastTransport === 'turn') {
set({ relayOnlyUntil: Date.now() + RELAY_DOWNGRADE_MS })
}
set({
connection: { phase: 'offline', stats: { mode: 'Disconnected', connected: false }, error: zhCN.runtime.hostClosed,
retryable: closeOptions?.retryable !== false },
connectionStage: undefined,
codexAvailable: false,
cursorAvailable: false,
antigravityAvailable: false,
piAvailable: false,
opencodeAvailable: false,
claudeAvailable: false,
hermesAvailable: false,
busyAction: undefined,
})
}
},
},
)
if (generation !== runtime.connectionGeneration) return false
set({ connectionStage: 'loading' })
const proxy = runtime.connection.requireProxy()
// Catalogs belong to the category the user opens, not connection setup.
const hostDescriptor = await proxy.hostDescribe()
const connectionNetworkDetails = await runtime.connection.getNetworkDetails().catch(() => undefined)
if (generation !== runtime.connectionGeneration) return false
const connectedStats = runtime.connection.getStats() ?? { mode: 'Relay', connected: true }
runtime.webRtcFallbackStreak = 0
set({
hostDescriptor,
codexAvailable: runtime.connection.hasCodex(),
cursorAvailable: runtime.connection.hasCursor(),
antigravityAvailable: runtime.connection.hasAntigravity(),
piAvailable: runtime.connection.hasPi(),
opencodeAvailable: runtime.connection.hasOpencode(),
claudeAvailable: runtime.connection.hasClaude(),
hermesAvailable: runtime.connection.hasHermes(),
connectionStage: 'ready',
connectionNetworkDetails,
lastConnectedDeviceId: device.deviceId,
pendingAutoConnectDeviceId: undefined,
connection: { phase: 'connected', stats: connectedStats },
...(connectedStats.mode !== 'Relay' && connectedStats.mode !== 'Disconnected' ? { relayOnlyUntil: undefined } : {}),
})
runtime.connectionStartedAt = Date.now()
await saveLastConnectedDeviceId(device.deviceId)
return true
} catch (error) {
if (generation !== runtime.connectionGeneration) return false
// Capture before close(): the carrier's close handler clears it.
const failedStage = get().connectionStage
console.warn('[dsh-remote] Connection setup failed at stage:', failedStage, error)
await runtime.connection.close({ preserveRecovery: recovering && !isSessionAuthError(error) })
if (isSessionAuthError(error)) {
await get().requireReauth(friendlyError(error))
return false
}
const message = friendlyError(error)
const errorCode = error instanceof Error && typeof (error as Error & { code?: unknown }).code === 'string'
? (error as Error & { code: string }).code
: undefined
const retryable = error instanceof Error && typeof (error as Error & { retryable?: unknown }).retryable === 'boolean'
? (error as Error & { retryable: boolean }).retryable
: undefined
// Failure inside transport negotiation means P2P/TURN could not
// establish: remember relay-only so the automatic retry (and the next
// manual attempt) skips the multi-second WebRTC wait entirely.
set({
connection: {
phase: 'offline',
stats: { mode: 'Disconnected', connected: false },
error: message,
...(errorCode !== undefined ? { errorCode } : {}),
...(retryable !== undefined ? { retryable } : {}),
},
connectionStage: undefined,
...(failedStage === 'transport' ? { relayOnlyUntil: Date.now() + RELAY_DOWNGRADE_MS } : {}),
codexAvailable: false,
cursorAvailable: false,
antigravityAvailable: false,
piAvailable: false,
opencodeAvailable: false,
claudeAvailable: false,
hermesAvailable: false,
error: message,
})
return false
}
},
reconnect(options = {}) {
if (runtime.reconnectFlight !== undefined) return runtime.reconnectFlight
const device = get().selectedDevice
const phase = get().connection.phase
if (device === undefined || phase === 'connecting' || phase === 'reconnecting') return Promise.resolve(false)
set(state => ({ connection: { ...state.connection, phase: 'reconnecting', error: undefined } }))
const task = (async () => {
if (!await get().connectDevice(device, options)) return false
const session = get().selectedSession
if (options.restoreSession !== false && session !== undefined) return get().openSession(session)
return true
})()
runtime.reconnectFlight = task
void task.finally(() => { if (runtime.reconnectFlight === task) runtime.reconnectFlight = undefined })
return task
},
async resumeConnection() {
const { selectedDevice, connection } = get()
if (selectedDevice === undefined) return
if (connection.phase === 'offline') {
if (connection.retryable === false) return
await get().reconnect()
return
}
if (connection.phase !== 'connected') return
const generation = runtime.connectionGeneration
// Both probes may race onClose, explicit disconnect or Host replacement.
const canContinueAfterProbe = async () => {
const current = get()
if (current.selectedDevice?.deviceId !== selectedDevice.deviceId) return false
// onClose can invalidate the generation while confirming a retryable
// offline carrier. Recover it before rejecting stale probe results.
if (current.connection.phase === 'offline') {
if (current.connection.retryable !== false) await get().reconnect()
return false
}
return generation === runtime.connectionGeneration && current.connection.phase === 'connected'
}
const healthy = await runtime.connection.checkHealth().catch(() => false)
if (!await canContinueAfterProbe()) return
if (!healthy) {
const retryHealthy = await runtime.connection.checkHealth().catch(() => false)
if (!await canContinueAfterProbe()) return
if (!retryHealthy) {
console.info('[dsh-remote] Resume health check failed; reconnecting')
await get().reconnect()
} else {
console.info('[dsh-remote] Resume health restored after retry')
await get().refreshConnectionNetworkDetails()
}
}
else await get().refreshConnectionNetworkDetails()
},
async refreshConnectionNetworkDetails() {
if (get().connection.phase !== 'connected') return
const details = await runtime.connection.getNetworkDetails().catch(() => undefined)
if (details !== undefined && get().connection.phase === 'connected') {
set(state => ({
connectionNetworkDetails: details,
connection: { ...state.connection, stats: runtime.connection.getStats() ?? state.connection.stats },
}))
}
},
async disconnect() {
runtime.flushPendingMuxFrames()
++runtime.connectionGeneration
++runtime.sessionLoadGeneration
runtime.reconnectFlight = undefined
runtime.clearPendingMuxFrames()
await runtime.closeActiveCodexStream(false)
await runtime.closeActiveCursorStream(false)
await runtime.connection.close()
runtime.codexModelSelections.clear()
set({
connection: disconnected,
connectionStage: undefined,
connectionProbeOrder: [],
connectionNetworkDetails: undefined,
selectedDevice: undefined,
hostDescriptor: undefined,
codexAvailable: false,
cursorAvailable: false,
antigravityAvailable: false,
piAvailable: false,
opencodeAvailable: false,
claudeAvailable: false,
hermesAvailable: false,
workspaceCatalog: undefined,
workspaces: [],
archivedSessionIds: [],
pinnedSessionIds: [],
sessions: [],
selectedSession: undefined,
scheduleTasks: [],
scheduleLoading: false,
scheduleError: undefined,
currentWorkSessionIds: [],
sessionLifecycles: {},
sessionProjectionSeqs: {},
sessionModels: undefined,
historyHasMore: false,
historyLoadingOlder: false,
oldestLoadedSeq: undefined,
})
},
setOffline() {
if (get().connection.phase !== 'disconnected') {
runtime.flushPendingMuxFrames()
++runtime.sessionLoadGeneration
runtime.clearPendingMuxFrames()
set({
connection: { phase: 'offline', stats: { mode: 'Disconnected', connected: false }, error: zhCN.runtime.networkUnavailable,
...(get().connection.retryable === false ? { retryable: false } : {}) },
codexAvailable: false,
busyAction: undefined,
cursorAvailable: false,
antigravityAvailable: false,
piAvailable: false,
opencodeAvailable: false,
claudeAvailable: false,
hermesAvailable: false,
})
}
},
}
}