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 { useEffect, useMemo, useState, type Dispatch, type SetStateAction } from 'react'
import { PixelRatio } from 'react-native'
import type { RpcClient } from '../transport/rpc-client'
import type { BrowserScreencastFrameMetadata } from '../transport/browser-screencast-protocol'
import {
buildMobileBrowserScreencastRequest,
type MobileBrowserViewMode
} from './browser-screencast-request'
import {
MAX_ZOOM,
MIN_ZOOM,
browserFrameMetadataEqual,
cacheBrowserFrame,
getCachedBrowserFrame
} from './mobile-browser-frame-state'
import {
clampBrowserZoomState,
computeBrowserFrameGeometry,
type BrowserTouchLayout,
type BrowserZoomState
} from './browser-touch-geometry'
import type { MobileBrowserTab } from './MobileBrowserPane'
import {
handleBrowserScreencastEvent,
type BrowserDialogState,
type ScreencastEvent
} from './mobile-browser-stream-events'
import { createBrowserFramePacer } from './browser-frame-pacer'
import { useMobileBrowserRequest } from './use-mobile-browser-request'
type MobileBrowserStreamArgs = {
binaryScreencastGranted: boolean
browserViewMode: MobileBrowserViewMode
busyRef: { current: boolean }
cacheKey: string | null
client: RpcClient | null
frameMetadata: BrowserScreencastFrameMetadata | null
frameMetadataRef: { current: BrowserScreencastFrameMetadata | null }
/** Null while the app is away; each return to the foreground is a new value. */
foregroundVisit: number | null
initialFrameUri: string | null
lastStreamCacheKeyRef: { current: string | null }
lastZoomResetUrlRef: { current: string }
layout: BrowserTouchLayout | null
resetBrowserZoomState: () => void
screencastSupported: boolean | null
setAddressValue: Dispatch<SetStateAction<string>>
setBusy: Dispatch<SetStateAction<boolean>>
setDialog: Dispatch<SetStateAction<BrowserDialogState | null>>
setError: Dispatch<SetStateAction<string | null>>
setFrameMetadata: Dispatch<SetStateAction<BrowserScreencastFrameMetadata | null>>
setZoom: Dispatch<SetStateAction<BrowserZoomState>>
streamGenerationRef: { current: number }
tab: MobileBrowserTab
worktreeId: string
zoomRef: { current: BrowserZoomState }
}
export function useMobileBrowserStream(args: MobileBrowserStreamArgs) {
const {
binaryScreencastGranted,
browserViewMode,
busyRef,
cacheKey,
client,
frameMetadata,
frameMetadataRef,
foregroundVisit,
initialFrameUri,
lastStreamCacheKeyRef,
lastZoomResetUrlRef,
layout,
resetBrowserZoomState,
screencastSupported,
setAddressValue,
setBusy,
setDialog,
setError,
setFrameMetadata,
setZoom,
streamGenerationRef,
tab,
worktreeId,
zoomRef
} = args
const { pageParams, sendBrowserRequest } = useMobileBrowserRequest({
busyRef,
client,
pageId: tab.browserPageId,
setBusy,
setError,
worktreeId
})
const [frameUri, setFrameUri] = useState(initialFrameUri)
const [framePacer] = useState(() =>
createBrowserFramePacer({
initialUri: initialFrameUri,
setFrameUri,
// Why: at the flip, so touch mapping uses the geometry of the frame on screen.
onShown: ({ frame, cacheKey: shownCacheKey, uri }) => {
cacheBrowserFrame(shownCacheKey, { uri, metadata: frame.metadata })
if (!browserFrameMetadataEqual(frameMetadataRef.current, frame.metadata)) {
frameMetadataRef.current = frame.metadata
setFrameMetadata(frame.metadata)
}
if (busyRef.current) {
busyRef.current = false
setBusy(false)
}
}
})
)
const streamRequest = useMemo(
() => buildMobileBrowserScreencastRequest(layout, PixelRatio.get(), browserViewMode),
[browserViewMode, layout]
)
const frameGeometry = useMemo(
() => computeBrowserFrameGeometry(layout, frameMetadata),
[frameMetadata, layout]
)
useEffect(() => {
if (!frameGeometry) {
return
}
setZoom((current) => {
const next = clampBrowserZoomState(current, frameGeometry, MIN_ZOOM, MAX_ZOOM)
if (
next.scale === current.scale &&
next.offsetX === current.offsetX &&
next.offsetY === current.offsetY
) {
return current
}
// Clamp pan after rotation/layout shrink so zoom state cannot retain invalid previous geometry.
zoomRef.current = next
return next
})
}, [frameGeometry])
useEffect(() => {
streamGenerationRef.current += 1
const generation = streamGenerationRef.current
const sameStream = Boolean(cacheKey) && lastStreamCacheKeyRef.current === cacheKey
lastStreamCacheKeyRef.current = cacheKey
if (sameStream && framePacer.hasFrame()) {
framePacer.reset()
} else {
const cachedFrame = getCachedBrowserFrame(cacheKey)
framePacer.replace(cachedFrame?.uri ?? null)
frameMetadataRef.current = cachedFrame?.metadata ?? null
setFrameMetadata(cachedFrame?.metadata ?? null)
}
setDialog(null)
setError(null)
if (
!client ||
!binaryScreencastGranted ||
screencastSupported !== true ||
!tab.browserPageId ||
foregroundVisit === null ||
!streamRequest
) {
busyRef.current = false
setBusy(false)
if (!binaryScreencastGranted) {
// Check app-local limitation before desktop reply; desktop updates cannot change phone build.
setError('Update the Orca app to stream browser tabs here.')
} else if (screencastSupported === false) {
setError('Update desktop Orca to stream browser tabs on mobile.')
} else if (screencastSupported === null) {
setError('Checking desktop browser streaming support.')
} else if (!tab.browserPageId) {
setError('Browser page is not available yet.')
}
return
}
busyRef.current = true
setBusy(true)
let startupTimer: ReturnType<typeof setTimeout> | null = setTimeout(() => {
if (streamGenerationRef.current !== generation) {
return
}
busyRef.current = false
setBusy(false)
setError('Browser stream timed out.')
}, 15_000)
const clearStartupTimer = (): void => {
if (startupTimer) {
clearTimeout(startupTimer)
startupTimer = null
}
}
const unsubscribe = client.subscribe(
'browser.screencast',
{
worktree: `id:${worktreeId}`,
page: tab.browserPageId,
...streamRequest
},
(payload) => {
if (streamGenerationRef.current !== generation) {
return
}
handleBrowserScreencastEvent({
busyRef,
clearStartupTimer,
event: payload as ScreencastEvent,
lastZoomResetUrlRef,
resetBrowserZoomState,
setAddressValue,
setBusy,
setDialog,
setError
})
},
{
onBinaryFrame: (frame) => {
if (streamGenerationRef.current !== generation) {
return
}
clearStartupTimer()
if (cacheKey) {
framePacer.push(frame, cacheKey)
}
}
}
)
return () => {
clearStartupTimer()
framePacer.reset()
unsubscribe()
}
}, [
binaryScreencastGranted,
client,
foregroundVisit,
framePacer,
resetBrowserZoomState,
screencastSupported,
streamRequest,
cacheKey,
tab.browserPageId,
worktreeId
])
// Why: only mounts the layers; the pacer re-points them natively, which a re-render must not undo.
const renderedFrameSource = frameUri ? { uri: frameUri } : null
return {
frameGeometry,
frameLayers: framePacer.layers,
pageParams,
renderedFrameSource,
sendBrowserRequest
}
}