codex-relay 1.3.2 → 1.4.0

package/README.md

@@ -32,21 +32,31 @@ After approval, the phone can list Codex threads, start new work, stream message
 
 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.
 
-On macOS, Linux, or WSL, opt in to Codex's shared app-server socket:
+Opt in to Codex's shared app-server:
 
 ```sh
 npx codex-relay@latest --shared-app-server
 ```
 
-Then connect a new terminal TUI to the shared app-server socket:
+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://
 ```
 
-Pass a thread ID after `unix://` 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`.
+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 Unix-socket app-server and `resume --remote` support. If those features are unavailable, update Codex or omit `--shared-app-server` to keep the existing private mode. Native Windows is not currently supported; use WSL or private mode there.
+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
 

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";

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";
@@ -19,6 +19,7 @@ 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";
@@ -33,11 +34,7 @@ const stdioAppServerArgs = [
 	"--listen",
 	"stdio://"
 ];
-const sharedServerArgs = [
-	"app-server",
-	"--listen",
-	"unix://"
-];
+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();
@@ -46,9 +43,9 @@ function resolveCodexAppServerMode(env = process.env) {
 	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$1 === "win32";
+	const isWindows = platform$2 === "win32";
 	return {
 		command,
 		args: [...stdioAppServerArgs],
@@ -57,19 +54,22 @@ function resolveCodexAppServerSpawn(input = {}) {
 	};
 }
 function resolveCodexSharedAppServerSpawn(input = {}) {
-	const platform$2 = input.platform ?? platform();
-	assertAppServerModeSupported("socket", platform$2);
+	const platform$3 = input.platform ?? platform();
 	const command = resolveCodexBinary(input.env ?? process.env);
-	const isWindows = platform$2 === "win32";
+	const isWindows = platform$3 === "win32";
 	return {
 		command,
-		args: [...sharedServerArgs],
+		args: [
+			"app-server",
+			"--listen",
+			resolveCodexSharedAppServerRemoteAddress(platform$3)
+		],
 		shell: isWindows && shouldUseWindowsShell(command),
 		windowsHide: isWindows
 	};
 }
-function assertAppServerModeSupported(mode, platform) {
-	if (mode === "socket" && platform === "win32") throw new Error("Shared Codex app-server mode requires macOS, Linux, or WSL.");
+function resolveCodexSharedAppServerRemoteAddress(platform$1 = platform()) {
+	return platform$1 === "win32" ? sharedWindowsServerUrl : "unix://";
 }
 function resolveCodexBinary(env) {
 	return env.CODEX_BIN?.trim() || "codex";
@@ -79,17 +79,68 @@ 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();
 	}
@@ -165,15 +216,18 @@ 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();
-		this.socket?.close();
+		const socket = this.socket;
+		this.socket = void 0;
+		socket?.close();
 		this.sharedServer?.kill();
 		this.readline = void 0;
 		this.child = void 0;
-		this.socket = void 0;
 		this.sharedServer = void 0;
 		this.initialized = void 0;
 	}
@@ -197,35 +251,37 @@ var CodexAppServerClient = class {
 		});
 	}
 	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;
 	}
 	async start() {
+		const mode = resolveCodexAppServerMode();
 		try {
-			if (resolveCodexAppServerMode() === "socket") {
-				this.sharedServer = await startSharedCodexAppServer();
-				await this.connectSharedCodexAppServer();
-			} else this.startStdioCodexAppServer();
-			await this.requestRaw("initialize", {
-				clientInfo: {
-					name: "codex-relay",
-					title: "Codex Relay Mobile Server",
-					version: "1.2.0"
-				},
-				capabilities: { experimentalApi: true }
-			});
+			if (mode === "socket") await this.startOrAttachSharedCodexAppServer();
+			else this.startStdioCodexAppServer();
+			await this.initializeAppServer();
 		} catch (error) {
-			this.readline?.close();
-			this.readline = void 0;
-			this.child?.kill();
-			this.child = void 0;
-			this.socket?.close();
-			this.socket = void 0;
-			this.sharedServer?.kill();
-			this.sharedServer = void 0;
+			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, {
@@ -248,31 +304,153 @@ var CodexAppServerClient = class {
 			this.initialized = 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 socket = new WebSocket(`ws+unix://${sharedCodexAppServerSocketPath()}:/`, { perMessageDeflate: false });
+		const remoteAddress = resolveCodexSharedAppServerRemoteAddress();
+		const socket = new WebSocket(remoteAddress === "unix://" ? `ws+unix://${sharedCodexAppServerSocketPath()}:/` : remoteAddress, { perMessageDeflate: false });
 		this.socket = socket;
-		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);
-		});
+		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.rejectAll(error));
+		socket.on("error", (error) => this.handleSharedSocketFailure(socket, error));
 		socket.once("close", (code, reason) => {
-			this.rejectAll(/* @__PURE__ */ new Error(`Codex app-server socket closed with ${code}${reason.length > 0 ? `: ${String(reason)}` : "."}`));
-			this.socket = void 0;
-			this.sharedServer?.kill();
-			this.sharedServer = void 0;
-			this.initialized = void 0;
+			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++;
 		const request = JSON.stringify({
@@ -376,11 +554,11 @@ async function startSharedCodexAppServer() {
 	child.once("exit", (code, signal) => {
 		exitReason = signal ?? code ?? 1;
 	});
-	const socketPath = sharedCodexAppServerSocketPath();
+	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 access(socketPath);
+			await waitForSharedCodexAppServer(remoteAddress);
 			return child;
 		} catch {
 			if (exitReason !== void 0) {
@@ -391,11 +569,34 @@ async function startSharedCodexAppServer() {
 		}
 	}
 	child.kill();
-	throw new Error(`Timed out waiting for the shared Codex app-server socket at ${socketPath}.`);
+	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}` : ""}`);
@@ -585,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
@@ -1186,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();
@@ -1410,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 {
@@ -2406,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;
@@ -5421,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"]);
@@ -6480,7 +6827,7 @@ serve({
 		listenUrl,
 		pairingPayload,
 		port: info.port,
-		sharedAppServer: appServerMode === "socket"
+		sharedAppServerRemoteAddress: appServerMode === "socket" ? resolveCodexSharedAppServerRemoteAddress() : void 0
 	}));
 });
 function stopSharedAppServer(exitCode) {
@@ -6499,9 +6846,9 @@ function formatStartupInstructions(details) {
 			`${color.prompt("›")} Server: ${color.muted(details.listenUrl)}`,
 			"",
 			`${color.prompt("›")} Pairing: ${color.url(details.pairingPayload)}`,
-			...details.sharedAppServer ? [
+			...details.sharedAppServerRemoteAddress ? [
 				"",
-				`${color.prompt("›")} Terminal: ${color.command("codex resume --remote unix://")}`,
+				`${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.")}`
 			] : [],
 			"",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codex-relay",
-  "version": "1.3.2",
+  "version": "1.4.0",
   "description": "Local Codex Relay CLI bridge for the Codex Relay mobile app.",
   "license": "Apache-2.0",
   "repository": {

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"],