ds-harness-remote-fast/apps/android/src/state/session-actions.ts

1070 lines
58 KiB
TypeScript

import { isSubagentSession } from '../lib/session-kind'
import { selectAcpModel } from '../services/acp-models'
import { createCodexTimelineState, projectCodexThread } from '@dsh-remote/client-core'
import { friendlyError, isRecoverableTransportError, isRpcTimeoutError, isStreamTimeoutError } from '../lib/errors'
import { strings as zhCN } from '../locales/i18n'
import { readAntigravityHistory } from '../services/antigravity'
import {
codexPermissionPreset,
codexPermissionPresetFromResponse,
codexSession,
codexThreadId,
isCodexPermissionPreset,
readCodexHistoryPage,
readCodexSession,
} from '../services/codex'
import {
createAntigravitySession,
createCursorSession,
createOpencodeSession,
createClaudeSession,
createHermesSession,
createPiSession,
cursorNativeId,
finalizeAssistantLive,
foldAcpHistory,
mergeAcpHistoryAndLive,
} from '../services/cursor'
import { forkMessage } from '../services/message-actions'
import { readOpencodeHistory, selectOpencodeModel } from '../services/opencode'
import { readClaudeHistory, selectClaudeModel } from '../services/claude'
import { loadHermesCatalog, mergeHermesCatalog, readHermesHistory, selectHermesModel } from '../services/hermes'
import { readPiHistory, selectPiModel } from '../services/pi'
import { saveCodexPermissionPreset } from '../services/storage'
import { browseKey, browseScope, getCachedSessionMessages, saveSessionMessagesSnapshot, updateBrowseEntry, useBrowseMemory } from '../services/browse-memory'
import type { RemoteSession } from '../types'
import { loadSavedCodexPermissions, withBestCodexPermission, withCodexPermissionState } from './codex-session-state'
import { foldHistory, settleTurnItems } from './event-reducer'
import { inboxRpcIds, mergeHistoryAndLive, oldestSeq, prependHistory, reconcileDeliveryStates, reconcileUserQuestionsProjection } from './message-helpers'
import type { SessionAccess } from './session-runtime'
import { applyFeedback, latestHistoryLifecycle, record, withActiveCodexTurn } from './session-state'
import type { AppState } from './store-state'
/** Session actions use the store's single connection/session runtime. */
export function createSessionActions({ get, set, runtime }: SessionAccess): Pick<AppState,
'refreshSessionStatus' | 'openSession' | 'forkChatMessage' | 'quoteChatMessage' | 'rateMessage' | 'createSession' | 'forkSession' | 'archiveSession' | 'unarchiveSession' | 'pinSession' | 'unpinSession' | 'renameSession' | 'selectModel' | 'selectPermission' | 'loadAgentPresets' | 'selectAgentPreset' | 'loadOlderHistory'> {
const isHarnessBackend = (backend?: RemoteSession['backend']) =>
(backend ?? 'harness') === 'harness'
const isHarnessTarget = (sessionId: string, backend?: RemoteSession['backend']) => {
const target = get().sessions.find(item => item.sessionId === sessionId)
const effectiveBackend = backend ?? target?.backend ?? 'harness'
return isHarnessBackend(effectiveBackend) && (!target || isHarnessBackend(target.backend))
}
return {
async refreshSessionStatus() {
if (get().connection.phase !== 'connected') return
try {
const rows = await runtime.connection.requireProxy().sessionList()
set(state => {
const known = new Set(state.sessions.map(item => item.sessionId))
const marks: typeof state.sessionLifecycles = { ...state.sessionLifecycles }
for (const row of state.sessions) {
const fresh = rows.find(item => item.sessionId === row.sessionId)
if (fresh === undefined) continue
const entry = marks[row.sessionId]
const wasRunning = entry?.running ?? row.running
if (wasRunning === fresh.running) continue
marks[row.sessionId] = {
seq: entry?.seq ?? -1,
turn: entry?.turn,
running: fresh.running,
// A run that ended while the list was watching leaves the "done"
// reminder; a fresh run clears it. Failure precision needs the
// turn/end frame (followed sessions), which keeps `failed` marks.
...(fresh.running
? { finished: undefined }
: { finished: entry?.finished === 'failed' ? 'failed' as const : 'completed' as const }),
}
}
let changed = false
const updated = state.sessions.map(row => {
const fresh = rows.find(item => item.sessionId === row.sessionId)
if (fresh === undefined || (fresh.running === row.running && fresh.updatedAt === row.updatedAt)) return row
changed = true
return { ...row, running: fresh.running, updatedAt: fresh.updatedAt }
})
const added = rows.filter(item => !known.has(item.sessionId))
const selectedFresh = state.selectedSession === undefined
? undefined
: rows.find(item => item.sessionId === state.selectedSession?.sessionId)
// Preserve array identity when nothing moved: the 8s refresh otherwise
// hands consumers a fresh `sessions` reference and re-runs their memos.
return {
sessionLifecycles: marks,
...(changed || added.length > 0
? { sessions: added.length > 0 ? [...added, ...updated] : updated }
: {}),
...(state.selectedSession !== undefined && selectedFresh !== undefined
&& (selectedFresh.running !== state.selectedSession.running || selectedFresh.updatedAt !== state.selectedSession.updatedAt)
? { selectedSession: { ...state.selectedSession, running: selectedFresh.running, updatedAt: selectedFresh.updatedAt } }
: {}),
}
})
} catch { /* status refresh is best-effort */ }
},
async openSession(session) {
runtime.flushPendingMuxFrames()
runtime.flushPendingCodexFrames()
const compact = get().compactHistory
const historyModeChanged = runtime.historyCompactMode !== undefined && runtime.historyCompactMode !== compact
if (historyModeChanged) {
runtime.browsePages.clear()
set(state => ({ messages: Object.fromEntries(Object.entries(state.messages).map(([id, items]) =>
[id, items.filter(item => item.kind === 'approval' || item.kind === 'question'
|| (item.kind === 'tool' && item.state === 'running')
|| (item.kind === 'message' && (item.sendState !== undefined || item.streaming)))])) }))
}
runtime.historyCompactMode = compact
const hostId = get().selectedDevice?.deviceId ?? ''
const pageScope = browseScope(get()) + (get().compactHistory ? ':compact' : ':full')
const pageKey = (id: string) => browseKey(pageScope, id)
const canPersistSnapshot = () => Boolean(get().config?.baseUrl && get().selectedDevice?.identityKey)
const memoryScope = browseScope(get())
const cachedSnapshot = canPersistSnapshot() ? getCachedSessionMessages(memoryScope, session.sessionId) : undefined
const inMemoryMessages = get().messages[session.sessionId]
const preservedMessages = (inMemoryMessages && inMemoryMessages.length > 0)
? inMemoryMessages
: (cachedSnapshot && cachedSnapshot.length > 0 ? cachedSnapshot : undefined)
if (get().connection.phase !== 'connected') {
set(state => ({
busyAction: undefined,
selectedSession: session,
sessions: state.sessions.some(item => item.sessionId === session.sessionId)
? state.sessions
: [session, ...state.sessions],
...(preservedMessages !== undefined ? {
messages: {
...state.messages,
[session.sessionId]: preservedMessages,
}
} : {}),
error: undefined,
historyLoadingOlder: false,
sessionModels: undefined,
modelSelecting: false,
historyHasMore: false,
oldestLoadedSeq: undefined,
}))
void runtime.rememberRecentWorkspace(session).catch(() => undefined)
set(state => ({ currentWorkSessionIds: [...state.currentWorkSessionIds.filter(id => id !== session.sessionId), session.sessionId].slice(-32) }))
return true
}
const previous = get().selectedSession
if (!historyModeChanged && previous !== undefined && !get().busyAction?.startsWith('session:') && !get().historyLoadingOlder) {
runtime.browsePages.set(pageKey(previous.sessionId), {
oldestLoadedSeq: get().oldestLoadedSeq, historyHasMore: get().historyHasMore,
})
if (runtime.browsePages.size > 32) runtime.browsePages.delete(runtime.browsePages.keys().next().value!)
}
const cachedPage = runtime.browsePages.get(pageKey(session.sessionId))
const cachedIds = new Set((get().messages[session.sessionId] ?? []).map(item => item.id))
let contiguousCache = false
const browseLive = (items: import('../types').ChatItem[], existing: import('../types').ChatItem[]) => {
contiguousCache = items.some(item => cachedIds.has(item.id))
// When the tail no longer overlaps, pagination starts from the new tail.
// Retain live/optimistic rows and pending approvals/questions, not a misleading gap in cached history.
return contiguousCache ? existing : existing.filter(item => !cachedIds.has(item.id) || item.id.startsWith('local:') || item.kind === 'approval' || item.kind === 'question')
}
runtime.sessionReadAbort?.abort()
const readAbort = new AbortController()
runtime.sessionReadAbort = readAbort
const loadGeneration = ++runtime.sessionLoadGeneration
const connectionGeneration = runtime.connectionGeneration
const current = () => loadGeneration === runtime.sessionLoadGeneration
&& connectionGeneration === runtime.connectionGeneration && !readAbort.signal.aborted
const pageState = (hasMore: boolean, oldest: number | undefined) => {
// Already loaded older pages remain contiguous with a refreshed tail.
const retained = cachedPage?.oldestLoadedSeq
return contiguousCache && retained !== undefined && oldest !== undefined && retained <= oldest
? cachedPage! : { historyHasMore: hasMore, oldestLoadedSeq: oldest }
}
const finishOpen = async () => {
void runtime.rememberRecentWorkspace(session).catch(() => undefined)
if (!current() || get().selectedSession?.sessionId !== session.sessionId) return false
set(state => ({ currentWorkSessionIds: [...state.currentWorkSessionIds.filter(id => id !== session.sessionId), session.sessionId].slice(-32) }))
return true
}
// Reset per-session view state up front: `historyLoadingOlder` and the
// model catalog belong to the previous session and must not leak into the
// new one (stuck pagination spinners, codex prompts sent with the previous
// session's model).
set(state => ({
busyAction: `session:${session.sessionId}`,
codexReadySessionId: undefined,
selectedSession: session,
...(preservedMessages !== undefined ? {
messages: {
...state.messages,
[session.sessionId]: preservedMessages,
}
} : {}),
historyHasMore: cachedPage?.historyHasMore ?? false,
oldestLoadedSeq: cachedPage?.oldestLoadedSeq,
error: undefined,
historyLoadingOlder: false,
sessionModels: undefined,
modelSelecting: false,
sessionLifecycles: state.sessionLifecycles[session.sessionId] === undefined
? state.sessionLifecycles
: {
...state.sessionLifecycles,
[session.sessionId]: { ...state.sessionLifecycles[session.sessionId]!, finished: undefined },
},
}))
const load = async () => {
await runtime.connection.configureHistory(compact)
if (!current()) return
if (session.backend === 'codex') {
void runtime.closeActiveCodexStream()
void runtime.closeActiveCursorStream()
const client = runtime.connection.requireCodex()
const threadId = codexThreadId(session)
const savedPermissions = await loadSavedCodexPermissions(get().selectedDevice?.deviceId)
if (!current()) return
const sessionWithPermission = withBestCodexPermission(session, undefined, savedPermissions)
const permission = codexPermissionPreset(sessionWithPermission)
const [read, history] = await Promise.all([
readCodexSession(client, threadId, permission, readAbort.signal),
readCodexHistoryPage(client, threadId, undefined, 16, readAbort.signal),
])
if (!current()) return
const timeline = createCodexTimelineState({ ...read.thread, turns: [] })
if (timeline === undefined) throw new Error(zhCN.runtime.codexInvalidResponse)
runtime.activeCodexTimeline = withActiveCodexTurn(timeline, history.activeTurnId)
const items = foldHistory(history.events, session.sessionId, true)
const nextSession = {
...sessionWithPermission,
...read.session,
...(history.activeTurnId === undefined ? {} : { running: true }),
}
set(state => {
const codexMerged = mergeHistoryAndLive(items, browseLive(items, state.messages[session.sessionId] ?? []))
if (canPersistSnapshot()) saveSessionMessagesSnapshot(memoryScope, session.sessionId, codexMerged)
return {
selectedSession: nextSession,
sessions: state.sessions.map(item => item.sessionId === session.sessionId ? nextSession : item),
messages: {
...state.messages,
[session.sessionId]: codexMerged,
},
...pageState(history.hasMore, oldestSeq(history.events)),
}
})
let streamClosed = false
const stream = await client.subscribe(
threadId,
frame => { if (current()) runtime.enqueueCodexFrame(loadGeneration, frame) },
// History reads can abort locally. An open must retain its ACK so
// a superseded load can close the subscription created on the Host.
undefined,
reason => {
streamClosed = true
if (!current()) return
if (runtime.activeCodexTimeline?.session.nativeId !== threadId) return
runtime.activeCodexStream = undefined
runtime.activeCodexTimeline = undefined
set(state => ({
codexReadySessionId: undefined,
sessions: state.sessions.map(item => item.sessionId === session.sessionId ? {...item, running: false} : item),
selectedSession: state.selectedSession?.sessionId === session.sessionId
? state.selectedSession
: state.selectedSession,
...(reason === 'failed' ? { error: zhCN.runtime.codexUnavailable } : {}),
}))
},
)
if (!current()) { await stream.close().catch(() => undefined); return }
if (streamClosed) throw new Error(zhCN.runtime.codexUnavailable)
runtime.activeCodexStream = stream
set({ busyAction: undefined, codexReadySessionId: session.sessionId })
void runtime.refreshCodexModels(session.sessionId)
return
}
if (session.backend === 'cursor' || session.backend === 'antigravity' || session.backend === 'pi' || session.backend === 'opencode' || session.backend === 'claude' || session.backend === 'hermes') {
await runtime.closeActiveCodexStream()
await runtime.closeActiveCursorStream()
if (!current()) return
const existingMessages = get().messages[session.sessionId] ?? []
// Retire or drop dead in-flight streaming chunks from the prior connection
const cleanExisting = existingMessages.filter(item => !(item.kind === 'message' && (item.streaming || item.id === 'cursor-assistant-live' || item.id === 'cursor-user-live')))
const initialAcpIds = new Set(cleanExisting.map(item => item.id))
const hasHistory = session.backend === 'antigravity' || session.backend === 'pi' || session.backend === 'opencode' || session.backend === 'claude' || session.backend === 'hermes'
// History replaces the previous connection's projection. Retain existing displayed
// messages so opening or reconnecting does not flash white, then in-place merge.
set(state => ({
selectedSession: session, sessionModels: undefined, historyHasMore: false,
...(cleanExisting.length !== existingMessages.length
? { messages: { ...state.messages, [session.sessionId]: cleanExisting } }
: {}),
}))
const acpClient = session.backend === 'claude' ? runtime.connection.requireClaude() : session.backend === 'hermes' ? runtime.connection.requireHermes() : session.backend === 'opencode'
? runtime.connection.requireOpencode()
: session.backend === 'pi'
? runtime.connection.requirePi()
: session.backend === 'antigravity' ? runtime.connection.requireAntigravity() : runtime.connection.requireCursor()
const [history] = await Promise.all([
session.backend === 'claude' ? readClaudeHistory(acpClient, cursorNativeId(session)) : session.backend === 'hermes'
? readHermesHistory(acpClient, cursorNativeId(session)) : session.backend === 'opencode'
? readOpencodeHistory(acpClient, cursorNativeId(session))
: session.backend === 'pi'
? readPiHistory(acpClient, cursorNativeId(session))
: session.backend === 'antigravity'
? readAntigravityHistory(acpClient, cursorNativeId(session))
: Promise.resolve([] as unknown[]),
runtime.ensureCursorStream(session, current),
])
if (!current()) return
const items = foldAcpHistory(history, session.sessionId)
set(state => {
const currentMessages = state.messages[session.sessionId] ?? []
const liveDeltas = currentMessages.filter(item => !initialAcpIds.has(item.id) || item.id.startsWith('local:') || item.kind === 'approval' || item.kind === 'question')
const merged = hasHistory
? mergeAcpHistoryAndLive(items, liveDeltas)
: mergeHistoryAndLive(items, liveDeltas)
if (canPersistSnapshot()) saveSessionMessagesSnapshot(memoryScope, session.sessionId, merged)
return {
selectedSession: state.selectedSession?.sessionId === session.sessionId ? state.selectedSession : session,
sessions: state.sessions.some(item => item.sessionId === session.sessionId)
? state.sessions
: [session, ...state.sessions],
messages: {
...state.messages,
[session.sessionId]: merged,
},
sessionModels: undefined,
historyHasMore: false,
oldestLoadedSeq: undefined,
busyAction: undefined,
}
})
if (session.backend === 'antigravity') void runtime.refreshAntigravityModels(session, current)
if (session.backend === 'pi') void runtime.refreshPiModels(session, current)
if (session.backend === 'opencode') void runtime.refreshOpencodeModels(session, current)
if (session.backend === 'claude') void runtime.refreshClaudeModels(session, current)
if (session.backend === 'hermes') void runtime.refreshHermesModels(session, current)
if (session.backend === 'cursor') void runtime.refreshCursorModels(session, current)
return
}
void runtime.closeActiveCodexStream()
void runtime.closeActiveCursorStream()
const [history, feedback] = await Promise.all([
runtime.connection.requireProxy().sessionHistory(session.sessionId, undefined, 16, isSubagentSession(session) ? session.parentSessionId : undefined),
// Older carriers may not expose feedback; history must remain usable.
runtime.connection.requireProxy().messageFeedbackList(session.sessionId).catch(() => undefined),
])
if (!current()) return
// The follow snapshot's projections were emitted synchronously inside
// sessionHistory — apply queued frames before reading them below, or the
// delivery reconcile judges against a stale inbox.
runtime.flushPendingMuxFrames()
const ratings = feedback === undefined ? undefined : new Map(feedback.map(row => [row.messageId, row.rating]))
const items = foldHistory(history.events, session.sessionId, true)
set(state => {
const latest = state.sessions.find(item => item.sessionId === session.sessionId)
?? (state.selectedSession?.sessionId === session.sessionId ? state.selectedSession : session)
const lifecycle = latestHistoryLifecycle(history.events)
const liveLifecycle = state.sessionLifecycles[session.sessionId]
const authoritativeLifecycle = liveLifecycle !== undefined && liveLifecycle.seq > (history.throughSeq ?? lifecycle?.seq ?? -1)
? liveLifecycle : lifecycle
const nextSession = { ...latest, running: authoritativeLifecycle?.running ?? latest.running }
// Reconcile local delivery states against Host truth — only when a real
// `inbox` snapshot exists (the key itself, not merely the projection
// channel), and only for rows created before this connection. The
// reconciliation marks, never deletes: a late `user/message` echo still
// replaces the row by requestRpcId, so a misjudgment self-heals.
const inboxSnapshot = latest.projections?.values?.inbox
const userQuestionsSnapshot = latest.projections?.values?.userQuestions
const merged = applyFeedback(mergeHistoryAndLive(items, browseLive(items, state.messages[session.sessionId] ?? []), history.throughSeq), ratings)
const reconciled = inboxSnapshot === undefined ? merged : reconcileDeliveryStates(
merged,
inboxRpcIds(inboxSnapshot),
new Set(items.flatMap(item => item.kind === 'message' && item.requestRpcId !== undefined ? [item.requestRpcId] : [])),
runtime.connectionStartedAt,
)
// A prompt acknowledged on this connection can still be missing from
// both history and the inbox (lost event after commit). Once the Host
// proves the session is idle and neither source knows the requestId,
// settle the optimistic row as unconfirmed instead of leaving the
// composer stuck on "sending" forever. Late echoes still replace it.
const historyRpcIds = new Set(items.flatMap(item => item.kind === 'message' && item.requestRpcId !== undefined ? [item.requestRpcId] : []))
const runningNow = nextSession.running === true || authoritativeLifecycle?.running === true
const unsettled = inboxSnapshot === undefined || runningNow ? reconciled : (() => {
const queuedRpcIds = inboxRpcIds(inboxSnapshot)
return reconciled.map(item => item.kind === 'message' && item.id.startsWith('local:')
&& item.sendState === undefined && item.requestRpcId !== undefined
&& !queuedRpcIds.has(item.requestRpcId) && !historyRpcIds.has(item.requestRpcId)
? { ...item, sendState: 'unconfirmed' as const }
: item)
})()
const withQuestions = userQuestionsSnapshot === undefined
? unsettled
: reconcileUserQuestionsProjection(unsettled, session.sessionId, userQuestionsSnapshot, inboxSnapshot)
const hasRunningAskUserTool = items.some(item => item.kind === 'tool' && item.state === 'running' && (item.toolKey ?? item.toolName) === 'ask_user_question')
const effectivelyRunning = nextSession.running || (authoritativeLifecycle === undefined && hasRunningAskUserTool)
const activeTurn = authoritativeLifecycle?.turn
?? (effectivelyRunning ? [...items].reverse().find(item => item.turn !== undefined && item.turnEnd === undefined)?.turn : undefined)
const restored = effectivelyRunning === false ? settleTurnItems(withQuestions)
: activeTurn === undefined ? withQuestions : settleTurnItems(withQuestions, undefined, activeTurn)
if (canPersistSnapshot()) saveSessionMessagesSnapshot(memoryScope, session.sessionId, restored)
return {
selectedSession: nextSession,
sessions: state.sessions.map(item => item.sessionId === session.sessionId ? nextSession : item),
...(authoritativeLifecycle === undefined ? {} : { sessionLifecycles: { ...state.sessionLifecycles, [session.sessionId]: authoritativeLifecycle } }),
historyLoadingOlder: false,
feedbackBySession: ratings === undefined ? state.feedbackBySession : { ...state.feedbackBySession, [session.sessionId]: ratings },
messages: { ...state.messages, [session.sessionId]: restored },
...pageState(history.hasMore, oldestSeq(history.events)),
busyAction: undefined,
}
})
void runtime.refreshSessionModels(session.sessionId)
}
try {
await load()
if (!current()) return false
return await finishOpen()
} catch (error) {
if (!current()) return false
// A subagent address that never answers must not burn a full reconnect
// cycle on every open; top-level session stalls still fall back to
// forceRelay once (the pre-bounding recovery path).
const transportRetry = (isRpcTimeoutError(error) || isRecoverableTransportError(error))
&& !(isStreamTimeoutError(error) && isSubagentSession(session))
&& !runtime.sessionReadRetry
if (transportRetry) {
if (runtime.reconnectFlight !== undefined) {
set({ busyAction: undefined, error: friendlyError(error) })
return false
}
// session.history is read-only, so it is safe to recover the stale
// path with a fresh Relay-only connection and retry exactly once.
// Mutating Harness calls deliberately do not use this path because a
// timeout leaves their result unknown.
const recovered = await get().reconnect({ forceRelay: true, restoreSession: false })
if (runtime.sessionReadAbort !== readAbort || get().selectedDevice?.deviceId !== hostId) return false
if (recovered) {
// The replaced connection owns a new abort/generation scope.
// Mark this bounded retry so another failed read cannot reconnect in a loop.
runtime.sessionReadRetry = true
try { return await get().openSession(session) }
finally { runtime.sessionReadRetry = false }
}
set({ busyAction: undefined })
return false
}
set({ busyAction: undefined, error: friendlyError(error) })
return false
}
},
async forkChatMessage(message) {
if (get().connection.phase !== 'connected' || get().busyAction !== undefined || get().selectedSession?.backend === 'codex') return false
set({ busyAction: `fork:${message.id}`, error: undefined })
try {
const result = await forkMessage(message, runtime.connection.requireProxy())
set({ sessions: result.sessions, workspaces: result.workspaces, busyAction: undefined })
return await get().openSession(result.session)
} catch (error) {
set({ busyAction: undefined, error: friendlyError(error) })
return false
}
},
async rateMessage(message, rating) {
if (get().connection.phase !== 'connected' || get().busyAction !== undefined || get().selectedSession?.backend === 'codex' || message.streaming) return false
set({ busyAction: `feedback:${message.id}`, error: undefined })
try {
const saved = await runtime.connection.requireProxy().messageFeedbackPut(message.sessionId, message.id, rating)
set(state => ({
busyAction: undefined,
feedbackBySession: state.feedbackBySession[message.sessionId] === undefined ? state.feedbackBySession : {
...state.feedbackBySession,
[message.sessionId]: new Map(state.feedbackBySession[message.sessionId]).set(message.id, saved.rating),
},
messages: {
...state.messages,
[message.sessionId]: (state.messages[message.sessionId] ?? []).map(item => item.id === message.id && item.kind === 'message' ? { ...item, feedback: saved.rating } : item),
}
}))
return true
} catch (error) {
set({ busyAction: undefined, error: friendlyError(error) })
return false
}
},
quoteChatMessage(text, sessionId) {
const targetId = sessionId ?? get().selectedSession?.sessionId
if (!targetId || !text.trim()) return
const scope = browseScope({ config: get().config, selectedDevice: get().selectedDevice })
const key = browseKey(scope, targetId)
const existing = useBrowseMemory.getState().entries[key]?.quotes ?? []
updateBrowseEntry(scope, targetId, { quotes: [...existing, text.trim()] })
},
async createSession(workspaceId, targetBackend) {
if (get().connection.phase !== 'connected') return false
if (runtime.createSessionFlight !== undefined || get().busyAction === 'create-session') return false
const task = (async () => {
const generation = runtime.connectionGeneration
const defaultPermission = get().defaultPermissionPreset
set({ busyAction: 'create-session', error: undefined })
try {
const workspace = workspaceId === undefined ? undefined : get().workspaces.find(item => item.workspaceId === workspaceId)
const backend = targetBackend ?? workspace?.backend ?? 'harness'
const existingPath = workspace?.path || get().workspaces.find(w => !!w.path)?.path
const isWin = get().selectedDevice?.platform === 'windows'
const cwd = existingPath || (isWin ? 'C:\\' : '/')
if (backend === 'codex') {
const client = runtime.connection.requireCodex()
const result = record(await client.request('thread/start', {
cwd,
permissionPreset: defaultPermission === 'default' ? 'workspace-write' : defaultPermission,
}))
if (generation !== runtime.connectionGeneration) return false
const display = projectCodexThread(result.thread)
if (display === undefined) throw new Error(zhCN.runtime.codexInvalidResponse)
const effectivePreset = codexPermissionPresetFromResponse(result)
?? (defaultPermission === 'default' ? 'workspace-write' : defaultPermission)
const created = codexSession(display, effectivePreset)
const hostDeviceId = get().selectedDevice?.deviceId
if (hostDeviceId === undefined) throw new Error(zhCN.runtime.connectHostFirst)
await saveCodexPermissionPreset(hostDeviceId, display.nativeId, effectivePreset)
if (generation !== runtime.connectionGeneration) return false
set(state => ({
sessions: [created, ...state.sessions.filter(item => item.sessionId !== created.sessionId)],
...(workspace === undefined ? {} : {
workspaces: state.workspaces.map(item => item.workspaceId === workspace.workspaceId
? { ...item, sessionIds: [created.sessionId, ...item.sessionIds.filter(id => id !== created.sessionId)] }
: item),
}),
busyAction: undefined,
}))
return get().openSession(created)
}
if (backend === 'cursor') {
const created = await runtime.connection.requireCursor().createSession(cwd, 'agent', 'cursor')
const session = createCursorSession({
acpSessionId: created.sessionId,
cwd,
title: workspace?.title ?? 'Cursor',
})
set(state => ({
sessions: [session, ...state.sessions.filter(item => item.sessionId !== session.sessionId)],
...(workspace === undefined ? {} : {
workspaces: state.workspaces.map(item => item.workspaceId === workspace.workspaceId
? {
...item,
sessionIds: [session.sessionId, ...item.sessionIds.filter(id => id !== session.sessionId)],
updatedAt: new Date().toISOString(),
}
: item),
}),
busyAction: undefined,
}))
return get().openSession(session)
}
if (backend === 'antigravity') {
const created = await runtime.connection.requireAntigravity().createSession(cwd, 'agent', 'antigravity')
const session = createAntigravitySession({
acpSessionId: created.sessionId,
cwd,
})
set(state => ({
sessions: [session, ...state.sessions.filter(item => item.sessionId !== session.sessionId)],
...(workspace === undefined ? {} : {
workspaces: state.workspaces.map(item => item.workspaceId === workspace.workspaceId
? {
...item,
sessionIds: [session.sessionId, ...item.sessionIds.filter(id => id !== session.sessionId)],
updatedAt: new Date().toISOString(),
}
: item),
}),
busyAction: undefined,
}))
return get().openSession(session)
}
if (backend === 'pi') {
const created = await runtime.connection.requirePi().createSession(cwd, 'agent', 'pi')
if (generation !== runtime.connectionGeneration) return false
const session = createPiSession({
acpSessionId: created.sessionId,
cwd,
})
set(state => ({
sessions: [session, ...state.sessions.filter(item => item.sessionId !== session.sessionId)],
...(workspace === undefined ? {} : {
workspaces: state.workspaces.map(item => item.workspaceId === workspace.workspaceId
? {
...item,
sessionIds: [session.sessionId, ...item.sessionIds.filter(id => id !== session.sessionId)],
updatedAt: new Date().toISOString(),
}
: item),
}),
busyAction: undefined,
}))
return get().openSession(session)
}
if (backend === 'opencode') {
const created = await runtime.connection.requireOpencode().createSession(cwd, 'agent', 'opencode')
if (generation !== runtime.connectionGeneration) return false
const session = createOpencodeSession({
acpSessionId: created.sessionId,
cwd,
})
set(state => ({
sessions: [session, ...state.sessions.filter(item => item.sessionId !== session.sessionId)],
...(workspace === undefined ? {} : {
workspaces: state.workspaces.map(item => item.workspaceId === workspace.workspaceId
? {
...item,
sessionIds: [session.sessionId, ...item.sessionIds.filter(id => id !== session.sessionId)],
updatedAt: new Date().toISOString(),
}
: item),
}),
busyAction: undefined,
}))
return get().openSession(session)
}
if (backend === 'claude' || backend === 'hermes') {
const created = backend === 'hermes'
? await runtime.connection.requireHermes().createSession(cwd, 'agent', 'hermes')
: await runtime.connection.requireClaude().createSession(cwd, 'agent', 'claude')
if (generation !== runtime.connectionGeneration) return false
const session = backend === 'hermes'
? createHermesSession({ acpSessionId: created.sessionId, cwd })
: createClaudeSession({
acpSessionId: created.sessionId,
cwd,
})
set(state => ({
sessions: [session, ...state.sessions.filter(item => item.sessionId !== session.sessionId)],
...(workspace === undefined ? {} : {
workspaces: state.workspaces.map(item => item.workspaceId === workspace.workspaceId
? {
...item,
sessionIds: [session.sessionId, ...item.sessionIds.filter(id => id !== session.sessionId)],
updatedAt: new Date().toISOString(),
}
: item),
}),
busyAction: undefined,
}))
return get().openSession(session)
}
const proxy = runtime.connection.requireProxy()
const { sessionId } = await proxy.sessionCreate(workspaceId)
if (generation !== runtime.connectionGeneration) return false
if (defaultPermission !== 'default') {
await proxy.sessionSelectPermission(sessionId, defaultPermission)
if (generation !== runtime.connectionGeneration) return false
}
const sessions = await proxy.sessionList()
if (generation !== runtime.connectionGeneration) return false
const created = sessions.find(session => session.sessionId === sessionId)
if (defaultPermission !== 'default') {
const permissions = created?.projections?.values?.permissions
if (typeof permissions !== 'object' || permissions === null || !('currentValue' in permissions) || permissions.currentValue !== defaultPermission) {
throw new Error(zhCN.settings.defaultPermissionNotConfirmed)
}
}
set(state => ({
sessions,
busyAction: undefined,
...(workspace === undefined ? {} : {
workspaces: state.workspaces.map(item => item.workspaceId === workspace.workspaceId
? { ...item, sessionIds: [sessionId, ...item.sessionIds.filter(id => id !== sessionId)] }
: item),
}),
}))
if (created === undefined) return false
return get().openSession(created)
} catch (error) {
set({ busyAction: undefined, error: friendlyError(error) })
return false
}
})()
runtime.createSessionFlight = task
void task.finally(() => { if (runtime.createSessionFlight === task) runtime.createSessionFlight = undefined })
return task
},
async forkSession(sessionId, backend) {
if (get().connection.phase !== 'connected') return undefined
if (!isHarnessTarget(sessionId, backend)) return undefined
const generation = runtime.connectionGeneration
set({ busyAction: `fork:${sessionId}`, error: undefined })
try {
const proxy = runtime.connection.requireProxy()
const { sessionId: childId } = await proxy.sessionFork(sessionId)
if (generation !== runtime.connectionGeneration) return undefined
const [sessions, workspaceList] = await Promise.all([proxy.sessionList(), proxy.workspaceList()])
if (generation !== runtime.connectionGeneration) return undefined
const created = sessions.find(s => s.sessionId === childId)
set(state => ({
sessions: [
...(state.sessions ?? []).filter(item => !isHarnessBackend(item.backend)),
...sessions,
],
workspaces: [
...(state.workspaces ?? []).filter(item => !isHarnessBackend(item.backend)),
...workspaceList.items,
],
archivedSessionIds: workspaceList.archivedSessionIds,
...(workspaceList.pinnedSessionIds ? { pinnedSessionIds: workspaceList.pinnedSessionIds } : {}),
busyAction: undefined,
}))
if (created) {
await get().openSession(created)
}
return created
} catch (error) {
if (generation !== runtime.connectionGeneration) return undefined
set({ busyAction: undefined, error: friendlyError(error) })
return undefined
}
},
async archiveSession(sessionId) {
if (get().connection.phase !== 'connected') return false
const generation = runtime.connectionGeneration
set({ busyAction: `archive:${sessionId}`, error: undefined })
try {
const session = get().sessions.find(item => item.sessionId === sessionId)
if (session?.backend === 'codex') {
await runtime.connection.requireCodex().request('thread/archive', { threadId: codexThreadId(session) })
if (generation !== runtime.connectionGeneration) return false
if (runtime.activeCodexTimeline?.session.id === sessionId) await runtime.closeActiveCodexStream()
if (generation !== runtime.connectionGeneration) return false
set(state => ({
sessions: state.sessions.filter(item => item.sessionId !== sessionId),
workspaces: state.workspaces.map(workspace => ({
...workspace,
sessionIds: workspace.sessionIds.filter(id => id !== sessionId),
})),
busyAction: undefined,
selectedSession: state.selectedSession?.sessionId === sessionId ? undefined : state.selectedSession,
sessionModels: state.selectedSession?.sessionId === sessionId ? undefined : state.sessionModels,
}))
return true
}
if (session?.backend === 'cursor' || session?.backend === 'antigravity' || session?.backend === 'pi' || session?.backend === 'opencode' || session?.backend === 'claude' || session?.backend === 'hermes') {
if (session.backend !== 'opencode') throw new Error(`Native session archiving is unavailable for ${session.backend}.`)
await runtime.connection.requireOpencode().archiveSession(cursorNativeId(session), 'opencode')
if (generation !== runtime.connectionGeneration) return false
if (get().selectedSession?.sessionId === sessionId) await runtime.closeActiveCursorStream()
if (generation !== runtime.connectionGeneration) return false
set(state => ({
sessions: state.sessions.filter(item => item.sessionId !== sessionId),
workspaces: state.workspaces.map(workspace => ({
...workspace,
sessionIds: workspace.sessionIds.filter(id => id !== sessionId),
})),
busyAction: undefined,
selectedSession: state.selectedSession?.sessionId === sessionId ? undefined : state.selectedSession,
sessionModels: state.selectedSession?.sessionId === sessionId ? undefined : state.sessionModels,
}))
return true
}
const proxy = runtime.connection.requireProxy()
const archivedSessionIds = await proxy.workspaceArchiveSession(sessionId)
if (generation !== runtime.connectionGeneration) return false
// The mutation returns the complete Host-confirmed archive set. Preserve
// catalog membership, and do not let a second read hide a successful write.
set(state => ({
archivedSessionIds,
pinnedSessionIds: state.pinnedSessionIds.filter(id => id !== sessionId),
busyAction: undefined,
selectedSession: state.selectedSession?.sessionId === sessionId ? undefined : state.selectedSession,
sessionModels: state.selectedSession?.sessionId === sessionId ? undefined : state.sessionModels,
}))
return true
} catch (error) {
if (generation !== runtime.connectionGeneration) return false
set({ busyAction: undefined, error: friendlyError(error) })
return false
}
},
async unarchiveSession(sessionId, backend) {
if (get().connection.phase !== 'connected') return false
if (!isHarnessTarget(sessionId, backend)) return false
const generation = runtime.connectionGeneration
set({ busyAction: `unarchive:${sessionId}`, error: undefined })
try {
const proxy = runtime.connection.requireProxy()
const archivedSessionIds = await proxy.workspaceUnarchiveSession(sessionId)
if (generation !== runtime.connectionGeneration) return false
set({ archivedSessionIds, busyAction: undefined })
return true
} catch (error) {
if (generation !== runtime.connectionGeneration) return false
set({ busyAction: undefined, error: friendlyError(error) })
return false
}
},
async pinSession(sessionId, backend) {
if (get().connection.phase !== 'connected') return false
if (!isHarnessTarget(sessionId, backend)) return false
const generation = runtime.connectionGeneration
set({ busyAction: `pin:${sessionId}`, error: undefined })
try {
const proxy = runtime.connection.requireProxy()
const pinnedSessionIds = await proxy.workspacePinSession(sessionId)
if (generation !== runtime.connectionGeneration) return false
set({ pinnedSessionIds, busyAction: undefined })
return true
} catch (error) {
if (generation !== runtime.connectionGeneration) return false
set({ busyAction: undefined, error: friendlyError(error) })
return false
}
},
async unpinSession(sessionId, backend) {
if (get().connection.phase !== 'connected') return false
if (!isHarnessTarget(sessionId, backend)) return false
const generation = runtime.connectionGeneration
set({ busyAction: `unpin:${sessionId}`, error: undefined })
try {
const proxy = runtime.connection.requireProxy()
const pinnedSessionIds = await proxy.workspaceUnpinSession(sessionId)
if (generation !== runtime.connectionGeneration) return false
set({ pinnedSessionIds, busyAction: undefined })
return true
} catch (error) {
if (generation !== runtime.connectionGeneration) return false
set({ busyAction: undefined, error: friendlyError(error) })
return false
}
},
async renameSession(sessionId, title, backend) {
if (get().connection.phase !== 'connected') return false
if (!isHarnessTarget(sessionId, backend)) return false
const generation = runtime.connectionGeneration
const trimmed = title.trim()
if (!trimmed) return false
set({ busyAction: `rename:${sessionId}`, error: undefined })
try {
const proxy = runtime.connection.requireProxy()
const result = await proxy.sessionRename(sessionId, trimmed)
if (generation !== runtime.connectionGeneration) return false
const updatedTitle = result?.title ?? trimmed
set(state => ({
busyAction: undefined,
sessions: state.sessions.map(s => (s.sessionId === sessionId ? { ...s, title: updatedTitle } : s)),
selectedSession: state.selectedSession?.sessionId === sessionId
? { ...state.selectedSession, title: updatedTitle }
: state.selectedSession,
}))
return true
} catch (error) {
if (generation !== runtime.connectionGeneration) return false
set({ busyAction: undefined, error: friendlyError(error) })
return false
}
},
async selectModel(selection) {
const generation = runtime.connectionGeneration
const session = get().selectedSession
if (session === undefined || get().connection.phase !== 'connected') return false
set({ modelSelecting: true, error: undefined })
try {
if (session.backend === 'codex') {
if (selection.provider !== 'codex') throw new Error(zhCN.runtime.codexInvalidResponse)
runtime.codexModelSelections.set(session.sessionId, selection)
set(state => ({
sessionModels: state.sessionModels === undefined ? undefined : { ...state.sessionModels, current: selection },
modelSelecting: false,
}))
return true
}
if (session.backend === 'pi') {
const models = await selectPiModel(runtime.connection.requirePi(), cursorNativeId(session), selection)
if (generation !== runtime.connectionGeneration || get().selectedSession?.sessionId !== session.sessionId) return false
set({ sessionModels: models, modelSelecting: false })
return true
}
if (session.backend === 'opencode') {
const models = await selectOpencodeModel(runtime.connection.requireOpencode(), cursorNativeId(session), selection)
if (generation !== runtime.connectionGeneration || get().selectedSession?.sessionId !== session.sessionId) return false
set({ sessionModels: models, modelSelecting: false })
return true
}
if (session.backend === 'claude' || session.backend === 'hermes') {
const models = session.backend === 'hermes'
? await selectHermesModel(runtime.connection.requireHermes(), cursorNativeId(session), selection)
: await selectClaudeModel(runtime.connection.requireClaude(), cursorNativeId(session), selection)
if (generation !== runtime.connectionGeneration || get().selectedSession?.sessionId !== session.sessionId) return false
set({ sessionModels: models, modelSelecting: false })
return true
}
if (session.backend === 'antigravity') {
const models = await selectAcpModel(runtime.connection.requireAntigravity(), cursorNativeId(session), 'antigravity', selection)
if (generation !== runtime.connectionGeneration || get().selectedSession?.sessionId !== session.sessionId) return false
set({ sessionModels: models, modelSelecting: false })
return true
}
if (session.backend === 'cursor') {
const models = await selectAcpModel(runtime.connection.requireCursor(), cursorNativeId(session), 'cursor', selection)
if (generation !== runtime.connectionGeneration || get().selectedSession?.sessionId !== session.sessionId) return false
set({ sessionModels: models, modelSelecting: false })
return true
}
const selected = await runtime.connection.requireProxy().sessionSelectModel(session.sessionId, selection)
set(state => ({
sessionModels: state.sessionModels === undefined ? undefined : { ...state.sessionModels, current: selected },
modelSelecting: false,
}))
return true
} catch (error) {
if ((session.backend === 'cursor' || session.backend === 'pi' || session.backend === 'opencode' || session.backend === 'claude' || session.backend === 'hermes' || session.backend === 'antigravity') && (generation !== runtime.connectionGeneration || get().selectedSession?.sessionId !== session.sessionId)) return false
set({ modelSelecting: false, error: friendlyError(error) })
return false
}
},
async selectPermission(preset) {
const session = get().selectedSession
if (session?.backend === 'cursor' || session?.backend === 'antigravity' || session?.backend === 'pi' || session?.backend === 'opencode' || session?.backend === 'claude' || session?.backend === 'hermes') return false
if (session === undefined || get().connection.phase !== 'connected' || get().permissionSelecting) return false
const generation = runtime.connectionGeneration
set({ permissionSelecting: true, error: undefined })
try {
if (session.backend === 'codex') {
if (!isCodexPermissionPreset(preset)) {
throw new Error(zhCN.runtime.codexInvalidResponse)
}
const hostDeviceId = get().selectedDevice?.deviceId
if (hostDeviceId === undefined) throw new Error(zhCN.runtime.connectHostFirst)
const threadId = codexThreadId(session)
const result = await runtime.connection.requireCodex().request('thread/resume', { threadId, permissionPreset: preset })
if (generation !== runtime.connectionGeneration) return false
const effectivePreset = codexPermissionPresetFromResponse(result) ?? preset
await saveCodexPermissionPreset(hostDeviceId, threadId, effectivePreset)
set(state => ({
...withCodexPermissionState(state, session.sessionId, effectivePreset),
permissionSelecting: false,
}))
return true
}
const proxy = runtime.connection.requireProxy()
await proxy.sessionSelectPermission(session.sessionId, preset)
// Read back the official projection; never fabricate an accepted grant.
const confirmed = (await proxy.sessionList()).find(item => item.sessionId === session.sessionId)
if (generation !== runtime.connectionGeneration) return false
const permissions = confirmed?.projections?.values?.permissions
if (typeof permissions !== 'object' || permissions === null || !('currentValue' in permissions) || permissions.currentValue !== preset) {
throw new Error('The Host did not confirm the selected permission preset.')
}
set(state => {
const update = (item: RemoteSession): RemoteSession => {
if (item.sessionId !== session.sessionId) return item
return {
...item,
projections: { ...item.projections, values: { ...item.projections?.values, permissions } },
}
}
return {
sessions: state.sessions.map(update),
selectedSession: state.selectedSession === undefined ? undefined : update(state.selectedSession),
permissionSelecting: false,
}
})
return true
} catch (error) {
set({ permissionSelecting: false, error: friendlyError(error) })
return false
}
},
async loadAgentPresets() {
const backend = get().selectedSession?.backend
if (backend === 'cursor' || backend === 'antigravity' || backend === 'pi' || backend === 'opencode' || backend === 'claude' || backend === 'hermes') return false
if (get().connection.phase !== 'connected') return false
if (get().agentPresetLoading) return false
set({ agentPresetLoading: true, error: undefined })
try {
const roster = await runtime.connection.requireProxy().agentPresetList()
set({ agentPresetOptions: [...roster.presets], agentPresetLoading: false })
return true
} catch (error) {
set({ agentPresetLoading: false, error: friendlyError(error) })
return false
}
},
async selectAgentPreset(preset) {
const session = get().selectedSession
if (session === undefined || get().connection.phase !== 'connected') return false
if (session.backend === 'codex' || session.backend === 'cursor' || session.backend === 'antigravity' || session.backend === 'pi' || session.backend === 'opencode' || session.backend === 'claude' || session.backend === 'hermes') return false
set({ agentPresetSelecting: true, error: undefined })
try {
const committed = await runtime.connection.requireProxy().agentPresetSelect(session.sessionId, preset)
set(state => {
const update = (item: RemoteSession): RemoteSession =>
item.sessionId === session.sessionId ? { ...item, agentPreset: committed } : item
return {
sessions: state.sessions.map(update),
selectedSession: state.selectedSession === undefined ? undefined : update(state.selectedSession),
agentPresetSelecting: false,
}
})
return true
} catch (error) {
set({ agentPresetSelecting: false, error: friendlyError(error) })
return false
}
},
async loadOlderHistory() {
runtime.flushPendingMuxFrames()
const session = get().selectedSession
const beforeSeq = get().oldestLoadedSeq
if (session === undefined || beforeSeq === undefined || get().historyLoadingOlder || !get().historyHasMore || get().busyAction?.startsWith('session:')) return
const generation = runtime.sessionLoadGeneration
const connectionGeneration = runtime.connectionGeneration
const current = () => generation === runtime.sessionLoadGeneration && connectionGeneration === runtime.connectionGeneration
if (session.backend === 'cursor' || session.backend === 'antigravity' || session.backend === 'pi' || session.backend === 'opencode' || session.backend === 'claude' || session.backend === 'hermes') {
set({ historyHasMore: false, historyLoadingOlder: false })
return
}
set({ historyLoadingOlder: true })
try {
const page = session.backend === 'codex'
? await readCodexHistoryPage(runtime.connection.requireCodex(), codexThreadId(session), beforeSeq, 60)
: await runtime.connection.requireProxy().sessionHistory(session.sessionId, beforeSeq, 60, isSubagentSession(session) ? session.parentSessionId : undefined)
if (!current()) return
const items = foldHistory(page.events, session.sessionId, true)
const older = oldestSeq(page.events)
set(state => ({
messages: {
...state.messages,
[session.sessionId]: applyFeedback(prependHistory(items, state.messages[session.sessionId] ?? []), session.backend === 'codex' ? undefined : state.feedbackBySession[session.sessionId]),
},
...(state.selectedSession?.sessionId === session.sessionId ? {
historyHasMore: page.hasMore,
oldestLoadedSeq: older ?? state.oldestLoadedSeq,
historyLoadingOlder: false,
} : {}),
}))
} catch (error) {
if (!current()) return
set(state => state.selectedSession?.sessionId === session.sessionId
? { historyLoadingOlder: false, error: friendlyError(error) } : {})
}
},
}
}