codex-team 0.0.9 → 0.0.11

package/README.md

@@ -22,11 +22,13 @@ codexm save <name>
 codexm update
 codexm switch <name>
 codexm switch --auto --dry-run
+codexm launch [name] [--json]
 codexm remove <name> --yes
 codexm rename <old> <new>
 ```
 
 Use `--json` on query and mutation commands when you need machine-readable output.
+`codexm launch` starts Codex Desktop with the current auth, or switches to a saved account first when you pass a name. If Codex Desktop is already running, `codexm launch` asks before relaunching it. If the running Desktop was started by `codexm launch`, later `codexm switch` attempts to refresh that session automatically; if it was started outside `codexm`, `codexm switch` still warns that existing sessions may keep the previous login state. This refresh works by restarting the Codex app server, so any in-progress thread in that Desktop session will be interrupted.
 
 ## Typical flow
 

package/dist/cli.cjs

@@ -5,7 +5,9 @@ var __webpack_modules__ = {
         __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");
@@ -13,10 +15,9 @@ var __webpack_modules__ = {
         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);
         }
@@ -221,11 +222,11 @@ var __webpack_modules__ = {
             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);
         }
@@ -323,8 +324,6 @@ var __webpack_modules__ = {
             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 [
@@ -334,6 +333,19 @@ var __webpack_modules__ = {
         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");
@@ -389,7 +401,9 @@ var __webpack_modules__ = {
             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, {
@@ -399,23 +413,35 @@ var __webpack_modules__ = {
                             "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);
             }
@@ -484,7 +510,6 @@ var __webpack_modules__ = {
                 };
             }
         }
-        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;
@@ -557,25 +582,6 @@ var __webpack_modules__ = {
             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;
@@ -871,8 +877,6 @@ var __webpack_modules__ = {
                     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,
@@ -1046,6 +1050,252 @@ var __webpack_modules__ = {
                 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) {
@@ -1089,12 +1339,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) {
@@ -1289,6 +1556,67 @@ Account names must match /^[A-Za-z0-9][A-Za-z0-9._-]{0,63}$/.
                 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,
@@ -1296,6 +1624,7 @@ Account names must match /^[A-Za-z0-9][A-Za-z0-9._-]{0,63}$/.
                 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 {
@@ -1428,6 +1757,8 @@ Account names must match /^[A-Za-z0-9][A-Za-z0-9._-]{0,63}$/.
                                 }
                                 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",
@@ -1451,6 +1782,8 @@ Account names must match /^[A-Za-z0-9][A-Za-z0-9._-]{0,63}$/.
                             }
                             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);
@@ -1482,6 +1815,70 @@ Account names must match /^[A-Za-z0-9][A-Za-z0-9._-]{0,63}$/.
                             }
                             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];