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 * as DocumentPicker from 'expo-document-picker'
import { File as FsFile } from 'expo-file-system'
import * as ImagePicker from 'expo-image-picker'
import {
CLIPBOARD_IMAGE_MAX_SOURCE_BYTES,
assertClipboardImageBase64LengthWithinLimit,
assertClipboardImageByteLengthWithinLimit
} from '../../../src/shared/clipboard-image'
import { MobileImageBase64Accumulator } from './mobile-image-base64-accumulator'
import { isPickedImageMime } from '../platform/mobile-picked-file-name'
// Import permission errors from the Expo-free contract so page-side catches cannot pull native picker code into the bundle.
import { ImageLibraryPermissionError } from '../platform/media-picker-contract'
import type { MobileImageSource, PickedMobileImage } from '../platform/media-picker-contract'
export { ImageLibraryPermissionError }
export type { MobileImageSource, PickedMobileImage }
const MOBILE_IMAGE_READ_CHUNK_BYTES = 256 * 1024
type MobileImageFileHandle = {
readonly size: number | null
readBytes(length: number): Uint8Array
close(): void
}
type MobileImageFile = {
readonly size: number
open(): MobileImageFileHandle
}
export type MobileImageFileFactory = (uri: string) => MobileImageFile
export function defaultMobileImageFileFactory(uri: string): MobileImageFile {
return new FsFile(uri)
}
export async function readUriAsBase64(
uri: string,
declaredSize: number | undefined | null,
createFile: MobileImageFileFactory,
assertBytes: (byteLength: number) => void = assertClipboardImageByteLengthWithinLimit
): Promise<string> {
if (typeof declaredSize === 'number' && Number.isFinite(declaredSize)) {
assertBytes(declaredSize)
}
const file = createFile(uri)
assertBytes(file.size)
const handle = file.open()
try {
if (handle.size !== null) {
assertBytes(handle.size)
}
const accumulator = new MobileImageBase64Accumulator()
let bytesRead = 0
while (bytesRead <= CLIPBOARD_IMAGE_MAX_SOURCE_BYTES) {
const requested = Math.min(
MOBILE_IMAGE_READ_CHUNK_BYTES,
CLIPBOARD_IMAGE_MAX_SOURCE_BYTES - bytesRead + 1
)
const bytes = handle.readBytes(requested)
if (bytes.byteLength === 0) {
break
}
bytesRead += bytes.byteLength
assertBytes(bytesRead)
accumulator.append(bytes)
}
const base64 = accumulator.finish()
assertClipboardImageBase64LengthWithinLimit(base64.length)
return base64
} finally {
handle.close()
}
}
async function* pickFromLibrary(
multiple: boolean,
requestPermission: typeof ImagePicker.requestMediaLibraryPermissionsAsync = ImagePicker.requestMediaLibraryPermissionsAsync,
launch: typeof ImagePicker.launchImageLibraryAsync = ImagePicker.launchImageLibraryAsync,
createFile: MobileImageFileFactory = defaultMobileImageFileFactory
): AsyncGenerator<PickedMobileImage> {
const permission = await requestPermission()
// Why: `granted` covers full + limited iOS access; only a hard denial blocks us.
if (!permission.granted) {
throw new ImageLibraryPermissionError()
}
const result = await launch({
mediaTypes: ['images'],
base64: false,
allowsMultipleSelection: multiple,
...(multiple ? { selectionLimit: 0, orderedSelection: true } : {}),
quality: 1
})
if (result.canceled) {
return
}
for (const asset of result.assets) {
if (!asset.uri) {
continue
}
const base64 = await readUriAsBase64(asset.uri, asset.fileSize, createFile)
if (base64) {
yield { base64, uri: asset.uri }
}
}
}
async function* pickFromFiles(
multiple: boolean,
launch: typeof DocumentPicker.getDocumentAsync = DocumentPicker.getDocumentAsync,
createFile: MobileImageFileFactory = defaultMobileImageFileFactory
): AsyncGenerator<PickedMobileImage> {
const result = await launch({
type: '*/*',
multiple,
copyToCacheDirectory: true
})
if (result.canceled) {
return
}
for (const asset of result.assets) {
if (!asset.uri) {
continue
}
const base64 = await readUriAsBase64(asset.uri, asset.size, createFile)
if (base64) {
const fileName = isPickedImageMime(asset.mimeType)
? undefined
: asset.name.trim() || 'attachment'
yield { base64, uri: asset.uri, fileName }
}
}
}
type MobileImagePickerDeps = {
readonly requestLibraryPermission?: typeof ImagePicker.requestMediaLibraryPermissionsAsync
readonly launchLibrary?: typeof ImagePicker.launchImageLibraryAsync
readonly launchFiles?: typeof DocumentPicker.getDocumentAsync
readonly createFile?: MobileImageFileFactory
}
function pickMobileImagesWithMode(
source: MobileImageSource,
multiple: boolean,
deps?: MobileImagePickerDeps
): AsyncIterable<PickedMobileImage> {
if (source === 'library') {
return pickFromLibrary(
multiple,
deps?.requestLibraryPermission,
deps?.launchLibrary,
deps?.createFile
)
}
return pickFromFiles(multiple, deps?.launchFiles, deps?.createFile)
}
export async function pickMobileImage(
source: MobileImageSource,
deps?: MobileImagePickerDeps
): Promise<PickedMobileImage | null> {
for await (const image of pickMobileImagesWithMode(source, false, deps)) {
return image
}
return null
}
export function pickMobileImages(
source: MobileImageSource,
deps?: MobileImagePickerDeps
): AsyncIterable<PickedMobileImage> {
return pickMobileImagesWithMode(source, true, deps)
}