Files
orca/mobile
Brennan Benson 0d94c0ba8f Native chat: queue messages sent while the agent works (on by default, Settings toggle, Cmd/Ctrl+Enter to send one now) (#36588)
* Advertise mid-turn queueing as queued-messages.v2

Released clients read the v1 name with an unfinished queue UI; they never
see v2 and keep sending immediately.

(cherry picked from commit f39382e090)

* Let each desktop send choose queue or steer while the agent works

The follow-up choice is now a Queue / Steer setting saved under
nativeChatFollowUpBehavior, Steer by default; the old
nativeChatQueueFollowUps switch, which every install saved as true
while queueing was dark, is retired on load. Every reader goes through
native-chat-follow-up-behavior.

While the agent works, Enter follows the setting and Cmd/Ctrl+Enter
sends the draft the other way; the alternate flips the setting before
the queue's own rules (a waiting command still queues, prompts no one
here can answer still send now) and never applies while Stopping.
Cmd/Ctrl+Shift+Enter steers the head card only and leaves the draft.
An idle agent's card reads Send, and the card menu no longer offers
"Turn off queueing".

(cherry picked from commit 55b48694e7)

* Hold Send on the phone to queue or steer a message mid-turn

While the agent works on a host that queues, holding Send opens a
Queue / Steer sheet; a choice other than the host's setting sends the
alternate, resolved against the chat as it is when it lands, by the
desktop's rule. Release and dismiss send nothing. The phone reads the
host's new follow-up setting (absent reads as Steer), and an idle
agent's card reads Send.

(cherry picked from commit db87cf51ea)

* Read the follow-up default from one place on desktop and phone

(cherry picked from commit 8e1438bfb6)

* Keep phone follow-up choices aligned with live host state

(cherry picked from commit dc9215be3d)

* Update stream and wire fixtures for live follow-up preferences

(cherry picked from commit e4d038cf0b)

* Document minimal runtime test fixture assertions

(cherry picked from commit 254f751ef3)

* Keep mobile preference tests in the mobile compiler project

(cherry picked from commit ae2aa8910e)

* feat(native-chat): queue follow-ups by default with a toggle

(cherry picked from commit 70969d6a43)

* test(mobile): assert shared preference renders on real changes

(cherry picked from commit 3f50de9b2a)

* Remove obsolete follow-up option translations

(cherry picked from commit b87b360cf3)

* Describe Cmd/Ctrl+Enter relative to the Queue follow-ups switch

The Settings description said Cmd/Ctrl+Enter sends into the running
turn, which is wrong while the switch is off. Describe it as doing the
opposite for one message, in every language.

* Show what a mid-turn phone Send does, and offer the other way only when it differs

While the agent works, the phone's Send button now shows Queue or Steer.
Holding it lists that action first with a check and the other second,
each with a one-line description, and appears only when both choices
would actually lead to different sends. A waiting command or prompts
nobody here can answer make a hold behave like a tap.

* Steer the head card once while its shortcut is held

Holding Cmd/Ctrl+Shift+Enter auto-repeats the key, which steered each
card that became the head in turn. Ignore the repeats.

* Show beside Stop what Enter does while the agent works

While a turn runs and the draft has something to send, a send control
now sits beside Stop. Its icon and label say whether Enter queues the
message or steers it into the running turn, and its tooltip names Enter
and, when it would send differently, Cmd/Ctrl+Enter. Clicking it sends
as Enter does. Stop keeps its place and nothing changes while Stopping,
with an empty draft, or before the host says it queues.

The phone and desktop now read what a send does from one shared helper
over the send's own resolver.

* Test the send keys and Queue follow-ups search against real wiring

One desktop test drives Enter and Cmd+Enter through the real composer,
transport and session to the outgoing send and checks its delivery with
queueing on and off. Settings search is checked against the capability
list this build's host advertises.

* Move the composer's send-hold check into its own helper

The pane had grown past the file length limit after the main merge.

* Disable the mid-turn Queue/Steer button whenever Send would be disabled

While an image is still loading, another device holds the input, or a send is blocked for a stated reason, the button beside Stop is now disabled and says why, the same way the idle Send button does. Before, it stayed clickable and a click did nothing.

* Hide the mid-turn Queue/Steer button in goal mode

In goal mode Enter sets the goal, so a button promising to queue or steer the message was wrong. It is now hidden there, as it already is while editing a queued message.

* Fix the Russian queue hint to say the message runs after this turn

It read as queueing until the end of this turn.

* Stub window.api without a type assertion in the Queue follow-ups settings search test

* Pass sendHeld to the composer field in tests and drop an unknown setting from the German Queue test

* Let Cmd-click (Ctrl-click elsewhere) on the mid-turn Queue/Steer button send the other way, like Cmd/Ctrl+Enter

The button shows the other action while the modifier is held, and its tooltip names the click. Only when the other way would send differently; otherwise a modified click is a plain send.

* Merge the duplicate composer-types import and give the composer's round buttons a Button size instead of restyling them

The focused code-quality check rejects importing one module twice, and the design-system check rejects rounded-full on a <Button>, which the new Queue/Steer button copied from Send. Both composer buttons now use a round icon size on the Button primitive and render as before.

* Share one window key listener across every chat's Queue/Steer button, and count Cmd/Ctrl as held only from its own key press

Each mounted chat with a mid-turn draft used to add its own window key listeners, so every keystroke did work per chat, hidden tabs included. One shared listener set now serves them all and wakes a button only when the held state really changes.

Other keys can now only clear the held state, so a dictation paste that leaves the Cmd flag on later key events no longer flips the button with Cmd up. Also tests the Ctrl-click on Windows and Linux.

* Remove the desktop Queue/Steer button shown beside Stop while the agent works

While the agent works, the desktop composer goes back to its usual
controls: Stop, with Enter and the send shortcuts doing what they did.
Enter still follows the queue setting, Cmd/Ctrl+Enter still sends one
message the other way, and Cmd/Ctrl+Shift+Enter still steers the first
queued card.

This also removes what only that button used: its Cmd/Ctrl-click
alternate, the shared Cmd/Ctrl key listener, the extra round Button
size, the send-preview value the desktop session passed to the
composer, and the button's text in every language. The phone is
unchanged.

* Put the composer's send-hold checks back inline in the pane

The separate send-hold helper only existed because the removed mid-turn
Queue/Steer button pushed the pane over the file-length limit. Without the
button the pane fits again, so it goes back to main's inline code.
2026-10-31 02:01:32 -07:00
..

Orca Mobile

React Native companion app for Orca. Monitor worktrees, view terminal output, and send commands from your phone.

Local development uses two processes:

  • Orca desktop/Electron from the repo root. This hosts the mobile WebSocket RPC server on port 6768.
  • Expo Metro from mobile/. This serves the React Native app on port 8081.

Unless a command says otherwise, run mobile app commands from the mobile/ directory.

The Node commands pnpm rpc:diff and pnpm rpc:record use a development dependency linked to ../src/packages/process-host. Mobile's install supplies the link, and tsx runs its source with the orca-source condition, so these command wrappers do not require a desktop install or package build. Keep that source directory in sparse checkouts. The recording suites still need root dependencies when they exercise desktop modules. The React Native app does not import this host package.

Prerequisites

  • Node.js 24+
  • pnpm
  • Xcode and/or Android Studio tooling for simulator or device builds
  • Expo Go on your phone, or a development client build when native modules are needed
  • Phone and desktop on the same LAN when testing a physical phone

Start Desktop Orca

From the repository root:

pnpm install
pnpm dev

Confirm the mobile RPC server is listening:

lsof -nP -iTCP:6768 -sTCP:LISTEN

Restart pnpm dev after changing Electron main-process code. Metro hot reload only applies to the mobile JavaScript bundle.

Start The Mobile App

cd mobile
pnpm install
pnpm start

Scan the Expo QR code with your phone's camera on iOS, or Expo Go on Android.

For a native dev-client build:

pnpm native ensure ios       # or: pnpm native ensure android [--device <name|udid|serial>]
pnpm start --dev-client

ensure computes the Expo fingerprint of the native inputs (native dependencies, config plugins, modules/, patches/, and the Expo config). On a HIT it installs the cached build on the booted simulator or the running emulator in a few seconds. On a MISS it regenerates ios/ or android/, runs expo run:<platform>, and caches the result. --rebuild forces a fresh build.

Builds are cached per fingerprint in the user cache directory (~/Library/Caches/orca-mobile/native-builds on macOS, $XDG_CACHE_HOME/orca-mobile/native-builds on Linux, %LOCALAPPDATA%\orca-mobile\native-builds on Windows, or ORCA_MOBILE_NATIVE_BUILD_CACHE_DIR), so every worktree reuses them. The newest three per platform are kept. app.config.js also registers the cache as Expo's buildCacheProvider, so a plain pnpm ios / pnpm android installs a cached build instead of compiling. Only ensure writes to the cache, because expo run reuses an existing ios/ or android/ directory even when it was generated from older inputs. Expo caches iOS Simulator builds only, not physical devices.

pnpm native fingerprint prints the current hashes. On pull requests, the Mobile native fingerprint job reports in its summary whether the PR changes them, which means dev clients need a native rebuild.

Pair With Desktop Orca

  1. Open Orca desktop.
  2. Go to Settings > Mobile.
  3. Scan the pairing QR code from the mobile app.
  4. Confirm the mobile host endpoint is ws://<desktop-ip>:6768.

For the Android emulator, use ws://10.0.2.2:6768. For a physical phone, use the desktop LAN IP, for example ws://192.168.0.179:6768.

If the phone has a stale host entry, remove it from the app and pair again.

Development Paths

Android Phone

  1. Install Expo Go from Google Play
  2. Run pnpm start, scan QR with Expo Go
  3. For native modules: pnpm exec expo run:android
  4. Run with pnpm start --dev-client

iOS Simulator

  1. Install Xcode from the App Store
  2. Run pnpm start --ios to open in iOS Simulator

Physical Phone Debugging

The phone can be inspected through the connected device tooling:

orca snapshot --json
orca click --element @e3 --json
orca fill --element @e1 --value "ls" --json
orca screenshot --json

Use snapshot first to find the current element refs, then click/fill those refs. After mobile file edits, Metro usually hot reloads automatically, but navigating out of and back into the session screen can be useful because it re-runs terminal.subscribe.

Terminal Streaming Repro Without A Phone

Use this when terminal output does not render on device and you need to split server streaming bugs from WebView/UI bugs:

cd mobile
ORCA_MOBILE_WS_URL=ws://127.0.0.1:6768 pnpm exec tsx scripts/test-subscribe.ts <deviceToken> <serverPublicKeyB64>

You can pass a worktree selector as the third argument:

pnpm exec tsx scripts/test-subscribe.ts <deviceToken> <serverPublicKeyB64> "id:<worktreeId>"
pnpm exec tsx scripts/test-subscribe.ts <deviceToken> <serverPublicKeyB64> "path:/absolute/worktree/path"
pnpm exec tsx scripts/test-subscribe.ts <deviceToken> <serverPublicKeyB64> "name:my-worktree"

The expected result includes:

streamSawMarker: true
readSawMarker: true

If this repro fails, debug the desktop runtime/PTY path before the mobile WebView. If it passes but the phone is blank, debug the session screen or TerminalWebView readiness/queueing path.

Terminal Color Repro Without A Phone

Use this when terminal colors disappear after switching tabs. Open a Claude Code terminal and at least one other terminal in the target worktree, then run:

cd mobile
ORCA_MOBILE_WS_URL=ws://127.0.0.1:6768 pnpm exec tsx scripts/repro-terminal-colors.ts \
  <deviceToken> <serverPublicKeyB64> "id:<worktreeId>"

The script captures terminal.subscribe snapshots in an A → B → A sequence and writes raw snapshots to mobile/terminal-color-repro/. If the two A snapshots have different sgrColor counts, the desktop snapshot changed during the switch. If they match, the ANSI color data is still present and the bug is in mobile replay/rendering.

Validation

Run these checks before committing mobile terminal changes:

cd mobile
pnpm exec tsc --noEmit
pnpm run check:tests-typecheck
pnpm lint
cd ..
pnpm typecheck:node

tsc --noEmit reads tsconfig.json, which excludes test files so Metro never bundles them. tsconfig.test.json puts them back, and pnpm run typecheck:tests shows their errors in full. check:tests-typecheck is the gate over it: a ratchet against tests-typecheck-baseline.txt, the 127 test files that do not typecheck yet. It fails when a file that checks today stops checking, and when a baseline entry starts checking (prune it with node scripts/check-tests-typecheck-ratchet.mjs --prune). The list may only shrink.

The same gate censuses the program first: every *.test.ts(x) on disk must be in it, or named in the script's TESTS_OUTSIDE_PROGRAM with a reason. Without that, a test excluded from tsconfig.test.json — or a Foo.test.tsx shadowed by a Foo.test.ts beside it, which a wildcard include drops for the higher-priority extension — would leave the ratchet silently.

Localization

UI copy goes through src/i18n, with the same call shape and languages as desktop:

  • In components and hooks: const t = useMobileTranslation(), then t('area.thing.label', 'English text'). The function changes with the language, so list it in memo and callback dependencies.
  • In helpers and imperative code (alerts, notifications): translate(key, fallback, options) from src/i18n/mobile-i18n, called when the text is shown, never at module scope.
  • Counts: count === 1 ? t('x.files_one', '{{count}} file', { count }) : t('x.files_other', '{{count}} files', { count }).
  • Dates and numbers: pass getUiIntlLocale() to Intl formatters instead of undefined.
  • Keep identity separate from display text: never compare or key on a translated string.

Run pnpm sync:mobile-localization from the repo root to add new keys to src/i18n/locales/en.json; other catalogs may lag and fall back to English. pnpm verify:mobile-localization and pnpm verify:mobile-localization-coverage run in CI. iOS permission prompts live in locales/<lang>.json.

Protocol Version Compatibility

Mobile and desktop talk over a versioned protocol. Because mobile updates lag desktop by 24-48h via the App Store, both sides exchange version numbers on status.get so a genuinely incompatible combo can hard-block instead of silently misbehaving.

Constants live in two files (Metro can't resolve outside mobile/):

  • src/shared/protocol-version.ts — DESKTOP_PROTOCOL_VERSION, MIN_COMPATIBLE_MOBILE_VERSION
  • mobile/src/transport/protocol-version.ts — MOBILE_PROTOCOL_VERSION, MIN_COMPATIBLE_DESKTOP_VERSION

Today all four are set so evaluateCompat always returns { kind: 'ok' } — nothing blocks. The wire format is in place to flip a switch when needed.

When to bump

Bump DESKTOP_PROTOCOL_VERSION (and the mobile mirror MOBILE_PROTOCOL_VERSION when relevant) for breaking changes:

  • Removed RPC method or required parameter that mobile uses
  • Changed meaning (units, nullability) of an existing field mobile reads
  • Changed encryption, framing, or auth handshake

Do not bump for additive changes:

  • New RPC methods
  • New optional fields on existing methods
  • New event types in terminal.subscribe

Set MIN_COMPATIBLE_MOBILE_VERSION (kill-switch) when desktop ships a change that requires a minimum mobile version to function safely. Same for MIN_COMPATIBLE_DESKTOP_VERSION from the mobile side.

When a verdict is blocked, mobile/src/components/ProtocolBlockScreen.tsx renders a screen pointing the user at the update that clears it. When mobile is too old it opens the newest release if the installed app's update check knows one, otherwise the App Store (iOS) or GitHub Releases (Android). When desktop is too old it opens GitHub Releases.

To exercise the block screen locally: set MIN_COMPATIBLE_DESKTOP_VERSION = 999 in mobile/src/transport/protocol-version.ts, rebuild, pair to any desktop. Revert before merging.

Mock Server

Develop the mobile app without a running Orca desktop instance:

pnpm mock-server           # starts mock WebSocket server on port 6768

Connect from the app using endpoint ws://localhost:6768 and token mock-device-token.

Environment variables

  • MOCK_NATIVE_CHAT=1 — serve the native-chat scenario (one live agent tab, empty transcript, image upload) instead of the default terminal fixtures.
  • MOCK_CHAT_AGENT=omp — with MOCK_NATIVE_CHAT=1, present an OMP tab and four decoded transcript messages, including a tool call and result, instead of the default Claude scenario. It deliberately omits transcriptPath to exercise legacy-hook readability discovery; current OMP hooks may report a path.
  • MOCK_SERVER_KEY_FILE — persist the server keypair across restarts so a paired device keeps its public-key pin. A missing or invalid file is re-keyed with a warning, which forces a re-pair.

Scenario control files

Read on every request, so behaviour can be flipped mid-session without a restart (a restart would re-key E2EE and force a re-pair). Write the mode into the file, or delete it for the default.

  • MOCK_SEND_MODE_FILE (default orca-mock-send-mode in the system temporary directory) — accept (default) accepts the send, error fails it with mobile_input_floor_unavailable, anything else reports the send as rejected.
  • MOCK_TERMINAL_LIST_MODE_FILE (default orca-mock-terminal-list-mode in the system temporary directory) — omit returns an empty terminal list, other returns a list that omits the chat handle, anything else lists it.
  • MOCK_TERMINAL_STREAM_MODE_FILE (default orca-mock-terminal-stream-mode in the system temporary directory) — dead answers a subscribe with subscribed then end (a gone PTY), which is what exercises the rearm bound and terminal prune; anything else streams normally.

Connecting to Real Orca

  1. Start Orca desktop with WebSocket transport enabled
  2. In Orca, go to Settings > Mobile and scan the QR code with this app
  3. The QR encodes the connection endpoint, device token, and TLS fingerprint

Project Structure

mobile/
├── app/                   # Expo Router screens (file-based routing)
│   ├── _layout.tsx        # Root layout with navigation stack
│   ├── index.tsx          # Home screen — paired hosts list
│   └── pair-scan.tsx      # QR code scanning screen
├── src/
│   ├── terminal/          # Terminal WebView and xterm bridge
│   └── transport/         # WebSocket RPC client
├── scripts/
│   ├── test-subscribe.ts  # Desktop streaming repro without a phone
│   └── mock-server.ts     # Standalone mock WebSocket server
└── assets/                # App icons and splash screen