dsh-codex-subscription 2.5.8 → 3.0.0-beta.1

package/lib/index.js

@@ -9,13 +9,14 @@ import { promisify } from "node:util";
 import { HttpsProxyAgent } from "https-proxy-agent";
 import WebSocket from "ws";
 import { clientRequestSchema } from "@deepseek-ai/dsh-client-connection";
-import { lstat, mkdir, open, readFile, rename, rm, stat } from "node:fs/promises";
-import { constants, readFileSync } from "node:fs";
-import { dirname, join, resolve } from "node:path";
+import { lstat, mkdir, open, readFile, rename, rm, stat, writeFile } from "node:fs/promises";
+import { constants, readFileSync, statSync } from "node:fs";
+import { dirname, isAbsolute, join, resolve } from "node:path";
 import { pathToFileURL } from "node:url";
 import { defineTool } from "@deepseek-ai/dsh-tools";
 import { LlmError, createUserMessage } from "@deepseek-ai/dsh-llm";
 import * as dshCredentials from "@deepseek-ai/dsh-credentials";
+import { hostname } from "node:os";
 import { dshHomePath, resolveDshHome } from "@deepseek-ai/dsh-home-paths";
 import { PiAiAdapter } from "@deepseek-ai/dsh-llm-pi-ai";
 import z from "@deepseek-ai/schemastery";
@@ -429,6 +430,11 @@ const PREFERENCE_FIELDS = Object.freeze({
 		default: "session",
 		error: "Invalid review model"
 	},
+	remoteControl: {
+		choices: ["off", "on"],
+		default: "off",
+		error: "Invalid Remote Control setting"
+	},
 	subagentBackend: {
 		choices: ["dsh", "codex"],
 		default: "dsh",
@@ -1110,6 +1116,10 @@ const RPC_ENDPOINTS = Object.freeze([
 	"runtime/cancel",
 	"storage/status",
 	"storage/clear-forecast",
+	"remote/status",
+	"remote/enable",
+	"remote/disable",
+	"remote/pair",
 	"reset-credit/inspect",
 	"reset-credit/prepare",
 	"reset-credit/consume",
@@ -2049,7 +2059,7 @@ function inheritedOriginalImageRef(session, assetId) {
 }
 //#endregion
 //#region src/version.js
-const PACKAGE_VERSION = "2.5.8";
+const PACKAGE_VERSION = "3.0.0-beta.1";
 const USER_AGENT = `dsh-codex-subscription/${PACKAGE_VERSION}`;
 //#endregion
 //#region src/codex-images.js
@@ -2677,6 +2687,1541 @@ function createSketchAgentTool(bridge, attachments, getSessionMessages = () => [
 	});
 }
 //#endregion
+//#region src/remote-control-host.js
+const METHOD_NOT_FOUND = -32601;
+const INVALID_PARAMS = -32602;
+const INTERNAL_ERROR = -32603;
+const MAX_SEEN = 128;
+const QUIET = /* @__PURE__ */ new Set([
+	"command/exec",
+	"thread/attachment/list",
+	"thread/list",
+	"thread/queue/list",
+	"threadSection/list",
+	"config/read",
+	"configRequirements/read"
+]);
+var RpcError = class extends Error {
+	constructor(code, message) {
+		super(message);
+		this.code = code;
+	}
+};
+const invalidParams = (message) => new RpcError(INVALID_PARAMS, message);
+/**
+* One host per relay; each remote client gets its own connection.
+* @param {{ methods: Record<string, (params: any, context: { client: object, signal: AbortSignal, notify: (method: string, params?: object) => Promise<void> }) => any>, notifications?: Record<string, Function>, onConnection?: (client: object) => void, onClose?: (client: object) => void }} options
+*/
+function createRemoteControlHost({ methods, notifications = {}, onConnection, onActive, onClose, debug = false }) {
+	const seen = /* @__PURE__ */ new Map();
+	const trace = [];
+	const record = (entry) => {
+		if (!debug) return;
+		trace.push({
+			at: Date.now(),
+			...entry
+		});
+		if (trace.length > 60) trace.shift();
+	};
+	const note = (kind, method) => {
+		const key = `${kind}:${method}`;
+		if (!seen.has(key) && seen.size >= MAX_SEEN) return;
+		seen.set(key, (seen.get(key) ?? 0) + 1);
+	};
+	return Object.freeze({
+		/** Methods remote clients called, for diagnostics; never params or content. */
+		seen: () => Object.fromEntries(seen),
+		/** Add a development trace entry from the bridge; ignored unless debug is on. */
+		note: (entry) => record(entry),
+		/** Development trace of recent calls; only filled when debug is on. */
+		trace: () => [...trace],
+		serve(client) {
+			const aborts = /* @__PURE__ */ new Set();
+			const pending = /* @__PURE__ */ new Map();
+			let initialized = false;
+			let active = false;
+			const notify = async (method, params) => {
+				await client.send(params === void 0 ? { method } : {
+					method,
+					params
+				});
+			};
+			/** Ask the phone something (approvals); settles with its result or rejects. */
+			const ask = (method, params, signal) => new Promise((resolve, reject) => {
+				const id = `s${randomUUID()}`;
+				const done = () => {
+					pending.delete(id);
+					signal?.removeEventListener("abort", onAbort);
+				};
+				const onAbort = () => {
+					done();
+					reject(new RpcError(-32800, "Request cancelled"));
+				};
+				if (signal?.aborted) return onAbort();
+				signal?.addEventListener("abort", onAbort, { once: true });
+				record({
+					method: `ask:${method}`,
+					params: JSON.stringify(params ?? null).slice(0, 400)
+				});
+				pending.set(id, {
+					resolve: (value) => {
+						record({
+							method: `answer:${method}`,
+							params: JSON.stringify(value ?? null).slice(0, 400)
+						});
+						done();
+						resolve(value);
+					},
+					reject: (error) => {
+						record({
+							method: `answer:${method}`,
+							error: String(error?.message ?? error).slice(0, 200)
+						});
+						done();
+						reject(error);
+					}
+				});
+				client.send({
+					id,
+					method,
+					params
+				}).catch((error) => {
+					done();
+					reject(error);
+				});
+			});
+			notify.ask = ask;
+			const context = {
+				client,
+				notify,
+				ask
+			};
+			onConnection?.(client);
+			const reply = async (id, result) => {
+				await client.send({
+					id,
+					result
+				});
+			};
+			const fail = async (id, error) => {
+				const known = error instanceof RpcError;
+				await client.send({
+					id,
+					error: {
+						code: known ? error.code : INTERNAL_ERROR,
+						message: known ? error.message : "Request failed"
+					}
+				});
+			};
+			return {
+				receive(message) {
+					if (message !== null && typeof message === "object" && typeof message.method !== "string" && message.id !== void 0) {
+						const waiting = pending.get(message.id);
+						if (waiting) if (message.error) waiting.reject(new RpcError(message.error.code ?? INTERNAL_ERROR, String(message.error.message ?? "Request failed")));
+						else waiting.resolve(message.result);
+						return;
+					}
+					if (message === null || typeof message !== "object" || typeof message.method !== "string") return;
+					const { id, method, params } = message;
+					if (id === void 0) {
+						note("notify", method);
+						if (method === "initialized") initialized = true;
+						notifications[method]?.(params, {
+							...context,
+							signal: new AbortController().signal
+						});
+						return;
+					}
+					note("request", method);
+					if (!active && method !== "initialize") {
+						active = true;
+						onActive?.(client);
+					}
+					if (debug && !QUIET.has(method)) record({
+						method: `request:${method}`,
+						params: JSON.stringify(params ?? null).slice(0, 700)
+					});
+					const handler = methods[method];
+					if (!handler) {
+						record({
+							method,
+							missing: true,
+							params: JSON.stringify(params ?? null).slice(0, 600)
+						});
+						fail(id, new RpcError(METHOD_NOT_FOUND, `Method not found: ${method}`)).catch(() => {});
+						return;
+					}
+					if (method !== "initialize" && !initialized && method !== "ping") initialized = true;
+					const controller = new AbortController();
+					aborts.add(controller);
+					Promise.resolve().then(() => handler(params, {
+						...context,
+						signal: controller.signal
+					})).then((result) => reply(id, result ?? {}), (error) => {
+						if (!QUIET.has(method)) record({
+							method,
+							error: String(error?.message ?? error).slice(0, 300),
+							params: JSON.stringify(params ?? null).slice(0, 600)
+						});
+						return fail(id, error);
+					}).catch(() => {}).finally(() => aborts.delete(controller));
+				},
+				close() {
+					for (const waiting of [...pending.values()]) waiting.reject(new RpcError(-32800, "Client disconnected"));
+					for (const controller of aborts) controller.abort();
+					aborts.clear();
+					onClose?.(client, notify);
+				}
+			};
+		}
+	});
+}
+//#endregion
+//#region src/remote-control-relay.js
+const REMOTE_CONTROL_BASE_URL = "https://chatgpt.com/backend-api/";
+const PROTOCOL_VERSION = "3";
+const MAX_SEGMENT_BYTES = 150 * 1024;
+const TARGET_SEGMENT_BYTES = 100 * 1024;
+const MAX_MESSAGE_BYTES = 100 * 1024 * 1024;
+const MAX_CHUNKS = 1024;
+const INITIAL_RECONNECT_MS = 1e3;
+const CONFLICT_RENEW_MS = 15 * 6e4;
+const MAX_RECONNECT_MS = 3e4;
+const REQUEST_TIMEOUT_MS = 3e4;
+const REFRESH_MARGIN_MS = 5 * 6e4;
+var RemoteControlError = class extends Error {
+	constructor(code, message) {
+		super(message);
+		this.name = "RemoteControlError";
+		this.code = code;
+	}
+};
+function remoteControlEndpoints(base = REMOTE_CONTROL_BASE_URL) {
+	const root = new URL(base);
+	const local = [
+		"localhost",
+		"127.0.0.1",
+		"[::1]"
+	].includes(root.hostname);
+	if (!(root.protocol === "https:" && (root.hostname === "chatgpt.com" || root.hostname.endsWith(".chatgpt.com"))) && !(local && root.protocol === "http:")) throw new RemoteControlError("unsupported-host", "Remote Control only talks to chatgpt.com");
+	if (!root.pathname.endsWith("/")) root.pathname += "/";
+	const at = (suffix) => new URL(suffix, root);
+	const websocket = at("wham/remote/control/server");
+	websocket.protocol = root.protocol === "https:" ? "wss:" : "ws:";
+	return Object.freeze({
+		enroll: at("wham/remote/control/server/enroll"),
+		refresh: at("wham/remote/control/server/refresh"),
+		pair: at("wham/remote/control/server/pair"),
+		websocket
+	});
+}
+const text = (value) => typeof value === "string" && value.length > 0 ? value : void 0;
+function enrollment(value) {
+	const environmentId = text(value?.environment_id);
+	const serverId = text(value?.server_id);
+	const token = text(value?.remote_control_token);
+	const expiresAt = Date.parse(value?.expires_at);
+	if (!environmentId || !serverId || !token || !Number.isFinite(expiresAt)) throw new RemoteControlError("bad-response", "Remote Control returned an unexpected enrollment");
+	return {
+		environmentId,
+		serverId,
+		token,
+		expiresAt
+	};
+}
+/**
+* @param {{
+*   credentials: (signal?: AbortSignal) => Promise<{ access?: string, accountId?: string }>,
+*   fetch?: typeof fetch,
+*   WebSocket: new (url: string, options: object) => any,
+*   installationId: string,
+*   hostName: string,
+*   userAgent: string,
+*   serve: (client: { send: (message: object) => Promise<void>, close: () => void, id: string }) => { receive: (message: object) => void, close: () => void },
+*   base?: string,
+*   now?: () => number,
+*   wait?: (ms: number, signal: AbortSignal) => Promise<void>,
+* }} options
+*/
+function createRemoteControlRelay(options) {
+	let installation = options.installationId;
+	const endpoints = remoteControlEndpoints(options.base);
+	const doFetch = options.fetch ?? globalThis.fetch;
+	const now = options.now ?? Date.now;
+	const wait = options.wait ?? ((ms, signal) => new Promise((resolve) => {
+		const timer = setTimeout(resolve, ms);
+		signal.addEventListener("abort", () => {
+			clearTimeout(timer);
+			resolve();
+		}, { once: true });
+	}));
+	let enrolled;
+	let stop;
+	let running;
+	let socket;
+	const clients = /* @__PURE__ */ new Map();
+	const assemblies = /* @__PURE__ */ new Map();
+	const sequences = /* @__PURE__ */ new Map();
+	const state = {
+		status: "stopped",
+		connectedAt: void 0,
+		lastError: void 0,
+		reconnects: 0
+	};
+	const request = async (url, init, signal) => {
+		const response = await doFetch(url, {
+			...init,
+			redirect: "error",
+			signal: signal ? AbortSignal.any([signal, AbortSignal.timeout(REQUEST_TIMEOUT_MS)]) : AbortSignal.timeout(REQUEST_TIMEOUT_MS)
+		});
+		if (!response.ok) throw new RemoteControlError(response.status === 401 || response.status === 403 ? "unauthorized" : "http-error", `Remote Control request failed (HTTP ${response.status})`);
+		return response.json();
+	};
+	const ensureEnrollment = async (signal) => {
+		if (enrolled && enrolled.expiresAt > now() + REFRESH_MARGIN_MS) return enrolled;
+		const { access, accountId } = await options.credentials(signal);
+		if (!access || !accountId) throw new RemoteControlError("not-signed-in", "ChatGPT subscription is not signed in");
+		const headers = {
+			authorization: `Bearer ${access}`,
+			"chatgpt-account-id": accountId,
+			"content-type": "application/json",
+			"user-agent": options.userAgent,
+			"x-codex-installation-id": installation
+		};
+		const refresh = enrolled !== void 0;
+		const body = refresh ? {
+			installation_id: installation,
+			server_id: enrolled.serverId
+		} : {
+			app_server_version: options.userAgent.split("/").at(-1),
+			arch: process.arch,
+			installation_id: installation,
+			name: options.hostName,
+			os: process.platform
+		};
+		const next = enrollment(await request(refresh ? endpoints.refresh : endpoints.enroll, {
+			method: "POST",
+			headers,
+			body: JSON.stringify(body)
+		}, signal));
+		if (refresh && next.serverId !== enrolled.serverId) throw new RemoteControlError("bad-response", "Remote Control returned a mismatched enrollment");
+		enrolled = next;
+		return enrolled;
+	};
+	/** Start a pairing: the code goes into a QR; the manual code can be typed in the app. */
+	const pair = async (signal) => {
+		const current = await ensureEnrollment(signal);
+		const value = await request(endpoints.pair, {
+			method: "POST",
+			headers: {
+				authorization: `Bearer ${current.token}`,
+				"content-type": "application/json",
+				"user-agent": options.userAgent
+			},
+			body: JSON.stringify({ manual_code: true })
+		}, signal);
+		const pairingCode = text(value?.pairing_code);
+		const expiresAt = Date.parse(value?.expires_at);
+		if (!pairingCode || value?.server_id !== current.serverId || !Number.isFinite(expiresAt)) throw new RemoteControlError("bad-response", "Remote Control returned an unexpected pairing");
+		return {
+			pairingCode,
+			manualCode: text(value?.manual_pairing_code) ?? null,
+			expiresAt
+		};
+	};
+	const sendEnvelope = async (envelope) => {
+		if (socket?.readyState !== 1) throw new RemoteControlError("not-connected", "Remote Control is not connected");
+		await new Promise((resolve, reject) => socket.send(JSON.stringify(envelope), (error) => error ? reject(error) : resolve()));
+	};
+	const sendServerMessage = async (clientId, streamId, message) => {
+		const key = `${clientId}\u0000${streamId}`;
+		const sequence = sequences.get(key) ?? 1;
+		sequences.set(key, sequence + 1);
+		const envelope = {
+			client_id: clientId,
+			message,
+			seq_id: sequence,
+			stream_id: streamId,
+			type: "server_message"
+		};
+		const encoded = JSON.stringify(envelope);
+		if (Buffer.byteLength(encoded) <= MAX_SEGMENT_BYTES) return sendEnvelope(envelope);
+		const bytes = Buffer.from(JSON.stringify(message));
+		if (bytes.byteLength > MAX_MESSAGE_BYTES) throw new RemoteControlError("too-large", "Remote Control message is too large");
+		const chunks = [];
+		for (let offset = 0; offset < bytes.byteLength; offset += TARGET_SEGMENT_BYTES) chunks.push(bytes.subarray(offset, offset + TARGET_SEGMENT_BYTES).toString("base64"));
+		await Promise.all(chunks.map((chunk, segmentId) => sendEnvelope({
+			client_id: clientId,
+			message_chunk_base64: chunk,
+			message_size_bytes: bytes.byteLength,
+			segment_count: chunks.length,
+			segment_id: segmentId,
+			seq_id: sequence,
+			stream_id: streamId,
+			type: "server_message_chunk"
+		})));
+	};
+	const closeClient = (clientId, streamId) => {
+		for (const [key, client] of clients) if (key.startsWith(`${clientId}\u0000`) && (streamId === void 0 || key === `${clientId}\u0000${streamId}`)) {
+			clients.delete(key);
+			sequences.delete(key);
+			client.close();
+		}
+	};
+	const deliver = async (envelope) => {
+		const streamId = envelope.stream_id ?? randomUUID();
+		const key = `${envelope.client_id}\u0000${streamId}`;
+		let client = clients.get(key);
+		if (!client) {
+			let closed = false;
+			const connection = options.serve({
+				id: `${envelope.client_id}/${streamId}`,
+				send: async (message) => {
+					if (!closed) await sendServerMessage(envelope.client_id, streamId, message);
+				},
+				close: () => {
+					closed = true;
+				}
+			});
+			client = {
+				receive: connection.receive,
+				close: () => {
+					closed = true;
+					connection.close();
+				}
+			};
+			clients.set(key, client);
+		}
+		client.receive(envelope.message);
+		if (Number.isInteger(envelope.seq_id)) await sendEnvelope({
+			client_id: envelope.client_id,
+			seq_id: envelope.seq_id,
+			stream_id: streamId,
+			type: "ack"
+		});
+	};
+	const receiveChunk = (envelope) => {
+		const streamId = envelope.stream_id ?? randomUUID();
+		const key = `${envelope.client_id}\u0000${streamId}\u0000${envelope.seq_id ?? 0}`;
+		const count = envelope.segment_count;
+		if (!Number.isInteger(count) || count < 1 || count > MAX_CHUNKS || !Number.isInteger(envelope.segment_id) || envelope.segment_id < 0 || envelope.segment_id >= count || !Number.isInteger(envelope.message_size_bytes) || envelope.message_size_bytes < 1 || envelope.message_size_bytes > MAX_MESSAGE_BYTES) {
+			assemblies.delete(key);
+			return;
+		}
+		const assembly = assemblies.get(key) ?? {
+			chunks: new Array(count),
+			size: envelope.message_size_bytes
+		};
+		if (assembly.chunks.length !== count || assembly.size !== envelope.message_size_bytes) {
+			assemblies.delete(key);
+			return;
+		}
+		assembly.chunks[envelope.segment_id] = envelope.message_chunk_base64;
+		assemblies.set(key, assembly);
+		if (assembly.chunks.some((chunk) => typeof chunk !== "string")) return void 0;
+		assemblies.delete(key);
+		const bytes = Buffer.concat(assembly.chunks.map((chunk) => Buffer.from(chunk, "base64")));
+		if (bytes.byteLength !== assembly.size) return void 0;
+		return {
+			client_id: envelope.client_id,
+			message: JSON.parse(bytes.toString("utf8")),
+			seq_id: envelope.seq_id,
+			stream_id: streamId,
+			type: "client_message"
+		};
+	};
+	const receive = async (raw) => {
+		const envelope = JSON.parse(raw);
+		if (typeof envelope?.client_id !== "string" || envelope.client_id.length === 0) return;
+		if (envelope.type === "client_message") await deliver(envelope);
+		else if (envelope.type === "client_message_chunk") {
+			const message = receiveChunk(envelope);
+			if (message) await deliver(message);
+		} else if (envelope.type === "client_closed") closeClient(envelope.client_id, envelope.stream_id);
+		else if (envelope.type === "ping") await sendEnvelope({
+			client_id: envelope.client_id,
+			seq_id: envelope.seq_id ?? 0,
+			status: "active",
+			stream_id: envelope.stream_id ?? randomUUID(),
+			type: "pong"
+		});
+	};
+	const connectOnce = async (signal) => {
+		const current = await ensureEnrollment(signal);
+		await new Promise((resolve, reject) => {
+			const ws = new options.WebSocket(endpoints.websocket.toString(), { headers: {
+				authorization: `Bearer ${current.token}`,
+				"user-agent": options.userAgent,
+				"x-codex-installation-id": installation,
+				"x-codex-name": Buffer.from(options.hostName).toString("base64"),
+				"x-codex-protocol-version": PROTOCOL_VERSION,
+				"x-codex-server-id": current.serverId
+			} });
+			socket = ws;
+			let queue = Promise.resolve();
+			const onAbort = () => ws.close();
+			signal.addEventListener("abort", onAbort, { once: true });
+			ws.on("open", () => {
+				state.status = "connected";
+				state.connectedAt = now();
+				state.lastError = void 0;
+			});
+			ws.on("message", (data) => {
+				queue = queue.then(() => receive(String(data))).catch((error) => {
+					state.lastError = error?.code ?? "protocol";
+				});
+			});
+			ws.on("error", (error) => reject(new RemoteControlError("socket", error?.message ?? "socket error")));
+			ws.on("close", () => {
+				signal.removeEventListener("abort", onAbort);
+				resolve();
+			});
+		});
+		for (const [, client] of clients) client.close();
+		clients.clear();
+		sequences.clear();
+		assemblies.clear();
+		socket = void 0;
+	};
+	const loop = async (signal) => {
+		let delay = INITIAL_RECONNECT_MS;
+		let conflicts = 0;
+		let conflictSince = 0;
+		while (!signal.aborted) {
+			state.status = "connecting";
+			try {
+				await connectOnce(signal);
+				delay = INITIAL_RECONNECT_MS;
+			} catch (error) {
+				state.lastError = error?.code ?? "network";
+				if (options.debug) state.detail = String(error?.message ?? error).slice(0, 160);
+				state.status = "error";
+				conflicts = /409/u.test(String(error?.message)) ? conflicts + 1 : 0;
+				if (conflicts === 1) conflictSince = now();
+				if (error?.code === "unauthorized" || conflicts >= 3) enrolled = void 0;
+				if (conflicts >= 3 && now() - conflictSince >= (options.conflictRenewMs ?? CONFLICT_RENEW_MS) && options.renewInstallation) {
+					installation = await options.renewInstallation();
+					enrolled = void 0;
+					conflicts = 0;
+				}
+				if (error?.code === "not-signed-in") {
+					state.status = "stopped";
+					return;
+				}
+			}
+			if (signal.aborted) break;
+			state.reconnects += 1;
+			await wait(delay, signal);
+			delay = Math.min(delay * 2, MAX_RECONNECT_MS);
+		}
+	};
+	return Object.freeze({
+		pair,
+		status: () => ({
+			...state,
+			enrolled: enrolled !== void 0,
+			server: enrolled?.serverId.slice(-6),
+			clients: clients.size
+		}),
+		start() {
+			if (running) return running;
+			stop = new AbortController();
+			state.status = "connecting";
+			running = loop(stop.signal).finally(() => {
+				running = void 0;
+				if (state.status !== "error") state.status = "stopped";
+			});
+			return running;
+		},
+		async stop() {
+			stop?.abort();
+			socket?.close();
+			await running;
+			state.status = "stopped";
+		}
+	});
+}
+//#endregion
+//#region src/remote-control.js
+const UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/iu;
+/** The installation id only tells ChatGPT "this is the same machine"; it is not a secret. */
+async function installationId(filename, fresh = false) {
+	try {
+		if (fresh) throw Object.assign(/* @__PURE__ */ new Error("rotate"), { code: "ENOENT" });
+		const value = JSON.parse(await readFile(filename, "utf8"))?.installationId;
+		if (typeof value === "string" && UUID.test(value)) return value;
+	} catch (error) {
+		if (error?.code !== "ENOENT" && !(error instanceof SyntaxError)) throw error;
+	}
+	const created = randomUUID();
+	await mkdir(dirname(filename), { recursive: true });
+	const temporary = `${filename}.${process.pid}.tmp`;
+	await writeFile(temporary, `${JSON.stringify({ installationId: created })}\n`, { mode: 384 });
+	await rename(temporary, filename);
+	return created;
+}
+/**
+* Optional ChatGPT Remote Control host. Nothing is contacted until enable().
+* @param {{ credentials: Function, WebSocket: Function, fetch?: Function, stateFile: string, hostName: string, userAgent: string, methods: object, notifications?: object, onConnection?: Function, onClose?: Function, base?: string }} options
+*/
+function createRemoteControl(options) {
+	const phones = /* @__PURE__ */ new Set();
+	const host = createRemoteControlHost({
+		methods: options.methods,
+		notifications: options.notifications,
+		onConnection: options.onConnection,
+		onActive: (client) => {
+			phones.add(client.id);
+		},
+		onClose: (client, notify) => {
+			phones.delete(client.id);
+			options.onClose?.(client, notify);
+		},
+		debug: process.env.DSH_CODEX_REMOTE_DEBUG === "1"
+	});
+	let relay;
+	let starting;
+	const ensureRelay = async () => {
+		relay ??= createRemoteControlRelay({
+			debug: process.env.DSH_CODEX_REMOTE_DEBUG === "1",
+			credentials: options.credentials,
+			fetch: options.fetch,
+			WebSocket: options.WebSocket,
+			installationId: await installationId(options.stateFile),
+			renewInstallation: () => installationId(options.stateFile, true),
+			hostName: options.hostName,
+			userAgent: options.userAgent,
+			base: options.base,
+			serve: (client) => host.serve(client)
+		});
+		return relay;
+	};
+	return Object.freeze({
+		host,
+		async enable() {
+			starting ??= ensureRelay().then((value) => {
+				value.start();
+				return value;
+			}).finally(() => {
+				starting = void 0;
+			});
+			await starting;
+			return this.status();
+		},
+		async disable() {
+			if (relay) await relay.stop();
+			return this.status();
+		},
+		async pair(signal) {
+			return (await ensureRelay()).pair(signal);
+		},
+		status() {
+			return {
+				...relay?.status() ?? {
+					status: "stopped",
+					enrolled: false,
+					clients: 0,
+					reconnects: 0
+				},
+				phones: phones.size,
+				methods: host.seen(),
+				trace: host.trace()
+			};
+		}
+	});
+}
+//#endregion
+//#region src/remote-control-dsh.js
+/** A folder the phone named, only when it is an existing absolute folder on this machine. */
+function localFolder(value) {
+	if (typeof value !== "string" || value === "" || !isAbsolute(value)) return void 0;
+	if (process.platform === "win32" && !/^[A-Za-z]:[\\/]/u.test(value)) return void 0;
+	try {
+		return statSync(value).isDirectory() ? value : void 0;
+	} catch {
+		return;
+	}
+}
+const seconds = (value) => Math.floor((Number.isFinite(value) ? value : Date.now()) / 1e3);
+const emptyTurn = () => ({
+	id: randomUUID(),
+	items: [],
+	itemsView: "full",
+	status: "inProgress",
+	error: null,
+	startedAt: seconds(Date.now()),
+	completedAt: null,
+	durationMs: null
+});
+const textOf = (content) => (content ?? []).map((block) => block?.type === "text" ? block.text : "").filter(Boolean).join("\n");
+const inputText = (input) => (Array.isArray(input) ? input : []).map((part) => part?.type === "text" ? part.text : "").filter(Boolean).join("\n");
+const notFound = (id) => new RpcError(-32602, `Thread not found: ${String(id).slice(0, 80)}`);
+const modelKey = (selection) => `${encodeURIComponent(selection.provider)}/${encodeURIComponent(selection.model)}`;
+function parseModelKey(value) {
+	const at = typeof value === "string" ? value.indexOf("/") : -1;
+	if (at <= 0) return void 0;
+	try {
+		return {
+			provider: decodeURIComponent(value.slice(0, at)),
+			model: decodeURIComponent(value.slice(at + 1))
+		};
+	} catch {
+		return;
+	}
+}
+function parseArguments(value) {
+	if (typeof value !== "string") return value ?? null;
+	try {
+		return JSON.parse(value);
+	} catch {
+		return { raw: value };
+	}
+}
+/** What the person typed: DSH appends its own system reminders (skills, context) to user messages. */
+const visibleText = (content) => textOf(content).replace(/<system-reminder>[\s\S]*?<\/system-reminder>/gu, "").trim();
+/** Text of a user-role message the person wrote; DSH's own injected ones (runtime context, notices) carry another source kind. */
+const typedText = (message) => message.role === "user" && (message.source === void 0 || message.source?.kind === "user") ? visibleText(message.content) : "";
+/** One user message starts a turn; assistant blocks and tool results fill it. */
+function projectTurns(messages, at = Date.now()) {
+	const turns = [];
+	let turn;
+	const calls = /* @__PURE__ */ new Map();
+	const close = () => {
+		if (turn && turn.items.length > 0) {
+			turn.status = "completed";
+			turn.completedAt = turn.startedAt;
+			turns.push(turn);
+		}
+		turn = void 0;
+	};
+	for (const message of messages) if (message.role === "user") {
+		const text = typedText(message);
+		if (text === "") continue;
+		close();
+		turn = {
+			...emptyTurn(),
+			id: message.id,
+			startedAt: seconds(at)
+		};
+		turn.items.push({
+			type: "userMessage",
+			id: message.id,
+			clientId: null,
+			content: [{
+				type: "text",
+				text,
+				text_elements: []
+			}]
+		});
+	} else if (message.role === "assistant") {
+		turn ??= {
+			...emptyTurn(),
+			startedAt: seconds(at)
+		};
+		for (const [index, block] of message.content.entries()) {
+			const id = `${message.id}:${index}`;
+			if (block.type === "text") turn.items.push({
+				type: "agentMessage",
+				id,
+				text: block.text,
+				phase: null,
+				memoryCitation: null,
+				delivery: null
+			});
+			else if (block.type === "reasoning") turn.items.push({
+				type: "reasoning",
+				id,
+				summary: [],
+				content: [block.text]
+			});
+			else if (block.type === "tool-call") {
+				const item = {
+					type: "dynamicToolCall",
+					id: block.id,
+					namespace: null,
+					tool: block.name,
+					arguments: parseArguments(block.arguments),
+					status: "inProgress",
+					contentItems: null,
+					success: null,
+					durationMs: null
+				};
+				calls.set(block.id, item);
+				turn.items.push(item);
+			}
+		}
+	} else if (message.role === "tool") {
+		const item = calls.get(message.toolCallId);
+		if (item) {
+			item.contentItems = [{
+				type: "inputText",
+				text: textOf(message.content)
+			}];
+			item.status = message.isError ? "failed" : "completed";
+			item.success = !message.isError;
+		}
+	}
+	close();
+	return turns;
+}
+function thread({ id, title, preview, cwd, createdAt, updatedAt, running, turns = [] }) {
+	return {
+		id,
+		sessionId: id,
+		forkedFromId: null,
+		parentThreadId: null,
+		preview: preview ?? title ?? "",
+		ephemeral: false,
+		modelProvider: "dsh",
+		createdAt: seconds(createdAt),
+		updatedAt: seconds(updatedAt ?? createdAt),
+		recencyAt: seconds(updatedAt ?? createdAt),
+		status: running ? {
+			type: "active",
+			activeFlags: []
+		} : { type: "idle" },
+		path: null,
+		cwd: cwd ?? "",
+		cliVersion: "dsh",
+		source: { custom: "dsh" },
+		threadSource: "dsh",
+		agentNickname: null,
+		agentRole: null,
+		gitInfo: null,
+		name: title ?? null,
+		turns,
+		historyMode: "legacy",
+		section: null,
+		sectionEnteredAt: null,
+		projectId: null,
+		canAcceptDirectInput: true,
+		extra: null
+	};
+}
+/**
+* @param {{ controller: () => any, agents: () => any, permissions?: () => any, userAgent: string }} options
+*/
+const PHONE_RETURN_MS = 12e4;
+function createDshRemoteControl({ controller, agents, permissions = () => void 0, workspaces = () => void 0, trace = () => {}, phoneReturnMs = PHONE_RETURN_MS, userAgent }) {
+	const subscribers = /* @__PURE__ */ new Map();
+	const active = /* @__PURE__ */ new Map();
+	const queues = /* @__PURE__ */ new Map();
+	let catalog;
+	const service = () => {
+		const value = controller();
+		if (!value) throw new RpcError(-32603, "DSH session service is unavailable in this profile");
+		return value;
+	};
+	const arrivals = /* @__PURE__ */ new Map();
+	const subscribe = (threadId, notify) => {
+		const set = subscribers.get(threadId) ?? /* @__PURE__ */ new Set();
+		set.add(notify);
+		subscribers.set(threadId, set);
+		for (const wake of arrivals.get(threadId) ?? []) wake();
+	};
+	/** Wait until a phone opens the thread again, the signal aborts, or the time runs out. */
+	const phoneReturns = (threadId, ms, signal) => new Promise((resolve) => {
+		const set = arrivals.get(threadId) ?? /* @__PURE__ */ new Set();
+		arrivals.set(threadId, set);
+		const done = (value) => {
+			clearTimeout(timer);
+			set.delete(wake);
+			signal?.removeEventListener("abort", stop);
+			if (set.size === 0) arrivals.delete(threadId);
+			resolve(value);
+		};
+		const wake = () => done(true);
+		const stop = () => done(false);
+		const timer = setTimeout(stop, ms);
+		set.add(wake);
+		signal?.addEventListener("abort", stop, { once: true });
+	});
+	const emit = (threadId, method, params) => {
+		for (const notify of subscribers.get(threadId) ?? []) notify(method, params).catch(() => {});
+	};
+	const agentFor = async (id) => {
+		const result = await service().resolveAgent(id);
+		if (!result?.agent) throw notFound(id);
+		return result.agent;
+	};
+	const loadCatalog = async () => {
+		catalog = await service().modelCatalog();
+		return catalog;
+	};
+	const selection = (agent) => agent?.options?.provider && agent?.options?.model ? {
+		provider: agent.options.provider,
+		model: agent.options.model,
+		reasoningEffort: agent.options.reasoningEffort
+	} : catalog?.default;
+	const settings = (agent, cwd) => {
+		const current = selection(agent);
+		const preset = agent?.session ? presetOf(agent.session) : void 0;
+		return {
+			activePermissionProfile: null,
+			approvalPolicy: preset === "danger-full-access" ? "never" : "on-request",
+			approvalsReviewer: "user",
+			cwd: cwd ?? "",
+			initialTurnsPage: null,
+			instructionSources: [],
+			itemsBackwardsCursor: null,
+			model: current ? modelKey(current) : "dsh/default",
+			modelProvider: current?.provider ?? "dsh",
+			multiAgentMode: "explicitRequestOnly",
+			reasoningEffort: current?.reasoningEffort ?? null,
+			runtimeWorkspaceRoots: cwd ? [cwd] : [],
+			sandbox: sandboxFor(preset, cwd),
+			serviceTier: null,
+			turnsBackwardsCursor: null
+		};
+	};
+	const openThread = async (id, notify) => {
+		const agent = await agentFor(id);
+		if (notify) subscribe(id, notify);
+		await (catalog ? void 0 : loadCatalog().catch(() => void 0));
+		const session = agent.session;
+		const messages = session.deriveMessages();
+		const first = messages.find((message) => typedText(message) !== "");
+		return {
+			agent,
+			thread: thread({
+				id,
+				cwd: session.meta?.cwd,
+				createdAt: session.meta?.createdAt,
+				running: active.has(id),
+				preview: first ? visibleText(first.content).slice(0, 200) : "",
+				turns: projectTurns(messages, session.meta?.createdAt)
+			})
+		};
+	};
+	/** Apply a model or effort the phone picked; DSH validates it against its own catalog. */
+	const applySelection = async (agent, sessionId, params) => {
+		const picked = parseModelKey(params?.model);
+		const effort = typeof params?.effort === "string" ? params.effort : void 0;
+		if (!picked && effort === void 0) return;
+		const current = selection(agent) ?? {};
+		const next = {
+			provider: picked?.provider ?? current.provider,
+			model: picked?.model ?? current.model,
+			...effort ?? current.reasoningEffort ? { reasoningEffort: effort ?? current.reasoningEffort } : {}
+		};
+		if (!next.provider || !next.model) return;
+		if (next.provider === current.provider && next.model === current.model && next.reasoningEffort === current.reasoningEffort) return;
+		await service().selectModel({
+			sessionId,
+			...next
+		});
+	};
+	const presetOf = (session) => {
+		try {
+			return permissions()?.current?.(session);
+		} catch {
+			return;
+		}
+	};
+	const sandboxFor = (preset, cwd) => preset === "danger-full-access" || preset === "auto" ? { type: "dangerFullAccess" } : {
+		type: "workspaceWrite",
+		writableRoots: cwd ? [cwd] : [],
+		networkAccess: false,
+		excludeTmpdirEnvVar: false,
+		excludeSlashTmp: false
+	};
+	const applyPermissions = (agent, params) => {
+		const type = params?.sandboxPolicy?.type ?? (typeof params?.sandbox === "string" ? params.sandbox : void 0);
+		const preset = type === "dangerFullAccess" || type === "danger-full-access" ? "danger-full-access" : type === "workspaceWrite" || type === "workspace-write" ? "workspace-write" : void 0;
+		if (!preset || !agent?.session || presetOf(agent.session) === preset) return;
+		permissions()?.set?.(agent.session, preset);
+	};
+	const titles = /* @__PURE__ */ new Map();
+	const lastPrompt = { text: "" };
+	const titleThread = (params) => {
+		const id = `ephemeral-${randomUUID()}`;
+		titles.set(id, Date.now());
+		for (const [key, at] of titles) if (Date.now() - at > 6e5) titles.delete(key);
+		return {
+			...settings(void 0, ""),
+			thread: {
+				...thread({
+					id,
+					cwd: "",
+					createdAt: Date.now()
+				}),
+				ephemeral: true,
+				modelProvider: "dsh"
+			}
+		};
+	};
+	const titleTurn = async (params, notify) => {
+		const title = (lastPrompt.text || inputText(params?.input).split(/\n\s*\n/u).map((part) => part.trim()).filter(Boolean).at(-1) || "DSH").split("\n")[0].trim().slice(0, 36);
+		const turn = {
+			...emptyTurn(),
+			status: "completed",
+			completedAt: seconds(Date.now())
+		};
+		const item = {
+			type: "agentMessage",
+			id: randomUUID(),
+			text: title,
+			phase: null,
+			memoryCitation: null,
+			delivery: null
+		};
+		turn.items.push(item);
+		const threadId = params.threadId;
+		titles.delete(threadId);
+		queueMicrotask(() => {
+			notify("turn/started", {
+				threadId,
+				turn: {
+					...turn,
+					items: [],
+					status: "inProgress",
+					completedAt: null
+				}
+			}).catch(() => {});
+			notify("item/completed", {
+				threadId,
+				turnId: turn.id,
+				item,
+				completedAtMs: Date.now()
+			}).catch(() => {});
+			notify("turn/completed", {
+				threadId,
+				turn
+			}).catch(() => {});
+		});
+		return { turn: {
+			...turn,
+			items: [],
+			status: "inProgress",
+			completedAt: null
+		} };
+	};
+	async function startTurn(params, notify) {
+		const text = inputText(params?.input);
+		if (text === "") throw invalidParams("Only text input is supported");
+		lastPrompt.text = text;
+		const id = params?.threadId;
+		const agent = await agentFor(id);
+		if (active.has(id)) throw new RpcError(-32602, "A turn is already running in this conversation");
+		subscribe(id, notify);
+		await applySelection(agent, id, params);
+		applyPermissions(agent, params);
+		const turn = emptyTurn();
+		active.set(id, {
+			turn,
+			ended: void 0
+		});
+		const userItem = {
+			type: "userMessage",
+			id: randomUUID(),
+			clientId: params.clientUserMessageId ?? null,
+			content: [{
+				type: "text",
+				text,
+				text_elements: []
+			}]
+		};
+		emit(id, "turn/started", {
+			threadId: id,
+			turn
+		});
+		emit(id, "item/started", {
+			threadId: id,
+			turnId: turn.id,
+			item: userItem,
+			startedAtMs: Date.now()
+		});
+		emit(id, "item/completed", {
+			threadId: id,
+			turnId: turn.id,
+			item: userItem,
+			completedAtMs: Date.now()
+		});
+		try {
+			await service().prompt({
+				requestId: randomUUID(),
+				sessionId: id,
+				mode: "queue",
+				content: [{
+					type: "text",
+					text
+				}]
+			}, AbortSignal.timeout(3e4));
+		} catch (error) {
+			active.delete(id);
+			throw new RpcError(-32603, error?.message ? `DSH did not accept the message: ${String(error.message).slice(0, 200)}` : "DSH did not accept the message");
+		}
+		Promise.resolve(agent.whenIdle?.()).catch(() => {}).then(() => {
+			const reason = active.get(id)?.ended;
+			turn.status = reason?.kind === "error" ? "failed" : reason?.kind === "aborted" || reason?.kind === "interrupted" ? "interrupted" : "completed";
+			if (reason?.kind === "error") {
+				const message = String(reason.error?.message ?? reason.error?.code ?? "The model request failed").slice(0, 500);
+				turn.error = {
+					message,
+					codexErrorInfo: null,
+					additionalDetails: null
+				};
+				emit(id, "error", {
+					threadId: id,
+					turnId: turn.id,
+					willRetry: false,
+					error: turn.error
+				});
+			}
+			turn.completedAt = seconds(Date.now());
+			active.delete(id);
+			emit(id, "turn/completed", {
+				threadId: id,
+				turn
+			});
+			const [next, ...rest] = queues.get(id) ?? [];
+			if (next) {
+				queues.set(id, rest);
+				emit(id, "thread/queue/changed", { threadId: id });
+				startTurn({
+					threadId: id,
+					input: next.input,
+					clientUserMessageId: next.clientUserMessageId
+				}, notify).catch(() => {});
+			}
+		});
+		return { turn };
+	}
+	const methods = {
+		initialize: () => ({
+			codexHome: "",
+			platformFamily: process.platform === "win32" ? "windows" : "unix",
+			platformOs: {
+				darwin: "macos",
+				win32: "windows"
+			}[process.platform] ?? process.platform,
+			userAgent
+		}),
+		"account/read": () => ({
+			account: {
+				type: "chatgpt",
+				email: null,
+				planType: "unknown"
+			},
+			requiresOpenaiAuth: false
+		}),
+		"modelProvider/capabilities/read": () => ({
+			imageGeneration: false,
+			namespaceTools: false,
+			webSearch: false
+		}),
+		"model/list": async () => {
+			const value = await loadCatalog();
+			const defaultKey = value.default ? modelKey(value.default) : void 0;
+			const data = [];
+			for (const group of value.groups ?? []) for (const model of group.models ?? []) {
+				const key = modelKey({
+					provider: group.id,
+					model: model.id
+				});
+				const efforts = (model.reasoning?.efforts ?? []).map((effort) => ({
+					reasoningEffort: effort.id,
+					description: effort.name ?? effort.id
+				}));
+				const supported = efforts.length > 0 ? efforts : [{
+					reasoningEffort: "medium",
+					description: "Default"
+				}];
+				data.push({
+					id: key,
+					model: key,
+					displayName: model.name ?? model.id,
+					description: group.name ?? "",
+					hidden: false,
+					isDefault: key === defaultKey,
+					supportedReasoningEfforts: supported,
+					defaultReasoningEffort: model.reasoning?.defaultEffort ?? supported[0].reasoningEffort,
+					inputModalities: ["text"],
+					supportsPersonality: false,
+					additionalSpeedTiers: [],
+					upgrade: null,
+					upgradeInfo: null,
+					availabilityNux: null,
+					serviceTiers: []
+				});
+			}
+			return {
+				data,
+				nextCursor: null
+			};
+		},
+		"configRequirements/read": () => ({ requirements: {
+			allowedSandboxModes: ["workspace-write", "danger-full-access"],
+			allowedApprovalPolicies: ["on-request", "never"],
+			allowRemoteControl: true
+		} }),
+		"thread/settings/update": async (params) => {
+			const agent = await agentFor(params?.threadId);
+			await applySelection(agent, params.threadId, params);
+			applyPermissions(agent, params);
+			return {};
+		},
+		"thread/attachment/list": () => ({
+			data: [],
+			nextCursor: null
+		}),
+		"config/batchWrite": () => ({
+			status: "ok",
+			version: "1",
+			filePath: process.platform === "win32" ? "C:dshconfig.toml" : "/dsh/config.toml",
+			overriddenMetadata: null
+		}),
+		"command/exec": () => {
+			throw new RpcError(-32600, "Running commands directly is not available on a DSH host; ask in the conversation instead");
+		},
+		"plugin/installed": () => ({
+			marketplaceLoadErrors: [],
+			marketplaces: []
+		}),
+		"fs/createDirectory": () => ({}),
+		"fs/getMetadata": () => ({
+			isDirectory: true,
+			isFile: false,
+			isSymlink: false,
+			createdAtMs: Date.now(),
+			modifiedAtMs: Date.now()
+		}),
+		"fs/readDirectory": () => ({ entries: [] }),
+		"collaborationMode/list": () => ({ data: [] }),
+		"permissionProfile/list": () => ({
+			data: [],
+			nextCursor: null
+		}),
+		"threadSection/list": () => ({
+			data: [],
+			nextCursor: null
+		}),
+		"thread/goal/get": () => ({ goal: null }),
+		"experimentalFeature/list": () => ({
+			data: [],
+			nextCursor: null
+		}),
+		"skills/list": () => ({ data: [] }),
+		"config/read": () => ({
+			config: {},
+			origins: {},
+			layers: null
+		}),
+		"thread/loaded/list": () => ({
+			data: [...subscribers.keys()],
+			nextCursor: null
+		}),
+		"thread/unsubscribe": () => ({ status: "notSubscribed" }),
+		"thread/list": async (params, { signal }) => {
+			const value = await service().list({}, signal);
+			const archived = new Set(workspaces()?.archivedSessionIds ?? []);
+			const wantArchived = params?.archived === true;
+			return {
+				data: (value.items ?? []).filter((item) => item.origin !== "subagent" && !item.blank && archived.has(item.sessionId) === wantArchived).map((item) => thread({
+					id: item.sessionId,
+					cwd: item.cwd,
+					createdAt: item.updatedAt,
+					updatedAt: item.updatedAt,
+					running: item.running,
+					title: item.projections?.values?.title ?? null
+				})).filter((entry) => !params?.searchTerm || `${entry.name ?? ""} ${entry.preview}`.toLocaleLowerCase().includes(String(params.searchTerm).toLocaleLowerCase())),
+				nextCursor: null,
+				backwardsCursor: null
+			};
+		},
+		"thread/archive": async (params) => {
+			const registry = workspaces();
+			if (!registry) throw new RpcError(-32603, "DSH archive is unavailable in this profile");
+			try {
+				await registry.archiveSession(params?.threadId, { stopActivity: true });
+			} catch {
+				throw notFound(params?.threadId);
+			}
+			active.delete(params?.threadId);
+			return {};
+		},
+		"thread/unarchive": async (params) => {
+			const registry = workspaces();
+			if (!registry) throw new RpcError(-32603, "DSH archive is unavailable in this profile");
+			await registry.unarchiveSession(params?.threadId);
+			return { thread: (await openThread(params?.threadId)).thread };
+		},
+		"thread/read": async (params) => ({ thread: (await openThread(params?.threadId)).thread }),
+		"thread/resume": async (params, { notify }) => {
+			const { agent, thread: value } = await openThread(params?.threadId, notify);
+			return {
+				...settings(agent, value.cwd),
+				thread: value
+			};
+		},
+		"thread/start": async (params, { notify }) => {
+			if (params?.ephemeral === true) return titleThread(params);
+			const cwd = localFolder(params?.cwd);
+			const created = await service().create(cwd ? { cwd } : {});
+			const agent = await agentFor(created.sessionId);
+			await applySelection(agent, created.sessionId, params);
+			const { thread: value } = await openThread(created.sessionId, notify);
+			emit(created.sessionId, "thread/started", { thread: value });
+			return {
+				...settings(agent, value.cwd),
+				thread: value
+			};
+		},
+		"turn/start": (params, { notify }) => titles.has(params?.threadId) ? titleTurn(params, notify) : startTurn(params, notify),
+		"turn/interrupt": (params) => {
+			service().cancel({ sessionId: params?.threadId });
+			return {};
+		},
+		"turn/steer": async (params) => {
+			const text = inputText(params?.input);
+			if (text === "") throw invalidParams("Only text input is supported");
+			await service().prompt({
+				requestId: randomUUID(),
+				sessionId: params?.threadId,
+				mode: "steer",
+				content: [{
+					type: "text",
+					text
+				}]
+			}, AbortSignal.timeout(3e4));
+			return { turnId: params?.expectedTurnId ?? active.get(params?.threadId)?.turn.id ?? "" };
+		},
+		"thread/name/set": async (params) => {
+			await service().rename({
+				sessionId: params?.threadId,
+				title: String(params?.name ?? "")
+			});
+			return {};
+		},
+		"thread/queue/list": (params) => ({
+			data: queues.get(params?.threadId) ?? [],
+			nextCursor: null
+		}),
+		"thread/queue/add": async (params, { notify }) => {
+			if (!Array.isArray(params?.input)) throw invalidParams("input is required");
+			const id = params?.threadId;
+			const queued = {
+				id: randomUUID(),
+				clientUserMessageId: String(params.clientUserMessageId ?? randomUUID()),
+				input: params.input
+			};
+			subscribe(id, notify);
+			if (!active.has(id)) await startTurn({
+				threadId: id,
+				input: queued.input,
+				clientUserMessageId: queued.clientUserMessageId,
+				model: params.model,
+				effort: params.effort
+			}, notify);
+			else {
+				queues.set(id, [...queues.get(id) ?? [], queued]);
+				emit(id, "thread/queue/changed", { threadId: id });
+			}
+			return { queuedSubmission: queued };
+		},
+		"thread/queue/delete": (params) => {
+			const list = queues.get(params?.threadId) ?? [];
+			const next = list.filter((entry) => entry.id !== params?.queuedSubmissionId);
+			queues.set(params?.threadId, next);
+			if (next.length !== list.length) emit(params?.threadId, "thread/queue/changed", { threadId: params?.threadId });
+			return { deleted: next.length !== list.length };
+		},
+		"thread/queue/reorder": (params) => {
+			const order = Array.isArray(params?.queuedSubmissionIds) ? params.queuedSubmissionIds : [];
+			const list = queues.get(params?.threadId) ?? [];
+			queues.set(params?.threadId, [...order.map((id) => list.find((entry) => entry.id === id)).filter(Boolean), ...list.filter((entry) => !order.includes(entry.id))]);
+			emit(params?.threadId, "thread/queue/changed", { threadId: params?.threadId });
+			return {};
+		},
+		"thread/queue/start": async (params, { notify }) => {
+			const list = queues.get(params?.threadId) ?? [];
+			const queued = list.find((entry) => params?.queuedSubmissionId == null || entry.id === params.queuedSubmissionId);
+			if (!queued) throw invalidParams("Nothing queued");
+			queues.set(params.threadId, list.filter((entry) => entry !== queued));
+			emit(params.threadId, "thread/queue/changed", { threadId: params.threadId });
+			return startTurn({
+				threadId: params.threadId,
+				input: queued.input,
+				clientUserMessageId: queued.clientUserMessageId
+			}, notify);
+		}
+	};
+	const callOf = (session, callId) => {
+		for (const message of session.deriveMessages().toReversed()) {
+			if (message.role !== "assistant") continue;
+			const block = message.content.find((entry) => entry.type === "tool-call" && entry.id === callId);
+			if (block) return block;
+		}
+	};
+	const commandText = (session, request) => {
+		const call = request.callId ? callOf(session, request.callId) : void 0;
+		const args = call ? parseArguments(call.arguments) : void 0;
+		const shown = typeof args?.command === "string" ? args.command : typeof args?.cmd === "string" ? args.cmd : call ? `${call.name} ${JSON.stringify(args)}` : request.toolName;
+		return String(shown).slice(0, 2e3);
+	};
+	/**
+	* DSH approval answerer: while a phone drives a turn, it answers that turn's approvals.
+	* Without a phone (or if it drops) the request goes on to DSH's own prompt.
+	*/
+	/** The phone driving this agent's running turn, when there is one. */
+	const phoneFor = (request) => {
+		const session = request.agent?.session;
+		const running = session ? active.get(session.id) : void 0;
+		const phone = session ? [...subscribers.get(session.id) ?? []].find((notify) => typeof notify.ask === "function") : void 0;
+		return running && phone ? {
+			session,
+			running,
+			phone
+		} : void 0;
+	};
+	/**
+	* Ask whichever phone drives the turn. A phone that drops (app switched away, network) gets the
+	* same request again when it reopens the thread within PHONE_RETURN_MS; otherwise DSH decides.
+	*/
+	const askPhone = async (request, method, params) => {
+		const sessionId = request.agent.session.id;
+		for (;;) {
+			const phone = phoneFor(request)?.phone;
+			if (!phone) throw new RpcError(-32800, "No phone");
+			try {
+				return await phone.ask(method, params, request.signal);
+			} catch (error) {
+				if (request.signal?.aborted || !active.has(sessionId) || phoneFor(request)?.phone === phone) throw error;
+				trace({
+					method: `wait:${method}`,
+					session: sessionId
+				});
+				if (!phoneFor(request) && !await phoneReturns(sessionId, phoneReturnMs, request.signal)) throw error;
+			}
+		}
+	};
+	/** DSH's ask-user tool: show the questions on the phone that drives the turn, else leave them to DSH. */
+	const onQuestion = (request, next) => {
+		const found = phoneFor(request);
+		trace({
+			method: "hook:user-questions",
+			phone: Boolean(found),
+			session: request.agent?.session?.id ?? null
+		});
+		if (!found) return next();
+		const { session, running } = found;
+		const labels = new Map(request.questions.map((question) => [question.id, new Set((question.options ?? []).map((option) => option.label))]));
+		return askPhone(request, "item/tool/requestUserInput", {
+			threadId: session.id,
+			turnId: running.turn.id,
+			itemId: request.wait?.callId ?? randomUUID(),
+			questions: request.questions.map((question) => ({
+				id: question.id,
+				header: question.header ?? "",
+				question: question.detail ? `${question.question}\n\n${question.detail}` : question.question,
+				isOther: true,
+				isSecret: false,
+				options: question.options?.length ? question.options.map((option) => ({
+					label: option.label,
+					description: option.description ?? ""
+				})) : null
+			}))
+		}).then((answer) => ({ answers: request.questions.map((question) => {
+			const given = Array.isArray(answer?.answers?.[question.id]?.answers) ? answer.answers[question.id].answers.map(String) : [];
+			const known = labels.get(question.id);
+			const selected = given.filter((value) => known.has(value));
+			const custom = given.filter((value) => !known.has(value)).join("\n");
+			return {
+				id: question.id,
+				selected,
+				...custom === "" ? {} : { custom }
+			};
+		}) }), () => next());
+	};
+	const onApproval = (request, next) => {
+		const found = phoneFor(request);
+		trace({
+			method: "hook:approval",
+			phone: Boolean(found),
+			session: request.agent?.session?.id ?? null
+		});
+		if (!found) return next();
+		const { session, running } = found;
+		return askPhone(request, "item/commandExecution/requestApproval", {
+			threadId: session.id,
+			turnId: running.turn.id,
+			itemId: request.callId ?? randomUUID(),
+			startedAtMs: Date.now(),
+			command: commandText(session, request),
+			cwd: session.meta?.cwd ?? null,
+			reason: request.displayReason?.en ?? request.reason ?? null,
+			commandActions: [],
+			availableDecisions: [
+				"accept",
+				"decline",
+				"cancel"
+			]
+		}).then((answer) => {
+			const decision = typeof answer?.decision === "string" ? answer.decision : "";
+			return decision === "accept" || decision === "acceptForSession" ? "allowed-once" : decision === "cancel" ? "cancelled" : "rejected";
+		}, () => next());
+	};
+	/** Forward committed assistant and tool events of a phone-started turn as items. */
+	const onSessionEvent = (session, event) => {
+		const running = active.get(session.id);
+		if (!running || !subscribers.has(session.id)) return;
+		if (event.type === "turn/end") {
+			running.ended = event.data?.reason;
+			return;
+		}
+		if (event.type !== "assistant/message" && event.type !== "tool/result") return;
+		const message = session.deriveMessages().at(-1);
+		if (message?.role === "tool") {
+			const item = running.turn.items.find((entry) => entry.type === "dynamicToolCall" && entry.id === message.toolCallId);
+			if (item) {
+				item.contentItems = [{
+					type: "inputText",
+					text: textOf(message.content)
+				}];
+				item.status = message.isError ? "failed" : "completed";
+				item.success = !message.isError;
+				emit(session.id, "item/completed", {
+					threadId: session.id,
+					turnId: running.turn.id,
+					item,
+					completedAtMs: Date.now()
+				});
+			}
+			return;
+		}
+		if (!message || message.role !== "assistant") return;
+		const items = projectTurns([{
+			role: "user",
+			id: "x",
+			content: []
+		}, message]).flatMap((turn) => turn.items.slice(1));
+		for (const item of items) {
+			running.turn.items.push(item);
+			emit(session.id, "item/started", {
+				threadId: session.id,
+				turnId: running.turn.id,
+				item,
+				startedAtMs: Date.now()
+			});
+			emit(session.id, "item/completed", {
+				threadId: session.id,
+				turnId: running.turn.id,
+				item,
+				completedAtMs: Date.now()
+			});
+		}
+	};
+	return {
+		methods,
+		onSessionEvent,
+		onApproval,
+		onQuestion,
+		forget: (notify) => {
+			for (const set of subscribers.values()) set.delete(notify);
+		}
+	};
+}
+//#endregion
 //#region src/account-vault.js
 const VERSION = 1;
 const DEFAULT_LABEL = "Account 1";
@@ -6061,7 +7606,7 @@ const publicError = (code, message) => ({
 		details: { issues: [] }
 	}
 });
-function createSubscriptionRpcHandler({ authHandler, usageReader, resetCreditService, preferences, defaultModel, runtimeManagement, diagnosticsReader, modelCatalog, originalImages, resolveInheritedOriginal, closeConnections, onAccountChanged, onCleanupFailure }) {
+function createSubscriptionRpcHandler({ authHandler, usageReader, resetCreditService, preferences, defaultModel, runtimeManagement, remoteControl, diagnosticsReader, modelCatalog, originalImages, resolveInheritedOriginal, closeConnections, onAccountChanged, onCleanupFailure }) {
 	return async (endpoint, payload, signal) => {
 		if (endpoint === "default-model/status" || endpoint === "default-model/select") try {
 			signal.throwIfAborted();
@@ -6076,6 +7621,23 @@ function createSubscriptionRpcHandler({ authHandler, usageReader, resetCreditSer
 			if (error?.code === "unavailable") return publicError("unavailable", endpoint === "default-model/status" ? "The default model is unavailable" : "Could not save the default model");
 			return publicError("internal", endpoint === "default-model/status" ? "Could not read the default model" : "Could not save the default model");
 		}
+		if ([
+			"remote/status",
+			"remote/enable",
+			"remote/disable",
+			"remote/pair"
+		].includes(endpoint)) try {
+			signal.throwIfAborted();
+			if (!remoteControl) return publicError("unavailable", "Remote Control is unavailable");
+			const action = endpoint.split("/")[1];
+			return {
+				ok: true,
+				value: action === "status" ? remoteControl.status() : action === "enable" ? await remoteControl.enable() : action === "disable" ? await remoteControl.disable() : await remoteControl.pair(signal)
+			};
+		} catch (error) {
+			if (signal.aborted) throw error;
+			return publicError(typeof error?.code === "string" ? error.code : "operation-error", "Remote Control request failed");
+		}
 		if (endpoint === "storage/status" || endpoint === "storage/clear-forecast") try {
 			signal.throwIfAborted();
 			if (endpoint === "storage/clear-forecast") await usageReader.clear();
@@ -6404,6 +7966,7 @@ function apply(ctx, config = {}) {
 				compactionMode: settings.get().compactionMode ?? "dsh",
 				connectionMode: settings.get().connectionMode ?? "sse",
 				reviewModel: settings.get().reviewModel ?? "session",
+				remoteControl: settings.get().remoteControl ?? "off",
 				subagentBackend: settings.get().subagentBackend ?? "dsh",
 				subagentBackendAvailable: subagentBackend !== void 0,
 				subagentRuntimeInstalled: inspectSubagentRuntime().installed,
@@ -6597,6 +8160,65 @@ function apply(ctx, config = {}) {
 		}
 	});
 	const coordinator = new CodexLoginCoordinator(auth);
+	const remoteBridge = createDshRemoteControl({
+		controller: () => ctx.get?.("sessionController"),
+		agents: () => ctx.get?.("agents"),
+		permissions: () => ctx.get?.("permissionPresets"),
+		workspaces: () => ctx.get?.("workspaceRegistry"),
+		trace: (entry) => {
+			try {
+				remoteControl.host.note(entry);
+			} catch {}
+		},
+		userAgent: USER_AGENT
+	});
+	const remoteControl = createRemoteControl({
+		credentials: (signal) => readSubscriptionCredentials(resolveAuth, (options) => store.read(PROVIDER, {
+			...options,
+			signal
+		}), signal),
+		WebSocket,
+		fetch: (input, init) => network.fetch("remote", input, init),
+		stateFile: dshHomePath("state", "codex-subscription", "remote-control.json"),
+		hostName: `DSH (${hostname()})`,
+		userAgent: USER_AGENT,
+		methods: remoteBridge.methods,
+		onClose: (_client, notify) => remoteBridge.forget(notify)
+	});
+	ctx.on("session/event", (session, event) => {
+		try {
+			remoteBridge.onSessionEvent(session, event);
+		} catch {}
+	});
+	ctx.on("approval/request", (request, next) => {
+		try {
+			return remoteBridge.onApproval(request, next);
+		} catch {
+			return next();
+		}
+	}, true);
+	ctx.on("user-questions/request", (request, next) => {
+		try {
+			return remoteBridge.onQuestion(request, next);
+		} catch {
+			return next();
+		}
+	}, true);
+	ctx.effect(() => {
+		let wanted = false;
+		const follow = (value) => {
+			const next = value.remoteControl === "on";
+			if (next === wanted) return;
+			wanted = next;
+			(next ? remoteControl.enable() : remoteControl.disable()).catch((error) => ctx.logger?.debug?.("Remote Control: %s", error?.code ?? error?.message));
+		};
+		follow(settings.get());
+		const unwatch = settings.watch(follow);
+		return () => {
+			unwatch();
+			remoteControl.disable().catch(() => {});
+		};
+	}, "codex-subscription: Remote Control host");
 	const usageReader = createQuotaForecastReader({
 		reader: createCodexUsageReader({
 			getAuth: resolveAuth,
@@ -6682,6 +8304,7 @@ function apply(ctx, config = {}) {
 		preferences,
 		defaultModel,
 		runtimeManagement,
+		remoteControl,
 		onAccountChanged: quotaRetryHandler.notifyAccountChanged,
 		diagnosticsReader: () => createSubscriptionDiagnostics({
 			auth,