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 { useCallback, useEffect, useMemo, useReducer, useRef, useState } from 'react'
import { translate } from '../i18n/mobile-i18n'
import { useMobileTranslation } from '../i18n/use-mobile-translation'
import { useMobileSourceControlSettings } from '../source-control/mobile-source-control-settings'
import type { FlatList } from 'react-native'
import type { DiffComment } from '../../../src/shared/diff-comment-types'
import type { ConnectionState } from '../transport/types'
import type { RpcClient } from '../transport/rpc-client'
import { getWorktreeLabel } from './worktree-label'
import { getUnsentMobileDiffComments } from './mobile-diff-comment-edit'
import {
buildMobileDiffReviewQueue,
filterMobileDiffReviewQueue,
mobileDiffReviewCommentMatchesItem,
summarizeMobileDiffReviewQueue,
type MobileDiffReviewQueueFilter
} from './mobile-diff-review-queue'
import {
findMobileDiffReviewInitialIndex,
type MobileDiffReviewInitialTarget
} from './mobile-diff-review-positioning'
import { loadMobileDiffReviewSnapshot } from './mobile-diff-review-loaders'
import { useMobileDiffReviewDiffLoading } from './use-mobile-diff-review-diff-loading'
import { canOpenMobileBranchCompareDiff } from '../source-control/mobile-branch-compare'
import type { ReviewDiffLine, ReviewScreenState } from './mobile-diff-review-screen-model'
import {
NO_REVIEW_SHEETS,
reduceReviewSheets,
reviewComposer,
reviewSheetIntents
} from './mobile-diff-review-sheets'
import { useMobileDiffReviewInteractions } from './use-mobile-diff-review-interactions'
import { resolveMobileAgentLaunchAvailability } from './mobile-agent-launch-availability'
import { useMobilePrSidebarController } from './use-mobile-pr-sidebar-controller'
type ControllerInput = {
client: RpcClient | null
connState: ConnectionState
hostCapabilities: readonly string[]
hostStatusPending: boolean
hostStatusReadable: boolean
hostId: string
worktreeId: string
name: string
initialFilter: MobileDiffReviewQueueFilter
initialTarget: MobileDiffReviewInitialTarget | null
onOpenSession: () => void
/** Null on the page, where the shell owns the connection. */
onReconnect: ((hostId: string) => void | Promise<void>) | null
}
export function useMobileDiffReviewController(input: ControllerInput) {
useMobileTranslation()
const {
client,
connState,
hostCapabilities,
hostStatusPending,
hostStatusReadable,
hostId,
worktreeId,
name,
initialFilter,
initialTarget,
onOpenSession,
onReconnect
} = input
const listRef = useRef<FlatList<ReviewDiffLine> | null>(null)
const loadGenerationRef = useRef(0)
const seededInitialTargetRef = useRef(false)
const initialTargetKey = initialTarget ? `${initialTarget.area}\0${initialTarget.filePath}` : ''
const [screenState, setScreenState] = useState<ReviewScreenState>({ kind: 'loading' })
const [filter, setFilter] = useState<MobileDiffReviewQueueFilter>(initialFilter)
const [currentIndex, setCurrentIndex] = useState(0)
const [activeHunkIndex, setActiveHunkIndex] = useState<number | null>(null)
const [sheets, dispatchSheets] = useReducer(reduceReviewSheets, NO_REVIEW_SHEETS)
const sheetIntents = useMemo(() => reviewSheetIntents(dispatchSheets), [])
const composer = reviewComposer(sheets)
const [composerBody, setComposerBody] = useState('')
const [actionError, setActionError] = useState<string | null>(null)
const [busyAction, setBusyAction] = useState<string | null>(null)
const worktreeLabel = getWorktreeLabel(name, worktreeId)
const { compareAgainstUpstream } = useMobileSourceControlSettings(client, connState).settings
const loadReviewData = useCallback(async () => {
const generation = loadGenerationRef.current + 1
loadGenerationRef.current = generation
const isCurrent = () => generation === loadGenerationRef.current
if (!worktreeId) {
setScreenState({
kind: 'error',
message: translate('session.useDiffReviewController.missingWorktree', 'Missing worktree')
})
return
}
// Keep an existing review through disconnects; only empty screens need the waiting state.
const keepReady = (fallback: ReviewScreenState) => (prev: ReviewScreenState) =>
prev.kind === 'ready' ? prev : fallback
if (!client || connState !== 'connected') {
setScreenState(
keepReady({
kind: 'error',
message: translate(
'session.useDiffReviewController.waitingForDesktop',
'Waiting for desktop...'
)
})
)
return
}
setScreenState(keepReady({ kind: 'loading' }))
try {
const nextState = await loadMobileDiffReviewSnapshot(
client,
worktreeId,
compareAgainstUpstream
)
if (!isCurrent()) {
return
}
setScreenState(nextState)
setActionError(nextState.kind === 'ready' ? (nextState.branchError ?? null) : null)
} catch (err) {
if (isCurrent()) {
// Failed reconnect reads must not destroy an already loaded review.
setScreenState(
keepReady({
kind: 'error',
message:
err instanceof Error
? err.message
: translate('session.useDiffReviewController.loadFailed', 'Unable to load review')
})
)
}
}
}, [client, compareAgainstUpstream, connState, worktreeId])
useEffect(() => {
void loadReviewData()
}, [loadReviewData])
const queue = useMemo(() => {
if (screenState.kind !== 'ready') {
return []
}
const branchEntries =
screenState.branchCompare && canOpenMobileBranchCompareDiff(screenState.branchCompare.summary)
? (screenState.branchCompare.entries ?? [])
: []
return buildMobileDiffReviewQueue({
worktreeId,
statusEntries: screenState.status.entries,
branchEntries,
branchHeadOid: screenState.branchCompare?.summary.headOid,
branchMergeBase: screenState.branchCompare?.summary.mergeBase,
comments: screenState.comments,
reviewState: screenState.reviewState
})
}, [screenState, worktreeId])
const filteredQueue = useMemo(() => filterMobileDiffReviewQueue(queue, filter), [filter, queue])
const currentItem = filteredQueue[currentIndex] ?? null
const { reviewedCount, reviewedUnstagedCount } = useMemo(
() => summarizeMobileDiffReviewQueue(queue),
[queue]
)
const unsentComments =
screenState.kind === 'ready' ? getUnsentMobileDiffComments(screenState.comments) : []
useEffect(() => {
seededInitialTargetRef.current = false
}, [initialTargetKey])
useEffect(() => {
if (seededInitialTargetRef.current || filteredQueue.length === 0) {
return
}
seededInitialTargetRef.current = true
// Seed the tapped file only once the queue exists or clamping would reset its selection.
setCurrentIndex(findMobileDiffReviewInitialIndex(filteredQueue, initialTarget))
}, [filteredQueue, initialTarget])
useEffect(() => {
if (filteredQueue.length === 0) {
setCurrentIndex(0)
return
}
if (currentIndex >= filteredQueue.length) {
setCurrentIndex(filteredQueue.length - 1)
}
}, [currentIndex, filteredQueue.length])
const diffState = useMobileDiffReviewDiffLoading({
client,
connState,
worktreeId,
currentItem,
screenState,
setActiveHunkIndex
})
const commentsForCurrentItem = useMemo(() => {
if (!currentItem || screenState.kind !== 'ready') {
return []
}
return screenState.comments.filter((comment) =>
mobileDiffReviewCommentMatchesItem(comment, currentItem)
)
}, [currentItem, screenState])
const staleCommentIds = useMemo(
() =>
new Set(
commentsForCurrentItem
.filter(
(comment) =>
currentItem &&
comment.diffIdentity !== undefined &&
comment.diffIdentity !== currentItem.diffIdentity
)
.map((comment) => comment.id)
),
[commentsForCurrentItem, currentItem]
)
const commentsByLine = useMemo(() => {
const map = new Map<number, DiffComment[]>()
for (const comment of commentsForCurrentItem) {
const list = map.get(comment.lineNumber) ?? []
list.push(comment)
map.set(comment.lineNumber, list)
}
return map
}, [commentsForCurrentItem])
// Use git.status for PR head identity; branchCompare’s base ref is not the head.
const prSidebarBranch = screenState.kind === 'ready' ? (screenState.status.branch ?? null) : null
const prSidebarHeadSha =
screenState.kind === 'ready'
? (screenState.status.head ?? screenState.branchCompare?.summary.headOid ?? null)
: null
const prSidebar = useMobilePrSidebarController({
client,
connState,
worktreeId,
branch: prSidebarBranch,
headSha: prSidebarHeadSha
})
const interactions = useMobileDiffReviewInteractions({
client,
connState,
hostCapabilities,
hostId,
worktreeId,
screenState,
diffState,
currentItem,
queue,
filteredQueue,
filter,
currentIndex,
activeHunkIndex,
composer,
composerBody,
listRef,
setScreenState,
setFilter,
setCurrentIndex,
setActiveHunkIndex,
setComposerBody,
setActionError,
setBusyAction,
sheets: sheetIntents,
loadReviewData,
onOpenSession,
onReconnect
})
return {
...interactions,
...prSidebar,
...sheetIntents,
agentLaunchAvailability: resolveMobileAgentLaunchAvailability({
hostCapabilities,
statusPending: hostStatusPending,
statusReadable: hostStatusReadable
}),
client,
connState,
worktreeId,
prSidebarBranch,
prSidebarHeadSha,
actionError,
activeHunkIndex,
busyAction,
commentsByLine,
composer,
composerBody,
currentIndex,
currentItem,
diffState,
fileNotes: commentsByLine.get(0) ?? [],
filter,
filteredQueue,
listRef,
queue,
reviewedCount,
reviewedUnstagedCount,
screenState,
setComposerBody,
sheet: sheets.requested,
staleCommentIds,
unsentComments,
worktreeLabel
}
}