ds-harness-remote-fast/apps/android/src/services/codex.ts

643 lines
24 KiB
TypeScript

import {
deriveCodexCwdWorkspaces,
projectCodexThread,
type CodexRemoteClient,
type DisplayHistoryItem,
type DisplaySession,
} from '@dsh-remote/client-core'
import { strings } from '../locales/i18n'
import type {
ChatItem,
CodexPermissionPreset,
HistoryEntry,
ModelCatalogModel,
ModelSelection,
ModelReasoningEffort,
NativeSessionEvent,
RemoteSession,
SessionHistoryPage,
SessionModels,
WorkspaceView,
} from '../types'
const PAGE_LIMIT = 100
const MAX_PAGES = 32
const CODEX_PROVIDER = 'codex'
const CODEX_PERMISSION_DEFAULT: CodexPermissionPreset = 'workspace-write'
const CODEX_EFFORTS = new Set(['none', 'minimal', 'low', 'medium', 'high', 'xhigh', 'max', 'ultra'])
interface CodexProject {
id: string
name: string
roots: string[]
position: number
createdAt: number
updatedAt: number
}
export interface CodexCatalog {
workspaces: WorkspaceView[]
sessions: RemoteSession[]
}
export interface CodexSessionRead {
thread: Record<string, unknown>
session: RemoteSession
}
export async function createCodexWorkspace(
client: CodexRemoteClient,
path: string,
idempotencyKey: string,
): Promise<WorkspaceView> {
const result = record(await client.request('project/create', {
name: basename(path),
roots: [{ path }],
idempotencyKey,
}))
const project = parseCodexProject(result.project, 0)
if (project === undefined) throw new Error(strings.runtime.codexInvalidResponse)
return projectWorkspace(project)
}
export async function loadCodexCatalog(client: CodexRemoteClient): Promise<CodexCatalog> {
const [listedProjects, threads] = await Promise.all([
loadProjects(client),
loadThreads(client),
])
const projects = listedProjects.length > 0
? listedProjects
: deriveCodexCwdWorkspaces(threads).map(workspace => ({
id: workspace.id,
name: workspace.name,
roots: [workspace.path],
position: workspace.position,
createdAt: workspace.createdAt,
updatedAt: workspace.updatedAt,
}))
const workspaces = projects.map(projectWorkspace)
const workspaceByProjectId = new Map(projects.map((project, index) => [project.id, workspaces[index]!]))
const sessions: RemoteSession[] = []
for (const thread of threads) {
const display = projectCodexThread(thread)
if (display === undefined || display.archived === true) continue
const workspace = findThreadWorkspace(thread, display, projects, workspaceByProjectId)
if (workspace === undefined) continue
const session = codexSession(display)
workspace.sessionIds.push(session.sessionId)
sessions.push(session)
const updatedAt = new Date(session.updatedAt || Date.now()).toISOString()
if (updatedAt > workspace.updatedAt) workspace.updatedAt = updatedAt
}
sessions.sort((left, right) => right.updatedAt - left.updatedAt || left.sessionId.localeCompare(right.sessionId))
return { workspaces, sessions }
}
export async function readCodexSession(
client: CodexRemoteClient,
threadId: string,
permissionPreset = CODEX_PERMISSION_DEFAULT,
signal?: AbortSignal,
): Promise<CodexSessionRead> {
const params = { threadId, includeTurns: false }
const result = record(await (signal === undefined
? client.request('thread/read', params)
: client.request('thread/read', params, signal)))
const thread = record(result.thread)
const display = projectCodexThread(thread)
if (display === undefined || display.nativeId !== threadId) throw new Error(strings.runtime.codexInvalidResponse)
return { thread, session: codexSession(display, permissionPreset) }
}
export async function readCodexHistoryPage(
client: CodexRemoteClient,
threadId: string,
beforeSeq?: number,
maxMessages = 60,
signal?: AbortSignal,
): Promise<SessionHistoryPage> {
const params = {
threadId,
...(beforeSeq === undefined ? {} : { beforeSeq }),
maxMessages,
}
const page = record(await (signal === undefined
? client.request('dsh/sessionHistory', params)
: client.request('dsh/sessionHistory', params, signal)))
const header = record(page.header)
if (header.id !== `codex:${threadId}` || !Array.isArray(page.records) || typeof page.hasMore !== 'boolean') {
throw new Error(strings.runtime.codexInvalidResponse)
}
const events = page.records.flatMap(value => {
const entry = record(value)
const event = record(entry.event)
if (entry.type !== 'event'
|| typeof event.type !== 'string'
|| !Number.isSafeInteger(event.seq)
|| !Number.isFinite(event.time)
|| !isRecord(event.data)) return []
return [{
event: event as unknown as NativeSessionEvent,
...(isRecord(entry.view) ? { view: entry.view as HistoryEntry['view'] } : {}),
} satisfies HistoryEntry]
})
const activeTurnId = string(page.activeTurnId)
return {
events,
hasMore: page.hasMore,
...(activeTurnId === undefined ? {} : { activeTurnId }),
}
}
export async function loadCodexModels(client: CodexRemoteClient, current?: ModelSelection): Promise<SessionModels> {
const models: ModelCatalogModel[] = []
let defaultModel: string | undefined
let cursor: string | undefined
for (let page = 0; page < MAX_PAGES; page += 1) {
const result = record(await client.request('model/list', {
limit: PAGE_LIMIT,
includeHidden: false,
...(cursor === undefined ? {} : { cursor }),
}))
if (!Array.isArray(result.data)) throw new Error(strings.runtime.codexInvalidResponse)
for (const value of result.data) {
const source = record(value)
if (source.hidden === true) continue
const id = string(source.model) ?? string(source.id)
if (id === undefined || models.some(model => model.id === id)) continue
const efforts = Array.isArray(source.supportedReasoningEfforts)
? source.supportedReasoningEfforts.flatMap(value => {
const effort = record(value)
const effortId = string(effort.reasoningEffort)
if (effortId === undefined || !CODEX_EFFORTS.has(effortId)) return []
return [{
id: effortId,
name: reasoningEffortName(effortId),
...(string(effort.description) === undefined ? {} : { description: string(effort.description)! }),
} satisfies ModelReasoningEffort]
})
: []
const defaultEffort = string(source.defaultReasoningEffort)
models.push({
id,
name: string(source.displayName) ?? id,
...(string(source.description) === undefined ? {} : { description: string(source.description)! }),
...(efforts.length === 0 ? {} : {
reasoning: {
efforts,
...(defaultEffort === undefined || !efforts.some(effort => effort.id === defaultEffort)
? {}
: { defaultEffort }),
},
}),
})
if (source.isDefault === true) defaultModel = id
}
cursor = string(result.nextCursor)
if (cursor === undefined) break
}
const selected = current?.provider === CODEX_PROVIDER
? models.find(model => model.id === current.model)
: undefined
const fallback = selected ?? models.find(model => model.id === defaultModel) ?? models[0]
if (fallback === undefined) throw new Error(strings.runtime.codexInvalidResponse)
return {
current: {
provider: CODEX_PROVIDER,
model: fallback.id,
...(current?.provider === CODEX_PROVIDER && current.model === fallback.id && current.reasoningEffort !== undefined
? { reasoningEffort: current.reasoningEffort }
: fallback.reasoning?.defaultEffort === undefined ? {} : { reasoningEffort: fallback.reasoning.defaultEffort }),
},
routable: true,
groups: [{ id: CODEX_PROVIDER, name: 'Codex', models }],
failures: [],
}
}
export function codexSession(
display: DisplaySession,
permissionPreset = CODEX_PERMISSION_DEFAULT,
): RemoteSession {
return {
sessionId: display.id,
backend: 'codex',
nativeId: display.nativeId,
updatedAt: display.updatedAt || display.createdAt || Date.now(),
running: display.status === 'running' || display.status === 'waiting',
blank: display.title === undefined && display.preview === undefined,
...(display.title === undefined ? {} : { title: display.title }),
...(display.cwd === undefined ? {} : { cwd: display.cwd }),
projections: {
values: {
...(display.preview === undefined ? {} : { summary: display.preview }),
backend: 'codex',
...(display.model === undefined ? {} : {
modelSelection: {
lastUsed: { provider: CODEX_PROVIDER, model: display.model, ...(display.reasoningEffort === undefined ? {} : { reasoningEffort: display.reasoningEffort }) },
next: { provider: CODEX_PROVIDER, model: display.model, ...(display.reasoningEffort === undefined ? {} : { reasoningEffort: display.reasoningEffort }) },
},
}),
codexStatus: display.status,
permissions: codexPermissions(permissionPreset),
imageLimits: codexImageLimits(),
},
},
}
}
export function codexModelSelectionFromSession(session: RemoteSession): ModelSelection | undefined {
const values = record(session.projections?.values)
const projection = record(values.modelSelection)
const candidate = record(projection.next ?? projection.lastUsed)
const provider = string(candidate.provider)
const model = string(candidate.model)
if (provider !== CODEX_PROVIDER || model === undefined) return undefined
const reasoningEffort = string(candidate.reasoningEffort)
return { provider, model, ...(reasoningEffort === undefined ? {} : { reasoningEffort }) }
}
export function updateCodexSession(
current: RemoteSession,
display: DisplaySession,
): RemoteSession {
const permission = codexPermissionPreset(current)
const next = codexSession(display, permission)
return {
...current,
...next,
projections: {
values: {
...current.projections?.values,
...next.projections?.values,
},
},
}
}
export function withCodexPermission(session: RemoteSession, preset: string): RemoteSession {
if (session.backend !== 'codex' || !isCodexPermissionPreset(preset)) return session
return {
...session,
projections: {
values: {
...session.projections?.values,
permissions: codexPermissions(preset),
},
},
}
}
export function codexPermissionPreset(session: RemoteSession): CodexPermissionPreset {
const permissions = record(session.projections?.values?.permissions)
return permissions.currentValue === 'danger-full-access' ? 'danger-full-access' : 'workspace-write'
}
export function codexPermissionPresetFromResponse(value: unknown): CodexPermissionPreset | undefined {
const root = record(value)
return codexPermissionPresetFromPolicyRecord(root)
?? codexPermissionPresetFromPolicyRecord(record(root.threadSettings))
}
function codexPermissionPresetFromPolicyRecord(value: Record<string, unknown>): CodexPermissionPreset | undefined {
const sandbox = value.sandbox ?? value.sandboxPolicy
if (value.approvalPolicy === 'never' && isDangerFullAccessSandbox(sandbox)) return 'danger-full-access'
if (value.approvalPolicy === 'on-request' && isWorkspaceWriteSandbox(sandbox)) return 'workspace-write'
return undefined
}
export function codexThreadId(session: RemoteSession): string {
if (session.backend !== 'codex' || typeof session.nativeId !== 'string' || session.nativeId.length === 0) {
throw new Error(strings.runtime.codexInvalidResponse)
}
return session.nativeId
}
export function codexItemsToChat(items: DisplayHistoryItem[]): ChatItem[] {
const output: ChatItem[] = []
items.forEach(item => {
// Missing upstream time stays unknown until a live row is first received.
// Array positions are ordering hints, never wall-clock timestamps.
const createdAt = typeof item.createdAt === 'number' && Number.isFinite(item.createdAt) && item.createdAt > 0
? item.createdAt : 0
const nativeTime = createdAt > 0 ? { nativeTime: createdAt } : {}
if (item.kind === 'message' && item.role !== undefined) {
output.push({
kind: 'message',
id: item.id,
sessionId: item.sessionId,
role: item.role,
text: item.text ?? '',
...(item.nativeRef.turnId === undefined ? {} : { replyGroup: item.nativeRef.turnId }),
...(item.nativeRef.turnId === undefined ? {} : { turn: item.nativeRef.turnId }),
...(item.images === undefined || item.images.length === 0 ? {} : { images: item.images }),
...(item.role === 'assistant' && item.status === 'running' ? { streaming: true as const } : {}),
createdAt,
...nativeTime,
})
return
}
if (item.kind === 'status' && item.details?.type === 'reasoning') {
output.push({
kind: 'message', id: item.id, sessionId: item.sessionId, role: 'assistant', text: '',
...(item.nativeRef.turnId === undefined ? {} : { replyGroup: item.nativeRef.turnId }),
...(item.nativeRef.turnId === undefined ? {} : { turn: item.nativeRef.turnId }),
reasoning: item.text ?? '',
...(item.status === 'running' ? { streaming: true as const, streamingPhase: 'reasoning' as const } : {}),
createdAt,
...nativeTime,
})
return
}
if (item.kind === 'error') {
output.push({
kind: 'message', id: item.id, sessionId: item.sessionId, role: 'assistant',
text: item.text ?? strings.chat.codexError, createdAt, ...nativeTime,
})
return
}
if (item.kind === 'approval' && item.nativeRef.requestHandle !== undefined) {
output.push({
kind: 'approval',
id: item.id,
sessionId: item.sessionId,
approvalId: item.nativeRef.requestHandle,
toolName: item.text ?? strings.chat.codexOperation,
...(item.nativeRef.turnId === undefined ? {} : { turn: item.nativeRef.turnId }),
...(typeof item.details?.reason === 'string' ? { reason: item.details.reason } : {}),
...(item.status === 'running' ? {} : { outcome: 'unavailable' as const }),
createdAt,
...nativeTime,
})
return
}
const text = item.text ?? item.details?.type?.toString() ?? strings.chat.codexOperation
output.push({
kind: 'tool',
id: item.id,
sessionId: item.sessionId,
toolName: codexToolName(item),
...(item.nativeRef.turnId === undefined ? {} : { turn: item.nativeRef.turnId }),
summary: text.split('\n', 1)[0],
...(item.images === undefined || item.images.length === 0 ? {} : { images: item.images }),
...(text.length === 0 ? {} : {
[item.status === 'running' ? 'callDetail' : 'resultDetail']: {
text,
format: item.kind === 'file-change' ? 'code' : 'markdown',
},
}),
state: item.status === 'failed' || item.status === 'declined'
? 'failed'
: item.status === 'running' ? 'running' : 'finished',
createdAt,
...nativeTime,
})
})
return output
}
export function mergeCodexLive(current: ChatItem[], live: ChatItem[]): ChatItem[] {
if (live.length === 0) return current
let next = [...current]
for (const rawItem of live) {
let item = rawItem
if (item.kind === 'message' && item.role === 'user') {
const messageText = item.text
// Text is the only echo correlation codex offers; prefer the same-text
// candidate whose image presence matches so queued same-text sends do
// not swap attachments, then fall back to FIFO order.
const incomingHasImages = item.images !== undefined
const textMatches = next.flatMap((value, index) => value.kind === 'message'
&& value.role === 'user'
&& value.id.startsWith('local:')
&& value.text === messageText
// A failed/canceled row is user-owned retry material; a later echo must
// not consume it (it belongs to a different send).
&& value.sendState !== 'failed' && value.sendState !== 'canceled' ? [index] : [])
const optimistic = textMatches.find(index => {
const value = next[index]!
return value.kind === 'message' && value.role === 'user' && (value.images !== undefined) === incomingHasImages
}) ?? textMatches[0] ?? -1
if (optimistic >= 0) {
const local = next[optimistic]
if (local?.kind === 'message' && local.images !== undefined) item = { ...item, images: local.images }
if (local !== undefined && item.createdAt <= 0) item = { ...item, createdAt: local.createdAt }
next.splice(optimistic, 1)
}
}
const index = next.findIndex(value => value.id === item.id)
if (index < 0) next.push(item.createdAt > 0 ? item : { ...item, createdAt: Date.now() })
else {
const previous = next[index]!
// Re-projecting the live timeline must retain both the first receipt time
// and any authoritative time already supplied by the history baseline.
next[index] = preserveLocalOutcome(previous, {
...item,
createdAt: item.createdAt > 0 ? item.createdAt : previous.createdAt,
...(item.nativeTime !== undefined || previous.nativeTime === undefined ? {} : { nativeTime: previous.nativeTime }),
})
}
}
return next
}
function preserveLocalOutcome(current: ChatItem, incoming: ChatItem): ChatItem {
if (current.kind === 'approval' && incoming.kind === 'approval' && current.outcome !== undefined) {
return { ...incoming, outcome: current.outcome }
}
return incoming
}
async function loadProjects(client: CodexRemoteClient): Promise<CodexProject[]> {
const projects: CodexProject[] = []
let cursor: string | undefined
try {
for (let page = 0; page < MAX_PAGES; page += 1) {
const result = record(await client.request('project/list', {
limit: PAGE_LIMIT,
...(cursor === undefined ? {} : { cursor }),
}))
if (!Array.isArray(result.data)) throw new Error(strings.runtime.codexInvalidResponse)
for (const value of result.data) {
const project = parseCodexProject(value, projects.length)
if (project !== undefined && !projects.some(existing => existing.id === project.id)) projects.push(project)
}
cursor = string(result.nextCursor)
if (cursor === undefined) break
}
} catch (error) {
if (!isProjectListUnavailable(error)) throw error
}
return projects.sort((left, right) => left.position - right.position || left.name.localeCompare(right.name))
}
function parseCodexProject(value: unknown, fallbackPosition: number): CodexProject | undefined {
const source = record(value)
const id = string(source.id)
const name = string(source.name)
const roots = Array.isArray(source.roots)
? source.roots.flatMap(root => string(record(root).path) ?? [])
: []
if (id === undefined || name === undefined || roots.length === 0) return undefined
return {
id,
name,
roots,
position: finiteNumber(source.position) ?? fallbackPosition,
createdAt: timestamp(source.createdAt),
updatedAt: timestamp(source.updatedAt),
}
}
async function loadThreads(client: CodexRemoteClient): Promise<Record<string, unknown>[]> {
// Native catalogs can list several rollout snapshots of the same thread,
// including across page boundaries. Project only its newest complete row.
const threads = new Map<string, Record<string, unknown>>()
let cursor: string | undefined
for (let page = 0; page < MAX_PAGES; page += 1) {
const result = record(await client.request('thread/list', {
limit: PAGE_LIMIT,
sortKey: 'updated_at',
sortDirection: 'desc',
archived: false,
...(cursor === undefined ? {} : { cursor }),
}))
if (!Array.isArray(result.data)) throw new Error(strings.runtime.codexInvalidResponse)
for (const value of result.data) {
const thread = record(value)
const id = string(thread.id)
if (id === undefined) continue
const previous = threads.get(id)
if (previous === undefined || timestamp(thread.updatedAt) > timestamp(previous.updatedAt)) threads.set(id, thread)
}
cursor = string(result.nextCursor)
if (cursor === undefined) break
}
return [...threads.values()]
}
function projectWorkspace(project: CodexProject): WorkspaceView {
const path = project.roots[0]!
return {
workspaceId: `codex:project:${project.id}`,
backend: 'codex',
nativeId: project.id,
path,
title: project.name.trim() || basename(path),
sessionIds: [],
createdAt: new Date(project.createdAt || Date.now()).toISOString(),
updatedAt: new Date(project.updatedAt || project.createdAt || Date.now()).toISOString(),
}
}
function findThreadWorkspace(
thread: Record<string, unknown>,
display: DisplaySession,
projects: CodexProject[],
byProjectId: Map<string, WorkspaceView>,
): WorkspaceView | undefined {
const explicit = string(thread.projectId)
if (explicit !== undefined && byProjectId.has(explicit)) return byProjectId.get(explicit)
if (display.cwd === undefined) return undefined
const match = projects
.flatMap(project => project.roots.map(root => ({ project, root })))
.filter(value => containsPath(value.root, display.cwd!))
.sort((left, right) => right.root.length - left.root.length || left.project.position - right.project.position)[0]
return match === undefined ? undefined : byProjectId.get(match.project.id)
}
function codexPermissions(currentValue: string) {
return {
currentValue,
options: [
{ value: 'workspace-write', name: strings.chat.codexWorkspaceWrite, description: strings.chat.codexWorkspaceWriteDescription },
{ value: 'danger-full-access', name: strings.chat.codexFullAccess, description: strings.chat.codexFullAccessDescription },
],
}
}
function codexImageLimits() {
return {
maxImageBytes: 20 * 1024 * 1024,
maxImagesPerMessage: 16,
maxMessageImageBytes: 100 * 1024 * 1024,
maxImagePixels: 40_000_000,
maxImageDimension: 8_192,
mediaTypes: ['image/png', 'image/jpeg', 'image/webp', 'image/gif'],
}
}
function codexToolName(item: DisplayHistoryItem): string {
const type = typeof item.details?.type === 'string' ? item.details.type : undefined
if (item.kind === 'file-change') return strings.chat.codexFileChange
if (type === 'commandExecution') return strings.chat.codexCommand
if (type === 'webSearch') return strings.chat.codexWebSearch
if (type === 'collabAgentToolCall' || type === 'subAgentActivity') return strings.chat.codexSubagent
if (type === 'plan') return strings.chat.codexPlan
return strings.chat.codexOperation
}
function reasoningEffortName(effort: string): string {
const names: Record<string, string> = {
none: 'None', minimal: 'Minimal', low: 'Low', medium: 'Medium', high: 'High',
xhigh: 'Extra High', max: 'Max', ultra: 'Ultra',
}
return names[effort] ?? effort
}
export function isCodexPermissionPreset(value: string): value is CodexPermissionPreset {
return value === 'workspace-write' || value === 'danger-full-access'
}
function isDangerFullAccessSandbox(value: unknown): boolean {
return value === 'danger-full-access' || record(value).type === 'dangerFullAccess'
}
function isWorkspaceWriteSandbox(value: unknown): boolean {
return value === 'workspace-write' || record(value).type === 'workspaceWrite'
}
function isProjectListUnavailable(error: unknown): boolean {
if (!(error instanceof Error)) return false
const code = 'code' in error && typeof error.code === 'string' ? error.code : undefined
return code === 'METHOD_NOT_ALLOWED'
|| code === 'METHOD_NOT_FOUND'
|| code === 'CODEX_UPSTREAM_ERROR'
|| error.message.includes('The requested Codex method is not available over Remote.')
}
function containsPath(root: string, candidate: string): boolean {
const normalizedRoot = root.replace(/[\\/]+$/u, '') || root
const normalizedCandidate = candidate.replace(/[\\/]+$/u, '') || candidate
return normalizedCandidate === normalizedRoot
|| normalizedCandidate.startsWith(`${normalizedRoot}/`)
|| normalizedCandidate.startsWith(`${normalizedRoot}\\`)
}
function basename(path: string): string {
return path.replace(/[\\/]+$/u, '').split(/[\\/]/u).filter(Boolean).at(-1) ?? path
}
function timestamp(value: unknown): number {
if (typeof value !== 'number' || !Number.isFinite(value) || value <= 0) return 0
return value < 10_000_000_000 ? Math.floor(value * 1_000) : Math.floor(value)
}
function finiteNumber(value: unknown): number | undefined {
return typeof value === 'number' && Number.isFinite(value) ? value : undefined
}
function string(value: unknown): string | undefined {
return typeof value === 'string' && value.length > 0 ? value : undefined
}
function record(value: unknown): Record<string, unknown> {
return isRecord(value) ? value : {}
}
function isRecord(value: unknown): value is Record<string, unknown> {
return typeof value === 'object' && value !== null && !Array.isArray(value)
}