mirror of
https://github.com/stablyai/orca.git
synced 2026-09-25 00:02:35 +00:00
Jinwoo Hong
6142657d7a
* test(mobile): record main's agent.launch create receipt before checking it `agent.launch` is the one read site in the tasks domain's project-board, runtime, source-search and workspace create/source files with no recording family at all, so main's answer to a malformed launch receipt was undocumented and a checked reader would have had nothing to move. One family, one scenario, two goldens: `worktree.agent-launch-create` drives `createWorktreeWithNameRetry` down the `agent.launch` arm instead of `worktree.create`, which needs an `agentLaunch` argument on the existing worktree-create-retry adapter. The agent is a constant there on purpose — which agent is picked changes only the params, and the arm under test is which method the create is issued on. A separate family rather than an eighth `worktree.create-retry` scenario: `familyGoldens` drives its reply matrix over the family's FIRST scenario, so adding to that family would have recorded a pilot golden and left the launch receipt with no partitions. As its own base it gets all eleven. Recorded from a detached worktree at the pinned baseline with this branch's `rpc-recording/` and manifest copied in, per the recipe in the recorder README: `mobile/pnpm-lock.yaml` has drifted past `4b876758d3` on main, so `--record` refuses on this branch's tree even though `mobile/src` and `src/shared` are byte-identical to the pin. Thirty-four existing goldens move on `adapterSha256` and nothing else — the six families mounted through the edited adapter module. No body moves. Claude-Session: https://claude.ai/code/session_01JNnE9qzUZMMnqpZWCqM3nb * refactor(mobile): checked reply readers for the tasks domain's board, runtime, search and create Forty-three unchecked reply readers across five files become checked zod readers, so a malformed host reply surfaces as one readable error naming the method instead of a downstream TypeError, a rendered `undefined`, or a screen left ready over garbage. Deliberately a behaviour change on malformed replies only. Five schema modules, each recording the consumer line behind every requirement and the host handler it was checked against: - `task-project-board-reply-schema.ts` — the sixteen `github.project.*` envelopes. Where a consumer reads a member off BOTH arms unguarded the schema is a union on `ok`; where it guards everything (`result.error?.message ?? '…'`, `result.labels ?? []`) it is a flat passthrough and requires only the container, because a requirement on a member the consumer already defaults would refuse a reply main rendered. - `task-runtime-reply-schema.ts` — the hydration reads. The three preference writes read `z.unknown()`: no call site interprets their body. - `task-source-search-reply-schema.ts` — the provider searches and the pasted single-item lookups. The Linear union replaces the hand reader in linear-mobile-issue-read.ts, whose own copy reached the screen unattributed. - `workspace-source-reply-schema.ts` — SSH state, agent detection, orca.yaml hooks, sparse presets and base-ref search. - `workspace-create-reply-schema.ts` — the create receipt, the launch receipt and the hosted-base union. Requirements are exactly the members a consumer reads unguarded AND a recorded golden shows the host sending. That second half is load-bearing: the recorded GitHub search row is `{ number, title }`, the recorded Linear issue is `{ id }`, the recorded project is missing `id`/`url`/`source` and the recorded sparse preset is missing `repoId`/`createdAt`/`updatedAt` — requiring what the shared types declare would have dropped rows main renders. Where the value therefore stays looser than the screen's own state type, the call site keeps one narrowing cast with that reason on it rather than a default that would fabricate state. Two enum decisions, both pinned: - `ownerType` is CLOSED with no fallback. It is echoed into the next `github.project.listViews` params, and remote-wire-compatibility.md rule 4 forbids a reply-schema fallback from shaping a param; the host's own listing handler answers `validation_error` for any other value. - `ssh` `status` is OPEN and degrades to `disconnected`, main's own answer for a state it did not receive. The readiness gate is an equality test against `connected`, so an arm this build has not heard of can never grant a create, and the record survives with its Connect affordance. - Every other host vocabulary a consumer equality-tests — the project view `layout`, the `setupRunPolicy` — stays `z.string()` for the same rule. Tri-states are preserved, not collapsed: the row detail's `reviewDecision`, a work item's `author` and the SSH record's `error` each keep explicit `null` distinct from absent, with a unit pin on each. `blank-workspace-create.test.ts` splits one `it.each` in two. The two create routes now answer a workspace-less reply differently: `agent.launch` still reports "Failed to create workspace", because its reader guards `worktreeId` itself, while `worktree.create` is named as unreadable, because the create screen reads `result.worktree.id` unguarded into the session route. Both reach the same catch; only the sentence changes. `mobile-tasks-refactor-parity.test.ts` moves four hashes and no count. Hooks hold at 350 with 28 bodies edited and no dependency array moved; statements hold at 417 and declarations at 194; `semantics` loses exactly four lines, all four string literals that lived inside the one deleted inline cast type. No method literal and no `rpc:` call signature moves. The inventory loses its five tasks lines; the boundary test stays green. Goldens are refreshed in the next commit, which is where the disclosed behaviour change is proved. Claude-Session: https://claude.ai/code/session_01JNnE9qzUZMMnqpZWCqM3nb * test(mobile): repin and re-record the corpus over the tasks domain's checked readers Repins `baseline` tod4cfac98b4, the commit that landed the checked readers, and re-records all 760 goldens. The repin rewrites that header on every file; the recorder edit below rewrites `recorderSha256` on every file too. The disclosed behaviour change is the body-moved set and nothing else: the malformed reply partitions of the families whose readers this branch converted. Two recorder files move with it, both re-anchoring evidence the checked readers displaced rather than deleted: - `pilot-recordings.test.ts` restates the b2 seed. The shipped null result is still the seed and the screen still reports an error the user can see; what moved is the sentence, from V8's "Cannot read properties of null (reading 'ok')" to the reply and method the reader names. - `operation-mutations.ts` re-anchors that seed's `acceptance` mutant. Its defect is a null envelope reaching the metadata sheet, and the call-site guard it was injected at can no longer see one, because the reader refuses the envelope first. The anchor is the schema now, and loosening it to `z.unknown()` puts the null back on the path to `result.ok` — the same defect at its new home. Claude-Session: https://claude.ai/code/session_01JNnE9qzUZMMnqpZWCqM3nb * test(mobile): assert the reply-schema pins without type assertions The changed-code casting gate counts a `as` in a test like any other, and eight of them had crept into the new schema pins. Each is replaced by an assertion that reads the same fact off the typed value: the schema already declares `worktreeCreateIdempotency`, `glab`, `status` and `error`, so the narrowing was never needed, and the two "is this key present" checks are JSON comparisons, which is the honest way to ask — `JSON.stringify` drops an absent key and keeps an explicit null, which is the whole distinction a tri-state pin is making. Claude-Session: https://claude.ai/code/session_01JNnE9qzUZMMnqpZWCqM3nb * test(mobile): repin the corpus to the tree it was recorded from The previous repin namedd4cfac98b4, and the assertion cleanup that followed it touched `mobile/src` — a fenced path — so the header pointed at a tree the working copy no longer was. Repins to6b740c3f61and re-records. Bodies are unchanged: only `baseline` moves, on all 760 goldens. Four test files cannot reach a recording, which is the point — the fence does not know that, and a header that names a tree nobody can reproduce is the one claim it exists to make. Claude-Session: https://claude.ai/code/session_01JNnE9qzUZMMnqpZWCqM3nb * docs(mobile): point the reply schemas' consumer citations at the landed lines Every requirement in the five schema modules names the consumer line that justifies it, and the migration moved those lines: deleting a thirty-line inline cast type shifts everything under it. The citations now resolve against the tree they ship in. Comment-only. No schema, no reader and no consumer changes. Claude-Session: https://claude.ai/code/session_01JNnE9qzUZMMnqpZWCqM3nb * test(mobile): repin the corpus to the tree the citations landed in `baseline` follows the last commit to touch a fenced path, and the citation fix did. Bodies unchanged: `baseline` moves on all 760 goldens and nothing else. Claude-Session: https://claude.ai/code/session_01JNnE9qzUZMMnqpZWCqM3nb * test(mobile): pin both reader vocabularies against the host's own unions The two enums these readers declare were checked against mobile's restatement of the wire, not against the types the handlers return. A closed enum written from the wrong vocabulary drops every row that carries an arm it omits, and no golden can catch it when no fixture carries one. Both arm sets are now keyed by the host type in a Record, so an arm added to or removed from SshConnectionStatus or GitHubProjectOwnerType fails tsc before any test runs. The SSH degrade's inertness is pinned at the gate that reads it rather than argued in a comment: an arm a newer host sends and the degraded value reach the same label, the same readiness verdict and the same error. Also corrects a comment claiming the file-mutation owner check reads members this schema forwards. It asks ssh.getState through a reader of its own, and no mobile code reads providerEpoch, supportsFolderDownload or remotePlatform. Claude-Session: https://claude.ai/code/session_01JNnE9qzUZMMnqpZWCqM3nb * test(mobile): repin the corpus to the tree the vocabulary pins landed in Comments and tests cannot change a decoded value, so the whole delta is the baseline header key: 760 goldens, one line each, no body moves and no scenario or adapter change. Claude-Session: https://claude.ai/code/session_01JNnE9qzUZMMnqpZWCqM3nb * test(mobile): record real provider rows in the smart-search and paste fixtures The smart-search and paste-lookup scenarios carried hand-written stubs, not rows any handler can build: Linear issues of `{ id }` alone, GitHub items of `{ number, title }`, and a GitLab item keyed by `iid`, a member neither work-item type declares. Every one of them omits members the host's own types declare non-optional and mobile then reads with no guard, so the corpus was evidence for a requirement it could never have justified. The rows are now the shapes the corpus already uses elsewhere (`tk-list-linear`, `tk-provider-load`, `tk-list-gitlab-items`), checked member for member against LinearIssue (src/shared/linear/issue-types.ts:3), GitHubWorkItem (src/shared/github/work-item-types.ts:17) and GitLabWorkItem (src/shared/gitlab-types.ts:165). No schema moves in this commit. It records what main renders for a real row, so the requirement that follows can be read against main's own behaviour rather than against a stub. Claude-Session: https://claude.ai/code/session_01JNnE9qzUZMMnqpZWCqM3nb * refactor(mobile): require the members the tasks readers' consumers read unguarded Round-1 review found four unguarded consumer reads at members the corpus proves the host sends, plus two the corrected fixtures now prove. Each one ends in a TypeError inside a render or a useMemo, which is the defect class this migration exists to close. Required, each because a consumer reads it with no guard and the host's own type declares it non-optional: title on an accessible project project.title.toLowerCase() name, directories on a preset localeCompare, and two joins labels on a work-item row item.source.labels.filter, both label editors state.name, team.name, priority createLinearTask, and the reviewer sort All six sit inside a salvagingArray, so a row that lacks one drops and the list survives. The single-row paste lookup names the reply instead, because there is no list for it to survive in. Loosened in the other direction: the SSH record no longer requires `error` or `reconnectAttempt`. Nothing reads either one — the gate spells `matchingState?.error ?? null` and nothing anywhere reads reconnectAttempt — and the record is a salvagedOptional, so requiring an unread member drops the WHOLE record, whose fallback on the connect path is `fallbackSshState(id,'connected')`. A reply of `{ targetId, status: 'auth-failed', error }` would have shown the drawer as connected. Mobile's own stored type is widened to match; the shared wire type is untouched. The `iid` extension on the lookup row goes with it. Neither work-item type declares such a member and every GitLab consumer builds its iid param out of `item.source.number`. Claude-Session: https://claude.ai/code/session_01JNnE9qzUZMMnqpZWCqM3nb * test(mobile): repin the screen parity hashes over the merged tree Main landed the sibling tasks lane, which edits the same screen hook files this branch does, so the merged tree hashes to neither side's constant. Both inputs are legitimate: main's reply-schema conversions and this branch's WorkspaceSshRecord rename. Claude-Session: https://claude.ai/code/session_01JNnE9qzUZMMnqpZWCqM3nb * test(mobile): justify the smart-source casts by the schema, not the fixture Five SAFETY notes argued from the corpus back to the wire: they justified a cast by the stub rows the fixtures used to carry (`{ iid, title }`, `{ number: 12, title: 'twelve' }`). Those rows were the defect corrected in6763ff12e9, so the claims are now false, and the reasoning was never sound — a fixture cannot say what the host may send. Each note now cites the schema's own requirement rule, the host type and the consumer read. Comment-only; no golden moves. The hook and statement parity hashes move because `normalized` hashes a statement's full span, comments included. Claude-Session: https://claude.ai/code/session_01JNnE9qzUZMMnqpZWCqM3nb * docs(mobile): repair the line citations this lane's own edits aged Eleven citations across five reply-schema modules pointed at the wrong line. Every one was correct when written and rotted afterwards: the SAFETY-note rewrites, the F4 dedupe's deleted casts and the sibling lane's merge each shifted the files being cited. A citation is the whole argument for a requirement, so a stale one reads as a fabricated one. Found by resolving every `file.ts:line` in the five modules against the merged tree and comparing the line's text to the claim beside it, not by reading them. The ones that still resolve correctly are left alone, including three that looked stale and were not. Claude-Session: https://claude.ai/code/session_01JNnE9qzUZMMnqpZWCqM3nb * fix(mobile): keep the two advisory task probes total so a nullish payload cannot unhydrate the screen `preflight.check` and `linear.status` are read under `success-result-or-skip` and documented as advisory. That policy accepts an envelope whose `result` is absent or null, then asks the reader to decode it; a `looseObject` refuses, the throw leaves the reader, and the caller's catch discards the entire hydration. The corpus records the difference: on the `result-absent` and `result-null` partitions main hydrates the Tasks screen and lists one provider, and the checked readers left it unhydrated with no providers. `.catch` restores main's answer exactly. Every consumer guards to the leaf and compares to `true`, so absence, null and a garbage payload have always meant "not installed" and "not connected". Four cases pin it, and removing either catch fails all four. Claude-Session: https://claude.ai/code/session_01JNnE9qzUZMMnqpZWCqM3nb * test(mobile): re-record the RPC corpus at this lane's head Repins the recording baseline tob354d1338a(the advisory-probe totality fix) and records all 382 scenarios from that tree. Claude-Session: https://claude.ai/code/session_01JNnE9qzUZMMnqpZWCqM3nb * test(mobile): re-record the RPC corpus after merging main Repins the recording baseline to the merge commit and records all 386 scenarios from that tree, so the corpus carries both main's step-7 batch and this lane's. Claude-Session: https://claude.ai/code/session_01JNnE9qzUZMMnqpZWCqM3nb * refactor(mobile): drop the Linear row cast the checked schema made unnecessary `found` is already assignable to the mobile `LinearMobileIssue` alias once `linearIssueRowSchema` requires its nine members, so the assertion and its disable line carried no type error. The sibling cast in smart-source-search-requests.ts stays: it targets the shared `LinearIssue`, whose `labelIds` is required where the schema leaves it optional. Claude-Session: https://claude.ai/code/session_01JNnE9qzUZMMnqpZWCqM3nb * docs(mobile): rewrite the SAFETY lines that argued from deleted fixtures Three casts still justified themselves with the `{ id }` and `{ number, title }` rows this branch replaced in round 1, which reads as a licence to loosen the requirements that close the reproduced crashes. Each now names what its schema requires and what the cast actually covers, each verified by deleting the cast and reading the error: - Linear rows: all nine read members are required, so `labelIds` alone is the gap between the schema and the shared LinearIssue. - GitHub search: `items` and eight row members are required; the salvaged `T | undefined` types and the deliberately opaque `sources`/`errors` are what remain. - Sparse presets: `id`, `name` and `directories` are required; the cast covers the three SparsePreset declares that the reply omits. Claude-Session: https://claude.ai/code/session_01JNnE9qzUZMMnqpZWCqM3nb * docs(mobile): resolve the bare :NN citations the first audit could not see The earlier repair resolved only qualified `file.ts:line` citations, and these doc blocks name a file once and then reference it as a bare `:NN`, so every continuation reference went unchecked. Re-running the audit with a resolver that carries the last-named file and directory forward finds twelve stale line numbers and four references whose nearest named file is the wrong one. Fixed: the four `find`/`filter` lines and the layout equality tests under the `views` requirement, the settings commit, the detail refusal throw, and the three metadata guarded reads, all shifted by one to five lines. The ui-state, paste-resolved and host-method references are now qualified, because an intervening citation to another file silently reassigned them. Claude-Session: https://claude.ai/code/session_01JNnE9qzUZMMnqpZWCqM3nb * test(mobile): re-pin the tasks parity hashes the round-2 fixes moved One statement changed (the Linear list cast is gone) and three SAFETY comments nested inside statements were rewritten, so the hook and statement hashes move. Counts hold at 350 and 417, and the declaration, semantic, render and style hashes do not move, which is what shows no type, call or rendered tree changed with them. Claude-Session: https://claude.ai/code/session_01JNnE9qzUZMMnqpZWCqM3nb * refactor(mobile): delete the Linear list reader the checked schema replaced `extractLinearIssueReadItems` lost its only caller when the smart-search operation moved to `rpcResultVariant('linear-issues', …)`. What remained was a function no screen can reach, a suite reporting coverage for it, and a second 'Unexpected Linear tasks response' string competing with the named reply error. The `LinearMobileIssue` type stays: it is the mobile `LinearIssue` alias. Claude-Session: https://claude.ai/code/session_01JNnE9qzUZMMnqpZWCqM3nb * docs(mobile): say what a refused sparse-preset list actually does to the screen "Reports the named error" overstates it: the error setter's value is destructured with a leading underscore and read by nobody, here and on main. The visible delta is `presetsLoaded` staying false, which disables "New preset" and both draft entry points where main let the user create one. No shipped host reaches the state: `repo.sparsePresets` has no refusal arm. Claude-Session: https://claude.ai/code/session_01JNnE9qzUZMMnqpZWCqM3nb * test(mobile): re-record the RPC corpus after the round-2 fixes Repins to the round-2 head and records all 386 scenarios from it. Claude-Session: https://claude.ai/code/session_01JNnE9qzUZMMnqpZWCqM3nb * test(mobile): re-record the RPC corpus after merging main at7a1f55c52aClaude-Session: https://claude.ai/code/session_01JNnE9qzUZMMnqpZWCqM3nb * fix(mobile): keep the persisted-ui-state reader total so an unreadable ui reply cannot unhydrate the Tasks screen Main boxed the payload and read `undefined` off a string, number or array, so the screen hydrated; a refusal here threw out of hydrateTaskState and failed the settings, preflight and Linear legs beside it. Null and absent now hydrate with the defaults too, since every read of the state is optional. The GitHub search SAFETY line separates the members the schema requires from the ones it only types, and the parity hashes follow that comment text. Claude-Session: https://claude.ai/code/session_01JNnE9qzUZMMnqpZWCqM3nb * test(mobile): re-record the RPC corpus over the total ui-state reader Claude-Session: https://claude.ai/code/session_01JNnE9qzUZMMnqpZWCqM3nb
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 port8081.
Unless a command says otherwise, run mobile app commands from the mobile/ directory.
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 exec expo run:android
pnpm exec expo run:ios
pnpm start --dev-client
Pair With Desktop Orca
- Open Orca desktop.
- Go to Settings > Mobile.
- Scan the pairing QR code from the mobile app.
- 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
- Install Expo Go from Google Play
- Run
pnpm start, scan QR with Expo Go - For native modules:
pnpm exec expo run:android - Run with
pnpm start --dev-client
iOS Simulator
- Install Xcode from the App Store
- Run
pnpm start --iosto 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 lint
cd ..
pnpm typecheck:node
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_VERSIONmobile/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 either the App Store (mobile too old) or GitHub Releases (desktop too old).
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— withMOCK_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 omitstranscriptPathto 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(defaultorca-mock-send-modein the system temporary directory) —accept(default) accepts the send,errorfails it withmobile_input_floor_unavailable, anything else reports the send as rejected.MOCK_TERMINAL_LIST_MODE_FILE(defaultorca-mock-terminal-list-modein the system temporary directory) —omitreturns an empty terminal list,otherreturns a list that omits the chat handle, anything else lists it.MOCK_TERMINAL_STREAM_MODE_FILE(defaultorca-mock-terminal-stream-modein the system temporary directory) —deadanswers a subscribe withsubscribedthenend(a gone PTY), which is what exercises the rearm bound and terminal prune; anything else streams normally.
Connecting to Real Orca
- Start Orca desktop with WebSocket transport enabled
- In Orca, go to Settings > Mobile and scan the QR code with this app
- 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