codex-relay 1.3.1 → 1.4.0

package/README.md

@@ -28,6 +28,36 @@ npx codex-relay@latest approve XXXX-XXXX
 
 After approval, the phone can list Codex threads, start new work, stream messages, and handle approval prompts from the local Codex runtime.
 
+## Shared Terminal and Mobile Sessions
+
+By default, Codex Relay starts a private app-server process. A terminal TUI that was started separately can resume the same saved thread, but it does not receive the relay process's live events.
+
+Opt in to Codex's shared app-server:
+
+```sh
+npx codex-relay@latest --shared-app-server
+```
+
+When a shared app-server is already running, the relay attaches to it instead of starting another one. If the relay's own socket connection resets, it reconnects without deliberately stopping the shared app-server.
+
+Then connect a new terminal TUI to the shared app-server. On macOS, Linux, or WSL:
+
+```sh
+codex resume --remote unix://
+```
+
+On native Windows, use the loopback WebSocket endpoint:
+
+```powershell
+codex resume --remote ws://127.0.0.1:8788
+```
+
+Pass a thread ID after the remote endpoint to open a specific thread. The relay prints the attach command at startup. Mobile and the connected terminal can then observe the same live sessions through one socket-backed app-server. An already-running standalone TUI cannot be converted in place; exit it and reconnect with `--remote`.
+
+Shared mode uses Codex's experimental app-server transport. A directly connected terminal TUI has its own WebSocket connection, which the relay cannot observe or reconnect. If that terminal reports a socket reset while the thread continues on mobile, reconnect it with the matching remote endpoint above and append the thread ID if needed.
+
+Shared mode requires a recent Codex CLI with app-server and `resume --remote` support. It uses a Unix socket on macOS, Linux, and WSL, or a loopback-only WebSocket on Windows. If those features are unavailable, update Codex or omit `--shared-app-server` to keep the existing private mode.
+
 ## Background Mode
 
 To keep the relay running after the command returns:
@@ -69,6 +99,12 @@ npx codex-relay@latest --bg
 
 Start the relay in the background.
 
+```sh
+npx codex-relay@latest --shared-app-server
+```
+
+Start the relay through Codex's shared app-server socket.
+
 ```sh
 npx codex-relay@latest qr
 ```
@@ -99,6 +135,7 @@ The relay listens on `0.0.0.0:8787` by default. Configure it with environment va
 | `CODEX_RELAY_AUTH_DB_PATH`             | Pairing and session database path. Defaults to `.codex-relay/auth.db`.                             |
 | `CODEX_RELAY_APPROVAL_SECRET`          | Secret used by the local approve command. Usually generated automatically.                         |
 | `CODEX_RELAY_DANGEROUSLY_AUTO_APPROVE` | Set to `1` to auto-approve mobile pairing requests. Prefer the CLI flag for local use.             |
+| `CODEX_RELAY_APP_SERVER_MODE`          | Set to `socket` for shared terminal/mobile sessions. Defaults to `stdio`.                          |
 | `CODEX_HOME`                           | Codex home directory, used when reading Codex session metadata.                                    |
 | `CODEX_BIN`                            | Codex CLI executable path.                                                                         |
 

package/dist/api-schema.js

@@ -1,2 +1,2 @@
-import { $ as RuntimePreferencesSchema, A as PairRequestSchema, At as WorkspacePreviewTabSchema, B as QueuedThreadInputActionResponseSchema, Bt as apiPaths, C as ListModelsResponseSchema, Ct as WorkspaceChangesResponseSchema, D as ListWorkspaceDirectoriesResponseSchema, Dt as WorkspaceGitActionResponseSchema, E as ListThreadsResponseSchema, Et as WorkspaceFileMentionSchema, F as PromptAttachmentSchema, Ft as WorkspaceTerminalOutputChunkSchema, G as ReasoningEffortSchema, Gt as promptMarkdownWithSkills, H as RateLimitBucketSchema, Ht as createOpenApiDocument, I as PromptAttachmentSummarySchema, It as WorkspaceTerminalOutputResponseSchema, J as RunThreadRequestSchema, Jt as promptSkillMentionMarkdown, K as ResolveApprovalRequestSchema, Kt as promptSkillDisplayName, L as PromptContextInputSchema, Lt as WorkspaceTerminalResizeRequestSchema, M as PendingInputRequestOptionSchema, Mt as WorkspaceTailscaleServeRequestSchema, N as PendingInputRequestQuestionSchema, Nt as WorkspaceTailscaleServeResponseSchema, O as ListWorkspaceFilesResponseSchema, Ot as WorkspaceMarkdownPreviewTargetSchema, P as PendingInputRequestSchema, Pt as WorkspaceTerminalInputRequestSchema, Q as RuntimePreferencesResponseSchema, R as PromptContextSchema, Rt as WorkspaceTerminalSessionResponseSchema, S as KnownReasoningEffortSchema, St as WebPreviewTargetSchema, T as ListSkillsResponseSchema, Tt as WorkspaceFileContentResponseSchema, U as RateLimitWindowSchema, Ut as isPromptSkillMarkdownMention, V as QueuedThreadInputSchema, Vt as chatMessageDetailsFromPromptContext, W as RateLimitsResponseSchema, Wt as normalizePromptContext, X as RuntimeModeSchema, Xt as stripPromptSkillMentions, Y as RunThreadResponseSchema, Yt as promptSkillMentionTextCandidates, Z as RuntimePreferencesByWorkspacePathSchema, _ as EncryptedPayloadSchema, _t as UpdateThreadGoalRequestSchema, a as ArchiveThreadResponseSchema, at as ThreadCollaborationModeSchema, b as InterruptThreadRunResponseSchema, bt as WORKSPACE_PREVIEW_OPEN_PROTOCOL, c as ChatMessageRoleSchema, ct as ThreadGoalResponseSchema, d as CheckoutWorkspaceBranchRequestSchema, dt as ThreadMessageDetailFieldSchema, et as SandboxModeSchema, f as CodexModelSchema, ft as ThreadMessageDetailResponseSchema, g as CreateThreadResponseSchema, gt as UpdateRuntimePreferencesRequestSchema, h as CreateThreadRequestSchema, ht as ThreadSummarySchema, i as ApprovalModeSchema, it as SubmitThreadInputResponseSchema, j as PairResponseSchema, jt as WorkspaceSelectionRequestSchema, k as PairEncryptedPayloadSchema, kt as WorkspacePreviewNavigationRequestSchema, l as ChatMessageSchema, lt as ThreadGoalSchema, m as ContextWindowUsageSchema, mt as ThreadStateSchema, n as AgentSkillSourceSchema, nt as StreamThreadRunEventSchema, o as ChatMessageKindSchema, ot as ThreadContextWindowResponseSchema, p as CommitPushWorkspaceRequestSchema, pt as ThreadRunOptionsSchema, q as ResolveApprovalResponseSchema, qt as promptSkillMentionLabel, r as ApprovalDecisionSchema, rt as StreamThreadRunRequestSchema, s as ChatMessagePromptDetailsSchema, st as ThreadDetailResponseSchema, t as AgentSkillSchema, tt as StatusResponseSchema, u as ChatMessageStateSchema, ut as ThreadGoalStatusSchema, v as ErrorResponseSchema, vt as UpdateWorkspaceFileContentRequestSchema, w as ListQueuedThreadInputsResponseSchema, wt as WorkspaceDirectoryEntrySchema, x as IsoDateTimeSchema, xt as WORKSPACE_PREVIEW_TAB_VALUES, y as ImageAttachmentUploadResponseSchema, yt as VersionResponseSchema, z as PromptSkillSchema, zt as WorkspaceTerminalStartRequestSchema } from "./api-schema2.js";
-export { AgentSkillSchema, AgentSkillSourceSchema, ApprovalDecisionSchema, ApprovalModeSchema, ArchiveThreadResponseSchema, ChatMessageKindSchema, ChatMessagePromptDetailsSchema, ChatMessageRoleSchema, ChatMessageSchema, ChatMessageStateSchema, CheckoutWorkspaceBranchRequestSchema, CodexModelSchema, CommitPushWorkspaceRequestSchema, ContextWindowUsageSchema, CreateThreadRequestSchema, CreateThreadResponseSchema, EncryptedPayloadSchema, ErrorResponseSchema, ImageAttachmentUploadResponseSchema, InterruptThreadRunResponseSchema, IsoDateTimeSchema, KnownReasoningEffortSchema, ListModelsResponseSchema, ListQueuedThreadInputsResponseSchema, ListSkillsResponseSchema, ListThreadsResponseSchema, ListWorkspaceDirectoriesResponseSchema, ListWorkspaceFilesResponseSchema, PairEncryptedPayloadSchema, PairRequestSchema, PairResponseSchema, PendingInputRequestOptionSchema, PendingInputRequestQuestionSchema, PendingInputRequestSchema, PromptAttachmentSchema, PromptAttachmentSummarySchema, PromptContextInputSchema, PromptContextSchema, PromptSkillSchema, QueuedThreadInputActionResponseSchema, QueuedThreadInputSchema, RateLimitBucketSchema, RateLimitWindowSchema, RateLimitsResponseSchema, ReasoningEffortSchema, ResolveApprovalRequestSchema, ResolveApprovalResponseSchema, RunThreadRequestSchema, RunThreadResponseSchema, RuntimeModeSchema, RuntimePreferencesByWorkspacePathSchema, RuntimePreferencesResponseSchema, RuntimePreferencesSchema, SandboxModeSchema, StatusResponseSchema, StreamThreadRunEventSchema, StreamThreadRunRequestSchema, SubmitThreadInputResponseSchema, ThreadCollaborationModeSchema, ThreadContextWindowResponseSchema, ThreadDetailResponseSchema, ThreadGoalResponseSchema, ThreadGoalSchema, ThreadGoalStatusSchema, ThreadMessageDetailFieldSchema, ThreadMessageDetailResponseSchema, ThreadRunOptionsSchema, ThreadStateSchema, ThreadSummarySchema, UpdateRuntimePreferencesRequestSchema, UpdateThreadGoalRequestSchema, UpdateWorkspaceFileContentRequestSchema, VersionResponseSchema, WORKSPACE_PREVIEW_OPEN_PROTOCOL, WORKSPACE_PREVIEW_TAB_VALUES, WebPreviewTargetSchema, WorkspaceChangesResponseSchema, WorkspaceDirectoryEntrySchema, WorkspaceFileContentResponseSchema, WorkspaceFileMentionSchema, WorkspaceGitActionResponseSchema, WorkspaceMarkdownPreviewTargetSchema, WorkspacePreviewNavigationRequestSchema, WorkspacePreviewTabSchema, WorkspaceSelectionRequestSchema, WorkspaceTailscaleServeRequestSchema, WorkspaceTailscaleServeResponseSchema, WorkspaceTerminalInputRequestSchema, WorkspaceTerminalOutputChunkSchema, WorkspaceTerminalOutputResponseSchema, WorkspaceTerminalResizeRequestSchema, WorkspaceTerminalSessionResponseSchema, WorkspaceTerminalStartRequestSchema, apiPaths, chatMessageDetailsFromPromptContext, createOpenApiDocument, isPromptSkillMarkdownMention, normalizePromptContext, promptMarkdownWithSkills, promptSkillDisplayName, promptSkillMentionLabel, promptSkillMentionMarkdown, promptSkillMentionTextCandidates, stripPromptSkillMentions };
+import { $ as RunThreadResponseSchema, $t as promptSkillMentionTextCandidates, A as PairRequestSchema, At as WorkspaceFileMentionSchema, B as PushNotificationIntentSchema, Bt as WorkspaceTerminalOutputResponseSchema, C as ListModelsResponseSchema, Ct as VersionResponseSchema, D as ListWorkspaceDirectoriesResponseSchema, Dt as WorkspaceChangesResponseSchema, E as ListThreadsResponseSchema, Et as WebPreviewTargetSchema, F as PromptAttachmentSchema, Ft as WorkspaceSelectionRequestSchema, G as RateLimitBucketSchema, Gt as chatMessageDetailsFromPromptContext, H as PushNotificationSettingsResponseSchema, Ht as WorkspaceTerminalSessionResponseSchema, I as PromptAttachmentSummarySchema, It as WorkspaceTailscaleServeRequestSchema, J as ReasoningEffortSchema, Jt as normalizePromptContext, K as RateLimitWindowSchema, Kt as createOpenApiDocument, L as PromptContextInputSchema, Lt as WorkspaceTailscaleServeResponseSchema, M as PendingInputRequestOptionSchema, Mt as WorkspaceMarkdownPreviewTargetSchema, N as PendingInputRequestQuestionSchema, Nt as WorkspacePreviewNavigationRequestSchema, O as ListWorkspaceFilesResponseSchema, Ot as WorkspaceDirectoryEntrySchema, P as PendingInputRequestSchema, Pt as WorkspacePreviewTabSchema, Q as RunThreadRequestSchema, Qt as promptSkillMentionMarkdown, R as PromptContextSchema, Rt as WorkspaceTerminalInputRequestSchema, S as KnownReasoningEffortSchema, St as UpdateWorkspaceFileContentRequestSchema, T as ListSkillsResponseSchema, Tt as WORKSPACE_PREVIEW_TAB_VALUES, U as QueuedThreadInputActionResponseSchema, Ut as WorkspaceTerminalStartRequestSchema, V as PushNotificationPreferencesSchema, Vt as WorkspaceTerminalResizeRequestSchema, W as QueuedThreadInputSchema, Wt as apiPaths, X as ResolveApprovalRequestSchema, Xt as promptSkillDisplayName, Y as RegisterPushNotificationRequestSchema, Yt as promptMarkdownWithSkills, Z as ResolveApprovalResponseSchema, Zt as promptSkillMentionLabel, _ as EncryptedPayloadSchema, _t as ThreadRunOptionsSchema, a as ArchiveThreadResponseSchema, at as StatusResponseSchema, b as InterruptThreadRunResponseSchema, bt as UpdateRuntimePreferencesRequestSchema, c as ChatMessageRoleSchema, ct as SubmitThreadInputResponseSchema, d as CheckoutWorkspaceBranchRequestSchema, dt as ThreadDetailResponseSchema, en as stripPromptSkillMentions, et as RuntimeModeSchema, f as CodexModelSchema, ft as ThreadGoalResponseSchema, g as CreateThreadResponseSchema, gt as ThreadMessageDetailResponseSchema, h as CreateThreadRequestSchema, ht as ThreadMessageDetailFieldSchema, i as ApprovalModeSchema, it as SandboxModeSchema, j as PairResponseSchema, jt as WorkspaceGitActionResponseSchema, k as PairEncryptedPayloadSchema, kt as WorkspaceFileContentResponseSchema, l as ChatMessageSchema, lt as ThreadCollaborationModeSchema, m as ContextWindowUsageSchema, mt as ThreadGoalStatusSchema, n as AgentSkillSourceSchema, nt as RuntimePreferencesResponseSchema, o as ChatMessageKindSchema, ot as StreamThreadRunEventSchema, p as CommitPushWorkspaceRequestSchema, pt as ThreadGoalSchema, q as RateLimitsResponseSchema, qt as isPromptSkillMarkdownMention, r as ApprovalDecisionSchema, rt as RuntimePreferencesSchema, s as ChatMessagePromptDetailsSchema, st as StreamThreadRunRequestSchema, t as AgentSkillSchema, tt as RuntimePreferencesByWorkspacePathSchema, u as ChatMessageStateSchema, ut as ThreadContextWindowResponseSchema, v as ErrorResponseSchema, vt as ThreadStateSchema, w as ListQueuedThreadInputsResponseSchema, wt as WORKSPACE_PREVIEW_OPEN_PROTOCOL, x as IsoDateTimeSchema, xt as UpdateThreadGoalRequestSchema, y as ImageAttachmentUploadResponseSchema, yt as ThreadSummarySchema, z as PromptSkillSchema, zt as WorkspaceTerminalOutputChunkSchema } from "./api-schema2.js";
+export { AgentSkillSchema, AgentSkillSourceSchema, ApprovalDecisionSchema, ApprovalModeSchema, ArchiveThreadResponseSchema, ChatMessageKindSchema, ChatMessagePromptDetailsSchema, ChatMessageRoleSchema, ChatMessageSchema, ChatMessageStateSchema, CheckoutWorkspaceBranchRequestSchema, CodexModelSchema, CommitPushWorkspaceRequestSchema, ContextWindowUsageSchema, CreateThreadRequestSchema, CreateThreadResponseSchema, EncryptedPayloadSchema, ErrorResponseSchema, ImageAttachmentUploadResponseSchema, InterruptThreadRunResponseSchema, IsoDateTimeSchema, KnownReasoningEffortSchema, ListModelsResponseSchema, ListQueuedThreadInputsResponseSchema, ListSkillsResponseSchema, ListThreadsResponseSchema, ListWorkspaceDirectoriesResponseSchema, ListWorkspaceFilesResponseSchema, PairEncryptedPayloadSchema, PairRequestSchema, PairResponseSchema, PendingInputRequestOptionSchema, PendingInputRequestQuestionSchema, PendingInputRequestSchema, PromptAttachmentSchema, PromptAttachmentSummarySchema, PromptContextInputSchema, PromptContextSchema, PromptSkillSchema, PushNotificationIntentSchema, PushNotificationPreferencesSchema, PushNotificationSettingsResponseSchema, QueuedThreadInputActionResponseSchema, QueuedThreadInputSchema, RateLimitBucketSchema, RateLimitWindowSchema, RateLimitsResponseSchema, ReasoningEffortSchema, RegisterPushNotificationRequestSchema, ResolveApprovalRequestSchema, ResolveApprovalResponseSchema, RunThreadRequestSchema, RunThreadResponseSchema, RuntimeModeSchema, RuntimePreferencesByWorkspacePathSchema, RuntimePreferencesResponseSchema, RuntimePreferencesSchema, SandboxModeSchema, StatusResponseSchema, StreamThreadRunEventSchema, StreamThreadRunRequestSchema, SubmitThreadInputResponseSchema, ThreadCollaborationModeSchema, ThreadContextWindowResponseSchema, ThreadDetailResponseSchema, ThreadGoalResponseSchema, ThreadGoalSchema, ThreadGoalStatusSchema, ThreadMessageDetailFieldSchema, ThreadMessageDetailResponseSchema, ThreadRunOptionsSchema, ThreadStateSchema, ThreadSummarySchema, UpdateRuntimePreferencesRequestSchema, UpdateThreadGoalRequestSchema, UpdateWorkspaceFileContentRequestSchema, VersionResponseSchema, WORKSPACE_PREVIEW_OPEN_PROTOCOL, WORKSPACE_PREVIEW_TAB_VALUES, WebPreviewTargetSchema, WorkspaceChangesResponseSchema, WorkspaceDirectoryEntrySchema, WorkspaceFileContentResponseSchema, WorkspaceFileMentionSchema, WorkspaceGitActionResponseSchema, WorkspaceMarkdownPreviewTargetSchema, WorkspacePreviewNavigationRequestSchema, WorkspacePreviewTabSchema, WorkspaceSelectionRequestSchema, WorkspaceTailscaleServeRequestSchema, WorkspaceTailscaleServeResponseSchema, WorkspaceTerminalInputRequestSchema, WorkspaceTerminalOutputChunkSchema, WorkspaceTerminalOutputResponseSchema, WorkspaceTerminalResizeRequestSchema, WorkspaceTerminalSessionResponseSchema, WorkspaceTerminalStartRequestSchema, apiPaths, chatMessageDetailsFromPromptContext, createOpenApiDocument, isPromptSkillMarkdownMention, normalizePromptContext, promptMarkdownWithSkills, promptSkillDisplayName, promptSkillMentionLabel, promptSkillMentionMarkdown, promptSkillMentionTextCandidates, stripPromptSkillMentions };

package/dist/api-schema2.js

@@ -104,6 +104,20 @@ const RuntimePreferencesResponseSchema = z.object({
 	threadId: z.string().trim().min(1).optional(),
 	workspacePath: z.string().trim().min(1).optional()
 });
+const PushNotificationIntentSchema = z.enum(["turn_terminal", "action_required"]);
+const PushNotificationPreferencesSchema = z.object({
+	actionRequired: z.boolean(),
+	turnTerminal: z.boolean()
+});
+const RegisterPushNotificationRequestSchema = z.object({
+	expoPushToken: z.string().trim().regex(/^(?:Expo|Exponent)PushToken\[[^\]\r\n]{1,512}\]$/),
+	platform: z.enum(["android", "ios"]),
+	preferences: PushNotificationPreferencesSchema
+});
+const PushNotificationSettingsResponseSchema = z.object({
+	preferences: PushNotificationPreferencesSchema,
+	registered: z.boolean()
+});
 const CodexModelSchema = z.object({
 	id: z.string().min(1),
 	model: z.string().min(1),
@@ -721,6 +735,7 @@ const apiPaths = {
 	sessionRefresh: "/v1/session/refresh",
 	status: "/v1/status",
 	preferences: "/v1/preferences",
+	pushNotifications: "/v1/notifications/push",
 	rateLimits: "/v1/rate-limits",
 	models: "/v1/models",
 	skills: "/v1/skills",
@@ -777,6 +792,31 @@ function createOpenApiDocument() {
 					"400": jsonResponse("ErrorResponse")
 				}
 			} },
+			"/v1/notifications/push": {
+				get: {
+					summary: "Read push notification settings for this paired device",
+					responses: {
+						"200": jsonResponse("PushNotificationSettingsResponse"),
+						"401": jsonResponse("ErrorResponse")
+					}
+				},
+				put: {
+					summary: "Register push notifications for this paired device",
+					requestBody: jsonRequest("RegisterPushNotificationRequest"),
+					responses: {
+						"200": jsonResponse("PushNotificationSettingsResponse"),
+						"400": jsonResponse("ErrorResponse"),
+						"401": jsonResponse("ErrorResponse")
+					}
+				},
+				delete: {
+					summary: "Remove push notifications for this paired device",
+					responses: {
+						"200": jsonResponse("PushNotificationSettingsResponse"),
+						"401": jsonResponse("ErrorResponse")
+					}
+				}
+			},
 			"/v1/threads": {
 				get: {
 					summary: "List locally known threads",
@@ -1243,6 +1283,41 @@ function createOpenApiDocument() {
 					workspacePath: { type: "string" }
 				}
 			},
+			PushNotificationPreferences: {
+				type: "object",
+				required: ["actionRequired", "turnTerminal"],
+				properties: {
+					actionRequired: { type: "boolean" },
+					turnTerminal: { type: "boolean" }
+				}
+			},
+			RegisterPushNotificationRequest: {
+				type: "object",
+				required: [
+					"expoPushToken",
+					"platform",
+					"preferences"
+				],
+				properties: {
+					expoPushToken: {
+						type: "string",
+						pattern: "^(?:Expo|Exponent)PushToken\\[[^\\]\\r\\n]{1,512}\\]$"
+					},
+					platform: {
+						type: "string",
+						enum: ["android", "ios"]
+					},
+					preferences: { $ref: "#/components/schemas/PushNotificationPreferences" }
+				}
+			},
+			PushNotificationSettingsResponse: {
+				type: "object",
+				required: ["preferences", "registered"],
+				properties: {
+					preferences: { $ref: "#/components/schemas/PushNotificationPreferences" },
+					registered: { type: "boolean" }
+				}
+			},
 			WorkspaceDirectoryEntry: {
 				type: "object",
 				required: ["name", "path"],
@@ -1725,4 +1800,4 @@ function jsonResponse(schemaName) {
 	};
 }
 //#endregion
-export { RuntimePreferencesSchema as $, PairRequestSchema as A, WorkspacePreviewTabSchema as At, QueuedThreadInputActionResponseSchema as B, apiPaths as Bt, ListModelsResponseSchema as C, WorkspaceChangesResponseSchema as Ct, ListWorkspaceDirectoriesResponseSchema as D, WorkspaceGitActionResponseSchema as Dt, ListThreadsResponseSchema as E, WorkspaceFileMentionSchema as Et, PromptAttachmentSchema as F, WorkspaceTerminalOutputChunkSchema as Ft, ReasoningEffortSchema as G, promptMarkdownWithSkills as Gt, RateLimitBucketSchema as H, createOpenApiDocument as Ht, PromptAttachmentSummarySchema as I, WorkspaceTerminalOutputResponseSchema as It, RunThreadRequestSchema as J, promptSkillMentionMarkdown as Jt, ResolveApprovalRequestSchema as K, promptSkillDisplayName as Kt, PromptContextInputSchema as L, WorkspaceTerminalResizeRequestSchema as Lt, PendingInputRequestOptionSchema as M, WorkspaceTailscaleServeRequestSchema as Mt, PendingInputRequestQuestionSchema as N, WorkspaceTailscaleServeResponseSchema as Nt, ListWorkspaceFilesResponseSchema as O, WorkspaceMarkdownPreviewTargetSchema as Ot, PendingInputRequestSchema as P, WorkspaceTerminalInputRequestSchema as Pt, RuntimePreferencesResponseSchema as Q, PromptContextSchema as R, WorkspaceTerminalSessionResponseSchema as Rt, KnownReasoningEffortSchema as S, WebPreviewTargetSchema as St, ListSkillsResponseSchema as T, WorkspaceFileContentResponseSchema as Tt, RateLimitWindowSchema as U, isPromptSkillMarkdownMention as Ut, QueuedThreadInputSchema as V, chatMessageDetailsFromPromptContext as Vt, RateLimitsResponseSchema as W, normalizePromptContext as Wt, RuntimeModeSchema as X, stripPromptSkillMentions as Xt, RunThreadResponseSchema as Y, promptSkillMentionTextCandidates as Yt, RuntimePreferencesByWorkspacePathSchema as Z, EncryptedPayloadSchema as _, UpdateThreadGoalRequestSchema as _t, ArchiveThreadResponseSchema as a, ThreadCollaborationModeSchema as at, InterruptThreadRunResponseSchema as b, WORKSPACE_PREVIEW_OPEN_PROTOCOL as bt, ChatMessageRoleSchema as c, ThreadGoalResponseSchema as ct, CheckoutWorkspaceBranchRequestSchema as d, ThreadMessageDetailFieldSchema as dt, SandboxModeSchema as et, CodexModelSchema as f, ThreadMessageDetailResponseSchema as ft, CreateThreadResponseSchema as g, UpdateRuntimePreferencesRequestSchema as gt, CreateThreadRequestSchema as h, ThreadSummarySchema as ht, ApprovalModeSchema as i, SubmitThreadInputResponseSchema as it, PairResponseSchema as j, WorkspaceSelectionRequestSchema as jt, PairEncryptedPayloadSchema as k, WorkspacePreviewNavigationRequestSchema as kt, ChatMessageSchema as l, ThreadGoalSchema as lt, ContextWindowUsageSchema as m, ThreadStateSchema as mt, AgentSkillSourceSchema as n, StreamThreadRunEventSchema as nt, ChatMessageKindSchema as o, ThreadContextWindowResponseSchema as ot, CommitPushWorkspaceRequestSchema as p, ThreadRunOptionsSchema as pt, ResolveApprovalResponseSchema as q, promptSkillMentionLabel as qt, ApprovalDecisionSchema as r, StreamThreadRunRequestSchema as rt, ChatMessagePromptDetailsSchema as s, ThreadDetailResponseSchema as st, AgentSkillSchema as t, StatusResponseSchema as tt, ChatMessageStateSchema as u, ThreadGoalStatusSchema as ut, ErrorResponseSchema as v, UpdateWorkspaceFileContentRequestSchema as vt, ListQueuedThreadInputsResponseSchema as w, WorkspaceDirectoryEntrySchema as wt, IsoDateTimeSchema as x, WORKSPACE_PREVIEW_TAB_VALUES as xt, ImageAttachmentUploadResponseSchema as y, VersionResponseSchema as yt, PromptSkillSchema as z, WorkspaceTerminalStartRequestSchema as zt };
+export { RunThreadResponseSchema as $, promptSkillMentionTextCandidates as $t, PairRequestSchema as A, WorkspaceFileMentionSchema as At, PushNotificationIntentSchema as B, WorkspaceTerminalOutputResponseSchema as Bt, ListModelsResponseSchema as C, VersionResponseSchema as Ct, ListWorkspaceDirectoriesResponseSchema as D, WorkspaceChangesResponseSchema as Dt, ListThreadsResponseSchema as E, WebPreviewTargetSchema as Et, PromptAttachmentSchema as F, WorkspaceSelectionRequestSchema as Ft, RateLimitBucketSchema as G, chatMessageDetailsFromPromptContext as Gt, PushNotificationSettingsResponseSchema as H, WorkspaceTerminalSessionResponseSchema as Ht, PromptAttachmentSummarySchema as I, WorkspaceTailscaleServeRequestSchema as It, ReasoningEffortSchema as J, normalizePromptContext as Jt, RateLimitWindowSchema as K, createOpenApiDocument as Kt, PromptContextInputSchema as L, WorkspaceTailscaleServeResponseSchema as Lt, PendingInputRequestOptionSchema as M, WorkspaceMarkdownPreviewTargetSchema as Mt, PendingInputRequestQuestionSchema as N, WorkspacePreviewNavigationRequestSchema as Nt, ListWorkspaceFilesResponseSchema as O, WorkspaceDirectoryEntrySchema as Ot, PendingInputRequestSchema as P, WorkspacePreviewTabSchema as Pt, RunThreadRequestSchema as Q, promptSkillMentionMarkdown as Qt, PromptContextSchema as R, WorkspaceTerminalInputRequestSchema as Rt, KnownReasoningEffortSchema as S, UpdateWorkspaceFileContentRequestSchema as St, ListSkillsResponseSchema as T, WORKSPACE_PREVIEW_TAB_VALUES as Tt, QueuedThreadInputActionResponseSchema as U, WorkspaceTerminalStartRequestSchema as Ut, PushNotificationPreferencesSchema as V, WorkspaceTerminalResizeRequestSchema as Vt, QueuedThreadInputSchema as W, apiPaths as Wt, ResolveApprovalRequestSchema as X, promptSkillDisplayName as Xt, RegisterPushNotificationRequestSchema as Y, promptMarkdownWithSkills as Yt, ResolveApprovalResponseSchema as Z, promptSkillMentionLabel as Zt, EncryptedPayloadSchema as _, ThreadRunOptionsSchema as _t, ArchiveThreadResponseSchema as a, StatusResponseSchema as at, InterruptThreadRunResponseSchema as b, UpdateRuntimePreferencesRequestSchema as bt, ChatMessageRoleSchema as c, SubmitThreadInputResponseSchema as ct, CheckoutWorkspaceBranchRequestSchema as d, ThreadDetailResponseSchema as dt, stripPromptSkillMentions as en, RuntimeModeSchema as et, CodexModelSchema as f, ThreadGoalResponseSchema as ft, CreateThreadResponseSchema as g, ThreadMessageDetailResponseSchema as gt, CreateThreadRequestSchema as h, ThreadMessageDetailFieldSchema as ht, ApprovalModeSchema as i, SandboxModeSchema as it, PairResponseSchema as j, WorkspaceGitActionResponseSchema as jt, PairEncryptedPayloadSchema as k, WorkspaceFileContentResponseSchema as kt, ChatMessageSchema as l, ThreadCollaborationModeSchema as lt, ContextWindowUsageSchema as m, ThreadGoalStatusSchema as mt, AgentSkillSourceSchema as n, RuntimePreferencesResponseSchema as nt, ChatMessageKindSchema as o, StreamThreadRunEventSchema as ot, CommitPushWorkspaceRequestSchema as p, ThreadGoalSchema as pt, RateLimitsResponseSchema as q, isPromptSkillMarkdownMention as qt, ApprovalDecisionSchema as r, RuntimePreferencesSchema as rt, ChatMessagePromptDetailsSchema as s, StreamThreadRunRequestSchema as st, AgentSkillSchema as t, RuntimePreferencesByWorkspacePathSchema as tt, ChatMessageStateSchema as u, ThreadContextWindowResponseSchema as ut, ErrorResponseSchema as v, ThreadStateSchema as vt, ListQueuedThreadInputsResponseSchema as w, WORKSPACE_PREVIEW_OPEN_PROTOCOL as wt, IsoDateTimeSchema as x, UpdateThreadGoalRequestSchema as xt, ImageAttachmentUploadResponseSchema as y, ThreadSummarySchema as yt, PromptSkillSchema as z, WorkspaceTerminalOutputChunkSchema as zt };

package/dist/cli.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { Bt as apiPaths } from "./api-schema2.js";
+import { Wt as apiPaths } from "./api-schema2.js";
 import { n as codexRelayHome, o as getConnectUrlGuidance, r as legacyCodexRelayDataPath, s as createTursoPairingSessionStore, t as codexRelayDataPath } from "./paths.js";
 import { Command } from "@commander-js/extra-typings";
 import qrcode from "qrcode-terminal";
@@ -48,16 +48,18 @@ function isRelayProcessCommand(command) {
 //#endregion
 //#region src/cli.ts
 const npxCommand = "npx codex-relay@latest";
-const program = new Command().name("codex-relay").description("Run and approve the codex-relay local CLI bridge.").option("--bg", "run the Codex Relay server in the background").option("--debug", "write verbose relay diagnostics to debug.log").option("--dangerously-auto-approve", "automatically approve mobile pairing requests without a local approval command").addHelpText("after", `
+const program = new Command().name("codex-relay").description("Run and approve the codex-relay local CLI bridge.").option("--bg", "run the Codex Relay server in the background").option("--debug", "write verbose relay diagnostics to debug.log").option("--shared-app-server", "use a shared Codex app-server socket so terminal and mobile can share live sessions").option("--dangerously-auto-approve", "automatically approve mobile pairing requests without a local approval command").addHelpText("after", `
 
 Examples:
   ${npxCommand}              Start the relay and print a pairing QR
+  ${npxCommand} --shared-app-server Share live sessions with a connected terminal
   ${npxCommand} --bg         Start the relay in the background
   ${npxCommand} qr           Print the current pairing QR
   ${npxCommand} clear        Sign out every paired mobile app
   ${npxCommand} approve CODE Approve a pending mobile pairing request`).action(async (options) => {
 	if (options.debug) process.env.CODEX_RELAY_DEBUG = "1";
 	if (options.dangerouslyAutoApprove) process.env.CODEX_RELAY_DANGEROUSLY_AUTO_APPROVE = "1";
+	if (options.sharedAppServer) process.env.CODEX_RELAY_APP_SERVER_MODE = "socket";
 	if (options.bg) {
 		await startBackgroundServer();
 		return;

package/dist/paths.js

@@ -122,6 +122,16 @@ async function createTursoPairingSessionStore(path) {
       created_at INTEGER NOT NULL,
       updated_at INTEGER NOT NULL
     );
+
+    CREATE TABLE IF NOT EXISTS push_notification_subscriptions (
+      client_session_id TEXT PRIMARY KEY,
+      expo_push_token TEXT NOT NULL,
+      platform TEXT NOT NULL,
+      turn_terminal_enabled INTEGER NOT NULL,
+      action_required_enabled INTEGER NOT NULL,
+      created_at INTEGER NOT NULL,
+      updated_at INTEGER NOT NULL
+    );
   `);
 	await ensurePairingSessionColumns();
 	async function countActive(now) {
@@ -178,6 +188,7 @@ async function createTursoPairingSessionStore(path) {
 				const pendingRow = await transaction.prepare("SELECT COUNT(*) AS count FROM pending_pairings").get();
 				await transaction.prepare("DELETE FROM pairing_sessions").run();
 				await transaction.prepare("DELETE FROM pending_pairings").run();
+				await transaction.prepare("DELETE FROM push_notification_subscriptions").run();
 				return {
 					pendingPairingsCleared: Number(pendingRow?.count ?? 0),
 					sessionsCleared: Number(sessionRow?.count ?? 0)
@@ -185,6 +196,12 @@ async function createTursoPairingSessionStore(path) {
 			})();
 		},
 		countActive,
+		async deletePushNotificationSubscription(clientSessionId) {
+			await db.prepare("DELETE FROM push_notification_subscriptions WHERE client_session_id = ?").run(clientSessionId);
+		},
+		async deletePushNotificationSubscriptionsByExpoPushToken(expoPushToken) {
+			await db.prepare("DELETE FROM push_notification_subscriptions WHERE expo_push_token = ?").run(expoPushToken);
+		},
 		async createPendingPairing(pairing) {
 			const now = Date.now();
 			await db.prepare(`INSERT INTO pending_pairings (
@@ -227,6 +244,16 @@ async function createTursoPairingSessionStore(path) {
 		deleteSession,
 		deletePendingPairing,
 		getPendingPairing,
+		async getPushNotificationSubscription(clientSessionId) {
+			const row = await db.prepare(`SELECT client_session_id AS clientSessionId,
+                  expo_push_token AS expoPushToken,
+                  platform,
+                  turn_terminal_enabled AS turnTerminal,
+                  action_required_enabled AS actionRequired
+           FROM push_notification_subscriptions
+           WHERE client_session_id = ?`).get(clientSessionId);
+			return row ? pushNotificationSubscriptionFromRow(row) : void 0;
+		},
 		async getValidSession(tokenHash, now) {
 			const row = await db.prepare(`SELECT client_name AS clientName,
                   client_session_id AS clientSessionId,
@@ -251,9 +278,30 @@ async function createTursoPairingSessionStore(path) {
 				secureSession: decodeSecureSession(row)
 			};
 		},
+		async listActivePushNotificationSubscriptions(now) {
+			return resultRows(await db.prepare(`SELECT subscriptions.client_session_id AS clientSessionId,
+                  subscriptions.expo_push_token AS expoPushToken,
+                  subscriptions.platform,
+                  subscriptions.turn_terminal_enabled AS turnTerminal,
+                  subscriptions.action_required_enabled AS actionRequired
+           FROM push_notification_subscriptions AS subscriptions
+           INNER JOIN pairing_sessions AS sessions
+             ON sessions.client_session_id = subscriptions.client_session_id
+           WHERE sessions.expires_at > ?
+           GROUP BY subscriptions.client_session_id`).all(now)).flatMap((row) => {
+				const subscription = pushNotificationSubscriptionFromRow(row);
+				return subscription ? [subscription] : [];
+			});
+		},
 		async pruneExpired(now) {
 			await db.prepare("DELETE FROM pairing_sessions WHERE expires_at <= ?").run(now);
 			await db.prepare("DELETE FROM pending_pairings WHERE expires_at <= ?").run(now);
+			await db.prepare(`DELETE FROM push_notification_subscriptions
+           WHERE NOT EXISTS (
+             SELECT 1
+             FROM pairing_sessions
+             WHERE pairing_sessions.client_session_id = push_notification_subscriptions.client_session_id
+           )`).run();
 		},
 		async rotateSession(oldTokenHash, newTokenHash, session) {
 			const now = Date.now();
@@ -292,6 +340,25 @@ async function createTursoPairingSessionStore(path) {
                next_server_counter = ?,
                updated_at = ?
            WHERE token_hash = ?`).run(secure.keyEpoch, secure.mobileToServerKey, secure.serverToMobileKey, secure.lastMobileCounter, secure.nextServerCounter, now, tokenHash);
+		},
+		async upsertPushNotificationSubscription(subscription) {
+			const now = Date.now();
+			await db.prepare(`INSERT INTO push_notification_subscriptions (
+             client_session_id,
+             expo_push_token,
+             platform,
+             turn_terminal_enabled,
+             action_required_enabled,
+             created_at,
+             updated_at
+           )
+           VALUES (?, ?, ?, ?, ?, ?, ?)
+           ON CONFLICT(client_session_id) DO UPDATE SET
+             expo_push_token = excluded.expo_push_token,
+             platform = excluded.platform,
+             turn_terminal_enabled = excluded.turn_terminal_enabled,
+             action_required_enabled = excluded.action_required_enabled,
+             updated_at = excluded.updated_at`).run(subscription.clientSessionId, subscription.expoPushToken, subscription.platform, subscription.turnTerminal ? 1 : 0, subscription.actionRequired ? 1 : 0, now, now);
 		}
 	};
 	async function ensurePairingSessionColumns() {
@@ -329,6 +396,17 @@ function decodeSecureSession(row) {
 		serverToMobileKey: toByteArray(row.serverToMobileKey)
 	};
 }
+function pushNotificationSubscriptionFromRow(row) {
+	const platform = row.platform;
+	if (typeof row.clientSessionId !== "string" || typeof row.expoPushToken !== "string" || platform !== "android" && platform !== "ios") return;
+	return {
+		actionRequired: Number(row.actionRequired) === 1,
+		clientSessionId: row.clientSessionId,
+		expoPushToken: row.expoPushToken,
+		platform,
+		turnTerminal: Number(row.turnTerminal) === 1
+	};
+}
 function resultRows(result) {
 	if (Array.isArray(result)) return result;
 	if (result && typeof result === "object" && Array.isArray(result.rows)) return result.rows;

package/dist/src.js

@@ -1,4 +1,4 @@
-import { $ as RuntimePreferencesSchema, A as PairRequestSchema, B as QueuedThreadInputActionResponseSchema, Bt as apiPaths, C as ListModelsResponseSchema, Ct as WorkspaceChangesResponseSchema, D as ListWorkspaceDirectoriesResponseSchema, Dt as WorkspaceGitActionResponseSchema, E as ListThreadsResponseSchema, G as ReasoningEffortSchema, Gt as promptMarkdownWithSkills, Ht as createOpenApiDocument, It as WorkspaceTerminalOutputResponseSchema, J as RunThreadRequestSchema, K as ResolveApprovalRequestSchema, Lt as WorkspaceTerminalResizeRequestSchema, Mt as WorkspaceTailscaleServeRequestSchema, Nt as WorkspaceTailscaleServeResponseSchema, O as ListWorkspaceFilesResponseSchema, Pt as WorkspaceTerminalInputRequestSchema, Q as RuntimePreferencesResponseSchema, Rt as WorkspaceTerminalSessionResponseSchema, S as KnownReasoningEffortSchema, T as ListSkillsResponseSchema, Tt as WorkspaceFileContentResponseSchema, Vt as chatMessageDetailsFromPromptContext, W as RateLimitsResponseSchema, Wt as normalizePromptContext, Xt as stripPromptSkillMentions, _ as EncryptedPayloadSchema, _t as UpdateThreadGoalRequestSchema, a as ArchiveThreadResponseSchema, b as InterruptThreadRunResponseSchema, ct as ThreadGoalResponseSchema, d as CheckoutWorkspaceBranchRequestSchema, dt as ThreadMessageDetailFieldSchema, ft as ThreadMessageDetailResponseSchema, gt as UpdateRuntimePreferencesRequestSchema, h as CreateThreadRequestSchema, ht as ThreadSummarySchema, it as SubmitThreadInputResponseSchema, j as PairResponseSchema, l as ChatMessageSchema, lt as ThreadGoalSchema, m as ContextWindowUsageSchema, nt as StreamThreadRunEventSchema, ot as ThreadContextWindowResponseSchema, p as CommitPushWorkspaceRequestSchema, q as ResolveApprovalResponseSchema, rt as StreamThreadRunRequestSchema, st as ThreadDetailResponseSchema, tt as StatusResponseSchema, ut as ThreadGoalStatusSchema, vt as UpdateWorkspaceFileContentRequestSchema, w as ListQueuedThreadInputsResponseSchema, y as ImageAttachmentUploadResponseSchema, yt as VersionResponseSchema, zt as WorkspaceTerminalStartRequestSchema } from "./api-schema2.js";
+import { A as PairRequestSchema, Bt as WorkspaceTerminalOutputResponseSchema, C as ListModelsResponseSchema, Ct as VersionResponseSchema, D as ListWorkspaceDirectoriesResponseSchema, Dt as WorkspaceChangesResponseSchema, E as ListThreadsResponseSchema, Gt as chatMessageDetailsFromPromptContext, H as PushNotificationSettingsResponseSchema, Ht as WorkspaceTerminalSessionResponseSchema, It as WorkspaceTailscaleServeRequestSchema, J as ReasoningEffortSchema, Jt as normalizePromptContext, Kt as createOpenApiDocument, Lt as WorkspaceTailscaleServeResponseSchema, O as ListWorkspaceFilesResponseSchema, Q as RunThreadRequestSchema, Rt as WorkspaceTerminalInputRequestSchema, S as KnownReasoningEffortSchema, St as UpdateWorkspaceFileContentRequestSchema, T as ListSkillsResponseSchema, U as QueuedThreadInputActionResponseSchema, Ut as WorkspaceTerminalStartRequestSchema, Vt as WorkspaceTerminalResizeRequestSchema, Wt as apiPaths, X as ResolveApprovalRequestSchema, Y as RegisterPushNotificationRequestSchema, Yt as promptMarkdownWithSkills, Z as ResolveApprovalResponseSchema, _ as EncryptedPayloadSchema, a as ArchiveThreadResponseSchema, at as StatusResponseSchema, b as InterruptThreadRunResponseSchema, bt as UpdateRuntimePreferencesRequestSchema, ct as SubmitThreadInputResponseSchema, d as CheckoutWorkspaceBranchRequestSchema, dt as ThreadDetailResponseSchema, en as stripPromptSkillMentions, ft as ThreadGoalResponseSchema, gt as ThreadMessageDetailResponseSchema, h as CreateThreadRequestSchema, ht as ThreadMessageDetailFieldSchema, j as PairResponseSchema, jt as WorkspaceGitActionResponseSchema, kt as WorkspaceFileContentResponseSchema, l as ChatMessageSchema, m as ContextWindowUsageSchema, mt as ThreadGoalStatusSchema, nt as RuntimePreferencesResponseSchema, ot as StreamThreadRunEventSchema, p as CommitPushWorkspaceRequestSchema, pt as ThreadGoalSchema, q as RateLimitsResponseSchema, rt as RuntimePreferencesSchema, st as StreamThreadRunRequestSchema, ut as ThreadContextWindowResponseSchema, w as ListQueuedThreadInputsResponseSchema, xt as UpdateThreadGoalRequestSchema, y as ImageAttachmentUploadResponseSchema, yt as ThreadSummarySchema } from "./api-schema2.js";
 import { a as getConnectUrlCandidates, i as createPairingQrPayload, o as getConnectUrlGuidance, r as legacyCodexRelayDataPath, s as createTursoPairingSessionStore, t as codexRelayDataPath } from "./paths.js";
 import { createRequire } from "node:module";
 import qrcode from "qrcode-terminal";
@@ -6,6 +6,7 @@ import { execFile, spawn } from "node:child_process";
 import fs, { existsSync, mkdirSync, readFileSync, readdirSync, statSync, writeFileSync } from "node:fs";
 import { access, appendFile, copyFile, mkdir, open, readFile, readdir, realpath, stat, writeFile } from "node:fs/promises";
 import path, { basename, dirname, extname, isAbsolute, join, relative, resolve } from "node:path";
+import { setTimeout as setTimeout$1 } from "node:timers/promises";
 import { fileURLToPath } from "node:url";
 import { z } from "zod";
 import { promisify } from "node:util";
@@ -18,7 +19,9 @@ import { openRepository } from "es-git";
 import { Hono } from "hono";
 import { cors } from "hono/cors";
 import * as pty from "@lydell/node-pty";
+import { connect } from "node:net";
 import { createInterface } from "node:readline";
+import WebSocket from "ws";
 import { Codex } from "@openai/codex-sdk";
 import { gcm } from "@noble/ciphers/aes.js";
 import { randomBytes as randomBytes$1, utf8ToBytes } from "@noble/ciphers/utils.js";
@@ -26,23 +29,48 @@ import { ed25519, x25519 } from "@noble/curves/ed25519.js";
 import { hkdf } from "@noble/hashes/hkdf.js";
 import { sha256 } from "@noble/hashes/sha2.js";
 //#region src/codex-binary.ts
-const appServerArgs = [
+const stdioAppServerArgs = [
 	"app-server",
 	"--listen",
 	"stdio://"
 ];
+const sharedWindowsServerUrl = "ws://127.0.0.1:8788";
 const windowsShellExtensions = new Set([".bat", ".cmd"]);
+function resolveCodexAppServerMode(env = process.env) {
+	const configuredMode = env.CODEX_RELAY_APP_SERVER_MODE?.trim().toLowerCase();
+	if (!configuredMode || configuredMode === "stdio") return "stdio";
+	if (configuredMode === "socket") return "socket";
+	throw new Error(`Unsupported CODEX_RELAY_APP_SERVER_MODE ${JSON.stringify(configuredMode)}. Expected "stdio" or "socket".`);
+}
 function resolveCodexAppServerSpawn(input = {}) {
-	const platform$1 = input.platform ?? platform();
+	const platform$2 = input.platform ?? platform();
+	const command = resolveCodexBinary(input.env ?? process.env);
+	const isWindows = platform$2 === "win32";
+	return {
+		command,
+		args: [...stdioAppServerArgs],
+		shell: isWindows && shouldUseWindowsShell(command),
+		windowsHide: isWindows
+	};
+}
+function resolveCodexSharedAppServerSpawn(input = {}) {
+	const platform$3 = input.platform ?? platform();
 	const command = resolveCodexBinary(input.env ?? process.env);
-	const isWindows = platform$1 === "win32";
+	const isWindows = platform$3 === "win32";
 	return {
 		command,
-		args: [...appServerArgs],
+		args: [
+			"app-server",
+			"--listen",
+			resolveCodexSharedAppServerRemoteAddress(platform$3)
+		],
 		shell: isWindows && shouldUseWindowsShell(command),
 		windowsHide: isWindows
 	};
 }
+function resolveCodexSharedAppServerRemoteAddress(platform$1 = platform()) {
+	return platform$1 === "win32" ? sharedWindowsServerUrl : "unix://";
+}
 function resolveCodexBinary(env) {
 	return env.CODEX_BIN?.trim() || "codex";
 }
@@ -51,15 +79,71 @@ function shouldUseWindowsShell(command) {
 	return extension === "" || windowsShellExtensions.has(extension);
 }
 //#endregion
+//#region src/debug-log.ts
+function isRelayDebugEnabled() {
+	return process.env.CODEX_RELAY_DEBUG === "1" || process.env.CODEX_RELAY_DEBUG_STREAM === "1";
+}
+function relayDebugLog(event, fields = {}) {
+	if (!isRelayDebugEnabled()) return;
+	const entry = sanitizeDebugValue({
+		ts: (/* @__PURE__ */ new Date()).toISOString(),
+		event,
+		...fields
+	});
+	const line = `${JSON.stringify(entry)}\n`;
+	const path = process.env.CODEX_RELAY_DEBUG_LOG_PATH?.trim();
+	if (path) mkdir(dirname(path), { recursive: true }).then(() => appendFile(path, line, { mode: 384 })).catch(() => void 0);
+	console.log(`[debug] ${event} ${formatDebugFields(fields)}`.trimEnd());
+}
+function sanitizeDebugValue(value) {
+	if (value instanceof Error) return {
+		message: value.message,
+		name: value.name,
+		stack: value.stack
+	};
+	if (Array.isArray(value)) return value.map(sanitizeDebugValue);
+	if (value && typeof value === "object") return Object.fromEntries(Object.entries(value).map(([key, item]) => [key, sanitizeDebugValue(item)]));
+	return value;
+}
+function formatDebugFields(fields) {
+	return Object.entries(fields).map(([key, value]) => `${key}=${formatDebugValue(value)}`).join(" ");
+}
+function formatDebugValue(value) {
+	if (value === void 0) return "undefined";
+	if (value === null) return "null";
+	if (typeof value === "string") return value.includes(" ") ? JSON.stringify(value) : value;
+	if (typeof value === "number" || typeof value === "boolean") return String(value);
+	return JSON.stringify(sanitizeDebugValue(value));
+}
+//#endregion
 //#region src/app-server.ts
+const sharedSocketReconnectDelaysMs = [
+	50,
+	100,
+	250,
+	500,
+	1e3,
+	2e3
+];
 var CodexAppServerClient = class {
 	child;
+	closed = false;
 	initialized;
 	notificationHandlers = /* @__PURE__ */ new Set();
 	nextId = 1;
 	pending = /* @__PURE__ */ new Map();
+	reconnecting;
 	requestHandlers = /* @__PURE__ */ new Set();
 	readline;
+	sharedServer;
+	socket;
+	startSharedServer;
+	constructor(options = {}) {
+		this.startSharedServer = options.startSharedServer ?? startSharedCodexAppServer;
+	}
+	initialize() {
+		return this.ensureInitialized();
+	}
 	async listThreads(limit = 80) {
 		return (await this.request("thread/list", {
 			limit,
@@ -132,12 +216,19 @@ var CodexAppServerClient = class {
 		});
 	}
 	close() {
+		if (this.closed) return;
+		this.closed = true;
 		for (const pending of this.pending.values()) pending.reject(/* @__PURE__ */ new Error("Codex app-server was closed."));
 		this.pending.clear();
 		this.readline?.close();
 		this.child?.kill();
+		const socket = this.socket;
+		this.socket = void 0;
+		socket?.close();
+		this.sharedServer?.kill();
 		this.readline = void 0;
 		this.child = void 0;
+		this.sharedServer = void 0;
 		this.initialized = void 0;
 	}
 	async request(method, params) {
@@ -150,23 +241,48 @@ var CodexAppServerClient = class {
 				resolve: (value) => resolve(value),
 				reject
 			});
-			this.child.stdin.write(`${JSON.stringify({
+			this.writeJson({
 				id,
 				method,
 				params
-			})}\n`, (error) => {
-				if (error) {
-					this.pending.delete(id);
-					reject(error);
-				}
+			}).catch((error) => {
+				if (this.pending.delete(id)) reject(error);
 			});
 		});
 	}
 	ensureInitialized() {
-		if (!this.initialized) this.initialized = this.start();
+		if (this.closed) return Promise.reject(/* @__PURE__ */ new Error("Codex app-server was closed."));
+		if (!this.initialized) {
+			const initialized = this.start();
+			this.initialized = initialized;
+			initialized.catch(() => {
+				if (this.initialized === initialized) this.initialized = void 0;
+			});
+		}
 		return this.initialized;
 	}
-	start() {
+	async start() {
+		const mode = resolveCodexAppServerMode();
+		try {
+			if (mode === "socket") await this.startOrAttachSharedCodexAppServer();
+			else this.startStdioCodexAppServer();
+			await this.initializeAppServer();
+		} catch (error) {
+			if (mode === "stdio") this.stopStdioCodexAppServer();
+			throw error;
+		}
+	}
+	async initializeAppServer() {
+		await this.requestRaw("initialize", {
+			clientInfo: {
+				name: "codex-relay",
+				title: "Codex Relay Mobile Server",
+				version: "1.2.0"
+			},
+			capabilities: { experimentalApi: true }
+		});
+	}
+	startStdioCodexAppServer() {
 		const spawnConfig = resolveCodexAppServerSpawn();
 		this.child = spawn(spawnConfig.command, spawnConfig.args, {
 			env: process.env,
@@ -187,14 +303,153 @@ var CodexAppServerClient = class {
 			this.child = void 0;
 			this.initialized = void 0;
 		});
-		return this.requestRaw("initialize", {
-			clientInfo: {
-				name: "codex-relay",
-				title: "Codex Relay Mobile Server",
-				version: "1.2.0"
-			},
-			capabilities: { experimentalApi: true }
-		}).then(() => void 0);
+	}
+	stopStdioCodexAppServer() {
+		this.readline?.close();
+		this.readline = void 0;
+		this.child?.kill();
+		this.child = void 0;
+	}
+	async startOrAttachSharedCodexAppServer() {
+		try {
+			await this.connectSharedCodexAppServer();
+			relayDebugLog("app_server.shared_socket.attached", {
+				ownership: "attached",
+				socketPath: sharedCodexAppServerSocketPath()
+			});
+			return;
+		} catch (error) {
+			const attachError = asError(error);
+			relayDebugLog("app_server.shared_socket.attach_failed", {
+				message: attachError.message,
+				socketPath: sharedCodexAppServerSocketPath()
+			});
+			if (this.sharedServer) throw attachError;
+		}
+		const sharedServer = await this.startSharedServer();
+		this.sharedServer = sharedServer;
+		this.observeSharedCodexAppServer(sharedServer);
+		relayDebugLog("app_server.shared_process.started", {
+			ownership: "relay-owned",
+			socketPath: sharedCodexAppServerSocketPath()
+		});
+		try {
+			await this.connectSharedCodexAppServer();
+		} catch (error) {
+			if (this.sharedServer === sharedServer) {
+				sharedServer.kill();
+				this.sharedServer = void 0;
+			}
+			throw error;
+		}
+	}
+	observeSharedCodexAppServer(sharedServer) {
+		sharedServer.on("error", (error) => {
+			relayDebugLog("app_server.shared_process.error", {
+				message: error.message,
+				ownership: "relay-owned"
+			});
+			if (this.sharedServer === sharedServer) this.sharedServer = void 0;
+		});
+		sharedServer.once("exit", (code, signal) => {
+			if (this.sharedServer !== sharedServer) return;
+			this.sharedServer = void 0;
+			const error = /* @__PURE__ */ new Error(`Codex shared app-server exited with ${signal ?? code ?? 1}.`);
+			relayDebugLog("app_server.shared_process.exited", {
+				message: error.message,
+				ownership: "relay-owned"
+			});
+			if (this.socket) this.handleSharedSocketFailure(this.socket, error);
+		});
+	}
+	async connectSharedCodexAppServer() {
+		const remoteAddress = resolveCodexSharedAppServerRemoteAddress();
+		const socket = new WebSocket(remoteAddress === "unix://" ? `ws+unix://${sharedCodexAppServerSocketPath()}:/` : remoteAddress, { perMessageDeflate: false });
+		this.socket = socket;
+		try {
+			await new Promise((resolve, reject) => {
+				const handleOpen = () => {
+					socket.off("error", handleInitialError);
+					resolve();
+				};
+				const handleInitialError = (error) => {
+					socket.off("open", handleOpen);
+					reject(error);
+				};
+				socket.once("open", handleOpen);
+				socket.once("error", handleInitialError);
+			});
+		} catch (error) {
+			if (this.socket === socket) this.socket = void 0;
+			socket.close();
+			throw error;
+		}
+		socket.on("message", (data) => this.handleLine(String(data)));
+		socket.on("error", (error) => this.handleSharedSocketFailure(socket, error));
+		socket.once("close", (code, reason) => {
+			this.handleSharedSocketFailure(socket, /* @__PURE__ */ new Error(`Codex app-server socket closed with ${code}${reason.length > 0 ? `: ${String(reason)}` : "."}`));
+		});
+		relayDebugLog("app_server.shared_socket.connected", {
+			ownership: this.sharedAppServerOwnership(),
+			socketPath: sharedCodexAppServerSocketPath()
+		});
+	}
+	handleSharedSocketFailure(socket, error) {
+		if (this.socket !== socket) return;
+		this.socket = void 0;
+		this.rejectAll(error);
+		this.initialized = void 0;
+		relayDebugLog("app_server.shared_socket.disconnected", {
+			message: error.message,
+			ownership: this.sharedAppServerOwnership()
+		});
+		this.scheduleSharedSocketReconnect();
+	}
+	sharedAppServerOwnership() {
+		return this.sharedServer ? "relay-owned" : "attached";
+	}
+	scheduleSharedSocketReconnect() {
+		if (this.closed || this.reconnecting) return;
+		const reconnecting = this.reconnectSharedCodexAppServer();
+		this.reconnecting = reconnecting;
+		this.initialized = reconnecting;
+		reconnecting.then(() => {
+			if (this.reconnecting === reconnecting) this.reconnecting = void 0;
+		}, (error) => {
+			relayDebugLog("app_server.shared_socket.reconnect_failed", {
+				message: asError(error).message,
+				ownership: this.sharedAppServerOwnership()
+			});
+			if (this.initialized === reconnecting) this.initialized = void 0;
+			if (this.reconnecting === reconnecting) this.reconnecting = void 0;
+		});
+	}
+	async reconnectSharedCodexAppServer() {
+		let lastError;
+		for (const delayMs of sharedSocketReconnectDelaysMs) {
+			await setTimeout$1(delayMs);
+			if (this.closed) return;
+			try {
+				await this.connectSharedCodexAppServer();
+				await this.initializeAppServer();
+				relayDebugLog("app_server.shared_socket.reconnected", {
+					ownership: this.sharedAppServerOwnership(),
+					socketPath: sharedCodexAppServerSocketPath()
+				});
+				return;
+			} catch (error) {
+				lastError = asError(error);
+				const socket = this.socket;
+				this.socket = void 0;
+				socket?.close();
+				relayDebugLog("app_server.shared_socket.reconnect_retry", {
+					delayMs,
+					message: lastError.message,
+					ownership: this.sharedAppServerOwnership()
+				});
+			}
+		}
+		throw lastError ?? /* @__PURE__ */ new Error("Unable to reconnect to the shared Codex app-server.");
 	}
 	requestRaw(method, params) {
 		const id = this.nextId++;
@@ -210,11 +465,8 @@ var CodexAppServerClient = class {
 				resolve: (value) => resolve(value),
 				reject
 			});
-			this.child.stdin.write(`${request}\n`, (error) => {
-				if (error) {
-					this.pending.delete(id);
-					reject(error);
-				}
+			this.writeSerializedJson(request).catch((error) => {
+				if (this.pending.delete(id)) reject(error);
 			});
 		});
 	}
@@ -256,12 +508,22 @@ var CodexAppServerClient = class {
 		} else pending.resolve(message.result);
 	}
 	writeJson(payload) {
+		return this.writeSerializedJson(JSON.stringify(payload));
+	}
+	writeSerializedJson(payload) {
 		return new Promise((resolve, reject) => {
+			if (this.socket) {
+				this.socket.send(payload, (error) => {
+					if (error) reject(error);
+					else resolve();
+				});
+				return;
+			}
 			if (!this.child?.stdin) {
 				reject(/* @__PURE__ */ new Error("Codex app-server is not running."));
 				return;
 			}
-			this.child.stdin.write(`${JSON.stringify(payload)}\n`, (error) => {
+			this.child.stdin.write(`${payload}\n`, (error) => {
 				if (error) reject(error);
 				else resolve();
 			});
@@ -272,6 +534,69 @@ var CodexAppServerClient = class {
 		this.pending.clear();
 	}
 };
+async function startSharedCodexAppServer() {
+	const spawnConfig = resolveCodexSharedAppServerSpawn();
+	const child = spawn(spawnConfig.command, spawnConfig.args, {
+		env: process.env,
+		shell: spawnConfig.shell,
+		windowsHide: spawnConfig.windowsHide
+	});
+	let spawnError;
+	let exitReason;
+	let stderr = "";
+	child.stdout.resume();
+	child.stderr.on("data", (chunk) => {
+		if (stderr.length < 8192) stderr += String(chunk).slice(0, 8192 - stderr.length);
+	});
+	child.once("error", (error) => {
+		spawnError = error;
+	});
+	child.once("exit", (code, signal) => {
+		exitReason = signal ?? code ?? 1;
+	});
+	const remoteAddress = resolveCodexSharedAppServerRemoteAddress();
+	for (let attempt = 0; attempt < 100; attempt += 1) {
+		if (spawnError) throw new Error(`Failed to start the shared Codex app-server: ${spawnError.message}`);
+		try {
+			await waitForSharedCodexAppServer(remoteAddress);
+			return child;
+		} catch {
+			if (exitReason !== void 0) {
+				const detail = stderr.trim();
+				throw new Error(`Failed to start the shared Codex app-server (exit ${exitReason})${detail ? `: ${detail}` : "."}`);
+			}
+			await setTimeout$1(25);
+		}
+	}
+	child.kill();
+	throw new Error(`Timed out waiting for the shared Codex app-server at ${remoteAddress}.`);
+}
+async function waitForSharedCodexAppServer(remoteAddress) {
+	if (remoteAddress === "unix://") {
+		await access(sharedCodexAppServerSocketPath());
+		return;
+	}
+	const url = new URL(remoteAddress);
+	await new Promise((resolve, reject) => {
+		const socket = connect({
+			host: url.hostname,
+			port: Number(url.port)
+		});
+		const onError = (error) => reject(error);
+		socket.once("error", onError);
+		socket.once("connect", () => {
+			socket.off("error", onError);
+			socket.destroy();
+			resolve();
+		});
+	});
+}
+function sharedCodexAppServerSocketPath() {
+	return join(process.env.CODEX_HOME?.trim() || join(homedir(), ".codex"), "app-server-control", "app-server-control.sock");
+}
+function asError(error) {
+	return error instanceof Error ? error : new Error(String(error));
+}
 function debugAppServer(kind, method, id, detail) {
 	if (process.env.CODEX_RELAY_DEBUG_APP_SERVER !== "1") return;
 	console.log(`[app-server] ${kind}${id === void 0 ? "" : ` #${id}`}${method ? ` ${method}` : ""}${detail ? ` ${detail}` : ""}`);
@@ -461,41 +786,79 @@ function sumPositiveIntegers(values) {
 	return found ? sum : null;
 }
 //#endregion
-//#region src/debug-log.ts
-function isRelayDebugEnabled() {
-	return process.env.CODEX_RELAY_DEBUG === "1" || process.env.CODEX_RELAY_DEBUG_STREAM === "1";
+//#region src/push-notifications.ts
+const expoPushEndpoint = "https://exp.host/--/api/v2/push/send";
+const expoPushChunkSize = 100;
+function createExpoPushNotificationSender(fetchImpl = fetch) {
+	return { async send(notifications) {
+		const invalidExpoPushTokens = /* @__PURE__ */ new Set();
+		for (const chunk of chunks(notifications, expoPushChunkSize)) {
+			const response = await fetchImpl(expoPushEndpoint, {
+				body: JSON.stringify(chunk.map((notification) => ({
+					body: notification.body,
+					channelId: "default",
+					data: notification.data,
+					priority: "high",
+					sound: "default",
+					title: notification.title,
+					to: notification.to
+				}))),
+				headers: {
+					accept: "application/json",
+					"content-type": "application/json"
+				},
+				method: "POST"
+			});
+			const body = await response.json().catch(() => void 0);
+			if (!response.ok) throw new Error(`Expo push service returned ${response.status}.`);
+			const tickets = expoPushTickets(body);
+			for (const [index, ticket] of tickets.entries()) {
+				const notification = chunk[index];
+				if (notification && isDeviceNotRegistered(ticket)) invalidExpoPushTokens.add(notification.to);
+			}
+		}
+		return { invalidExpoPushTokens: [...invalidExpoPushTokens] };
+	} };
 }
-function relayDebugLog(event, fields = {}) {
-	if (!isRelayDebugEnabled()) return;
-	const entry = sanitizeDebugValue({
-		ts: (/* @__PURE__ */ new Date()).toISOString(),
-		event,
-		...fields
-	});
-	const line = `${JSON.stringify(entry)}\n`;
-	const path = process.env.CODEX_RELAY_DEBUG_LOG_PATH?.trim();
-	if (path) mkdir(dirname(path), { recursive: true }).then(() => appendFile(path, line, { mode: 384 })).catch(() => void 0);
-	console.log(`[debug] ${event} ${formatDebugFields(fields)}`.trimEnd());
+function createPushNotificationDispatcher(input) {
+	return { async dispatch(event) {
+		const subscriptions = await input.sessions.listActivePushNotificationSubscriptions(Date.now());
+		const selectedTokens = new Set(subscriptions.filter((subscription) => notificationEnabled(subscription, event.intent)).map((subscription) => subscription.expoPushToken));
+		if (selectedTokens.size === 0) return;
+		const delivery = await input.sender.send([...selectedTokens].map((expoPushToken) => notificationForEvent(expoPushToken, event)));
+		await Promise.all(delivery.invalidExpoPushTokens.map((expoPushToken) => input.sessions.deletePushNotificationSubscriptionsByExpoPushToken(expoPushToken)));
+	} };
 }
-function sanitizeDebugValue(value) {
-	if (value instanceof Error) return {
-		message: value.message,
-		name: value.name,
-		stack: value.stack
+function notificationEnabled(subscription, intent) {
+	return intent === "action_required" ? subscription.actionRequired : subscription.turnTerminal;
+}
+function notificationForEvent(expoPushToken, event) {
+	return {
+		body: event.intent === "action_required" ? "Codex needs your attention." : "A Codex turn has finished.",
+		data: {
+			intent: event.intent,
+			threadId: event.threadId,
+			...event.turnId ? { turnId: event.turnId } : {}
+		},
+		title: "Codex Relay",
+		to: expoPushToken
 	};
-	if (Array.isArray(value)) return value.map(sanitizeDebugValue);
-	if (value && typeof value === "object") return Object.fromEntries(Object.entries(value).map(([key, item]) => [key, sanitizeDebugValue(item)]));
-	return value;
 }
-function formatDebugFields(fields) {
-	return Object.entries(fields).map(([key, value]) => `${key}=${formatDebugValue(value)}`).join(" ");
+function expoPushTickets(value) {
+	if (!value || typeof value !== "object") return [];
+	const data = value.data;
+	return Array.isArray(data) ? data : [];
 }
-function formatDebugValue(value) {
-	if (value === void 0) return "undefined";
-	if (value === null) return "null";
-	if (typeof value === "string") return value.includes(" ") ? JSON.stringify(value) : value;
-	if (typeof value === "number" || typeof value === "boolean") return String(value);
-	return JSON.stringify(sanitizeDebugValue(value));
+function isDeviceNotRegistered(ticket) {
+	if (!ticket || typeof ticket !== "object") return false;
+	const record = ticket;
+	if (record.status !== "error" || !record.details || typeof record.details !== "object") return false;
+	return record.details.error === "DeviceNotRegistered";
+}
+function chunks(items, size) {
+	const result = [];
+	for (let index = 0; index < items.length; index += size) result.push(items.slice(index, index + size));
+	return result;
 }
 //#endregion
 //#region src/preferences-store.ts
@@ -1062,6 +1425,11 @@ function createApp(options = {}) {
 	const secureSessionsByTokenHash = /* @__PURE__ */ new Map();
 	const activeStreamControllers = /* @__PURE__ */ new Set();
 	const threadOptions = { workingDirectory: workspacePath };
+	const pushNotificationDispatcher = options.pairing ? createPushNotificationDispatcher({
+		sender: options.pushNotificationSender ?? createExpoPushNotificationSender(),
+		sessions: options.pairing.sessions
+	}) : void 0;
+	if (appServer && pushNotificationDispatcher) observeAppServerPushNotifications(appServer, pushNotificationDispatcher);
 	const scheduleAppServerHistoryLoad = (threadId, cachedMessages) => {
 		if (!appServer || appServerHistoryLoadsByThreadId.has(threadId)) return;
 		const startedAt = Date.now();
@@ -1286,6 +1654,48 @@ function createApp(options = {}) {
 		});
 		return secureJson(c, options.pairing, secureSessionsByTokenHash, response);
 	});
+	app.get(apiPaths.pushNotifications, async (c) => {
+		const clientSessionId = await pairedClientSessionIdForAuthorization(c.req.header("authorization"), options.pairing);
+		if (!clientSessionId) return secureJson(c, options.pairing, secureSessionsByTokenHash, apiError("push_notifications_unavailable", "Pair this device again to manage notifications."), 401);
+		const subscription = await options.pairing.sessions.getPushNotificationSubscription(clientSessionId);
+		const response = PushNotificationSettingsResponseSchema.parse({
+			preferences: subscription ? {
+				actionRequired: subscription.actionRequired,
+				turnTerminal: subscription.turnTerminal
+			} : defaultPushNotificationPreferences(),
+			registered: Boolean(subscription)
+		});
+		return secureJson(c, options.pairing, secureSessionsByTokenHash, response);
+	});
+	app.put(apiPaths.pushNotifications, async (c) => {
+		if (!options.pairing) return secureJson(c, options.pairing, secureSessionsByTokenHash, apiError("pairing_required", "Pair this device before registering notifications."), 404);
+		const parsed = await parseRequestJson(c, options.pairing, secureSessionsByTokenHash, RegisterPushNotificationRequestSchema);
+		if (!parsed.success) return secureJson(c, options.pairing, secureSessionsByTokenHash, validationError(parsed.error), 400);
+		const clientSessionId = await pairedClientSessionIdForAuthorization(c.req.header("authorization"), options.pairing);
+		if (!clientSessionId) return secureJson(c, options.pairing, secureSessionsByTokenHash, apiError("push_notifications_unavailable", "Pair this device again to manage notifications."), 401);
+		await options.pairing.sessions.upsertPushNotificationSubscription({
+			actionRequired: parsed.data.preferences.actionRequired,
+			clientSessionId,
+			expoPushToken: parsed.data.expoPushToken,
+			platform: parsed.data.platform,
+			turnTerminal: parsed.data.preferences.turnTerminal
+		});
+		const response = PushNotificationSettingsResponseSchema.parse({
+			preferences: parsed.data.preferences,
+			registered: true
+		});
+		return secureJson(c, options.pairing, secureSessionsByTokenHash, response);
+	});
+	app.delete(apiPaths.pushNotifications, async (c) => {
+		const clientSessionId = await pairedClientSessionIdForAuthorization(c.req.header("authorization"), options.pairing);
+		if (!clientSessionId) return secureJson(c, options.pairing, secureSessionsByTokenHash, apiError("push_notifications_unavailable", "Pair this device again to manage notifications."), 401);
+		await options.pairing.sessions.deletePushNotificationSubscription(clientSessionId);
+		const response = PushNotificationSettingsResponseSchema.parse({
+			preferences: defaultPushNotificationPreferences(),
+			registered: false
+		});
+		return secureJson(c, options.pairing, secureSessionsByTokenHash, response);
+	});
 	app.get(apiPaths.workspaceDirectories, async (c) => {
 		const targetPath = resolve(c.req.query("path") ?? workspacePath);
 		try {
@@ -2282,6 +2692,18 @@ function createApp(options = {}) {
 function parseBearerToken(value) {
 	return (value?.match(/^Bearer\s+(.+)$/i))?.[1];
 }
+async function pairedClientSessionIdForAuthorization(authorization, pairing) {
+	if (!pairing) return;
+	const token = parseBearerToken(authorization);
+	if (!token) return;
+	return (await pairing.sessions.getValidSession(pairing.hashClientToken(token), Date.now()))?.clientSessionId;
+}
+function defaultPushNotificationPreferences() {
+	return {
+		actionRequired: false,
+		turnTerminal: false
+	};
+}
 function normalizeApprovalCode(value) {
 	const normalized = value.toUpperCase().replace(/[^A-Z0-9]/g, "").replaceAll("O", "0").replaceAll("I", "1");
 	return normalized.length === 8 ? `${normalized.slice(0, 4)}-${normalized.slice(4)}` : normalized;
@@ -5297,6 +5719,55 @@ function structuredStreamMessage(role, event, fallbackContent) {
 function isApprovalServerRequest(method) {
 	return method === "item/commandExecution/requestApproval" || method === "item/fileChange/requestApproval" || method === "item/permissions/requestApproval" || method === "item/tool/requestUserInput" || method === "mcpServer/elicitation/request" || method === "execCommandApproval" || method === "applyPatchApproval";
 }
+function observeAppServerPushNotifications(appServer, dispatcher) {
+	const dispatchedEventIds = /* @__PURE__ */ new Set();
+	const dispatch = (event, eventId) => {
+		if (dispatchedEventIds.has(eventId)) return;
+		if (dispatchedEventIds.size >= 1e3) dispatchedEventIds.clear();
+		dispatchedEventIds.add(eventId);
+		dispatcher.dispatch(event).catch((error) => {
+			relayDebugLog("push_notification.dispatch_failed", {
+				error: errorMessage(error),
+				intent: event.intent,
+				threadId: event.threadId,
+				turnId: event.turnId
+			});
+		});
+	};
+	appServer.onNotification((notification) => {
+		const event = pushNotificationEventFromTerminalNotification(notification);
+		if (!event) return;
+		dispatch(event, `${event.intent}:${event.threadId}:${event.turnId ?? ""}`);
+	});
+	appServer.onRequest((request) => {
+		const event = pushNotificationEventFromApprovalRequest(request);
+		if (!event) return;
+		dispatch(event, `${event.intent}:${event.threadId}:${event.turnId ?? ""}:${request.id}`);
+	});
+}
+function pushNotificationEventFromTerminalNotification(notification) {
+	if (notification.method !== "turn/completed" && notification.method !== "turn/failed") return;
+	const params = recordParams(notification);
+	const status = turnStatus(params);
+	if (status === "aborted" || status === "cancelled" || status === "canceled" || status === "interrupted") return;
+	const threadId = firstString(params, ["threadId", "conversationId"]);
+	if (!threadId) return;
+	return {
+		intent: "turn_terminal",
+		threadId,
+		turnId: firstString(params, ["turnId"]) ?? turnIdFromParams(params)
+	};
+}
+function pushNotificationEventFromApprovalRequest(request) {
+	if (!isApprovalServerRequest(request.method)) return;
+	const approval = approvalMessageFromRequest(request);
+	if (!approval) return;
+	return {
+		intent: "action_required",
+		threadId: approval.threadId,
+		turnId: approval.turnId
+	};
+}
 function approvalMessageFromRequest(request) {
 	const params = recordParams(request);
 	const threadId = firstString(params, ["threadId", "conversationId"]);
@@ -6274,8 +6745,17 @@ const color = {
 const npxCommand = "npx codex-relay@latest";
 const sessionStore = await createTursoPairingSessionStore(process.env.CODEX_RELAY_AUTH_DB_PATH ?? await prepareCodexRelayDataPath("auth.db", ["auth.db-shm", "auth.db-wal"]));
 const preferencesStore = createFileRuntimePreferencesStore(process.env.CODEX_RELAY_PREFERENCES_PATH ?? await prepareCodexRelayDataPath("preferences.json"));
+const appServerMode = resolveCodexAppServerMode();
+const sharedAppServer = appServerMode === "socket" ? new CodexAppServerClient() : void 0;
+if (sharedAppServer) {
+	await sharedAppServer.initialize();
+	process.once("SIGINT", () => stopSharedAppServer(130));
+	process.once("SIGTERM", () => stopSharedAppServer(143));
+	process.once("exit", () => sharedAppServer.close());
+}
 serve({
 	fetch: createApp({
+		appServer: sharedAppServer,
 		pairing: {
 			approvalSecret,
 			dangerouslyAutoApprove,
@@ -6346,9 +6826,14 @@ serve({
 		dangerouslyAutoApprove,
 		listenUrl,
 		pairingPayload,
-		port: info.port
+		port: info.port,
+		sharedAppServerRemoteAddress: appServerMode === "socket" ? resolveCodexSharedAppServerRemoteAddress() : void 0
 	}));
 });
+function stopSharedAppServer(exitCode) {
+	sharedAppServer?.close();
+	process.exit(exitCode);
+}
 function formatStartupInstructions(details) {
 	return [
 		"",
@@ -6361,6 +6846,11 @@ function formatStartupInstructions(details) {
 			`${color.prompt("›")} Server: ${color.muted(details.listenUrl)}`,
 			"",
 			`${color.prompt("›")} Pairing: ${color.url(details.pairingPayload)}`,
+			...details.sharedAppServerRemoteAddress ? [
+				"",
+				`${color.prompt("›")} Terminal: ${color.command(`codex resume --remote ${details.sharedAppServerRemoteAddress}`)}`,
+				`  ${color.muted("Connect through the shared Codex app-server to follow and steer the same live sessions.")}`
+			] : [],
 			"",
 			`${color.prompt("›")} Commands`,
 			`  ${color.command(npxCommand)}              Start and print a pairing QR`,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codex-relay",
-  "version": "1.3.1",
+  "version": "1.4.0",
   "description": "Local Codex Relay CLI bridge for the Codex Relay mobile app.",
   "license": "Apache-2.0",
   "repository": {
@@ -41,7 +41,7 @@
     "@noble/ciphers": "2.2.0",
     "@noble/curves": "2.2.0",
     "@noble/hashes": "2.2.0",
-    "@openai/codex-sdk": "0.144.1",
+    "@openai/codex-sdk": "0.144.5",
     "base64-js": "1.5.1",
     "commander": "^14.0.3",
     "es-git": "^0.6.0",

package/src/api-schema.ts

@@ -95,6 +95,27 @@ export const RuntimePreferencesResponseSchema = z.object({
   workspacePath: z.string().trim().min(1).optional(),
 });
 
+export const PushNotificationIntentSchema = z.enum(["turn_terminal", "action_required"]);
+
+export const PushNotificationPreferencesSchema = z.object({
+  actionRequired: z.boolean(),
+  turnTerminal: z.boolean(),
+});
+
+export const RegisterPushNotificationRequestSchema = z.object({
+  expoPushToken: z
+    .string()
+    .trim()
+    .regex(/^(?:Expo|Exponent)PushToken\[[^\]\r\n]{1,512}\]$/),
+  platform: z.enum(["android", "ios"]),
+  preferences: PushNotificationPreferencesSchema,
+});
+
+export const PushNotificationSettingsResponseSchema = z.object({
+  preferences: PushNotificationPreferencesSchema,
+  registered: z.boolean(),
+});
+
 export const CodexModelSchema = z.object({
   id: z.string().min(1),
   model: z.string().min(1),
@@ -753,6 +774,12 @@ export type RuntimePreferencesByWorkspacePath = z.infer<
   typeof RuntimePreferencesByWorkspacePathSchema
 >;
 export type RuntimePreferencesResponse = z.infer<typeof RuntimePreferencesResponseSchema>;
+export type PushNotificationIntent = z.infer<typeof PushNotificationIntentSchema>;
+export type PushNotificationPreferences = z.infer<typeof PushNotificationPreferencesSchema>;
+export type RegisterPushNotificationRequest = z.infer<typeof RegisterPushNotificationRequestSchema>;
+export type PushNotificationSettingsResponse = z.infer<
+  typeof PushNotificationSettingsResponseSchema
+>;
 export type ContextWindowUsage = z.infer<typeof ContextWindowUsageSchema>;
 export type RateLimitBucket = z.infer<typeof RateLimitBucketSchema>;
 export type RateLimitWindow = z.infer<typeof RateLimitWindowSchema>;
@@ -1033,6 +1060,7 @@ export const apiPaths = {
   sessionRefresh: "/v1/session/refresh",
   status: "/v1/status",
   preferences: "/v1/preferences",
+  pushNotifications: "/v1/notifications/push",
   rateLimits: "/v1/rate-limits",
   models: "/v1/models",
   skills: "/v1/skills",
@@ -1111,6 +1139,31 @@ export function createOpenApiDocument() {
           },
         },
       },
+      "/v1/notifications/push": {
+        get: {
+          summary: "Read push notification settings for this paired device",
+          responses: {
+            "200": jsonResponse("PushNotificationSettingsResponse"),
+            "401": jsonResponse("ErrorResponse"),
+          },
+        },
+        put: {
+          summary: "Register push notifications for this paired device",
+          requestBody: jsonRequest("RegisterPushNotificationRequest"),
+          responses: {
+            "200": jsonResponse("PushNotificationSettingsResponse"),
+            "400": jsonResponse("ErrorResponse"),
+            "401": jsonResponse("ErrorResponse"),
+          },
+        },
+        delete: {
+          summary: "Remove push notifications for this paired device",
+          responses: {
+            "200": jsonResponse("PushNotificationSettingsResponse"),
+            "401": jsonResponse("ErrorResponse"),
+          },
+        },
+      },
       "/v1/threads": {
         get: {
           summary: "List locally known threads",
@@ -1491,6 +1544,34 @@ export function createOpenApiDocument() {
             workspacePath: { type: "string" },
           },
         },
+        PushNotificationPreferences: {
+          type: "object",
+          required: ["actionRequired", "turnTerminal"],
+          properties: {
+            actionRequired: { type: "boolean" },
+            turnTerminal: { type: "boolean" },
+          },
+        },
+        RegisterPushNotificationRequest: {
+          type: "object",
+          required: ["expoPushToken", "platform", "preferences"],
+          properties: {
+            expoPushToken: {
+              type: "string",
+              pattern: "^(?:Expo|Exponent)PushToken\\[[^\\]\\r\\n]{1,512}\\]$",
+            },
+            platform: { type: "string", enum: ["android", "ios"] },
+            preferences: { $ref: "#/components/schemas/PushNotificationPreferences" },
+          },
+        },
+        PushNotificationSettingsResponse: {
+          type: "object",
+          required: ["preferences", "registered"],
+          properties: {
+            preferences: { $ref: "#/components/schemas/PushNotificationPreferences" },
+            registered: { type: "boolean" },
+          },
+        },
         WorkspaceDirectoryEntry: {
           type: "object",
           required: ["name", "path"],