01
Control Center
Pair with Relay, manage known servers, reconnect quickly, and keep the active endpoint clear before diving into a thread.
Relay-backed Codex workflow on iPhone
Pair Once. Keep Your Threads Moving.
Irisbrige is a SwiftUI iOS client for Relay-backed Codex App Server workflows. Pair securely, open live thread sessions, review approvals, and continue work from your phone.
Relay connected
$ thread/group/list
Current thread
turn/start • turn/steer • turn/interrupt
Live activity
fileChange • commandExecution • requestUserInput
Pending request
Review and continue
Features
Built Around the Mobile Relay Loop.
The current Irisbrige codebase focuses on secure pairing, thread control, approvals, and the day-to-day flow of working with Relay from iOS.
Secure Relay Pairing
Scan a pairing QR code or paste a token manually, then complete the handshake against Relay with the current device identity.
Persistent Device Identity
Irisbrige keeps a stable device ID and an Ed25519 keypair locally with Keychain and CryptoKit for challenge signing.
Multi-Server History
Known Relay servers can be selected, connected, disconnected, renamed, inspected, and removed from one control surface.
Live Thread Workspace
Browse thread groups by working directory, reopen cached history, and continue assistant conversations from an iPhone UI.
Approval Handling
Review command execution, file change, permission, and basic request-user-input flows without leaving the conversation.
Directory-Aware Creation
Use RPC-backed directory browsing to create project folders and start a fresh thread directly in the target workspace.
Challenge + WebSocket Transport
The app covers challenge-based authentication, authenticated WebSocket setup, connection lifecycle management, and reconnect behavior.
APNs Token Sync
When iOS provides an APNs device token, Irisbrige can sync it to Relay as part of the authenticated device flow.
Appearance and Transport Controls
Switch appearance mode, open system settings, inspect device information, clear logs, and enable insecure TLS for local or self-signed Relay endpoints.
Workflow
Three Surfaces. One Mobile Operator View.
The app is structured around the actual iOS flow: pair and manage endpoints, work inside live threads, then inspect detail and request state when something needs attention.
02
Thread Workspace
Open grouped history, create threads inside directories, send new turns, steer active turns, and interrupt long-running work.
03
Detail and Request Ledger
Inspect metadata, pending approvals, request state, and the raw event ledger when you need the full conversation trail.
Coverage
Implemented Surface Today
The current repository already covers the main mobile loop for a Relay-backed Codex workflow and makes its unsupported edges explicit.
HTTP Pairing and Auth
Pairing completion, auth challenge requests, APNs token upload, and authenticated WebSocket connection are part of the current app flow.
RPC Thread Flow
The app covers initialize, thread start/list/read/resume, turn start/steer/interrupt, grouped history, and directory RPC calls.
Interactive Requests
Command approvals, file change approvals, permission approvals, and basic item/tool/requestUserInput forms are handled in the client.
FAQ
Frequently Asked Questions
What is Irisbrige?
Irisbrige is a SwiftUI iOS client for Relay-backed Codex App Server workflows. Its goal is to let an iPhone pair with Relay, authenticate with a persistent device identity, and keep Codex threads usable from mobile.
How does pairing work?
The app reads an Irisbrige pairing QR payload or manual token, completes pairing with the device public key, requests a challenge, signs it locally, and then opens an authenticated WebSocket session to Relay.
What can I do in the app today?
You can manage Relay servers, browse grouped thread history, create threads inside directories, continue conversations, steer or interrupt turns, inspect metadata, and handle the main approval flows from iOS.
Does the iPhone connect directly to my Mac?
No. The intended architecture is relay plus edge: iOS connects only to Relay over HTTPS and WSS, while the macOS edge keeps its own outbound connection to Relay and talks to Codex App Server locally.
What is still missing or intentionally limited?
The current codebase still lacks a dedicated Relay health screen, does not fully support mcpServer/elicitation/request or item/tool/call, and only has modest UI automation coverage.