Orca is the place for working with a fleet of agents (e.g. Grok Bot, Claude Code). Run any coding agent with your own subscription. Available on desktop, mobile and remote runtime.
TypeScript adeagent-ideai-agentsautomationbotclaude-codecodexghosttygrok-bothermes-agentmobile-appmuseopenclawopencodeorchestrationpiruntimeterminalworktreesyc-backed
import { loadMobileResumeMetadata } from './mobile-agent-history-resume-metadata'
import { useCallback, useEffect, useMemo, useRef, useState } from 'react'
import { ActivityIndicator, Pressable, Text, View } from 'react-native'
import { SafeAreaView } from 'react-native-safe-area-context'
import { ChevronLeft, RefreshCw } from 'lucide-react-native'
import { colors } from '../theme/mobile-theme'
import { useMobileColorScheme } from '../theme/use-mobile-color-scheme'
import { MobileSearchField } from '../components/MobileSearchField'
import { useWorkspaceClient } from '../transport/use-workspace-client'
import { useWorkspaceRouteHandoff } from '../navigation/workspace-route-handoff'
import { useSessionScreenHandlers } from '../session/session-screen-handlers'
import { worktreeCatalogRead } from '../worktree/worktree-catalog-operations'
import { getWorktreeLabel } from '../session/worktree-label'
import {
buildMobileAiVaultResumeLaunch,
createMobileAiVaultResumeMutationRegistry,
readMobileAiVaultResumeHost,
readMobileRuntimeTerminalWindowsShell,
resolveMobileAiVaultResumePlatform,
resumeAiVaultSessionInTerminal
} from '../session/ai-vault-resume-launch'
import { prepareMobileAiVaultSessionResume } from '../session/ai-vault-resume-preparation'
import { triggerError, triggerSuccess } from '../platform/haptics'
import type { AiVaultScope, AiVaultSession } from '../../../src/shared/ai-vault-types'
import type { Worktree } from '../worktree/workspace-list-types'
import { useMobileAgentHistoryState } from './use-mobile-agent-history-state'
import { buildMobileAgentHistorySections } from './agent-history-sections'
import { shouldShowMobileCurrentWorktreeBadge } from './agent-history-current-worktree-badge'
import { MobileAgentSessionHistoryList } from './MobileAgentSessionHistoryList'
import { resolveMobileAiVaultSessionResumeTarget } from './agent-history-resume-target'
import { buildMobileAgentHistoryResumeActionState } from './agent-history-session-card'
import { styles } from './agent-history-styles'
import { useNow } from '../hooks/use-now'
import { useMobileResumeOperationOwnership } from './use-mobile-resume-operation-ownership'
import type { Translate } from '../i18n/mobile-i18n'
import { useMobileTranslation } from '../i18n/use-mobile-translation'
export type MobileAgentSessionHistoryPanelProps = {
hostId: string
worktreeId: string
name?: string
origin?: string
}
function scopeTabs(t: Translate): { scope: AiVaultScope; label: string }[] {
return [
{ scope: 'workspace', label: t('agentHistory.panel.workspace', 'Workspace') },
{ scope: 'project', label: t('agentHistory.panel.project', 'Project') },
{ scope: 'all', label: t('agentHistory.panel.all', 'All') }
]
}
export function MobileAgentSessionHistoryPanel(props: MobileAgentSessionHistoryPanelProps) {
return <MobileAgentSessionHistoryPanelContent key={props.hostId} {...props} />
}
function MobileAgentSessionHistoryPanelContent({
hostId,
worktreeId,
name = '',
origin = ''
}: MobileAgentSessionHistoryPanelProps) {
useMobileColorScheme()
const t = useMobileTranslation()
// Use handoff, not useRouter: resumed session is a native route outside this single-document page.
const router = useWorkspaceRouteHandoff()
const sessionBelow = useSessionScreenHandlers(hostId, worktreeId)
const { client, state: connState } = useWorkspaceClient(hostId)
const claimResumeOwnership = useMobileResumeOperationOwnership(
hostId,
worktreeId,
client,
connState
)
const [worktrees, setWorktrees] = useState<Worktree[]>([])
const [worktreesLoaded, setWorktreesLoaded] = useState(false)
const [query, setQuery] = useState('')
const [resumingSessionId, setResumingSessionId] = useState<string | null>(null)
const [resumeMessage, setResumeMessage] = useState<string | null>(null)
const now = useNow(30_000)
const resumeLaunchInFlightRef = useRef(false)
const resumeMutationRegistryRef = useRef(
createMobileAiVaultResumeMutationRegistry(createMobileAiVaultResumeMutationId)
)
const worktreeLabel = getWorktreeLabel(name, worktreeId)
const {
scope,
screenState,
refreshing,
hostStatusResult,
activeWorktreePath,
scopeFilterPaths,
onSelectScope,
onRefresh,
retry
} = useMobileAgentHistoryState({ hostId, worktreeId, worktrees, worktreesLoaded })
// Worktree list seeds host-local scopePaths and current-worktree badge.
useEffect(() => {
if (!client || connState !== 'connected') {
return
}
let cancelled = false
void (async () => {
try {
const worktreeReply = await worktreeCatalogRead.request(client, { limit: 10000 })
if (cancelled) {
return
}
const catalog = worktreeCatalogRead.interpret(worktreeReply)
if (catalog.accepted) {
// Why `?? []`: the member is salvaged, so an envelope the host answers without rows leaves it
// absent, and `use-mobile-agent-history-state.ts:61` calls `.find` on it unguarded.
// oxlint-disable-next-line typescript/consistent-type-assertions -- SAFETY: the rows stay opaque in the reader because three screens project them differently; this panel reads only `path` off a row to seed `scopePaths`, and `matrix-aivault.history-screen-worktree.ps-1` records every partition of its own family rendering a list rather than a crash.
setWorktrees((catalog.value.worktrees ?? []) as Worktree[])
}
} catch {
// Best-effort context: failed worktree list leaves scoped tabs scanning full history.
} finally {
// Mark loaded on failure too so scoped tabs fetch unscoped instead of spinning forever.
if (!cancelled) {
setWorktreesLoaded(true)
}
}
})()
return () => {
cancelled = true
}
}, [client, connState])
const sessions = screenState.kind === 'ready' ? screenState.sessions : EMPTY_SESSIONS
const issues = screenState.kind === 'ready' ? screenState.issues : EMPTY_ISSUES
const count = issues.length
const sessionsById = useMemo(
() => new Map(sessions.map((session) => [session.id, session])),
[sessions]
)
const sections = useMemo(
() =>
buildMobileAgentHistorySections(sessions, {
query,
scope,
scopeFilterPaths,
activeWorktreePath,
now
}),
[sessions, query, scope, scopeFilterPaths, activeWorktreePath, now, t]
)
const resumeHost = useMemo(
() => readMobileAiVaultResumeHost(hostStatusResult),
[hostStatusResult]
)
const hostTerminalWindowsShell = useMemo(
() => readMobileRuntimeTerminalWindowsShell(hostStatusResult),
[hostStatusResult]
)
const resumeActionStateBySessionId = useMemo(
() => buildMobileAgentHistoryResumeActionState(sessions, resumingSessionId),
[resumingSessionId, sessions]
)
const onResumeSession = useCallback(
async (session: AiVaultSession): Promise<void> => {
if (resumeLaunchInFlightRef.current) {
return
}
if (!client || connState !== 'connected') {
setResumeMessage(t('agentHistory.panel.waitingForHost', 'Waiting for host...'))
triggerError()
return
}
if (!session.sessionId) {
setResumeMessage(
t('agentHistory.panel.missingResumeId', 'This session is missing a resume id.')
)
triggerError()
return
}
const assertCurrentOwner = claimResumeOwnership()
resumeLaunchInFlightRef.current = true
setResumingSessionId(session.id)
setResumeMessage(null)
try {
const {
settings,
worktrees: freshWorktrees,
...catalog
} = await loadMobileResumeMetadata(client)
assertCurrentOwner()
const target = resolveMobileAiVaultSessionResumeTarget({
session,
activeWorktreeId: worktreeId,
// Prefer live worktrees so deleted/archived workspace cannot be selected; fall back to mount list only on fetch failure.
worktrees: freshWorktrees ?? worktrees,
catalog,
hostPlatform: resumeHost.platform
})
if (target.status !== 'ready') {
setResumeMessage(target.message)
triggerError()
return
}
const platform = resolveMobileAiVaultResumePlatform(
target.targetStatus,
resumeHost.platform,
target.workspacePath,
target.terminalPlatform
)
if (!platform) {
setResumeMessage(
t('agentHistory.panel.unknownHostPlatform', 'Unable to determine host platform.')
)
triggerError()
return
}
const preparedSession = await prepareMobileAiVaultSessionResume(client, session)
assertCurrentOwner()
const launch = buildMobileAiVaultResumeLaunch({
session: preparedSession,
workspacePlatform: platform,
hostTerminalWindowsShell,
settings
})
const resumed = await resumeAiVaultSessionInTerminal(
client,
target.worktreeId,
{
...launch,
hostCapabilities: resumeHost.capabilities,
clientMutationId: resumeMutationRegistryRef.current.claim(session.id)
},
assertCurrentOwner
)
resumeMutationRegistryRef.current.releaseOnSuccess(session.id)
triggerSuccess()
// The host accepted the resume; a cutover now only stops navigation.
try {
assertCurrentOwner()
} catch {
return
}
setResumeMessage(t('agentHistory.panel.sessionQueued', 'Agent session queued.'))
// From a session screen the same workspace is the screen below; otherwise the session takes this screen's place.
if (origin === 'session' && target.worktreeId === worktreeId) {
sessionBelow?.onResumedTerminal(resumed.terminal)
router.back()
} else {
router.replace(
`/h/${encodeURIComponent(hostId)}/session/${encodeURIComponent(target.worktreeId)}`
)
}
} catch (err) {
triggerError()
setResumeMessage(
err instanceof Error
? err.message
: t('agentHistory.panel.resumeFailed', 'Failed to resume session.')
)
} finally {
resumeLaunchInFlightRef.current = false
setResumingSessionId(null)
}
},
[
client,
connState,
hostId,
origin,
sessionBelow,
resumeHost,
hostTerminalWindowsShell,
router,
worktreeId,
worktrees,
claimResumeOwnership,
t
]
)
return (
<View style={styles.container}>
<SafeAreaView style={styles.header} edges={['top']}>
<View style={styles.topBar}>
<Pressable
style={({ pressed }) => [styles.backButton, pressed && styles.backButtonPressed]}
onPress={() => router.back()}
hitSlop={8}
accessibilityRole="button"
accessibilityLabel={t('common.back', 'Back')}
>
<ChevronLeft size={22} color={colors.textSecondary} strokeWidth={2.2} />
</Pressable>
<View style={styles.titleBlock}>
<Text style={styles.title} numberOfLines={1}>
{t('agentHistory.panel.title', 'Agent Session History')}
</Text>
<Text style={styles.meta} numberOfLines={1}>
{worktreeLabel}
</Text>
</View>
<Pressable
style={({ pressed }) => [styles.refreshButton, pressed && styles.refreshButtonPressed]}
onPress={() => void onRefresh()}
hitSlop={8}
accessibilityLabel={t('agentHistory.panel.refreshSessions', 'Refresh agent sessions')}
>
<RefreshCw size={18} color={colors.textSecondary} strokeWidth={2.1} />
</Pressable>
</View>
</SafeAreaView>
{screenState.kind === 'loading' ? (
<View style={styles.state}>
<ActivityIndicator size="small" color={colors.textSecondary} />
</View>
) : screenState.kind === 'unsupported' ? (
<View style={styles.state}>
<Text style={styles.stateTitle}>
{t('agentHistory.panel.unavailable', 'Agent Session History Unavailable')}
</Text>
<Text style={styles.stateText}>
{t(
'agentHistory.panel.updateHost',
'Update Orca on this host to browse agent session history.'
)}
</Text>
</View>
) : screenState.kind === 'error' ? (
<View style={styles.state}>
<Text style={styles.stateTitle}>
{t('agentHistory.panel.loadFailed', 'Unable to Load')}
</Text>
<Text style={styles.stateText}>{screenState.message}</Text>
{retry ? (
<Pressable style={styles.retryButton} onPress={retry}>
<Text style={styles.retryText}>{t('common.retry', 'Retry')}</Text>
</Pressable>
) : null}
</View>
) : (
<>
<View style={styles.scopeTabs}>
{scopeTabs(t).map((tab) => {
const active = scope === tab.scope
return (
<Pressable
key={tab.scope}
style={[styles.scopeTab, active && styles.scopeTabActive]}
onPress={() => onSelectScope(tab.scope)}
>
<Text style={[styles.scopeTabText, active && styles.scopeTabTextActive]}>
{tab.label}
</Text>
</Pressable>
)
})}
</View>
<View style={styles.searchRow}>
<MobileSearchField
value={query}
onChangeText={setQuery}
placeholder={t('agentHistory.panel.placeholder', 'Search sessions, repo:, path:')}
/>
</View>
{issues.length > 0 ? (
<View style={styles.noticeBanner}>
<Text style={styles.noticeText}>
{count === 1
? t('agentHistory.panel.skipped_one', '{{count}} transcript skipped', {
count
})
: t('agentHistory.panel.skipped_other', '{{count}} transcripts skipped', {
count
})}
</Text>
</View>
) : null}
{resumeMessage ? (
<View style={styles.resumeBanner}>
<Text style={styles.resumeBannerText}>{resumeMessage}</Text>
</View>
) : null}
{sections.length === 0 ? (
<View style={styles.state}>
<Text style={styles.stateTitle}>
{t('agentHistory.panel.noSessions', 'No agent sessions')}
</Text>
<Text style={styles.stateText}>
{query
? t('agentHistory.panel.noSearchResults', 'No sessions match your search.')
: t('agentHistory.panel.emptyScope', 'No past agent sessions in this scope.')}
</Text>
</View>
) : (
<MobileAgentSessionHistoryList
sections={sections}
sessionsById={sessionsById}
refreshing={refreshing}
showCurrentWorktreeBadges={shouldShowMobileCurrentWorktreeBadge(scope)}
resumeActionStateBySessionId={resumeActionStateBySessionId}
onResume={onResumeSession}
onRefresh={() => void onRefresh()}
/>
)}
</>
)}
</View>
)
}
const EMPTY_SESSIONS: AiVaultSession[] = []
const EMPTY_ISSUES: { agent: AiVaultSession['agent']; path: string; message: string }[] = []
function createMobileAiVaultResumeMutationId(sessionId: string): string {
const sessionPart = sessionId.replace(/[^a-zA-Z0-9_.:-]/g, '_').slice(0, 64) || 'session'
const randomPart = Math.random().toString(36).slice(2, 10)
return `ai-vault-resume:${sessionPart}:${Date.now().toString(36)}:${randomPart}`
}