codex-team 0.0.9 → 0.0.11

package/dist/main.cjs

@@ -35,7 +35,9 @@ __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
     runCli: ()=>runCli
 });
+const promises_namespaceObject = require("node:fs/promises");
 const external_node_process_namespaceObject = require("node:process");
+const external_node_path_namespaceObject = require("node:path");
 const external_dayjs_namespaceObject = require("dayjs");
 var external_dayjs_default = /*#__PURE__*/ __webpack_require__.n(external_dayjs_namespaceObject);
 const timezone_js_namespaceObject = require("dayjs/plugin/timezone.js");
@@ -43,10 +45,9 @@ var timezone_js_default = /*#__PURE__*/ __webpack_require__.n(timezone_js_namesp
 const utc_js_namespaceObject = require("dayjs/plugin/utc.js");
 var utc_js_default = /*#__PURE__*/ __webpack_require__.n(utc_js_namespaceObject);
 var package_namespaceObject = {
-    rE: "0.0.9"
+    rE: "0.0.11"
 };
 const external_node_crypto_namespaceObject = require("node:crypto");
-const promises_namespaceObject = require("node:fs/promises");
 function isRecord(value) {
     return "object" == typeof value && null !== value && !Array.isArray(value);
 }
@@ -251,11 +252,11 @@ function decodeJwtPayload(token) {
     return parsed;
 }
 const external_node_os_namespaceObject = require("node:os");
-const external_node_path_namespaceObject = require("node:path");
-const external_node_child_process_namespaceObject = require("node:child_process");
-const external_node_util_namespaceObject = require("node:util");
 const DEFAULT_CHATGPT_BASE_URL = "https://chatgpt.com";
 const USER_AGENT = "codexm/0.1";
+const USAGE_FETCH_ATTEMPTS = 3;
+const USAGE_FETCH_RETRY_DELAY_MS = 250;
+const USAGE_FETCH_TIMEOUT_MS = 15000;
 function quota_client_isRecord(value) {
     return "object" == typeof value && null !== value && !Array.isArray(value);
 }
@@ -353,8 +354,6 @@ async function resolveUsageUrls(homeDir) {
     const normalizedBaseUrl = baseUrl.replace(/\/+$/u, "");
     const candidates = [
         `${normalizedBaseUrl}/backend-api/wham/usage`,
-        `${normalizedBaseUrl}/wham/usage`,
-        `${normalizedBaseUrl}/api/codex/usage`,
         "https://chatgpt.com/backend-api/wham/usage"
     ];
     return [
@@ -364,6 +363,19 @@ async function resolveUsageUrls(homeDir) {
 function normalizeFetchError(error) {
     return error instanceof Error ? error.message : String(error);
 }
+async function delay(milliseconds) {
+    await new Promise((resolve)=>setTimeout(resolve, milliseconds));
+}
+function isTransientUsageStatus(status) {
+    return 408 === status || 429 === status || status >= 500 && status <= 599;
+}
+function isLastAttempt(attempt) {
+    return attempt >= USAGE_FETCH_ATTEMPTS;
+}
+function formatUsageAttemptError(url, attempt, message) {
+    const retryContext = USAGE_FETCH_ATTEMPTS > 1 ? ` attempt ${attempt}/${USAGE_FETCH_ATTEMPTS}` : "";
+    return `${url}${retryContext} -> ${message}`;
+}
 function shouldRetryWithTokenRefresh(message) {
     const normalized = message.toLowerCase();
     return normalized.includes("401") || normalized.includes("403") || normalized.includes("unauthorized") || normalized.includes("invalid_token") || normalized.includes("deactivated_workspace");
@@ -419,7 +431,9 @@ async function requestUsage(snapshot, options) {
     const urls = await resolveUsageUrls(options.homeDir);
     const now = (options.now ?? new Date()).toISOString();
     const errors = [];
-    for (const url of urls){
+    for (const url of urls)for(let attempt = 1; attempt <= USAGE_FETCH_ATTEMPTS; attempt += 1){
+        const abortController = new AbortController();
+        const timeout = setTimeout(()=>abortController.abort(), USAGE_FETCH_TIMEOUT_MS);
         let response;
         try {
             response = await fetchImpl(url, {
@@ -429,23 +443,35 @@ async function requestUsage(snapshot, options) {
                     "ChatGPT-Account-Id": extracted.accountId,
                     Accept: "application/json",
                     "User-Agent": USER_AGENT
-                }
+                },
+                signal: abortController.signal
             });
         } catch (error) {
-            errors.push(`${url} -> ${normalizeFetchError(error)}`);
-            continue;
+            clearTimeout(timeout);
+            const message = abortController.signal.aborted ? `timed out after ${USAGE_FETCH_TIMEOUT_MS}ms` : normalizeFetchError(error);
+            errors.push(formatUsageAttemptError(url, attempt, message));
+            if (!isLastAttempt(attempt)) {
+                await delay(USAGE_FETCH_RETRY_DELAY_MS * attempt);
+                continue;
+            }
+            break;
         }
+        clearTimeout(timeout);
         if (!response.ok) {
             const body = await response.text();
-            errors.push(`${url} -> ${response.status}: ${body.slice(0, 140).replace(/\s+/gu, " ").trim()}`);
-            continue;
+            errors.push(formatUsageAttemptError(url, attempt, `${response.status}: ${body.slice(0, 140).replace(/\s+/gu, " ").trim()}`));
+            if (isTransientUsageStatus(response.status) && !isLastAttempt(attempt)) {
+                await delay(USAGE_FETCH_RETRY_DELAY_MS * attempt);
+                continue;
+            }
+            break;
         }
         let payload;
         try {
             payload = await response.json();
         } catch (error) {
-            errors.push(`${url} -> failed to parse JSON: ${normalizeFetchError(error)}`);
-            continue;
+            errors.push(formatUsageAttemptError(url, attempt, `failed to parse JSON: ${normalizeFetchError(error)}`));
+            break;
         }
         return mapUsagePayload(payload, extracted.planType, now);
     }
@@ -514,7 +540,6 @@ async function fetchQuotaSnapshot(snapshot, options = {}) {
         };
     }
 }
-const execFile = (0, external_node_util_namespaceObject.promisify)(external_node_child_process_namespaceObject.execFile);
 const DIRECTORY_MODE = 448;
 const FILE_MODE = 384;
 const SCHEMA_VERSION = 1;
@@ -587,25 +612,6 @@ function canAutoMigrateLegacyChatGPTMeta(meta, snapshot) {
     if (!snapshotUserId) return false;
     return meta.account_id === getSnapshotAccountId(snapshot);
 }
-async function detectRunningCodexProcesses() {
-    try {
-        const { stdout } = await execFile("ps", [
-            "-Ao",
-            "pid=,command="
-        ]);
-        const pids = [];
-        for (const line of stdout.split("\n")){
-            const match = line.trim().match(/^(\d+)\s+(.+)$/);
-            if (!match) continue;
-            const pid = Number(match[1]);
-            const command = match[2];
-            if (pid !== process.pid && /(^|\s|\/)codex(\s|$)/.test(command) && !command.includes("codex-team")) pids.push(pid);
-        }
-        return pids;
-    } catch  {
-        return [];
-    }
-}
 class AccountStore {
     paths;
     fetchImpl;
@@ -901,8 +907,6 @@ class AccountStore {
             last_switched_account: name,
             last_backup_path: backupPath
         });
-        const runningCodexPids = await detectRunningCodexProcesses();
-        if (runningCodexPids.length > 0) warnings.push(`Detected running codex processes (${runningCodexPids.join(", ")}). Existing sessions may still hold the previous login state.`);
         return {
             account: await this.readManagedAccount(name),
             warnings,
@@ -1076,6 +1080,252 @@ function createAccountStore(homeDir, options) {
         fetchImpl: options?.fetchImpl
     });
 }
+const external_node_child_process_namespaceObject = require("node:child_process");
+const external_node_util_namespaceObject = require("node:util");
+const execFile = (0, external_node_util_namespaceObject.promisify)(external_node_child_process_namespaceObject.execFile);
+const DEFAULT_CODEX_REMOTE_DEBUGGING_PORT = 9223;
+const DEFAULT_CODEX_DESKTOP_STATE_PATH = (0, external_node_path_namespaceObject.join)((0, external_node_os_namespaceObject.homedir)(), ".codex-team", "desktop-state.json");
+const CODEX_BINARY_SUFFIX = "/Contents/MacOS/Codex";
+const CODEX_APP_NAME = "Codex";
+const CODEX_LOCAL_HOST_ID = "local";
+const CODEX_APP_SERVER_RESTART_EXPRESSION = 'window.electronBridge.sendMessageFromView({ type: "codex-app-server-restart", hostId: "local" })';
+const DEVTOOLS_REQUEST_TIMEOUT_MS = 5000;
+function codex_desktop_launch_isRecord(value) {
+    return "object" == typeof value && null !== value && !Array.isArray(value);
+}
+function isNonEmptyString(value) {
+    return "string" == typeof value && "" !== value.trim();
+}
+async function codex_desktop_launch_delay(ms) {
+    await new Promise((resolve)=>setTimeout(resolve, ms));
+}
+async function pathExistsViaStat(execFileImpl, path) {
+    try {
+        await execFileImpl("stat", [
+            "-f",
+            "%N",
+            path
+        ]);
+        return true;
+    } catch  {
+        return false;
+    }
+}
+function parseManagedState(raw) {
+    if ("" === raw.trim()) return null;
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    } catch  {
+        return null;
+    }
+    if (!codex_desktop_launch_isRecord(parsed)) return null;
+    const pid = parsed.pid;
+    const appPath = parsed.app_path;
+    const remoteDebuggingPort = parsed.remote_debugging_port;
+    const managedByCodexm = parsed.managed_by_codexm;
+    const startedAt = parsed.started_at;
+    if ("number" != typeof pid || !Number.isInteger(pid) || pid <= 0 || !isNonEmptyString(appPath) || "number" != typeof remoteDebuggingPort || !Number.isInteger(remoteDebuggingPort) || remoteDebuggingPort <= 0 || true !== managedByCodexm || !isNonEmptyString(startedAt)) return null;
+    return {
+        pid,
+        app_path: appPath,
+        remote_debugging_port: remoteDebuggingPort,
+        managed_by_codexm: true,
+        started_at: startedAt
+    };
+}
+async function ensureStateDirectory(statePath) {
+    await (0, promises_namespaceObject.mkdir)((0, external_node_path_namespaceObject.dirname)(statePath), {
+        recursive: true,
+        mode: 448
+    });
+}
+function createDefaultWebSocket(url) {
+    return new WebSocket(url);
+}
+function isDevtoolsTarget(value) {
+    return codex_desktop_launch_isRecord(value);
+}
+function isManagedDesktopProcess(runningApps, state) {
+    const expectedBinaryPath = `${state.app_path}${CODEX_BINARY_SUFFIX}`;
+    const expectedPort = `--remote-debugging-port=${state.remote_debugging_port}`;
+    return runningApps.some((entry)=>entry.pid === state.pid && entry.command.includes(expectedBinaryPath) && entry.command.includes(expectedPort));
+}
+async function evaluateDevtoolsExpression(createWebSocketImpl, webSocketDebuggerUrl, expression) {
+    const socket = createWebSocketImpl(webSocketDebuggerUrl);
+    await new Promise((resolve, reject)=>{
+        const requestId = 1;
+        const timeout = setTimeout(()=>{
+            cleanup();
+            reject(new Error("Timed out waiting for Codex Desktop devtools response."));
+        }, DEVTOOLS_REQUEST_TIMEOUT_MS);
+        const cleanup = ()=>{
+            clearTimeout(timeout);
+            socket.onopen = null;
+            socket.onmessage = null;
+            socket.onerror = null;
+            socket.onclose = null;
+            socket.close();
+        };
+        socket.onopen = ()=>{
+            socket.send(JSON.stringify({
+                id: requestId,
+                method: "Runtime.evaluate",
+                params: {
+                    expression,
+                    awaitPromise: true
+                }
+            }));
+        };
+        socket.onmessage = (event)=>{
+            if ("string" != typeof event.data) return;
+            let payload;
+            try {
+                payload = JSON.parse(event.data);
+            } catch  {
+                return;
+            }
+            if (!codex_desktop_launch_isRecord(payload) || payload.id !== requestId) return;
+            if (codex_desktop_launch_isRecord(payload.error)) {
+                cleanup();
+                reject(new Error(String(payload.error.message ?? "Codex Desktop devtools request failed.")));
+                return;
+            }
+            const result = codex_desktop_launch_isRecord(payload.result) ? payload.result : null;
+            if (result && codex_desktop_launch_isRecord(result.exceptionDetails)) {
+                cleanup();
+                reject(new Error("Codex Desktop rejected the app-server restart request."));
+                return;
+            }
+            cleanup();
+            resolve();
+        };
+        socket.onerror = ()=>{
+            cleanup();
+            reject(new Error("Failed to communicate with Codex Desktop devtools."));
+        };
+        socket.onclose = ()=>{
+            cleanup();
+            reject(new Error("Codex Desktop devtools connection closed before replying."));
+        };
+    });
+}
+function createCodexDesktopLauncher(options = {}) {
+    const execFileImpl = options.execFileImpl ?? execFile;
+    const statePath = options.statePath ?? DEFAULT_CODEX_DESKTOP_STATE_PATH;
+    const readFileImpl = options.readFileImpl ?? (async (path)=>(0, promises_namespaceObject.readFile)(path, "utf8"));
+    const writeFileImpl = options.writeFileImpl ?? promises_namespaceObject.writeFile;
+    const fetchImpl = options.fetchImpl ?? globalThis.fetch.bind(globalThis);
+    const createWebSocketImpl = options.createWebSocketImpl ?? createDefaultWebSocket;
+    async function findInstalledApp() {
+        const candidates = [
+            "/Applications/Codex.app",
+            (0, external_node_path_namespaceObject.join)((0, external_node_os_namespaceObject.homedir)(), "Applications", "Codex.app")
+        ];
+        for (const candidate of candidates)if (await pathExistsViaStat(execFileImpl, candidate)) return candidate;
+        try {
+            const { stdout } = await execFileImpl("mdfind", [
+                'kMDItemFSName == "Codex.app"'
+            ]);
+            for (const line of stdout.split("\n")){
+                const candidate = line.trim();
+                if ("" !== candidate) {
+                    if (await pathExistsViaStat(execFileImpl, candidate)) return candidate;
+                }
+            }
+        } catch  {}
+        return null;
+    }
+    async function listRunningApps() {
+        const { stdout } = await execFileImpl("ps", [
+            "-Ao",
+            "pid=,command="
+        ]);
+        const running = [];
+        for (const line of stdout.split("\n")){
+            const match = line.trim().match(/^(\d+)\s+(.+)$/);
+            if (!match) continue;
+            const pid = Number(match[1]);
+            const command = match[2];
+            if (pid !== process.pid && command.includes(CODEX_BINARY_SUFFIX)) running.push({
+                pid,
+                command
+            });
+        }
+        return running;
+    }
+    async function quitRunningApps() {
+        const running = await listRunningApps();
+        if (0 === running.length) return;
+        await execFileImpl("osascript", [
+            "-e",
+            `tell application "${CODEX_APP_NAME}" to quit`
+        ]);
+        for(let attempt = 0; attempt < 10; attempt += 1){
+            const remaining = await listRunningApps();
+            if (0 === remaining.length) return;
+            await codex_desktop_launch_delay(300);
+        }
+        throw new Error("Timed out waiting for Codex Desktop to quit.");
+    }
+    async function launch(appPath) {
+        await execFileImpl("open", [
+            "-na",
+            appPath,
+            "--args",
+            `--remote-debugging-port=${DEFAULT_CODEX_REMOTE_DEBUGGING_PORT}`
+        ]);
+    }
+    async function readManagedState() {
+        try {
+            return parseManagedState(await readFileImpl(statePath));
+        } catch  {
+            return null;
+        }
+    }
+    async function writeManagedState(state) {
+        await ensureStateDirectory(statePath);
+        await writeFileImpl(statePath, `${JSON.stringify(state, null, 2)}\n`);
+    }
+    async function clearManagedState() {
+        await ensureStateDirectory(statePath);
+        await writeFileImpl(statePath, "");
+    }
+    async function isManagedDesktopRunning() {
+        const state = await readManagedState();
+        if (!state) return false;
+        const runningApps = await listRunningApps();
+        return isManagedDesktopProcess(runningApps, state);
+    }
+    async function restartManagedAppServer() {
+        const state = await readManagedState();
+        if (!state) return false;
+        const runningApps = await listRunningApps();
+        if (!isManagedDesktopProcess(runningApps, state)) return false;
+        const response = await fetchImpl(`http://127.0.0.1:${state.remote_debugging_port}/json/list`);
+        if (!response.ok) throw new Error(`Failed to query Codex Desktop devtools targets (HTTP ${response.status}).`);
+        const targets = await response.json();
+        if (!Array.isArray(targets)) throw new Error("Codex Desktop devtools target list was not an array.");
+        const localTarget = targets.find((target)=>{
+            if (!isDevtoolsTarget(target)) return false;
+            return "page" === target.type && target.url === `app://-/index.html?hostId=${CODEX_LOCAL_HOST_ID}` && isNonEmptyString(target.webSocketDebuggerUrl);
+        });
+        if (!localTarget || !isNonEmptyString(localTarget.webSocketDebuggerUrl)) throw new Error("Could not find the local Codex Desktop devtools target.");
+        await evaluateDevtoolsExpression(createWebSocketImpl, localTarget.webSocketDebuggerUrl, CODEX_APP_SERVER_RESTART_EXPRESSION);
+        return true;
+    }
+    return {
+        findInstalledApp,
+        listRunningApps,
+        quitRunningApps,
+        launch,
+        readManagedState,
+        writeManagedState,
+        clearManagedState,
+        isManagedDesktopRunning,
+        restartManagedAppServer
+    };
+}
 external_dayjs_default().extend(utc_js_default());
 external_dayjs_default().extend(timezone_js_default());
 function parseArgs(argv) {
@@ -1119,12 +1369,29 @@ Usage:
   codexm update [--json]
   codexm switch <name> [--json]
   codexm switch --auto [--dry-run] [--json]
+  codexm launch [name] [--json]
   codexm remove <name> [--yes] [--json]
   codexm rename <old> <new> [--json]
 
 Account names must match /^[A-Za-z0-9][A-Za-z0-9._-]{0,63}$/.
 `);
 }
+function stripManagedDesktopWarning(warnings) {
+    return warnings.filter((warning)=>!warning.startsWith("Detected running codex processes (") || !warning.endsWith("Existing sessions may still hold the previous login state."));
+}
+async function refreshManagedDesktopAfterSwitch(warnings, desktopLauncher) {
+    try {
+        if (await desktopLauncher.restartManagedAppServer()) return;
+    } catch (error) {
+        warnings.push(`Failed to refresh the running codexm-managed Codex Desktop session: ${error.message}`);
+        return;
+    }
+    try {
+        const runningApps = await desktopLauncher.listRunningApps();
+        if (0 === runningApps.length) return;
+        warnings.push(`Detected running codex processes (${runningApps.map((app)=>app.pid).join(", ")}). Existing sessions may still hold the previous login state.`);
+    } catch  {}
+}
 function describeCurrentStatus(status) {
     const lines = [];
     if (status.exists) {
@@ -1319,6 +1586,67 @@ async function confirmRemoval(name, streams) {
         streams.stdin.on("data", onData);
     });
 }
+async function confirmDesktopRelaunch(streams) {
+    if (!streams.stdin.isTTY) throw new Error("Refusing to relaunch Codex Desktop in a non-interactive terminal.");
+    streams.stdout.write("Codex Desktop is already running. Close it and relaunch with the selected auth? [y/N] ");
+    return await new Promise((resolve)=>{
+        const cleanup = ()=>{
+            streams.stdin.off("data", onData);
+            streams.stdin.pause();
+        };
+        const onData = (buffer)=>{
+            const answer = buffer.toString("utf8").trim().toLowerCase();
+            cleanup();
+            streams.stdout.write("\n");
+            resolve("y" === answer || "yes" === answer);
+        };
+        streams.stdin.resume();
+        streams.stdin.on("data", onData);
+    });
+}
+async function sleep(ms) {
+    await new Promise((resolve)=>setTimeout(resolve, ms));
+}
+async function main_pathExists(path) {
+    try {
+        await (0, promises_namespaceObject.stat)(path);
+        return true;
+    } catch (error) {
+        const nodeError = error;
+        if ("ENOENT" === nodeError.code) return false;
+        throw error;
+    }
+}
+function isRunningDesktopFromApp(app, appPath) {
+    return app.command.includes(`${appPath}/Contents/MacOS/Codex`);
+}
+async function resolveManagedDesktopState(desktopLauncher, appPath, existingApps) {
+    const existingPids = new Set(existingApps.map((app)=>app.pid));
+    for(let attempt = 0; attempt < 10; attempt += 1){
+        const runningApps = await desktopLauncher.listRunningApps();
+        const launchedApp = runningApps.filter((app)=>isRunningDesktopFromApp(app, appPath) && !existingPids.has(app.pid)).sort((left, right)=>right.pid - left.pid)[0] ?? runningApps.filter((app)=>isRunningDesktopFromApp(app, appPath)).sort((left, right)=>right.pid - left.pid)[0] ?? null;
+        if (launchedApp) return {
+            pid: launchedApp.pid,
+            app_path: appPath,
+            remote_debugging_port: DEFAULT_CODEX_REMOTE_DEBUGGING_PORT,
+            managed_by_codexm: true,
+            started_at: new Date().toISOString()
+        };
+        await sleep(300);
+    }
+    return null;
+}
+async function restoreLaunchBackup(store, backupPath) {
+    if (backupPath && await main_pathExists(backupPath)) await (0, promises_namespaceObject.copyFile)(backupPath, store.paths.currentAuthPath);
+    else await (0, promises_namespaceObject.rm)(store.paths.currentAuthPath, {
+        force: true
+    });
+    const configBackupPath = (0, external_node_path_namespaceObject.join)(store.paths.backupsDir, "last-active-config.toml");
+    if (await main_pathExists(configBackupPath)) await (0, promises_namespaceObject.copyFile)(configBackupPath, store.paths.currentConfigPath);
+    else await (0, promises_namespaceObject.rm)(store.paths.currentConfigPath, {
+        force: true
+    });
+}
 async function runCli(argv, options = {}) {
     const streams = {
         stdin: options.stdin ?? external_node_process_namespaceObject.stdin,
@@ -1326,6 +1654,7 @@ async function runCli(argv, options = {}) {
         stderr: options.stderr ?? external_node_process_namespaceObject.stderr
     };
     const store = options.store ?? createAccountStore();
+    const desktopLauncher = options.desktopLauncher ?? createCodexDesktopLauncher();
     const parsed = parseArgs(argv);
     const json = parsed.flags.has("--json");
     try {
@@ -1458,6 +1787,8 @@ async function runCli(argv, options = {}) {
                         }
                         const result = await store.switchAccount(selected.name);
                         for (const warning of warnings)result.warnings.push(warning);
+                        result.warnings = stripManagedDesktopWarning(result.warnings);
+                        await refreshManagedDesktopAfterSwitch(result.warnings, desktopLauncher);
                         const payload = {
                             ok: true,
                             action: "switch",
@@ -1481,6 +1812,8 @@ async function runCli(argv, options = {}) {
                     }
                     if (!name) throw new Error("Usage: codexm switch <name>");
                     const result = await store.switchAccount(name);
+                    result.warnings = stripManagedDesktopWarning(result.warnings);
+                    await refreshManagedDesktopAfterSwitch(result.warnings, desktopLauncher);
                     let quota = null;
                     try {
                         await store.refreshQuotaForAccount(result.account.name);
@@ -1512,6 +1845,70 @@ async function runCli(argv, options = {}) {
                     }
                     return 0;
                 }
+            case "launch":
+                {
+                    const name = parsed.positionals[0] ?? null;
+                    if (parsed.positionals.length > 1) throw new Error("Usage: codexm launch [name] [--json]");
+                    const warnings = [];
+                    const appPath = await desktopLauncher.findInstalledApp();
+                    if (!appPath) throw new Error("Codex Desktop not found at /Applications/Codex.app.");
+                    const runningApps = await desktopLauncher.listRunningApps();
+                    if (runningApps.length > 0) {
+                        const confirmed = await confirmDesktopRelaunch(streams);
+                        if (!confirmed) {
+                            if (json) writeJson(streams.stdout, {
+                                ok: false,
+                                action: "launch",
+                                cancelled: true
+                            });
+                            else streams.stdout.write("Aborted.\n");
+                            return 1;
+                        }
+                        await desktopLauncher.quitRunningApps();
+                    }
+                    let switchedAccount = null;
+                    let switchBackupPath = null;
+                    if (name) {
+                        const switchResult = await store.switchAccount(name);
+                        warnings.push(...stripManagedDesktopWarning(switchResult.warnings));
+                        switchedAccount = switchResult.account;
+                        switchBackupPath = switchResult.backup_path;
+                    }
+                    try {
+                        await desktopLauncher.launch(appPath);
+                        const managedState = await resolveManagedDesktopState(desktopLauncher, appPath, runningApps);
+                        if (!managedState) {
+                            await desktopLauncher.clearManagedState().catch(()=>void 0);
+                            throw new Error("Failed to confirm the newly launched Codex Desktop process for managed-session tracking.");
+                        }
+                        await desktopLauncher.writeManagedState(managedState);
+                    } catch (error) {
+                        if (switchedAccount) await restoreLaunchBackup(store, switchBackupPath).catch(()=>void 0);
+                        throw error;
+                    }
+                    if (json) writeJson(streams.stdout, {
+                        ok: true,
+                        action: "launch",
+                        account: switchedAccount ? {
+                            name: switchedAccount.name,
+                            account_id: switchedAccount.account_id,
+                            user_id: switchedAccount.user_id ?? null,
+                            identity: switchedAccount.identity,
+                            auth_mode: switchedAccount.auth_mode
+                        } : null,
+                        launched_with_current_auth: null === switchedAccount,
+                        app_path: appPath,
+                        relaunched: runningApps.length > 0,
+                        warnings
+                    });
+                    else {
+                        if (switchedAccount) streams.stdout.write(`Switched to "${switchedAccount.name}" (${maskAccountId(switchedAccount.identity)}).\n`);
+                        if (runningApps.length > 0) streams.stdout.write("Closed existing Codex Desktop instance and launched a new one.\n");
+                        streams.stdout.write(switchedAccount ? `Launched Codex Desktop with "${switchedAccount.name}" (${maskAccountId(switchedAccount.identity)}).\n` : "Launched Codex Desktop with current auth.\n");
+                        for (const warning of warnings)streams.stdout.write(`Warning: ${warning}\n`);
+                    }
+                    return 0;
+                }
             case "remove":
                 {
                     const name = parsed.positionals[0];