codexteer 0.18.2 → 0.19.0

package/src/launcher.mjs

@@ -121,19 +121,19 @@ export function desktopLaunchArgs(home, wrapper) {
 export async function startDesktop({ dryRun = false, run = spawnSync, prepare = prepareDeployment, discover = discoverRuntime, connect = RpcClient.connect } = {}) {
   const home = codexHome();
   if (dryRun) return { backend: "app-server", dry_run: true, started: false, command: "desktop.start" };
-  if (process.platform !== "darwin") throw new Error("Desktop startup requires macOS.");
-  if (process.env.CODEX_APP_SERVER_WS_URL?.trim()) throw new Error("An existing CODEX_APP_SERVER_WS_URL override conflicts with shared Desktop startup. Remove it from this launch environment first.");
+  if (process.platform !== "darwin") throw Object.assign(new Error("Desktop startup requires macOS."), { code: "DESKTOP_START_UNSUPPORTED" });
+  if (process.env.CODEX_APP_SERVER_WS_URL?.trim()) throw Object.assign(new Error("An existing CODEX_APP_SERVER_WS_URL override conflicts with shared Desktop startup. Remove it from this launch environment first."), { code: "DESKTOP_START_UNSUPPORTED" });
   await access(BUNDLED_CLI, constants.X_OK);
   await access(BUNDLED_NODE, constants.X_OK);
   // No Accessibility APIs, focus changes, process termination, or -n (new instance).
   const processes = run("/bin/ps", ["-axo", "comm="], { encoding: "utf8", timeout: 3000 });
-  if (processes.status !== 0) throw new Error("Cannot check whether Desktop is running. Run desktop start from your terminal.");
+  if (processes.status !== 0) throw Object.assign(new Error("Cannot check whether Desktop is running. Run desktop start from your terminal."), { code: "DESKTOP_START_FAILED" });
   if (processes.stdout.split("\n").some(line => line.trim() === `${APP_PATH}/Contents/MacOS/ChatGPT`)) {
-    throw new Error("Desktop is already running. Finish current tasks and quit Desktop, then run: codexteer desktop start");
+    throw Object.assign(new Error("Desktop is already running. Finish current tasks and quit Desktop, then run: codexteer desktop start"), { code: "DESKTOP_ALREADY_RUNNING" });
   }
   const deployment = await prepare(home);
   const launched = run("/usr/bin/open", desktopLaunchArgs(home, deployment.wrapper_path), { encoding: "utf8", timeout: 5000 });
-  if (launched.status !== 0) throw new Error("Desktop launch failed. Normal startup from the Dock is still available.");
+  if (launched.status !== 0) throw Object.assign(new Error("Desktop launch failed. Normal startup from the Dock is still available."), { code: "DESKTOP_START_FAILED" });
   let lastError;
   for (let attempt = 0; attempt < 100; attempt++) {
     try {
@@ -149,5 +149,5 @@ export async function startDesktop({ dryRun = false, run = spawnSync, prepare =
     }
     await delay(200);
   }
-  throw new Error(`Desktop started, but its shared App Server is not ready. ${lastError?.message ?? ""}`);
+  throw Object.assign(new Error(`Desktop started, but its shared App Server is not ready. ${lastError?.message ?? ""}`), { code: "RUNTIME_NOT_READY" });
 }

package/src/monitor.mjs

@@ -24,8 +24,8 @@ export async function streamThread(threadInput, options, onChange, { discover =
     if (discover === discoverRuntime) discover = cloud.discover;
     if (connect === RpcClient.connect) connect = cloud.connect;
   }
-  if (!Number.isInteger(pollMs) || pollMs < 250 || pollMs > 10000) throw new Error("--poll-ms must be between 250 and 10000.");
-  if (!Number.isInteger(reconnectTimeoutMs) || reconnectTimeoutMs < 1 || reconnectTimeoutMs > 60000) throw new Error("Invalid reconnect timeout.");
+  if (!Number.isInteger(pollMs) || pollMs < 250 || pollMs > 10000) throw Object.assign(new Error("--poll-ms must be between 250 and 10000."), { code: "OPTIONS_INVALID" });
+  if (!Number.isInteger(reconnectTimeoutMs) || reconnectTimeoutMs < 1 || reconnectTimeoutMs > 60000) throw Object.assign(new Error("Invalid reconnect timeout."), { code: "OPTIONS_INVALID" });
   const notification = notificationOptions(options);
   const buffer = notification.notify === "digest" ? new NotificationBuffer(notification) : null;
   if (signal?.aborted) return;

package/src/notify.mjs

@@ -5,9 +5,9 @@ const key = event => JSON.stringify([event.turn_id, event.id]);
 const commandState = ({ change, output, ...event }) => event;
 
 export function notificationOptions({ notify = "digest", settleMs = 20000, maxHoldMs = 600000 } = {}) {
-  if (!["all", "digest"].includes(notify)) throw new Error("--notify must be all or digest.");
-  if (!Number.isInteger(settleMs) || settleMs < 1000 || settleMs > 120000) throw new Error("--settle-ms must be between 1000 and 120000.");
-  if (!Number.isInteger(maxHoldMs) || maxHoldMs < 10000 || maxHoldMs > 1800000) throw new Error("--max-hold-ms must be between 10000 and 1800000.");
+  if (!["all", "digest"].includes(notify)) throw Object.assign(new Error("--notify must be all or digest."), { code: "OPTIONS_INVALID" });
+  if (!Number.isInteger(settleMs) || settleMs < 1000 || settleMs > 120000) throw Object.assign(new Error("--settle-ms must be between 1000 and 120000."), { code: "OPTIONS_INVALID" });
+  if (!Number.isInteger(maxHoldMs) || maxHoldMs < 10000 || maxHoldMs > 1800000) throw Object.assign(new Error("--max-hold-ms must be between 10000 and 1800000."), { code: "OPTIONS_INVALID" });
   return { notify, settleMs, maxHoldMs };
 }
 

package/src/observe.mjs

@@ -95,7 +95,7 @@ export function trimEvent(event, maxChars, includeOutput) {
 }
 
 export function readSnapshot(thread, { since, limit = 50, maxChars = 2000, includeOutput = false } = {}) {
-  if (!Number.isInteger(limit) || limit < 1 || limit > 1000 || !Number.isInteger(maxChars) || maxChars < 100 || maxChars > 20000) throw new Error("Invalid read limit or max-chars.");
+  if (!Number.isInteger(limit) || limit < 1 || limit > 1000 || !Number.isInteger(maxChars) || maxChars < 100 || maxChars > 20000) throw Object.assign(new Error("Invalid read limit or max-chars."), { code: "OPTIONS_INVALID" });
   const s = threadSnapshot(thread), old = since ? decodeCursor(since, thread.id) : null;
   if (old && old.v !== 1) throw invalidCursor();
   if (old && (old.count > s.events.length || prefixHash(s.hashes, old.count, old.open) !== old.prefix)) throw invalidCursor();
@@ -137,7 +137,7 @@ export async function fetchThread(client, threadId, metadata) {
 
 async function readAttempt(client, threadId, options) {
   const old = options.since ? decodeCursor(options.since, threadId) : null;
-  if (options.fullHistory && old?.v === 2) throw new Error("A v2 cursor uses paged history. Omit --full-history, or read --full-history without --since to start a full check.");
+  if (options.fullHistory && old?.v === 2) throw Object.assign(new Error("A v2 cursor uses paged history. Omit --full-history, or read --full-history without --since to start a full check."), { code: "OPTIONS_INVALID" });
   const { thread } = await client.request("thread/read", { threadId, includeTurns: false });
   if (thread?.id !== threadId || !Array.isArray(thread.turns)) throw protocolFailure("App Server returned invalid task metadata.");
   if (thread.historyMode === "paginated" && !options.fullHistory) {
@@ -169,6 +169,8 @@ export async function observeThread(threadInput, options = {}, { discover = disc
   }
   if (options.supervisor) await assertSupervisor(threadId, options.supervisor, { connection: options.connection });
   if (options.since) decodeCursor(options.since, threadId);
+  const { until = "change", timeoutMs = 30000, pollMs = 1000 } = options;
+  if (options.watch && (!["change", "idle", "attention"].includes(until) || !Number.isInteger(timeoutMs) || timeoutMs < 0 || timeoutMs > 60000 || !Number.isInteger(pollMs) || pollMs < 250 || pollMs > 10000)) throw Object.assign(new Error("Invalid watch condition, timeout-ms or poll-ms."), { code: "OPTIONS_INVALID" });
   let client;
   try {
     const { paths, state } = await discover();
@@ -179,8 +181,6 @@ export async function observeThread(threadInput, options = {}, { discover = disc
       if (options.supervisor) await recordSupervisorObservation(threadId, options.supervisor, result);
       return result;
     }
-    const { until = "change", timeoutMs = 30000, pollMs = 1000 } = options;
-    if (!["change", "idle", "attention"].includes(until) || !Number.isInteger(timeoutMs) || timeoutMs < 0 || timeoutMs > 60000 || !Number.isInteger(pollMs) || pollMs < 250 || pollMs > 10000) throw new Error("Invalid watch condition, timeout-ms or poll-ms.");
     const deadline = now() + timeoutMs;
     let baseline = options.since;
     while (true) {

package/src/paged-read.mjs

@@ -75,13 +75,13 @@ function finish(state, cursor, events, commands, old, pending, omitted) {
   Object.assign(cursor, hostFields());
   cursor.state = digest(state); cursor.active_turn_id = state.active_turn_id; cursor.pending = pending;
   const encoded = Buffer.from(JSON.stringify(cursor)).toString("base64url");
-  if (encoded.length > 1024 * 1024) throw new Error("Too many in-progress items for a fast cursor. Use --full-history.");
+  if (encoded.length > 1024 * 1024) throw Object.assign(new Error("Too many in-progress items for a fast cursor. Use --full-history."), { code: "CURSOR_TOO_LARGE" });
   return { ...state, events, running_commands: [...commands.values()], cursor: encoded, changed: !old || events.length > 0 || old.state !== cursor.state,
     has_more: pending, omitted_older_events: omitted, history_scope: "tail-and-tracked-items", running_commands_complete: !pending, observed_at: new Date().toISOString() };
 }
 
 export async function readPaged(client, thread, { since, limit = 50, maxChars = 2000, includeOutput = false } = {}) {
-  if (!Number.isInteger(limit) || limit < 1 || limit > 1000 || !Number.isInteger(maxChars) || maxChars < 100 || maxChars > 20000) throw new Error("Invalid read limit or max-chars.");
+  if (!Number.isInteger(limit) || limit < 1 || limit > 1000 || !Number.isInteger(maxChars) || maxChars < 100 || maxChars > 20000) throw Object.assign(new Error("Invalid read limit or max-chars."), { code: "OPTIONS_INVALID" });
   const old = since ? decodeCursor(since, thread.id) : null;
   if (old && old.v !== 2) throw invalidCursor();
   const turns = await turnMetadata(client, thread.id), state = stateOf(thread, turns), commands = new Map();

package/src/resource.mjs

@@ -6,10 +6,10 @@ import { runCommand } from "./runner.mjs";
 import { targetHost } from "./target.mjs";
 
 function resourceKey(name) {
-  if (!name?.trim() || name.length > 200 || /[\r\n\x00-\x1f]/.test(name)) throw new Error("Resource name must be a non-empty single line (up to 200 characters).");
+  if (!name?.trim() || name.length > 200 || /[\r\n\x00-\x1f]/.test(name)) throw Object.assign(new Error("Resource name must be a non-empty single line (up to 200 characters)."), { code: "OPTIONS_INVALID" });
   return digest(name).slice(0, 40);
 }
-function validTtl(ttlMs) { if (!Number.isInteger(ttlMs) || ttlMs < 1000 || ttlMs > 86400000) throw new Error("--ttl-ms must be between 1000 and 86400000."); }
+function validTtl(ttlMs) { if (!Number.isInteger(ttlMs) || ttlMs < 1000 || ttlMs > 86400000) throw Object.assign(new Error("--ttl-ms must be between 1000 and 86400000."), { code: "OPTIONS_INVALID" }); }
 function leaseState(entry, now = Date.now()) { return !entry ? "available" : entry.released_at ? "released" : Date.parse(entry.expires_at) <= now ? "expired" : "held"; }
 
 export async function resourceStatus(name, { now = Date.now, ...storage } = {}) {
@@ -19,7 +19,7 @@ export async function resourceStatus(name, { now = Date.now, ...storage } = {})
 
 export async function acquireResource(name, { owner, ttlMs = 600000, reason = "", condition = "", threadId, now = Date.now, ...storage }) {
   const key = resourceKey(name); validTtl(ttlMs);
-  if (!owner?.trim()) throw new Error("--owner is required (for example claude-code or codex).");
+  if (!owner?.trim()) throw Object.assign(new Error("--owner is required (for example claude-code or codex)."), { code: "OPTIONS_INVALID" });
   if (threadId) threadId = normalizeTaskId(threadId);
   return withStoreLock(`resource-${key}`, async () => {
     const current = await readRecord("resources", key, storage);
@@ -34,7 +34,7 @@ export async function renewResource(name, token, { ttlMs = 600000, now = Date.no
   const key = resourceKey(name); validTtl(ttlMs);
   return withStoreLock(`resource-${key}`, async () => {
     const entry = await readRecord("resources", key, storage);
-    if (!token || entry?.token !== token || leaseState(entry, now()) !== "held") throw new Error("Lease is no longer owned by this token. Acquire it again after checking status.");
+    if (!token || entry?.token !== token || leaseState(entry, now()) !== "held") throw Object.assign(new Error("Lease is no longer owned by this token. Acquire it again after checking status."), { code: "RESOURCE_NOT_OWNED" });
     entry.expires_at = new Date(now() + ttlMs).toISOString();
     await writeRecord("resources", key, entry, storage); return entry;
   }, storage);
@@ -44,7 +44,7 @@ export async function releaseResource(name, token, { now = Date.now, ...storage
   const key = resourceKey(name);
   return withStoreLock(`resource-${key}`, async () => {
     const entry = await readRecord("resources", key, storage);
-    if (!token || entry?.token !== token) throw new Error("Lease token does not match. Another owner's lease was not released.");
+    if (!token || entry?.token !== token) throw Object.assign(new Error("Lease token does not match. Another owner's lease was not released."), { code: "RESOURCE_NOT_OWNED" });
     entry.released_at ??= new Date(now()).toISOString();
     await writeRecord("resources", key, entry, storage); return entry;
   }, storage);
@@ -55,7 +55,7 @@ export async function listResources({ now = Date.now, ...storage } = {}) {
 }
 
 export async function runWithResource(name, argv, { timeoutMs = 0, cwd = targetHost() === "local" ? process.cwd() : undefined, ttlMs = 600000, execBackend, remoteShell, supervisor, connection, ...options }, { execute = runCommand } = {}) {
-  if (!argv.length || !Number.isInteger(timeoutMs) || timeoutMs < 0 || timeoutMs > 86400000) throw new Error("A command and valid --timeout-ms are required.");
+  if (!argv.length || !Number.isInteger(timeoutMs) || timeoutMs < 0 || timeoutMs > 86400000) throw Object.assign(new Error("A command and valid --timeout-ms are required."), { code: "OPTIONS_INVALID" });
   const lease = await acquireResource(name, { ...options, ttlMs }), controller = new AbortController();
   let timer, renewal = Promise.resolve(), stopped = false, leaseError = null, released = false, result, uncertain = false;
   const schedule = () => { timer = setTimeout(() => {

package/src/runner.mjs

@@ -3,10 +3,10 @@ import { targetHost } from "./target.mjs";
 import { runRemoteCommand, runRemoteShellCommand } from "./remote-io.mjs";
 
 export function runCommand(argv, { cwd, timeoutMs = 0, onStart = async () => {}, signal: abortSignal, execBackend = "app-server", threadId, remoteShell, supervisor, connection } = {}) {
-  if (!argv.length || !argv[0] || !Number.isInteger(timeoutMs) || timeoutMs < 0 || timeoutMs > 86400000) throw new Error("A command and timeout-ms between 0 and 86400000 are required.");
-  if (!["app-server", "thread-shell"].includes(execBackend)) throw new Error("--exec-backend must be app-server or thread-shell.");
+  if (!argv.length || !argv[0] || !Number.isInteger(timeoutMs) || timeoutMs < 0 || timeoutMs > 86400000) throw Object.assign(new Error("A command and timeout-ms between 0 and 86400000 are required."), { code: "OPTIONS_INVALID" });
+  if (!["app-server", "thread-shell"].includes(execBackend)) throw Object.assign(new Error("--exec-backend must be app-server or thread-shell."), { code: "OPTIONS_INVALID" });
   if (targetHost() !== "local") return (execBackend === "thread-shell" ? runRemoteShellCommand : runRemoteCommand)(argv, { cwd, timeoutMs, onStart, signal: abortSignal, threadId, shell: remoteShell, supervisor, connection });
-  if (execBackend !== "app-server") throw new Error("thread-shell is an explicit remote execution backend.");
+  if (execBackend !== "app-server") throw Object.assign(new Error("thread-shell is an explicit remote execution backend."), { code: "OPTIONS_INVALID" });
   return new Promise((resolve, reject) => {
     const started = new Date().toISOString();
     let output = "", truncated = false, timedOut = false, failure, killer, timer, startUpdate = Promise.resolve(), closed = false;
@@ -16,7 +16,7 @@ export function runCommand(argv, { cwd, timeoutMs = 0, onStart = async () => {},
       try { process.kill(-child.pid, signal); } catch (e) { if (e.code !== "ESRCH") failure ??= e; }
     };
     const stop = () => { terminate("SIGTERM"); killer ??= setTimeout(() => terminate("SIGKILL"), 1000); };
-    const interrupt = () => { failure ??= new Error("Command interrupted."); stop(); };
+    const interrupt = () => { failure ??= Object.assign(new Error("Command interrupted."), { code: "CANCELLED" }); stop(); };
     process.on("SIGINT", interrupt); process.on("SIGTERM", interrupt);
     abortSignal?.addEventListener("abort", interrupt, { once: true });
     for (const stream of [child.stdout, child.stderr]) {
@@ -30,7 +30,7 @@ export function runCommand(argv, { cwd, timeoutMs = 0, onStart = async () => {},
       clearTimeout(timer); clearTimeout(killer); process.off("SIGINT", interrupt); process.off("SIGTERM", interrupt);
       abortSignal?.removeEventListener("abort", interrupt);
       await startUpdate;
-      const result = { pid: child.pid ?? null, exit_code: code, signal, timed_out: timedOut, started_at: started, completed_at: new Date().toISOString(), output_tail: output, output_truncated: truncated, error: failure?.message ?? null };
+      const result = { pid: child.pid ?? null, exit_code: code, signal, timed_out: timedOut, started_at: started, completed_at: new Date().toISOString(), output_tail: output, output_truncated: truncated, error: failure?.message ?? null, error_code: failure ? failure.code ?? null : null };
       resolve(result);
     });
   });

package/src/store.mjs

@@ -7,14 +7,14 @@ import { hostNamespace, hostFields } from "./target.mjs";
 const valid = value => typeof value === "string" && /^[a-zA-Z0-9][a-zA-Z0-9._-]{0,150}$/.test(value);
 // The persisted namespace predates the codexteer rename; keep existing records.
 export function storePath(bucket, id, home = codexHome()) {
-  if (!valid(bucket) || (id != null && !valid(id))) throw new Error("Invalid local record identifier.");
+  if (!valid(bucket) || (id != null && !valid(id))) throw Object.assign(new Error("Invalid local record identifier."), { code: "OPTIONS_INVALID" });
   const namespace = hostNamespace();
   return path.join(home, "codex-steer", ...(namespace ? ["hosts", namespace] : []), bucket, ...(id == null ? [] : [`${id}.json`]));
 }
 
 async function owned(file, directory = false) {
   const s = await lstat(file);
-  if (s.uid !== process.getuid() || s.isSymbolicLink() || (s.mode & 0o077) || (directory ? !s.isDirectory() : !s.isFile())) throw new Error("Unsafe local state ownership, permissions, or file type.");
+  if (s.uid !== process.getuid() || s.isSymbolicLink() || (s.mode & 0o077) || (directory ? !s.isDirectory() : !s.isFile())) throw Object.assign(new Error("Unsafe local state ownership, permissions, or file type."), { code: "STORE_UNSAFE" });
 }
 
 async function directory(bucket, home, create = false) {

package/src/supervise.mjs

@@ -19,7 +19,7 @@ export async function prepareSupervisorPrompt(threadInput, policy, { agent = "cl
   connection = taskConnection(threadId, connection);
   validateSupervisionPolicy(policy);
   connectionMode(connection);
-  if (!SUPERVISOR_AGENTS.includes(agent)) throw new Error("--agent must be claude or codex.");
+  if (!SUPERVISOR_AGENTS.includes(agent)) throw Object.assign(new Error("--agent must be claude or codex."), { code: "OPTIONS_INVALID" });
   const supervisor = { session_id: randomUUID(), owner: agent, connection, ...hostFields() };
   let context = targetContext() ?? process.env.CODEX_THREAD_ID;
   if (targetHost() !== "local" && remoteTransport() === "native" && !context) throw Object.assign(new Error("Remote supervision requires --context-thread <LOCAL-THREAD-ID> or CODEX_THREAD_ID."), { code: "REMOTE_CONTEXT_REQUIRED" });

package/src/task-id.mjs

@@ -1,6 +1,7 @@
 import { isDesktopCloudTask, desktopCloudId } from "./desktop-cloud-id.mjs";
 import { normalizeThreadId } from "./thread-id.mjs";
 import { isCloudTask, cloudTaskId } from "./cloud-id.mjs";
+import { connectionMismatch } from "./connection-error.mjs";
 
 export { isCloudTask } from "./cloud-id.mjs";
 
@@ -12,12 +13,12 @@ export function normalizeTaskId(value) {
 
 export function taskConnection(value, selected = "shared") {
   if (isDesktopCloudTask(value)) {
-    if (!["shared", "desktop-cloud"].includes(selected)) throw Object.assign(new Error("Desktop Cloud cannot use another connection."), { code: "CLOUD_TARGET_CONFLICT" });
+    if (!["shared", "desktop-cloud"].includes(selected)) throw connectionMismatch("desktop-cloud", selected);
     return "desktop-cloud";
   }
-  if (selected === "desktop-cloud") throw Object.assign(new Error("Use a durable_ ID or hostId=durable link for Desktop Cloud."), { code: "CLOUD_TARGET_CONFLICT" });
+  if (selected === "desktop-cloud") throw connectionMismatch(isCloudTask(value) ? "cloud" : "shared", selected);
   const cloud = isCloudTask(value);
-  if (cloud && selected === "desktop") throw Object.assign(new Error("A cloud task cannot use a Desktop observation endpoint."), { code: "CLOUD_TARGET_CONFLICT" });
-  if (!cloud && selected === "cloud") throw Object.assign(new Error("The cloud connection requires a cloud task ID or link."), { code: "CLOUD_TARGET_CONFLICT" });
+  if (cloud && selected === "desktop") throw connectionMismatch("cloud", selected);
+  if (!cloud && selected === "cloud") throw connectionMismatch("shared", selected);
   return cloud ? "cloud" : selected;
 }

package/src/thread-id.mjs

@@ -3,7 +3,7 @@ const UUID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{
 
 export function parseThreadTarget(input) {
   if (typeof input !== "string" || input.trim() === "") {
-    throw new Error("Thread ID is required.");
+    throw Object.assign(new Error("Thread ID is required."), { code: "OPTIONS_INVALID" });
   }
 
   let value = input.trim(), hostId;
@@ -12,19 +12,19 @@ export function parseThreadTarget(input) {
     try {
       url = new URL(value);
     } catch {
-      throw new Error(`Invalid Codex thread URL: ${input}`);
+      throw Object.assign(new Error(`Invalid Codex thread URL: ${input}`), { code: "OPTIONS_INVALID" });
     }
     if (url.hostname !== "threads") {
-      throw new Error(`Expected codex://threads/<thread-id>: ${input}`);
+      throw Object.assign(new Error(`Expected codex://threads/<thread-id>: ${input}`), { code: "OPTIONS_INVALID" });
     }
     const hosts = url.searchParams.getAll("hostId");
-    if (hosts.length > 1) throw new Error("A thread link must have only one hostId.");
+    if (hosts.length > 1) throw Object.assign(new Error("A thread link must have only one hostId."), { code: "OPTIONS_INVALID" });
     if (hosts.length) hostId = validateHostId(hosts[0]);
     value = decodeURIComponent(url.pathname.replace(/^\/+/, ""));
   }
 
   if (!UUID_PATTERN.test(value)) {
-    throw new Error(`Invalid local Codex thread ID: ${input}`);
+    throw Object.assign(new Error(`Invalid local Codex thread ID: ${input}`), { code: "OPTIONS_INVALID" });
   }
   return { threadId: value.toLowerCase(), hostId };
 }

package/src/wrapper.mjs

@@ -104,12 +104,12 @@ export function serverArguments(args, socketPath) {
     if (arg === "--stdio") continue;
     if (arg === "--listen" || arg.startsWith("--listen=")) {
       const value = arg === "--listen" ? args[++i] : arg.slice(9);
-      if (value !== "stdio://") throw new Error("Desktop requested a conflicting App Server transport.");
+      if (value !== "stdio://") throw Object.assign(new Error("Desktop requested a conflicting App Server transport."), { code: "OPTIONS_INVALID" });
       continue;
     }
     transformed.push(arg);
     if (values.has(arg) || ["--code-mode-host", "--ws-auth", "--ws-token-file", "--ws-token-sha256", "--ws-shared-secret-file", "--ws-issuer", "--ws-audience", "--ws-max-clock-skew-seconds"].includes(arg)) {
-      if (args[i + 1] == null) throw new Error("Incomplete App Server startup arguments.");
+      if (args[i + 1] == null) throw Object.assign(new Error("Incomplete App Server startup arguments."), { code: "OPTIONS_INVALID" });
       transformed.push(args[++i]);
     }
   }