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 type { DragReorderMove } from '../components/drag-reorder-positions'
import { useMobileQueuedMessageComposerActions } from './use-mobile-queued-message-composer-actions'
// The host owns queued drafts; render its published cards even when it cannot queue new sends.
import { useCallback, useMemo } from 'react'
import { useMobileTranslation } from '../i18n/use-mobile-translation'
import type {
AgentJournalRenderItem,
AgentJournalSubmission
} from '../../../src/shared/agent-session-journal-types'
import { agentSessionVisibleFailureFacts } from '../../../src/shared/agent-session-visible-failures'
import { mapSettledWithConcurrency } from '../../../src/shared/map-with-concurrency'
import type {
AgentSessionQueuedMessage,
AgentSessionQueuedMessageDeleteResult,
AgentSessionQueuedMessagesResumeResult,
AgentSessionQueuePause,
AgentSessionSendResult
} from '../../../src/shared/agent-session-wire'
import { queuedMessagesQueuePause } from '../../../src/shared/structured-agent-session-queued-cards'
import {
mobileQueuedMessageCards,
type MobileQueuedMessageCard
} from './mobile-structured-queued-message-cards'
import type { MobileStructuredAgentMutate } from './use-mobile-structured-agent-mutation'
import type { RpcClient } from '../transport/rpc-client'
import {
useMobileStructuredQueuedEdit,
type MobileQueuedMessageInlineEditor
} from './use-mobile-structured-queued-edit'
const CLEAR_DELETE_CONCURRENCY = 8
// Notify only after copying into the composer, before Delete leaves.
export type MobileQueuedMessageEdit = (messageId: string, onCopied?: () => void) => Promise<boolean>
export type MobileStructuredQueuedMessageControls = {
cards: MobileQueuedMessageCard[]
send: (messageId: string) => Promise<boolean>
delete: (messageId: string) => Promise<boolean>
clear: (messageIds: string[]) => Promise<boolean>
edit?: MobileQueuedMessageEdit
editor?: MobileQueuedMessageInlineEditor
move?: (move: DragReorderMove) => Promise<boolean>
pause: AgentSessionQueuePause | null
resume: () => Promise<boolean>
sessionKey: string
}
export function useMobileStructuredQueuedMessageControls(args: {
sessionKey: string
sessionId: string | null
client: RpcClient | null
chatActive: boolean
enabled: boolean
editCapable: boolean | null
imagesCapable?: boolean
skillsCapable?: boolean
composerScopeKey?: string | null
reorderCapable?: boolean
agentName?: string
journalItems?: readonly AgentJournalRenderItem[]
queuedMessages: readonly AgentSessionQueuedMessage[] | null
queuePause: AgentSessionQueuePause | null
submissions: readonly AgentJournalSubmission[]
agentWorking?: boolean
mutate: MobileStructuredAgentMutate
// Without a live composer or a successful copy, Edit must refuse.
appendComposerText: ((text: string) => boolean) | undefined
onQueuedEditNotice?: (message: string) => void
onSendError: (message: string) => void
onActionResolved?: () => void
}): MobileStructuredQueuedMessageControls {
const t = useMobileTranslation()
const {
appendComposerText,
mutate,
onActionResolved,
onSendError,
queuedMessages,
queuePause,
sessionKey,
submissions
} = args
const composerActions = useMobileQueuedMessageComposerActions({
...args,
messages: queuedMessages,
reorderCapable: args.reorderCapable === true
})
const orderedMessages = composerActions.messages
const agentWorking = args.agentWorking === true
const cards = useMemo(
() =>
mobileQueuedMessageCards(orderedMessages, submissions, {
agentWorking,
queuePaused: queuePause !== null,
agentName: args.agentName,
statedFailures: queuedMessages?.some((draft) => draft.state === 'returned')
? agentSessionVisibleFailureFacts(args.journalItems ?? [])
: []
}),
[
agentWorking,
args.agentName,
args.journalItems,
orderedMessages,
queuePause,
queuedMessages,
submissions,
t
]
)
const { begin: beginInlineEdit, editor } = useMobileStructuredQueuedEdit({
...args,
enabled: args.enabled && args.editCapable === true,
messages: queuedMessages,
cards
})
const resolved = useCallback(
(accepted: boolean): boolean => {
if (accepted) {
onActionResolved?.()
}
return accepted
},
[onActionResolved]
)
const send = useCallback(
async (messageId: string): Promise<boolean> =>
resolved(
(
await mutate<AgentSessionSendResult>(
'agentSession.queuedMessageSend',
'agentSession.queuedMessageSend',
{ messageId }
)
).status === 'accepted'
),
[mutate, resolved]
)
const deleteQueued = useCallback(
async (messageId: string, copied: boolean): Promise<boolean> => {
const result = await mutate<AgentSessionQueuedMessageDeleteResult>(
'agentSession.queuedMessageDelete',
'agentSession.queuedMessageDelete',
{ messageId }
)
if (result.status !== 'accepted') {
return false
}
if (!result.value.deleted && result.value.disposition === 'dispatched') {
// Delete can race dispatch; after Edit’s copy, disclose that it sent so the copy is not resent.
onSendError(
copied
? 'Already sent — your text is still in the composer.'
: 'This message was already sent.'
)
return false
}
return resolved(true)
},
[mutate, onSendError, resolved]
)
const deleteDraft = useCallback(
(messageId: string) => deleteQueued(messageId, false),
[deleteQueued]
)
const clear = useCallback(
async (messageIds: string[]): Promise<boolean> => {
if (messageIds.length === 0) {
return false
}
const results = await mapSettledWithConcurrency(
messageIds,
CLEAR_DELETE_CONCURRENCY,
(messageId) =>
mutate<AgentSessionQueuedMessageDeleteResult>(
'agentSession.queuedMessageDelete',
'agentSession.queuedMessageDelete',
{ messageId }
)
)
const dispatched = results.some(
(result) =>
result.status === 'fulfilled' &&
result.value.status === 'accepted' &&
!result.value.value.deleted &&
result.value.value.disposition === 'dispatched'
)
if (dispatched) {
onSendError('This message was already sent.')
}
return resolved(
!dispatched &&
results.every(
(result) => result.status === 'fulfilled' && result.value.status === 'accepted'
)
)
},
[mutate, onSendError, resolved]
)
const edit = useCallback<MobileQueuedMessageEdit>(
async (messageId, onCopied) => {
if (args.editCapable) {
if (!args.enabled) {
onSendError('Reconnect to edit.')
return false
}
return beginInlineEdit(messageId)
}
const card = cards.find((candidate) => candidate.messageId === messageId)
// Copy before Delete so refusal or lost reply cannot lose text; failed deletion leaves both copies visible.
// Never delete without a copy, and never turn command text into an editable message draft.
if (!card || card.command || !appendComposerText?.(card.text)) {
return false
}
onCopied?.()
return deleteQueued(messageId, true)
},
[
appendComposerText,
args.editCapable,
args.enabled,
beginInlineEdit,
cards,
deleteQueued,
onSendError
]
)
const resume = useCallback(
async (): Promise<boolean> =>
resolved(
(
await mutate<AgentSessionQueuedMessagesResumeResult>(
'agentSession.queuedMessagesResume',
'agentSession.queuedMessagesResume',
{}
)
).status === 'accepted'
),
[mutate, resolved]
)
const pause = queuedMessagesQueuePause(cards, queuePause)
return {
cards,
send,
delete: deleteDraft,
clear,
edit: args.editCapable === null ? undefined : edit,
editor,
move: composerActions.move,
pause,
resume,
sessionKey
}
}