agentroam 0.2.0-preview.46 → 0.2.0-preview.48

package/dist/args.js

@@ -81,8 +81,8 @@ export function parseArgs(argv) {
         if (command === "desktop" && !["--data-dir", "--help", "-h"].includes(arg)) {
             throw cliError("desktop accepts only --data-dir");
         }
-        if (command === "codex-desktop" && !["--restart", "--dry-run", "--setup", "--data-dir", "--help", "-h"].includes(arg)) {
-            throw cliError("codex-desktop accepts only --setup, --restart, --dry-run and --data-dir");
+        if (command === "codex-desktop" && !["--restart", "--dry-run", "--setup", "--status", "--repair", "--data-dir", "--help", "-h"].includes(arg)) {
+            throw cliError("codex-desktop accepts only --setup, --restart, --dry-run, --status, --repair and --data-dir");
         }
         const next = () => {
             const value = values[++index];
@@ -94,6 +94,10 @@ export function parseArgs(argv) {
             options.desktopRestart = true;
         else if (arg === "--dry-run" && command === "codex-desktop")
             options.desktopDryRun = true;
+        else if (arg === "--status" && command === "codex-desktop")
+            options.desktopSharingStatus = true;
+        else if (arg === "--repair" && command === "codex-desktop")
+            options.desktopRepair = true;
         else if (arg === "--setup" && command === "codex-desktop")
             options.desktopSetup = true;
         else if (arg === "--setup-codex-desktop" && command === "service" && serviceAction === "install")
@@ -137,6 +141,10 @@ export function parseArgs(argv) {
     if (command === "codex-desktop" && options.desktopSetup && (options.desktopRestart || options.desktopDryRun)) {
         throw cliError("--setup cannot be combined with --restart or --dry-run");
     }
+    if (command === "codex-desktop" && (options.desktopSharingStatus || options.desktopRepair)
+        && [options.desktopSharingStatus, options.desktopRepair, options.desktopSetup, options.desktopRestart, options.desktopDryRun].filter(Boolean).length !== 1) {
+        throw cliError("--status and --repair cannot be combined with other desktop actions");
+    }
     if (command === "update" && updateVersion && !/^\d+\.\d+\.\d+$/.test(updateVersion)) {
         throw cliError("update version must be an exact stable X.Y.Z version");
     }

package/dist/cli.js

@@ -48,6 +48,8 @@ export async function main(argv) {
   agentroam unlock-service install|uninstall|status  管理 Windows 远程解锁服务（安装时弹出 UAC）
   agentroam codex-desktop [--dry-run]  通过共享后端启动官方 Codex 桌面端（macOS）
   agentroam codex-desktop --restart   退出并重新连接官方桌面端，会中断它的全部运行会话
+  agentroam codex-desktop --status    输出实际共享连接状态（JSON）
+  agentroam codex-desktop --repair    修复默认共享和自动恢复，保留运行中的桌面任务
   agentroam codex-desktop --setup     空闲桌面自动重新连接；有任务或状态未知时询问是否重启
   agentroam service install --setup-codex-desktop  扫码前配置官方桌面共享连接（macOS）
 设备命令支持 --data-dir PATH；配对码有效期 5 分钟，设备授权有效期 30 天。`);

package/dist/codex-desktop-command.js

@@ -4,6 +4,7 @@ import { promisify } from "node:util";
 import { resolveCodexRuntime } from "./codex-runtime-manager.js";
 import { readServiceConfig, resolveServicePaths } from "./service/service-files.js";
 import { detectPlatform } from "./platform.js";
+import { configureCodexSharing, inspectCodexSharing } from "./codex-sharing.js";
 const execFileAsync = promisify(execFile);
 const scriptPath = fileURLToPath(new URL("../install/start-codex-desktop-shared.sh", import.meta.url));
 export async function runCodexDesktopCommand(options, context = {}) {
@@ -19,6 +20,12 @@ export async function runCodexDesktopCommand(options, context = {}) {
         if (!environment.CODEX_HOME && service.codexHome)
             environment.CODEX_HOME = service.codexHome;
     }
+    if (options.desktopSharingStatus || options.desktopRepair) {
+        if (options.desktopRepair)
+            await (context.configureSharing ?? configureCodexSharing)(options, { platform, environment });
+        log(JSON.stringify(await (context.inspectSharing ?? inspectCodexSharing)({ platform, environment })));
+        return;
+    }
     // A dry run reads the installed configuration and never installs a runtime.
     if (!options.desktopDryRun) {
         const codex = await (context.codexResolver ?? resolveCodexRuntime)({
@@ -30,6 +37,7 @@ export async function runCodexDesktopCommand(options, context = {}) {
             onProgress: (message) => log(`… ${message}`),
         });
         environment.AGENT_CODEX_BIN = codex.executable;
+        await (context.configureSharing ?? configureCodexSharing)(options, { platform, environment });
     }
     const args = [scriptPath];
     if (!options.desktopDryRun) {

package/dist/codex-desktop-setup.js

@@ -4,6 +4,7 @@ import { ReadStream, WriteStream } from "node:tty";
 import { fileURLToPath } from "node:url";
 import { runCodexDesktopCommand } from "./codex-desktop-command.js";
 import { inspectCodexDesktop } from "./codex-desktop-status.js";
+import { configureCodexSharing } from "./codex-sharing.js";
 import { withoutCliProgress } from "../bin/cli-progress.mjs";
 export async function setupCodexDesktop(options, context = {}) {
     if ((context.platform ?? process.platform) !== "darwin")
@@ -19,6 +20,8 @@ export async function setupCodexDesktop(options, context = {}) {
     const inspect = context.inspect ?? inspectCodexDesktop;
     const deferred = () => log("已保留当前 Codex 桌面端。扫码仍可连接 AgentRoam；原桌面会话暂未共享，可稍后执行 agentroam codex-desktop --setup。");
     try {
+        await (context.configureSharing ?? configureCodexSharing)(options, { environment });
+        log("已保存默认共享启动与后台自动恢复配置。");
         let snapshot = await inspect(environment);
         if (snapshot.status === "not-installed") {
             log("未安装官方 Codex 桌面端，继续生成扫码连接入口。");

package/dist/codex-runtime-manager.js

@@ -1,13 +1,13 @@
 import { execFile } from "node:child_process";
 import { constants } from "node:fs";
-import { access, chmod, mkdir, mkdtemp, open, rename, rm, stat, } from "node:fs/promises";
+import { access, chmod, mkdir, mkdtemp, open, readdir, rename, rm, stat, } from "node:fs/promises";
 import { delimiter, dirname, isAbsolute, relative, resolve, win32 } from "node:path";
 import { promisify } from "node:util";
 const execFileAsync = promisify(execFile);
-export const CODEX_RUNTIME_VERSION = "0.153.0";
-// Managed install pin tracks releases; the compatibility floor for user installs is independent.
+// Fresh installs follow npm's latest stable release; existing installs have an independent floor.
+export const CODEX_RUNTIME_TAG = "latest";
 export const CODEX_MINIMUM_VERSION = "0.153.0";
-const CODEX_PACKAGE = `@openai/codex@${CODEX_RUNTIME_VERSION}`;
+const CODEX_PACKAGE = `@openai/codex@${CODEX_RUNTIME_TAG}`;
 const NPM_REGISTRY = "https://registry.npmjs.org";
 export const CODEX_INSTALL_TIMEOUT_MS = 60 * 60_000;
 const DEFAULT_LOCK_WAIT_MS = 190_000;
@@ -50,17 +50,16 @@ export async function resolveCodexRuntime(options) {
     const global = await findCompatibleGlobalCodex(environment.PATH, platform, dependencies);
     if (global)
         return global;
-    const managedRoot = resolve(options.dataDir, "runtimes", "codex", CODEX_RUNTIME_VERSION);
-    const managed = await validateManagedRuntime(managedRoot, options.target, platform, dependencies);
+    const managedParent = resolve(options.dataDir, "runtimes", "codex");
+    const managed = await findManagedRuntime(managedParent, options.target, platform, dependencies);
     if (managed)
         return managed;
-    options.onProgress?.(`Installing managed Codex ${CODEX_RUNTIME_VERSION}...`);
+    options.onProgress?.(`Installing managed Codex from ${CODEX_PACKAGE}...`);
     return installManagedCodex({
         ...options,
         environment,
         platform,
         dependencies,
-        managedRoot,
     });
 }
 export async function resolveNpmExecutor(options = {}) {
@@ -165,19 +164,19 @@ async function findCompatibleGlobalCodex(pathValue, platform, dependencies) {
 }
 async function installManagedCodex(options) {
     const parent = resolve(options.dataDir, "runtimes", "codex");
-    const lockPath = `${options.managedRoot}.lock`;
+    const lockPath = resolve(parent, "install.lock");
     const lockWaitMs = options.lockWaitMs ?? DEFAULT_LOCK_WAIT_MS;
     const staleLockMs = options.staleLockMs ?? DEFAULT_STALE_LOCK_MS;
     await mkdir(parent, { recursive: true });
-    const lock = await acquireInstallLock(lockPath, options.managedRoot, options.target, options.platform, options.dependencies, lockWaitMs, staleLockMs);
+    const lock = await acquireInstallLock(lockPath, parent, options.target, options.platform, options.dependencies, lockWaitMs, staleLockMs);
     if (lock.completed)
         return lock.completed;
     let temporaryRoot = null;
     try {
-        const existing = await validateManagedRuntime(options.managedRoot, options.target, options.platform, options.dependencies);
+        const existing = await findManagedRuntime(parent, options.target, options.platform, options.dependencies);
         if (existing)
             return existing;
-        temporaryRoot = await mkdtemp(resolve(parent, `.${CODEX_RUNTIME_VERSION}-${process.pid}-`));
+        temporaryRoot = await mkdtemp(resolve(parent, `.${CODEX_RUNTIME_TAG}-${process.pid}-`));
         const npm = await resolveNpmExecutor({
             environment: options.environment,
             platform: options.platform,
@@ -189,6 +188,7 @@ async function installManagedCodex(options) {
             "--ignore-scripts",
             "--no-audit",
             "--no-fund",
+            "--prefer-online",
             `--registry=${NPM_REGISTRY}`,
             "--prefix",
             temporaryRoot,
@@ -198,18 +198,21 @@ async function installManagedCodex(options) {
         if (!temporary) {
             throw new Error(`Codex runtime validation failed after installing ${CODEX_PACKAGE}`);
         }
-        await rename(temporaryRoot, options.managedRoot);
+        const managedRoot = resolve(parent, temporary.version);
+        // An invalid cache for this version must not block a validated replacement.
+        await rm(managedRoot, { recursive: true, force: true });
+        await rename(temporaryRoot, managedRoot);
         temporaryRoot = null;
-        const installed = await validateManagedRuntime(options.managedRoot, options.target, options.platform, options.dependencies);
+        const installed = await validateManagedRuntime(managedRoot, options.target, options.platform, options.dependencies);
         if (!installed)
             throw new Error("Codex runtime validation failed after activation");
         return installed;
     }
     catch (error) {
-        const concurrent = await validateManagedRuntime(options.managedRoot, options.target, options.platform, options.dependencies);
+        const concurrent = await findManagedRuntime(parent, options.target, options.platform, options.dependencies);
         if (concurrent)
             return concurrent;
-        throw new Error(`Unable to install managed Codex ${CODEX_RUNTIME_VERSION}: ${describeError(error)}`, {
+        throw new Error(`Unable to install managed Codex from ${CODEX_PACKAGE}: ${describeError(error)}`, {
             cause: error,
         });
     }
@@ -220,7 +223,7 @@ async function installManagedCodex(options) {
         await rm(lockPath, { force: true });
     }
 }
-async function acquireInstallLock(lockPath, managedRoot, target, platform, dependencies, waitMs, staleMs) {
+async function acquireInstallLock(lockPath, managedParent, target, platform, dependencies, waitMs, staleMs) {
     const deadline = dependencies.now() + waitMs;
     while (true) {
         try {
@@ -231,7 +234,7 @@ async function acquireInstallLock(lockPath, managedRoot, target, platform, depen
         catch (error) {
             if (error.code !== "EEXIST")
                 throw error;
-            const completed = await validateManagedRuntime(managedRoot, target, platform, dependencies);
+            const completed = await findManagedRuntime(managedParent, target, platform, dependencies);
             if (completed)
                 return { completed };
             try {
@@ -251,6 +254,24 @@ async function acquireInstallLock(lockPath, managedRoot, target, platform, depen
         }
     }
 }
+async function findManagedRuntime(parent, target, platform, dependencies) {
+    const entries = await readdir(parent, { withFileTypes: true }).catch((error) => {
+        if (error.code === "ENOENT")
+            return [];
+        throw error;
+    });
+    const versions = entries
+        .filter((entry) => entry.isDirectory() && parseCodexVersion(entry.name) === entry.name)
+        .map((entry) => entry.name)
+        .filter(meetsCodexMinimum)
+        .sort((left, right) => left === right ? 0 : isCodexVersionAtLeast(left, right) ? -1 : 1);
+    for (const version of versions) {
+        const runtime = await validateManagedRuntime(resolve(parent, version), target, platform, dependencies);
+        if (runtime?.version === version)
+            return runtime;
+    }
+    return null;
+}
 async function validateManagedRuntime(runtimeRoot, target, platform, dependencies) {
     for (const candidate of managedCodexBinaryCandidates(runtimeRoot, target)) {
         if (!isWithin(runtimeRoot, candidate) || !(await pathAccessible(candidate)))

package/dist/codex-sharing.js

@@ -0,0 +1,153 @@
+import { execFile } from "node:child_process";
+import { access, chmod, mkdir, readFile, realpath, rename, rm } from "node:fs/promises";
+import { constants } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { isDeepStrictEqual, promisify } from "node:util";
+import { resolveCodexRuntime } from "./codex-runtime-manager.js";
+import { inspectCodexDesktop } from "./codex-desktop-status.js";
+import { withDesktopRpc } from "./codex-desktop-probe.js";
+import { detectPlatform } from "./platform.js";
+import { writePrivateText } from "./service/service-files.js";
+const executeFile = promisify(execFile);
+export const CODEX_SHARING_LABEL = "com.agentroam.codex-desktop-shared-env";
+function locations(context) {
+    const home = resolve(context.homeDir ?? homedir());
+    const environment = context.environment ?? process.env;
+    const codexHome = resolve(environment.CODEX_HOME || resolve(home, ".codex"));
+    const socketPath = resolve(codexHome, "app-server-control/app-server-control.sock");
+    return { home, environment, codexHome, socketPath,
+        endpoint: `ws+unix://localhost${encodeURI(socketPath).replaceAll("#", "%23").replaceAll("?", "%3F").replaceAll(":", "%3A")}:/rpc`,
+        root: resolve(home, ".agentroam/codex-desktop"),
+        plist: resolve(home, "Library/LaunchAgents", `${CODEX_SHARING_LABEL}.plist`),
+        target: `gui/${context.uid ?? process.getuid?.() ?? 0}/${CODEX_SHARING_LABEL}`,
+    };
+}
+/** Save defaults and ensure the daemon; never quit Desktop or restart a live backend. */
+export async function configureCodexSharing(options, context = {}) {
+    if ((context.platform ?? process.platform) !== "darwin")
+        return;
+    const paths = locations(context);
+    const environment = { ...paths.environment };
+    const executable = environment.AGENT_CODEX_BIN || (await resolveCodexRuntime({
+        dataDir: options.dataDir, target: detectPlatform(), environment,
+    })).executable;
+    if (!executable.startsWith("/"))
+        throw new Error("Codex 运行文件必须使用绝对路径");
+    await access(executable, constants.X_OK);
+    const execute = context.execute ?? executeFile;
+    const script = resolve(paths.root, "watchdog.sh");
+    await writePrivateText(script, await readFile(fileURLToPath(new URL("../install/codex-shared-watchdog.sh", import.meta.url)), "utf8"));
+    const args = [script, executable, paths.codexHome, paths.endpoint, environment.PATH || "/usr/bin:/bin:/usr/sbin:/sbin", paths.home];
+    const definition = {
+        Label: CODEX_SHARING_LABEL, ProgramArguments: ["/bin/bash", ...args],
+        RunAtLoad: true, StartInterval: 15, ProcessType: "Background", WorkingDirectory: paths.home,
+        StandardOutPath: resolve(paths.root, "watchdog.log"), StandardErrorPath: resolve(paths.root, "watchdog-error.log"),
+    };
+    const json = `${paths.root}/job.json`;
+    const temporary = `${paths.root}/job.plist`;
+    const commandOptions = { encoding: "utf8", timeout: 20_000, maxBuffer: 1024 * 1024 };
+    // Identical startup calls must not unload/reload an already healthy job.
+    let unchanged = false;
+    try {
+        const current = await execute("/usr/bin/plutil", ["-convert", "json", "-o", "-", paths.plist], commandOptions);
+        unchanged = isDeepStrictEqual(JSON.parse(String(current.stdout)), definition);
+    }
+    catch { /* First install or older definition. */ }
+    if (!unchanged) {
+        await writePrivateText(json, JSON.stringify(definition));
+        try {
+            await execute("/usr/bin/plutil", ["-convert", "xml1", "-o", temporary, json], commandOptions);
+            await chmod(temporary, 0o600);
+            await mkdir(dirname(paths.plist), { recursive: true });
+            let loaded = false;
+            try {
+                await execute("/bin/launchctl", ["print", paths.target], commandOptions);
+                loaded = true;
+            }
+            catch { /* Absent job. */ }
+            if (loaded)
+                await execute("/bin/launchctl", ["bootout", paths.target], commandOptions);
+            await rename(temporary, paths.plist);
+        }
+        finally {
+            await Promise.all([rm(json, { force: true }), rm(temporary, { force: true })]);
+        }
+    }
+    await execute("/bin/launchctl", ["enable", paths.target], commandOptions);
+    let loaded = false;
+    try {
+        await execute("/bin/launchctl", ["print", paths.target], commandOptions);
+        loaded = true;
+    }
+    catch { /* bootstrap below */ }
+    if (!loaded)
+        await execute("/bin/launchctl", ["bootstrap", paths.target.slice(0, paths.target.lastIndexOf("/")), paths.plist], commandOptions);
+    // Make defaults effective now as well as on the next GUI login.
+    await execute("/bin/bash", args, { ...commandOptions, env: environment, cwd: paths.home });
+}
+/** Read process/socket evidence; configuration by itself never proves sharing. */
+export async function inspectCodexSharing(context = {}) {
+    const result = { state: "failed", configured: false, autoStart: false, daemonReachable: false, message: "共享连接检查失败，请修复后重试。" };
+    if ((context.platform ?? process.platform) !== "darwin")
+        return { ...result, state: "unsupported", message: "当前系统暂不支持 Codex 桌面共享配置。" };
+    const paths = locations(context);
+    result.backendEndpoint = paths.endpoint;
+    const execute = context.execute ?? executeFile;
+    const commandOptions = { encoding: "utf8", timeout: 4_000, maxBuffer: 4 * 1024 * 1024 };
+    try {
+        const current = await execute("/bin/launchctl", ["getenv", "CODEX_APP_SERVER_WS_URL"], commandOptions).catch(() => ({ stdout: "" }));
+        const [force, home] = await Promise.all([
+            execute("/bin/launchctl", ["getenv", "CODEX_APP_SERVER_FORCE_CLI"], commandOptions).catch(() => ({ stdout: "" })),
+            execute("/bin/launchctl", ["getenv", "CODEX_HOME"], commandOptions).catch(() => ({ stdout: "" })),
+        ]);
+        result.configured = String(current.stdout).trim() === paths.endpoint && String(force.stdout).trim() !== "1"
+            && (String(home.stdout).trim() || resolve(paths.home, ".codex")) === paths.codexHome;
+        try {
+            const job = await execute("/bin/launchctl", ["print", paths.target], commandOptions);
+            const plist = await execute("/usr/bin/plutil", ["-convert", "json", "-o", "-", paths.plist], commandOptions);
+            const definition = JSON.parse(String(plist.stdout));
+            await access(resolve(paths.root, "watchdog.sh"), constants.R_OK);
+            await access(definition.ProgramArguments?.[2] ?? "", constants.X_OK);
+            result.autoStart = Boolean(job.stdout) && definition.RunAtLoad === true && definition.StartInterval === 15
+                && definition.ProgramArguments?.[0] === "/bin/bash" && definition.ProgramArguments?.[1] === resolve(paths.root, "watchdog.sh")
+                && definition.ProgramArguments?.[3] === paths.codexHome && definition.ProgramArguments?.[4] === paths.endpoint;
+        }
+        catch { /* Missing or outdated watchdog. */ }
+        try {
+            await (context.probe ?? (async (endpoint) => { await withDesktopRpc(endpoint, async (request) => { await request("config/read", { includeLayers: false }); }, 4_000); }))(paths.endpoint);
+            result.daemonReachable = true;
+        }
+        catch { /* Keep checking private Desktop evidence. */ }
+        const desktop = await (context.inspect ?? inspectCodexDesktop)(paths.environment);
+        if (desktop.status !== "running")
+            return { ...result, state: desktop.status, message: desktop.status === "stopped"
+                    ? result.configured && result.autoStart && result.daemonReachable ? "Codex 尚未启动；下次打开时使用共享后台。" : "Codex 尚未启动；请先修复共享配置。" : "尚未安装官方 Codex 桌面端。" };
+        const { stdout } = await execute("/bin/ps", ["-axo", "pid=,ppid=,args="], commandOptions);
+        const processes = String(stdout).split("\n").flatMap(line => {
+            const match = /^\s*(\d+)\s+(\d+)\s+(.+)$/.exec(line);
+            return match ? [{ pid: Number(match[1]), parent: Number(match[2]), command: match[3] }] : [];
+        });
+        if (processes.some(p => p.parent === desktop.pid && /\bapp-server\b/.test(p.command) && !/\b(?:proxy|daemon)\b/.test(p.command))) {
+            return { ...result, state: "independent", message: "Codex 正在使用独立后台。修复后，请在任务结束时退出并重新打开 Codex。" };
+        }
+        if (!result.daemonReachable)
+            return result;
+        const socket = await realpath(paths.socketPath);
+        const pids = [desktop.pid, ...processes.filter(p => /\bapp-server\b/.test(p.command) && /\bcodex\b/.test(p.command)).map(p => p.pid)];
+        const sockets = await execute("/usr/sbin/lsof", ["-nP", "-a", "-p", [...new Set(pids)].join(","), "-U"], commandOptions);
+        const rows = String(sockets.stdout).split("\n").flatMap(line => {
+            const match = /^\S+\s+(\d+)\s+\S+\s+\S+\s+unix\s+(0x[\da-f]+)\s+\S+\s+(.*)$/i.exec(line);
+            return match ? [{ pid: Number(match[1]), device: match[2], name: match[3].trim() }] : [];
+        });
+        const devices = new Set(rows.filter(row => row.pid !== desktop.pid && row.name === socket).map(row => row.device));
+        if (rows.some(row => row.pid === desktop.pid && row.name.startsWith("->") && devices.has(row.name.slice(2)))) {
+            return { ...result, state: "shared", message: "Codex 已连接共享后台。" };
+        }
+        return { ...result, message: "共享后台可用，但尚未确认 Codex 连接。请修复后，在任务结束时重新打开 Codex。" };
+    }
+    catch {
+        return result;
+    }
+}

package/dist/runtime-manager.js

@@ -7,6 +7,7 @@ import { resolveOpenCodeRuntime, } from "./opencode-runtime-manager.js";
 import { resolvePlatformRuntime } from "./platform-packages.js";
 import { findAvailablePort } from "./port.js";
 import { ProcessSupervisor } from "./process-supervisor.js";
+import { configureCodexSharing } from "./codex-sharing.js";
 import { withCliProgress } from "../bin/cli-progress.mjs";
 export class RuntimeManager {
     supervisor;
@@ -24,6 +25,14 @@ export class RuntimeManager {
         const dataDir = resolve(options.dataDir);
         await Promise.all(["data", "bin", "cache", "logs"].map((name) => mkdir(resolve(dataDir, name), { recursive: true })));
         const codexEnvironment = await withCliProgress("正在准备 Codex 组件", () => prepareCodexRuntimeEnvironment(process.env, { dataDir, target }, this.codexResolver, this.report));
+        if (process.platform === "darwin" && codexEnvironment.AGENT_CODEX_BIN) {
+            try {
+                await configureCodexSharing(options, { environment: codexEnvironment });
+            }
+            catch (error) {
+                this.report(`Codex 共享启动配置未完成，可在电脑菜单中修复：${error instanceof Error ? error.message : error}`);
+            }
+        }
         const childEnvironment = await withCliProgress("正在准备 OpenCode 组件", () => prepareOpenCodeRuntimeEnvironment(codexEnvironment, { dataDir, target }, this.opencodeResolver, this.report));
         const { runtimeRoot } = resolvePlatformRuntime(target);
         await repairNativeRuntimePermissions(runtimeRoot);

package/dist/service/service-command.js

@@ -8,6 +8,7 @@ import { MacLaunchAgent } from "./macos-launch-agent.js";
 import { WindowsTaskService } from "./windows-task-service.js";
 import { assertSupportedNodeVersion } from "../../bin/runtime-policy.mjs";
 import { cleanupOldLaunchers } from "./launcher-cleanup.js";
+import { configureCodexSharing } from "../codex-sharing.js";
 import { setupCodexDesktop } from "../codex-desktop-setup.js";
 import { authorizeRemoteDesktop } from "../desktop-authorization.js";
 import { withCliProgress } from "../../bin/cli-progress.mjs";
@@ -60,6 +61,14 @@ export async function runServiceCommand(options, context) {
                 dataDir: options.dataDir,
                 installedAt: now.toISOString(),
             };
+            if (platform === "darwin" && codexPath) {
+                try {
+                    await (context.configureSharing ?? configureCodexSharing)(options, { homeDir: context.homeDir, environment: { ...environment, PATH: environmentPath, AGENT_CODEX_BIN: codexPath } });
+                }
+                catch (error) {
+                    log(`Codex 默认共享配置未完成，可在电脑菜单中修复：${error instanceof Error ? error.message : error}`);
+                }
+            }
             const { definition, state } = await withCliProgress("正在安装后台服务，等待服务和手机访问连接就绪", () => controller.install(config));
             log(`✓ AgentRoam service installed: ${definition}`);
             if (state?.localUrl && state.status !== "stopped")

package/install/codex-shared-watchdog.sh

@@ -0,0 +1,16 @@
+#!/bin/bash
+# Copied to a stable private directory: upgrades must not invalidate this job.
+set -euo pipefail
+codex_bin="$1"
+codex_home="$2"
+shared_url="$3"
+export CODEX_HOME="$codex_home"
+export PATH="$4"
+export CODEX_APP_SERVER_FORCE_CLI=0
+export CODEX_APP_SERVER_WS_URL="$shared_url"
+/bin/launchctl setenv CODEX_APP_SERVER_WS_URL "$shared_url"
+/bin/launchctl setenv CODEX_APP_SERVER_FORCE_CLI 0
+/bin/launchctl setenv CODEX_HOME "$codex_home"
+# daemon start is idempotent; never stop or replace a live daemon.
+cd "$5"
+exec "$codex_bin" app-server daemon start

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentroam",
-  "version": "0.2.0-preview.46",
+  "version": "0.2.0-preview.48",
   "description": "Zero-install mobile remote terminal and file console",
   "type": "module",
   "bin": {
@@ -27,12 +27,12 @@
     "ws": "^8.21.3"
   },
   "optionalDependencies": {
-    "agentroam-runtime-darwin-arm64": "0.2.0-preview.46",
-    "agentroam-runtime-win32-x64": "0.2.0-preview.46",
+    "agentroam-runtime-darwin-arm64": "0.2.0-preview.48",
+    "agentroam-runtime-win32-x64": "0.2.0-preview.48",
     "agentroam-cloudflared-darwin-arm64": "0.2.0-preview.39",
     "agentroam-cloudflared-win32-x64": "0.2.0-preview.39",
-    "agentroam-tui-darwin-arm64": "0.2.0-preview.46",
-    "@caoqu/agentroam-tui-win32-x64": "0.2.0-preview.46"
+    "agentroam-tui-darwin-arm64": "0.2.0-preview.47",
+    "@caoqu/agentroam-tui-win32-x64": "0.2.0-preview.47"
   },
   "devDependencies": {
     "@types/node": "^22.0.0",