agentroam 0.2.0-preview.36 → 0.2.0-preview.38

package/bin/cli-progress.d.mts

@@ -0,0 +1,9 @@
+export interface CliProgressOptions {
+  enabled?: boolean;
+  environment?: NodeJS.ProcessEnv;
+  log?: (line: string) => void;
+  delayMs?: number;
+  intervalMs?: number;
+}
+export function withCliProgress<T>(label: string, operation: () => T | Promise<T>, options?: CliProgressOptions): Promise<T>;
+export function withoutCliProgress<T>(operation: () => T | Promise<T>): Promise<T>;

package/bin/cli-progress.mjs

@@ -0,0 +1,65 @@
+import { AsyncLocalStorage } from 'node:async_hooks';
+
+const context = new AsyncLocalStorage();
+
+// Append complete lines to stderr so stdout (URLs, QR codes, JSON) stays usable.
+class ProgressReporter {
+  constructor(options) {
+    const environment = options.environment ?? process.env;
+    this.enabled = options.enabled ?? (environment.AGENTROAM_SERVICE !== '1' && environment.AGENTROAM_NO_PROGRESS !== '1');
+    this.log = options.log ?? ((line) => process.stderr.write(`${line}\n`));
+    this.delayMs = options.delayMs ?? 800;
+    this.intervalMs = options.intervalMs ?? 5000;
+    this.steps = [];
+    this.pauses = 0;
+  }
+
+  begin(label) {
+    const step = { label, started: Date.now() };
+    this.steps.push(step);
+    this.schedule(this.delayMs);
+    return () => {
+      const wasActive = this.steps.at(-1) === step;
+      this.steps.splice(this.steps.indexOf(step), 1);
+      if (wasActive) this.schedule(this.delayMs);
+    };
+  }
+
+  schedule(milliseconds) {
+    clearTimeout(this.timer);
+    if (!this.enabled || this.pauses || !this.steps.length) return;
+    this.timer = setTimeout(() => {
+      const step = this.steps.at(-1);
+      const seconds = Math.floor((Date.now() - step.started) / 1000);
+      this.log(`… ${step.label}（已等待 ${seconds} 秒）`);
+      this.schedule(this.intervalMs);
+    }, milliseconds);
+    this.timer.unref?.();
+  }
+
+  pause() {
+    this.pauses++;
+    clearTimeout(this.timer);
+    return () => {
+      this.pauses--;
+      this.schedule(this.delayMs);
+    };
+  }
+}
+
+/** Nested stages share one heartbeat. Timers always stop, including on failure. */
+export async function withCliProgress(label, operation, options = {}) {
+  const reporter = context.getStore() ?? new ProgressReporter(options);
+  return context.run(reporter, async () => {
+    const finish = reporter.begin(label);
+    try { return await operation(); }
+    finally { finish(); }
+  });
+}
+
+/** Suspend every nested heartbeat while a terminal prompt owns the cursor. */
+export async function withoutCliProgress(operation) {
+  const resume = context.getStore()?.pause();
+  try { return await operation(); }
+  finally { resume?.(); }
+}

package/bin/desktop-download.mjs

@@ -8,6 +8,7 @@ import { fileURLToPath } from 'node:url';
 import { Transform, Readable } from 'node:stream';
 import { pipeline } from 'node:stream/promises';
 import { execFile } from 'node:child_process';
+import { withCliProgress } from './cli-progress.mjs';
 
 // 桌面端安装包是构建产物（dmg / exe），进不了只放源码的仓库，只能走 Releases 资产。
 // 资产由 `node scripts/publish-agentroam-release.mjs sync-github --commit <sha>` 上传；
@@ -57,7 +58,7 @@ export async function downloadDesktop(version, { platform = process.platform, ar
 
 if (process.argv[1] && resolve(process.argv[1]) === fileURLToPath(import.meta.url)) {
   try {
-    const destination = await downloadDesktop(process.argv[2]);
+    const destination = await withCliProgress('正在下载并校验桌面端安装包', () => downloadDesktop(process.argv[2]));
     console.log(`桌面端安装包已下载：${destination}\n请打开安装包完成安装。首次打开 AgentRoam 后，按提示授权远程桌面。`);
     if (process.platform === 'darwin') execFile('/usr/bin/open', ['-R', destination], () => undefined);
     else if (process.platform === 'win32') execFile('explorer.exe', [`/select,${destination}`], () => undefined);

package/bin/node-preflight.mjs

@@ -5,6 +5,7 @@ import { delimiter, dirname, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 import { promisify } from "node:util";
 import { MINIMUM_NODE_VERSION, compareNodeVersions, isSupportedNodeVersion, parseNodeVersion } from "./runtime-policy.mjs";
+import { withCliProgress } from "./cli-progress.mjs";
 
 const execFileAsync = promisify(execFile);
 // 安装引导地址：指向仓库主分支上的安装脚本（raw 路径）。
@@ -35,10 +36,9 @@ export async function runNodePreflight(options = {}) {
   const target = detectManagedTarget(platform, arch);
   const dataDir = parsePreflightDataDir(argv, environment, options.homeDir ?? homedir());
   const findSystemNode = options.findSystemNode ?? defaultFindSystemNode;
-  const systemNode = await findSystemNode(environment, platform, options.currentExecutable ?? process.execPath);
-  let executable = systemNode;
-
-  if (!executable) {
+  const executable = await withCliProgress("正在查找或安装兼容的 Node.js", async () => {
+    const systemNode = await findSystemNode(environment, platform, options.currentExecutable ?? process.execPath);
+    if (systemNode) return systemNode;
     const ensureNode = options.ensureNode ?? (async (installOptions) => {
       const { ensureManagedNode } = await import("../dist/node-runtime-manager.js");
       return ensureManagedNode(installOptions);
@@ -50,8 +50,8 @@ export async function runNodePreflight(options = {}) {
       arch,
       onProgress: options.onProgress ?? ((message) => processHost.stderr.write(`${message}\n`)),
     });
-    executable = resolution.executable;
-  }
+    return resolution.executable;
+  }, { environment, log: (line) => processHost.stderr.write(`${line}\n`) });
 
   const spawnChild = options.spawnChild ?? defaultSpawnChild;
   const child = spawnChild(executable, [launcherPath, ...argv], {

package/dist/args.js

@@ -3,11 +3,18 @@ import { resolve } from "node:path";
 export function parseArgs(argv) {
     const values = [...argv];
     let command = "start";
-    if (values[0] && ["start", "doctor", "version", "service", "unlock-service", "update", "update-worker", "pair", "devices", "revoke", "approvals", "approve", "deny", "lock", "unlock", "audit", "codex-desktop"].includes(values[0])) {
+    if (values[0] && ["start", "doctor", "version", "service", "unlock-service", "update", "update-worker", "pair", "devices", "revoke", "approvals", "approve", "deny", "lock", "unlock", "audit", "codex-desktop", "desktop"].includes(values[0])) {
         command = values.shift();
     }
     let serviceAction = null;
     let unlockServiceAction = null;
+    let desktopAction;
+    if (command === "desktop") {
+        const action = values.shift();
+        if (!action || !["authorize", "status", "disable"].includes(action))
+            throw cliError("desktop requires authorize, status, or disable");
+        desktopAction = action;
+    }
     if (command === "service") {
         const action = values.shift();
         if (!action || !["install", "start", "stop", "status", "url", "logs", "restart", "uninstall"].includes(action)) {
@@ -67,9 +74,13 @@ export function parseArgs(argv) {
         ...(approvalRequestId ? { approvalRequestId } : {}),
         updateVersion,
         updateStateFile,
+        ...(desktopAction ? { desktopAction } : {}),
     };
     for (let index = 0; index < values.length && command !== "update-worker"; index++) {
         const arg = values[index];
+        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");
         }

package/dist/cli.js

@@ -23,6 +23,8 @@ import { runUnlockServiceCommand } from "./unlock-service.js";
 import { createCliErrorLog } from "./error-log.js";
 import { runCodexDesktopCommand } from "./codex-desktop-command.js";
 import { setupCodexDesktop } from "./codex-desktop-setup.js";
+import { runDesktopCommand } from "./desktop-authorization.js";
+import { withCliProgress } from "../bin/cli-progress.mjs";
 const VERSION = AGENTROAM_VERSION;
 export async function main(argv) {
     if (argv.includes("--help") || argv.includes("-h")) {
@@ -40,6 +42,9 @@ export async function main(argv) {
   agentroam revoke <设备ID>          移除一台设备
   agentroam revoke --all            全部退出并取消待用配对码
   agentroam service install|start|stop|restart|status|url|logs|uninstall
+  agentroam desktop authorize       本机弹窗授权远程桌面，无需浏览器；可重复执行
+  agentroam desktop status          重新检查远程桌面权限和共享状态
+  agentroam desktop disable         关闭远程桌面共享，保留系统权限
   agentroam unlock-service install|uninstall|status  管理 Windows 远程解锁服务（安装时弹出 UAC）
   agentroam codex-desktop [--dry-run]  通过共享后端启动官方 Codex 桌面端（macOS）
   agentroam codex-desktop --restart   退出并重新连接官方桌面端，会中断它的全部运行会话
@@ -49,6 +54,19 @@ export async function main(argv) {
         return;
     }
     const options = parseArgs(argv);
+    // Foreground start remains alive after readiness; only its startup stages load.
+    if (options.command === "start" || options.command === "update-worker")
+        return executeCommand(options, argv);
+    const label = options.command === "service" ? `正在处理后台服务：${options.serviceAction}`
+        : options.command === "desktop" ? "正在检查远程桌面授权"
+            : options.command === "codex-desktop" ? "正在配置官方 Codex 桌面连接"
+                : options.command === "doctor" ? "正在检查运行组件"
+                    : options.command === "update" ? "正在检查并准备更新"
+                        : options.command === "unlock-service" ? "正在处理 Windows 解锁服务，请留意管理员授权弹窗"
+                            : "正在处理设备授权命令";
+    await withCliProgress(label, () => executeCommand(options, argv));
+}
+async function executeCommand(options, argv) {
     // CLI 进程自身的按天错误日志:<dataDir>/logs/YYYY-MM-DD.log(NDJSON,与
     // server/desktop 的 core logger 同格式)。uncaughtException 记录后按默认
     // 语义退出(1),unhandledRejection 只记录。
@@ -98,6 +116,12 @@ export async function main(argv) {
         return;
     }
     const target = detectPlatform();
+    if (options.command === "desktop") {
+        if (!argv.includes("--data-dir"))
+            options.dataDir = await installedDataDir(options.dataDir);
+        await runDesktopCommand(options);
+        return;
+    }
     if (options.command === "codex-desktop") {
         if (!argv.includes("--data-dir"))
             options.dataDir = await installedDataDir(options.dataDir);
@@ -110,7 +134,7 @@ export async function main(argv) {
     if (options.command === "unlock-service") {
         if (target !== "windows-amd64")
             throw new Error("远程解锁服务仅支持 Windows 10/11 x64");
-        runUnlockServiceCommand(options.unlockServiceAction, resolvePlatformRuntime(target).runtimeRoot);
+        await runUnlockServiceCommand(options.unlockServiceAction, resolvePlatformRuntime(target).runtimeRoot);
         return;
     }
     if (options.command === "update") {
@@ -129,7 +153,7 @@ export async function main(argv) {
         return;
     }
     console.log(`AgentRoam ${VERSION}\n✓ Node ${process.versions.node} · ${target}`);
-    const sleepInhibitor = await acquireSleepInhibitor();
+    const sleepInhibitor = await withCliProgress("正在准备启动环境", () => acquireSleepInhibitor());
     const controller = new AbortController();
     let runtime = null;
     let relay = null;
@@ -145,23 +169,23 @@ export async function main(argv) {
             return closePromise;
         closing = true;
         controller.abort();
-        closePromise = (async () => {
+        closePromise = withCliProgress("正在停止本机服务和访问连接", async () => {
             await relay?.tunnel?.close().catch(() => { });
             await runtime?.close().catch(() => { });
-        })();
+        });
         return closePromise;
     };
     const requestClose = () => void close();
     process.once("SIGINT", requestClose);
     process.once("SIGTERM", requestClose);
     try {
-        releaseStartup = await lockInstanceStartup(options.dataDir);
-        await stopPreviousInstances(options.dataDir, console.log);
+        releaseStartup = await withCliProgress("正在等待启动锁", () => lockInstanceStartup(options.dataDir));
+        await withCliProgress("正在接管旧实例", () => stopPreviousInstances(options.dataDir, console.log));
         if (controller.signal.aborted)
             return;
         await serviceReporter?.starting();
         reportedStarting = Boolean(serviceReporter);
-        runtime = await new RuntimeManager().start(options, target);
+        runtime = await withCliProgress("正在启动本机服务", () => new RuntimeManager().start(options, target));
         if (controller.signal.aborted) {
             await runtime.close();
             return;
@@ -172,18 +196,19 @@ export async function main(argv) {
         if (!serviceReporter)
             printLocalDesktopUrl(runtime.localUrl);
         const lanUrl = options.localOnly ? findLanUrl(runtime.port) ?? runtime.localUrl : runtime.localUrl;
-        relay = await selectRelay({
+        const relayRuntime = runtime;
+        relay = await withCliProgress("正在建立手机访问连接", () => selectRelay({
             cli: options,
             target,
-            localUrl: runtime.localUrl,
+            localUrl: relayRuntime.localUrl,
             lanUrl,
-            port: runtime.port,
+            port: relayRuntime.port,
             signal: controller.signal,
             log: (line) => process.stderr.write(`${line}\n`),
             onAttempt: (provider) => console.log(`▲ Trying ${providerDisplayName(provider)} relay...`),
             onFailure: (provider, message) => console.error(`⚠ ${providerDisplayName(provider)} unavailable: ${message}`),
             allowLanFallback: options.localOnly,
-        });
+        }));
         if (controller.signal.aborted) {
             await relay.tunnel?.close();
             return;
@@ -255,7 +280,7 @@ async function doctor(target, dataDir) {
         ["better-sqlite3", probeSQLiteRuntime],
     ]) {
         try {
-            await probe(runtimeRequire);
+            await withCliProgress(`正在检查 ${module}`, () => probe(runtimeRequire));
             console.log(`✓ ${module}`);
         }
         catch (error) {
@@ -270,18 +295,18 @@ async function doctor(target, dataDir) {
         reportDoctorFailure(error, "agent-tui: ");
     }
     try {
-        const codex = await resolveCodexRuntime({
+        const codex = await withCliProgress("正在检查和准备 Codex", () => resolveCodexRuntime({
             dataDir,
             target,
             onProgress: (message) => console.log(`… ${message}`),
-        });
+        }));
         console.log(`✓ Codex ${codex.version} (${codex.source}) ${codex.executable}`);
     }
     catch (error) {
         reportDoctorFailure(error, "Codex: ");
     }
     try {
-        const executable = await ensureCloudflared(target, dataDir);
+        const executable = await withCliProgress("正在检查和准备 Cloudflare 组件", () => ensureCloudflared(target, dataDir));
         console.log(`✓ cloudflared ${executable}`);
     }
     catch (error) {

package/dist/codex-desktop-command.js

@@ -24,7 +24,7 @@ export async function runCodexDesktopCommand(options, context = {}) {
         const codex = await (context.codexResolver ?? resolveCodexRuntime)({
             dataDir: options.dataDir,
             target: detectPlatform(platform, process.arch, process.versions.node),
-            environment,
+            environment: { ...environment },
             platform,
             nodeExecutable: process.execPath,
             onProgress: (message) => log(`… ${message}`),
@@ -32,13 +32,17 @@ export async function runCodexDesktopCommand(options, context = {}) {
         environment.AGENT_CODEX_BIN = codex.executable;
     }
     const args = [scriptPath];
+    if (!options.desktopDryRun) {
+        environment.AGENTROAM_CODEX_DESKTOP_PREFLIGHT_NODE = process.execPath;
+        environment.AGENTROAM_CODEX_DESKTOP_PREFLIGHT = fileURLToPath(new URL("./codex-desktop-preflight.js", import.meta.url));
+    }
     if (options.desktopRestart)
         args.push("--restart");
     if (options.desktopDryRun)
         args.push("--dry-run");
     try {
         const { stdout, stderr } = await (context.execute ?? execFileAsync)("/bin/bash", args, {
-            env: environment, encoding: "utf8", timeout: 30_000, maxBuffer: 1024 * 1024,
+            env: environment, encoding: "utf8", timeout: 60_000, maxBuffer: 1024 * 1024,
         });
         if (stdout.trim())
             log(stdout.trimEnd());

package/dist/codex-desktop-preflight.js

@@ -0,0 +1,57 @@
+import { execFile } from "node:child_process";
+import { homedir } from "node:os";
+import { promisify } from "node:util";
+import { pathToFileURL } from "node:url";
+import { DesktopProbeRpcError, readDesktopActivity, withDesktopRpc } from "./codex-desktop-probe.js";
+const execFileAsync = promisify(execFile);
+async function inspectBackend(endpoint) {
+    return withDesktopRpc(endpoint, async (request, becameActive) => {
+        try {
+            await request("config/read", {});
+            try {
+                await request("account/gatewayOAuth/read", {});
+            }
+            catch (error) {
+                // Older servers may not have the Desktop gateway RPC.
+                if (!(error instanceof DesktopProbeRpcError && error.code === -32601))
+                    throw error;
+            }
+            return true;
+        }
+        catch (error) {
+            if (!(error instanceof DesktopProbeRpcError) || !/No such file or directory|os error 2/.test(error.message))
+                throw error;
+            const activity = await readDesktopActivity(request);
+            if (activity.state !== "idle" || becameActive())
+                throw new Error("共享后端配置失效，但任务忙碌或状态无法确认；已保留桌面和共享后端");
+            return false;
+        }
+    });
+}
+/** Repair only a missing-directory backend after two complete idle snapshots. */
+export async function preflightCodexDesktop(endpoint, executable, context = {}) {
+    if (await inspectBackend(endpoint))
+        return;
+    if (await inspectBackend(endpoint))
+        return;
+    (context.log ?? console.log)("共享后端的工作目录已失效，已确认全部任务空闲，正在从稳定目录重建…");
+    await (context.restart ?? (async () => {
+        await execFileAsync(executable, ["app-server", "daemon", "restart"], {
+            cwd: homedir(), env: process.env, timeout: 15_000, maxBuffer: 1024 * 1024,
+        });
+    }))();
+    if (!await inspectBackend(endpoint))
+        throw new Error("共享后端重建后仍无法读取配置；已保留桌面");
+}
+if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href) {
+    const [endpoint, executable] = process.argv.slice(2);
+    if (!endpoint || !executable) {
+        console.error("Missing shared backend endpoint or Codex executable");
+        process.exitCode = 1;
+    }
+    else
+        preflightCodexDesktop(endpoint, executable).catch(error => {
+            console.error(`共享后端检查失败：${error instanceof Error ? error.message : error}`);
+            process.exitCode = 1;
+        });
+}

package/dist/codex-desktop-probe.js

@@ -1,6 +1,24 @@
 import { Agent, WebSocket } from "undici";
+export class DesktopProbeRpcError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.code = code;
+    }
+}
 /** Read live state only. Never resume, subscribe, interrupt or unload a thread. */
 export async function probeDesktopActivity(endpoint, timeoutMs = 5_000) {
+    try {
+        return await withDesktopRpc(endpoint, async (request, becameActive) => {
+            const activity = await readDesktopActivity(request);
+            return becameActive() && activity.state === "idle" ? { state: "busy", activeCount: 1 } : activity;
+        }, timeoutMs);
+    }
+    catch {
+        return { state: "unknown", reason: "无法完整查询桌面端的实时任务状态" };
+    }
+}
+export async function withDesktopRpc(endpoint, operation, timeoutMs = 5_000) {
     let dispatcher;
     let socket;
     let timer;
@@ -49,7 +67,7 @@ export async function probeDesktopActivity(endpoint, timeoutMs = 5_000) {
                     return;
                 pending.delete(message.id);
                 if (message.error)
-                    item.reject(new Error("Desktop probe RPC failed"));
+                    item.reject(new DesktopProbeRpcError(message.error.code, String(message.error.message ?? "Desktop probe RPC failed")));
                 else
                     item.resolve(message.result);
             }
@@ -68,21 +86,17 @@ export async function probeDesktopActivity(endpoint, timeoutMs = 5_000) {
                 reject(error);
             }
         });
-        const operation = async () => {
+        const run = async () => {
             await opened;
-            await request("initialize", { clientInfo: { name: "agentroam_desktop_setup", version: "1" } });
+            await request("initialize", { clientInfo: { name: "agentroam_desktop_setup", version: "1" }, capabilities: { experimentalApi: true } });
             connection.send(JSON.stringify({ method: "initialized", params: {} }));
-            const activity = await readDesktopActivity(request);
-            return changedToActive && activity.state === "idle" ? { state: "busy", activeCount: 1 } : activity;
+            return operation(request, () => changedToActive);
         };
         return await Promise.race([
-            operation(),
+            run(),
             new Promise((_, reject) => { timer = setTimeout(() => reject(new Error("Desktop probe timed out")), timeoutMs); }),
         ]);
     }
-    catch {
-        return { state: "unknown", reason: "无法完整查询桌面端的实时任务状态" };
-    }
     finally {
         if (timer)
             clearTimeout(timer);

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 { withoutCliProgress } from "../bin/cli-progress.mjs";
 export async function setupCodexDesktop(options, context = {}) {
     if ((context.platform ?? process.platform) !== "darwin")
         return;
@@ -39,7 +40,7 @@ export async function setupCodexDesktop(options, context = {}) {
                 ? `官方 Codex 桌面端当前有 ${snapshot.activity.activeCount} 个运行中的会话。`
                 : "无法可靠确认官方 Codex 桌面端的全部任务已结束。";
             log(reason);
-            const answer = await (context.confirm ?? confirmDesktopRestart)("现在重启桌面端以共享会话？重启可能中断桌面端的所有运行任务；选择保留则暂不能共享原桌面会话 [y/N]：");
+            const answer = await withoutCliProgress(() => (context.confirm ?? confirmDesktopRestart)("现在重启桌面端以共享会话？重启可能中断桌面端的所有运行任务；选择保留则暂不能共享原桌面会话 [y/N]："));
             if (!answer || !/^(?:y|yes)$/i.test(answer.trim())) {
                 deferred();
                 return;

package/dist/desktop-authorization.js

@@ -0,0 +1,148 @@
+import { execFile } from "node:child_process";
+import { createInterface } from "node:readline/promises";
+import { Readable } from "node:stream";
+import { setTimeout as delay } from "node:timers/promises";
+import { promisify } from "node:util";
+import { resolveApprovalInput, terminalText } from "./device-pairing.js";
+import { localServiceRequest } from "./local-service-request.js";
+import { withCliProgress, withoutCliProgress } from "../bin/cli-progress.mjs";
+const runFile = promisify(execFile);
+const endpoint = "/api/remote-authorization";
+async function requestAuthorization(dataDir, body) {
+    const status = await localServiceRequest(dataDir, endpoint, {
+        method: body ? "POST" : "GET", body, timeoutMs: body?.action === "request-permission" ? 135_000 : 30_000,
+    });
+    if (status.local !== true || typeof status.supported !== "boolean" || typeof status.installed !== "boolean"
+        || typeof status.enabled !== "boolean" || typeof status.screen !== "boolean" || typeof status.accessibility !== "boolean"
+        || typeof status.online !== "boolean" || typeof status.platform !== "string"
+        || (status.error !== null && typeof status.error !== "string")) {
+        throw new Error("本机远程授权状态无效，请升级 CLI 后重试");
+    }
+    return status;
+}
+/** A native macOS dialog; no browser, shell interpolation, or piped stdin. */
+export async function confirmDesktopAuthorization(platform) {
+    if (platform === "darwin") {
+        const script = 'display dialog "是否启用 AgentRoam 远程桌面？\n接下来将请求屏幕录制和辅助功能权限。授权后，已配对的设备可以查看和控制这台电脑。" with title "AgentRoam 远程桌面授权" buttons {"稍后", "开始授权"} default button "开始授权" cancel button "稍后" giving up after 120';
+        try {
+            const { stdout } = await runFile("/usr/bin/osascript", ["-e", script], { timeout: 125_000, maxBuffer: 4096 });
+            return stdout.includes("button returned:开始授权") && !stdout.includes("gave up:true");
+        }
+        catch {
+            return false;
+        }
+    }
+    const input = resolveApprovalInput({ interactive: true });
+    if (!input)
+        return false;
+    const reader = createInterface({ input, output: process.stdout });
+    try {
+        const answer = await withoutCliProgress(() => reader.question("启用远程桌面，允许已配对设备查看和控制这台电脑？[y/N]："));
+        return /^(y|yes)$/i.test(answer.trim());
+    }
+    finally {
+        reader.close();
+        if (input !== process.stdin && input instanceof Readable)
+            input.destroy();
+    }
+}
+function recoveryHint(log) {
+    log("稍后重新授权：agentroam desktop authorize；也可在本机浏览器的“远程授权”面板中操作。");
+}
+function complete(status) {
+    return status.enabled && status.screen && status.accessibility && !status.error;
+}
+/** Request permissions without enabling sharing, then verify before activation. */
+export async function authorizeRemoteDesktop(dataDir, context = {}) {
+    const log = context.log ?? console.log;
+    if (!(context.isTTY ?? process.stdout.isTTY === true)) {
+        log("未检测到交互终端，已跳过远程桌面授权。");
+        recoveryHint(log);
+        return false;
+    }
+    const request = context.request ?? requestAuthorization;
+    let status = await withCliProgress("正在检查本机远程桌面权限", () => request(dataDir));
+    if (!status.supported)
+        throw new Error("远程桌面支持 macOS 14 及以上的 Apple Silicon 电脑和 Windows 10/11 x64");
+    if (!status.installed)
+        throw new Error("当前 CLI 未包含远程授权组件，请升级 CLI");
+    if (status.enabled) {
+        status = await request(dataDir, { action: "recheck" });
+        if (complete(status)) {
+            log("✓ 远程桌面已授权并开启共享。");
+            return true;
+        }
+    }
+    const platform = context.platform ?? process.platform;
+    const confirm = context.confirm ?? (() => confirmDesktopAuthorization(platform));
+    const confirmed = await (platform === "darwin"
+        ? withCliProgress("正在等待本机授权弹窗确认", confirm)
+        : withoutCliProgress(confirm));
+    if (!confirmed) {
+        log("已跳过远程桌面授权。");
+        recoveryHint(log);
+        return false;
+    }
+    status = await request(dataDir, { action: "recheck" });
+    const wait = context.wait ?? delay;
+    if (platform === "darwin") {
+        for (const permission of ["screen", "accessibility"]) {
+            if (status[permission])
+                continue;
+            const name = permission === "screen" ? "屏幕录制" : "辅助功能";
+            log(`正在请求${name}权限，请在系统设置中允许 AgentRoam Remote Desktop…`);
+            status = await withCliProgress(`正在等待${name}权限，请在系统弹窗或设置中允许`, async () => {
+                let current = await request(dataDir, { action: "request-permission", permission });
+                for (let attempt = 0; !current[permission] && attempt < (context.pollAttempts ?? 60); attempt++) {
+                    await wait(2000);
+                    current = await request(dataDir, { action: "recheck" });
+                }
+                return current;
+            });
+            if (!status[permission]) {
+                log(`${name}权限尚未授予，本次未开启共享。`);
+                recoveryHint(log);
+                return false;
+            }
+        }
+    }
+    if (!status.screen || !status.accessibility) {
+        log("远程桌面尚不可用，请确认系统权限及当前桌面状态，本次未开启共享。");
+        recoveryHint(log);
+        return false;
+    }
+    status = await withCliProgress("正在开启并检查远程桌面共享", () => request(dataDir, { action: "enable" }));
+    if (!complete(status))
+        throw new Error(status.error ? terminalText(status.error) : "远程桌面共享未就绪，请重新检查系统权限");
+    log("✓ 远程桌面授权完成，已开启共享。手机首次连接仍需设备配对。");
+    return true;
+}
+export async function runDesktopCommand(options, context = {}) {
+    const log = context.log ?? console.log;
+    const request = context.request ?? requestAuthorization;
+    if (options.desktopAction === "authorize") {
+        try {
+            if (!await authorizeRemoteDesktop(options.dataDir, context))
+                process.exitCode = 1;
+        }
+        catch (error) {
+            recoveryHint(log);
+            throw error;
+        }
+        return;
+    }
+    let status = await request(options.dataDir);
+    if (options.desktopAction === "disable") {
+        status = await request(options.dataDir, { action: "disable" });
+        if (status.enabled)
+            throw new Error("远程桌面共享尚未关闭，请重试");
+        log("✓ 已关闭远程桌面共享，系统权限保留。重新开启：agentroam desktop authorize");
+        return;
+    }
+    if (status.supported && status.installed)
+        status = await request(options.dataDir, { action: "recheck" });
+    log(`远程桌面：${status.supported ? "支持" : "不支持"}；共享：${status.enabled ? "已开启" : "未开启"}；屏幕录制：${status.screen ? "已授权" : "未授权或桌面不可用"}；辅助功能：${status.accessibility ? "已授权" : "未授权"}`);
+    if (status.error)
+        log(`状态提示：${terminalText(status.error)}`);
+    recoveryHint(log);
+}