weaver-e9-assistant-cli 1.0.0

package/dist/auth-token.js

@@ -0,0 +1,690 @@
+/**
+ * aiAgentToken 认证核心（对标 e9-cli lib/auth-token.js）。
+ *
+ * 链路：
+ *   loginForCookie（有头 autoFill，失败转手动；轮询 loginidweaver，60s hash-portal 兜底）
+ *   → saveCookieToProfile（存 cookie 供回退，写回 config.json 对应字段）
+ *   → registerToken: GET /api/ai/agent/login/register 带 cookie → aiAgentToken（8h，加密存）
+ *       成功 → { token, expireTime, expireSeconds, cookieSavedAt, noToken:false }
+ *       404/异常 → { token:'', noToken:true }（回退 cookie）
+ *   → promptAuthConfirm（有头，弹授权 overlay，用户点确认才 registerToken）
+ *
+ * token 文件：~/.e9/tokens/<profileName>.json（AES-256-GCM 加密）。
+ * profileName 由当前 baseUrl 的 hostname+port 派生（一个环境一个 token 文件）。
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+import { execSync, spawn } from 'node:child_process';
+import { encrypt, decrypt } from './crypto.js';
+import { endpointFor, profileNameFromBaseUrl, saveConfig } from './config.js';
+// token 文件固定写在 ~/.e9/tokens/（与 storageState、config 的 ~/.e9 回退一致），
+// 不再用 process.cwd()——否则换工作目录就找不到 token → 回退 cookie → 连锁触发续期弹浏览器
+const CONFIG_DIR = path.join(os.homedir(), '.e9');
+const TOKEN_DIR = path.join(CONFIG_DIR, 'tokens');
+function ensureDir(p) {
+    if (!fs.existsSync(p))
+        fs.mkdirSync(p, { recursive: true });
+}
+function tokenFilePath(profileName) {
+    return path.join(TOKEN_DIR, `${profileName}.json`);
+}
+function sleep(ms) {
+    return new Promise((r) => setTimeout(r, ms));
+}
+/**
+ * 启动浏览器：优先用系统默认浏览器（注册表查），Chromium 系（Chrome/Edge/Brave）直接 executablePath 打开；
+ * 非 Chromium 系（Firefox 等）跳过 → 回退 channel chrome/msedge → 最后 Playwright 自带 chromium
+ * （自带内核未下载时才懒下载一次——见末尾兜底）。
+ */
+async function launchSystemBrowser(chromium, headless, args) {
+    // 1. 查系统默认浏览器路径
+    const defaultPath = getDefaultBrowserPath();
+    if (defaultPath) {
+        const lower = defaultPath.toLowerCase();
+        // Chromium 系浏览器可直接用 executablePath 打开
+        if (/chrome|msedge|edge|brave|chromium/i.test(lower)) {
+            try {
+                return await chromium.launch({ executablePath: defaultPath, headless, args });
+            }
+            catch {
+                /* 路径无效，试下一个 */
+            }
+        }
+        // Firefox 等非 Chromium 系：跳过（Playwright chromium 模块不支持），走下面的 channel 回退
+    }
+    // 2. 回退：试 channel chrome → msedge → Playwright 自带 chromium
+    for (const channel of ['chrome', 'msedge']) {
+        try {
+            return await chromium.launch({ channel, headless, args });
+        }
+        catch {
+            /* 未安装，试下一个 */
+        }
+    }
+    try {
+        return await chromium.launch({ headless, args });
+    }
+    catch (e) {
+        // 前两条都失败（系统无 Chrome/Edge/Brave）才走到这里：此时才需要 Playwright 自带内核。
+        // 懒加载：仅当这次 launch 是因为缺内核失败，才去下载；下载成功再重试一次。
+        const msg = String(e?.message || e);
+        const missingCore = /Executable doesn't exist|executablePath.*(exist|found)|not found.*browser|download.*chromium|Please run the following command|playwright install/i.test(msg);
+        if (!missingCore)
+            throw new Error(`无法启动浏览器（系统浏览器与 Playwright 自带内核均不可用）：${msg}`);
+        console.log('  [AUTH] 系统未检测到 Chrome/Edge/Brave，需下载 Playwright chromium 内核（约 120-200 MiB，仅此情况才需要）...');
+        const dl = await runCmd('npx playwright install chromium', 300000);
+        if (dl.code !== 0) {
+            throw new Error(`chromium 内核下载失败（exit ${dl.code}，网络可能拦截）。可手动 \`npx playwright install chromium\`，或改用 \`e9 auth cookie-login\`。`);
+        }
+        try {
+            return await chromium.launch({ headless, args });
+        }
+        catch (e2) {
+            throw new Error(`无法启动浏览器：${String(e2?.message || e2)}`);
+        }
+    }
+}
+/** 查系统默认浏览器可执行路径。Windows 用注册表；macOS 用 Launch Services；Linux 用 xdg-mime。 */
+function getDefaultBrowserPath() {
+    const tryExec = (cmd) => {
+        try {
+            return execSync(cmd, { encoding: 'utf8', timeout: 5000 }).trim();
+        }
+        catch {
+            return null;
+        }
+    };
+    if (process.platform === 'win32') {
+        // Windows: 注册表两步（ProgId → command → exe）
+        const out1 = tryExec('reg query "HKEY_CURRENT_USER\\Software\\Microsoft\\Windows\\Shell\\Associations\\UrlAssociations\\http\\UserChoice" /v ProgId');
+        const progIdMatch = out1?.match(/ProgId\s+REG_SZ\s+(\S+)/);
+        if (!progIdMatch)
+            return null;
+        const out2 = tryExec(`reg query "HKEY_CLASSES_ROOT\\${progIdMatch[1]}\\shell\\open\\command" /ve`);
+        const exeMatch = out2?.match(/"([^"]+\.exe)"/i);
+        return exeMatch ? exeMatch[1] : null;
+    }
+    if (process.platform === 'darwin') {
+        // macOS: Launch Services 查 http handler 的 bundle ID → mdfind 取 app 路径
+        const out = tryExec('defaults read com.apple.LaunchServices/com.apple.launchservices.secure LSHandlers 2>/dev/null');
+        if (!out)
+            return null;
+        const lines = out.split('\n');
+        let inHttps = false;
+        let bundleId = null;
+        for (const line of lines) {
+            if (line.includes('"https"'))
+                inHttps = true;
+            if (inHttps && line.includes('LSHandlerRoleViewer')) {
+                const m = line.match(/=\s*"([^"]+)"/);
+                if (m)
+                    bundleId = m[1];
+                inHttps = false;
+            }
+        }
+        if (!bundleId)
+            return null;
+        const appPath = tryExec(`mdfind "kMDItemCFBundleIdentifier == '${bundleId}'" 2>/dev/null | head -1`);
+        return appPath || null;
+    }
+    if (process.platform === 'linux') {
+        // Linux: xdg-mime 查默认 http handler → which 取路径
+        const handler = tryExec('xdg-mime query default x-scheme-handler/http 2>/dev/null');
+        if (!handler)
+            return null;
+        const exe = tryExec(`which ${handler} 2>/dev/null`) || tryExec(`which ${handler.split('.')[0]} 2>/dev/null`);
+        return exe || null;
+    }
+    return null;
+}
+/**
+ * 探测当前是否处于非交互式环境（cron/CI/无显示/E9_NO_REAUTH）。保守判定，避免误杀交互式终端。
+ * 用于 ensureValid 跳过会弹浏览器的续期——非交互式下 acquireToken 必失败，直接回退 cookie。
+ */
+export function looksNonInteractive() {
+    if (process.env.E9_NO_REAUTH)
+        return true;
+    if (process.env.CI)
+        return true;
+    if (process.platform === 'linux' && !process.env.DISPLAY && !process.env.WAYLAND_DISPLAY)
+        return true;
+    return false;
+}
+/** 探测 URL 是否可连（短超时），忽略 HTTPS 错误，只看能否拿到 <500 响应。 */
+export async function canReach(url, timeoutMs = 6000) {
+    try {
+        const res = await fetch(url, { signal: AbortSignal.timeout(timeoutMs) });
+        return res.status < 500;
+    }
+    catch {
+        return false;
+    }
+}
+/** 继承 stdio 跑 shell 命令，超时强杀。返回 { code }。 */
+function runCmd(cmd, timeoutMs) {
+    return new Promise((resolve) => {
+        const p = spawn(cmd, { stdio: 'inherit', shell: true, timeout: timeoutMs });
+        const t = setTimeout(() => { try {
+            p.kill('SIGKILL');
+        }
+        catch { /* ignore */ } }, timeoutMs);
+        p.on('exit', (code) => { clearTimeout(t); resolve({ code: code ?? -1 }); });
+        p.on('error', (e) => { clearTimeout(t); console.error(`  [AUTH] 命令执行失败: ${e.message}`); resolve({ code: -1 }); });
+    });
+}
+/**
+ * 确保 playwright 可用：能 import 返回 chromium；不能 import 则探网→能联网就自动装模块（不装内核）。
+ * 内核改为懒加载：launchSystemBrowser 优先用系统 Chrome/Edge/Brave，只有系统里确实没有时才下载自带 chromium。
+ * 装不上抛清晰错并引导 cookie-login。**仅在 token-login（用户主动触发）调，勿在 ensureValid 运行时调**
+ * （否则每次请求过期都会触发安装）。
+ */
+export async function ensurePlaywright() {
+    try {
+        // @ts-ignore
+        return (await import('playwright')).chromium;
+    }
+    catch { /* 未装，尝试自动安装 */ }
+    const online = await canReach('https://registry.npmjs.org', 5000);
+    if (!online) {
+        throw new Error('playwright 未安装且当前环境无法联网安装。请先 `npm install playwright`，或改用 `e9 auth cookie-login` 手动导入 cookie（无需浏览器）。');
+    }
+    console.log('  [AUTH] playwright 未安装，联网自动安装模块（chromium 内核按需懒下载，通常无需）...');
+    const r1 = await runCmd('npm install playwright', 120000);
+    if (r1.code !== 0) {
+        throw new Error(`playwright 模块安装失败（npm exit ${r1.code}）。可手动 \`npm install playwright\`，或改用 \`e9 auth cookie-login\`。`);
+    }
+    try {
+        // @ts-ignore
+        return (await import('playwright')).chromium;
+    }
+    catch {
+        throw new Error('playwright 安装后仍无法 import，请检查 node_modules，或改用 `e9 auth cookie-login`。');
+    }
+}
+/** 跨进程续期锁窗口（ms）：窗口内其他进程检测到 acquiringAt 即跳过续期走 cookie，防并发弹多个浏览器。 */
+const ACQUIRING_WINDOW_MS = 120_000;
+/** 进程内续期共享锁表：key=profileName → 进行中的 acquireToken promise（同进程同环境只弹一个浏览器）。 */
+const _renewInflight = new Map();
+const EMPTY_DATA = { token: '', expireTime: '', expireSeconds: 0, cookieSavedAt: 0, acquireFailedAt: 0, acquiringAt: 0 };
+/** 读 token 文件（加密信封 → decrypt → JSON；兼容明文 {token}）。 */
+function loadTokenFile(filePath) {
+    if (!fs.existsSync(filePath))
+        return null;
+    try {
+        const raw = fs.readFileSync(filePath, 'utf8').trim();
+        const j = JSON.parse(raw);
+        if (j && j.enc === true && typeof j.data === 'string') {
+            return JSON.parse(decrypt(j.data));
+        }
+        if (j && typeof j.token === 'string')
+            return j; // 明文兼容
+    }
+    catch {
+        /* 损坏，视为无 */
+    }
+    return null;
+}
+/**
+ * 双模式浏览器登录拿 cookie（对标 e9-cli loginForCookie）。
+ * 有 username+password → 有头 autoFill（wui headless 不渲染登录框）；失败转手动。
+ * 轮询 loginidweaver（200ms），60s hash-portal 兜底（导航 /wui/index.html#/main/portal）。
+ * 返回 "name=value; name=value; ..." 形式的 cookie 串；缺 loginidweaver 抛错。
+ */
+export async function loginForCookie(baseUrl, username, password, opts = {}) {
+    const headless = opts.headless ?? false;
+    let chromium;
+    try {
+        // @ts-ignore
+        chromium = (await import('playwright')).chromium;
+    }
+    catch {
+        throw new Error('playwright 未安装。浏览器登录需要它。装一下：npm install playwright && npx playwright install chromium\n或改用 `e9 auth cookie-login` 手动导入 cookie（无需浏览器）。\n其他命令（blog/todo/create）走 token 不需浏览器。');
+    }
+    const autoFill = !!(username && password);
+    const args = headless ? ['--disable-blink-features=AutomationControlled'] : ['--start-maximized'];
+    let browser;
+    let context;
+    // 启动浏览器会话；开不出窗口（内核缺/无桌面）抛清晰错并引导 cookie-login，不让 Playwright 天书外泄
+    try {
+        browser = await launchSystemBrowser(chromium, headless, args);
+        context = await browser.newContext({
+            ignoreHTTPSErrors: true,
+            viewport: { width: 1280, height: 800 },
+        });
+    }
+    catch (launchErr) {
+        const m = String(launchErr?.message || launchErr);
+        throw new Error(`无法启动浏览器会话：${m}\n  可能原因：chromium 内核未下载，或当前为后台/无桌面会话（如把 token-login 当后台任务跑）。\n  处置：① 手动 \`npx playwright install chromium\`；② 在可见屏幕的终端直接跑 \`e9 auth token-login\`；③ 或改用 \`e9 auth cookie-login\` 手动导入 cookie（无需浏览器）。`);
+    }
+    await context.addInitScript(() => {
+        Object.defineProperty(navigator, 'webdriver', { get: () => undefined });
+    });
+    const page = await context.newPage();
+    try {
+        await page.goto(baseUrl, { waitUntil: 'domcontentloaded', timeout: 60000 }).catch((e) => {
+            if (headless)
+                throw e;
+            console.error(`  ⚠ 首页加载失败: ${e.message}，请在浏览器手动访问登录`);
+        });
+        if (autoFill) {
+            // 有头 autoFill：等待登录输入框渲染；headless 不渲染会超时抛错降级
+            await page.waitForSelector('#loginid, input[name=loginid], input[type=text]', { timeout: 10000 }).catch(() => { });
+            await page.fill('#loginid, input[name=loginid], input[type=text]', username).catch(() => { });
+            await page.fill('#userpassword, input[type=password]', password).catch(() => { });
+            await Promise.all([
+                page.waitForNavigation({ waitUntil: 'networkidle', timeout: 15000 }).catch(() => { }),
+                page.click('button#submit, button[type=submit], button, input[type=submit]').catch(() => { }),
+            ]);
+        }
+        else if (!headless) {
+            console.log('  请在浏览器登录页输入账密并点登录（最长 600s）...');
+        }
+        // 轮询 loginidweaver。autoFill 未拿到 cookie 时原地转手动登录（复用同一浏览器会话，不重开）
+        const t0 = Date.now();
+        const autoFillDeadline = t0 + (autoFill ? 45000 : 0);
+        const deadline = t0 + (headless ? 30000 : 600000);
+        let cookies = [];
+        let prompted = false;
+        let portaled = false;
+        let fellBackToManual = false;
+        while (Date.now() < deadline) {
+            cookies = await context.cookies();
+            if (cookies.some((c) => c.name === 'loginidweaver'))
+                break;
+            // autoFill 用尽仍无 cookie → 原地提示手动登录（同一浏览器，避免二次 launchSystemBrowser）
+            if (autoFill && !fellBackToManual && Date.now() >= autoFillDeadline) {
+                fellBackToManual = true;
+                console.error('  [AUTH] autoFill 未拿到登录 cookie，请在已打开的浏览器手动登录并点确认授权（最长 600s）...');
+            }
+            if (!headless && !portaled && Date.now() - t0 > 60000) {
+                // hash-portal 兜底：hash 路由切 SPA portal 设 cookie
+                await page
+                    .goto(`${baseUrl}/wui/index.html#/main/portal`, { waitUntil: 'commit', timeout: 30000 })
+                    .catch(() => { });
+                await sleep(3000);
+                portaled = true;
+            }
+            if (!headless && !prompted && Date.now() - t0 > 30000) {
+                console.log('  ⏳ 仍在等待 loginidweaver cookie...');
+                prompted = true;
+            }
+            await sleep(200);
+        }
+        if (!cookies.some((c) => c.name === 'loginidweaver')) {
+            throw new Error('登录后未拿到 loginidweaver cookie，无法换 token');
+        }
+        const cookieString = cookies.map((c) => `${c.name}=${c.value}`).join('; ');
+        if (!headless)
+            await promptAuthConfirm(page);
+        // 保存浏览器登录态（cookie+localStorage），供打印 PDF headless 复用
+        try {
+            const os = await import('node:os');
+            const p = await import('node:path');
+            const cfgDir = p.join(os.homedir(), '.e9');
+            const profile = profileNameFromBaseUrl(baseUrl);
+            await context.storageState({ path: p.join(cfgDir, `storageState_${profile}.json`) });
+        }
+        catch { /* 保存失败不阻断 */ }
+        return cookieString;
+    }
+    finally {
+        try {
+            if (browser)
+                await browser.close();
+        }
+        catch { /* 关闭失败忽略 */ }
+    }
+}
+/** 登录后注入授权确认 overlay；用户点「确认授权」才放行。 */
+async function promptAuthConfirm(page) {
+    const agent = getAgentInfo();
+    await page.evaluate((agentDisplay) => {
+        // 注入动画样式
+        const style = document.createElement('style');
+        style.textContent = `
+      @keyframes __e9_fade_in { from { opacity:0; } to { opacity:1; } }
+      @keyframes __e9_slide_up { from { opacity:0; transform:translateY(24px) scale(.96); } to { opacity:1; transform:translateY(0) scale(1); } }
+    `;
+        document.head.appendChild(style);
+        const mask = document.createElement('div');
+        mask.id = '__e9_auth_confirm__';
+        mask.style.cssText =
+            'position:fixed;top:0;left:0;width:100%;height:100%;background:rgba(15,23,42,.55);backdrop-filter:blur(4px);z-index:2147483647;display:flex;align-items:center;justify-content:center;animation:__e9_fade_in .25s ease;font-family:-apple-system,BlinkMacSystemFont,"Segoe UI","Microsoft YaHei",sans-serif;';
+        const card = document.createElement('div');
+        card.style.cssText =
+            'background:#fff;border-radius:16px;overflow:hidden;box-shadow:0 12px 48px rgba(0,0,0,.3);width:400px;animation:__e9_slide_up .35s cubic-bezier(.16,1,.3,1);';
+        // 顶部渐变色条
+        const topBar = document.createElement('div');
+        topBar.style.cssText = 'height:5px;background:linear-gradient(90deg,#3b82f6,#6366f1,#8b5cf6);';
+        // 内容区
+        const body = document.createElement('div');
+        body.style.cssText = 'padding:36px 36px 32px;text-align:center;';
+        // SVG 盾牌图标
+        const icon = document.createElement('div');
+        icon.style.cssText = 'width:64px;height:64px;margin:0 auto 20px;';
+        icon.innerHTML = `<svg viewBox="0 0 24 24" fill="none" width="64" height="64">
+      <defs><linearGradient id="g" x1="0" y1="0" x2="1" y2="1">
+        <stop offset="0%" stop-color="#3b82f6"/><stop offset="100%" stop-color="#6366f1"/>
+      </linearGradient></defs>
+      <path d="M12 2L4 5v6c0 5 3.5 9.5 8 11 4.5-1.5 8-6 8-11V5l-8-3z" fill="url(#g)"/>
+      <path d="M9 12l2 2 4-4" stroke="#fff" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" fill="none"/>
+    </svg>`;
+        const title = document.createElement('div');
+        title.style.cssText = 'font-size:17px;font-weight:600;color:#0f172a;margin-bottom:6px;letter-spacing:.3px;';
+        title.textContent = `【${agentDisplay}】请求授权访问OA系统，请确认。`;
+        const desc = document.createElement('div');
+        desc.style.cssText = 'font-size:12px;color:#94a3b8;line-height:1.6;margin-bottom:28px;';
+        desc.textContent = '确认后将以您的身份访问系统';
+        // 按钮区（只保留确认授权；关浏览器/超时不授权 → 走 cookie 回退）
+        const btnYes = document.createElement('button');
+        btnYes.id = '__e9_auth_yes__';
+        btnYes.style.cssText =
+            'width:100%;background:linear-gradient(135deg,#3b82f6,#6366f1);color:#fff;border:none;padding:12px 0;border-radius:8px;cursor:pointer;font-size:15px;font-weight:500;transition:transform .15s,box-shadow .15s;box-shadow:0 2px 8px rgba(59,130,246,.35);';
+        btnYes.textContent = '确认授权';
+        btnYes.onmouseenter = () => { btnYes.style.transform = 'translateY(-1px)'; btnYes.style.boxShadow = '0 4px 16px rgba(59,130,246,.45)'; };
+        btnYes.onmouseleave = () => { btnYes.style.transform = 'translateY(0)'; btnYes.style.boxShadow = '0 2px 8px rgba(59,130,246,.35)'; };
+        body.appendChild(icon);
+        body.appendChild(title);
+        body.appendChild(desc);
+        body.appendChild(btnYes);
+        card.appendChild(topBar);
+        card.appendChild(body);
+        mask.appendChild(card);
+        document.body.appendChild(mask);
+        btnYes.addEventListener('click', () => mask.remove());
+    }, agent.display);
+    await page
+        .waitForFunction(() => !document.getElementById('__e9_auth_confirm__'), { timeout: 180000 })
+        .catch(() => {
+        throw new Error('授权确认超时（180s）或未点击');
+    });
+}
+/** 已知 agent 工具的 env 签名表（叶子层探测，按顺序匹配）。 */
+const KNOWN_AGENT_TOOLS = [
+    // Claude Code：子进程注入 CLAUDECODE=1 / CLAUDE_CODE_SESSION_ID / CLAUDE_CODE_EXECPATH（已实跑确认）
+    { keys: ['CLAUDECODE', 'CLAUDE_CODE_SESSION_ID', 'CLAUDE_CODE_EXECPATH'], display: 'Claude-Code' },
+    // Kimi Work：签名待该工具实跑 env 确认；未命中时走 AI_AGENT 或产品名兜底。
+    { keys: ['KIMI_WORK', 'KIMI', 'MOONSHOT_SESSION_ID'], display: 'Kimi-Work' },
+    // TRAE Work（字节 Trae）：签名待确认（猜 TRAE_WORK/TRAE/TRAE_SESSION_ID）
+    { keys: ['TRAE_WORK', 'TRAE', 'TRAE_SESSION_ID'], display: 'Trae-Work' },
+    // DuMate：签名待确认（猜 DUMATE/DU_MATE/DUMATE_SESSION_ID）
+    { keys: ['DUMATE', 'DU_MATE', 'DUMATE_SESSION_ID'], display: 'DuMate' },
+];
+/** 无法识别实际 agent 时的兜底展示名。 */
+const FALLBACK_DISPLAY = 'E9办公助手';
+function detectKnownAgent() {
+    for (const tool of KNOWN_AGENT_TOOLS) {
+        for (const k of tool.keys) {
+            const v = process.env[k];
+            if (v !== undefined && v !== '')
+                return tool.display;
+        }
+    }
+    return null;
+}
+export function getAgentInfo() {
+    // 0. 通用覆盖：任何 agent 工具/宿主都可设 E9_AGENT_DISPLAY=<名> 自报家门（免改代码）
+    const override = process.env.E9_AGENT_DISPLAY;
+    if (override) {
+        const display = override.trim();
+        return { framework: display.toLowerCase(), display };
+    }
+    // 1. 叶子层：已知 agent 工具 env 签名探测
+    const known = detectKnownAgent();
+    if (known)
+        return { framework: known.toLowerCase(), display: known };
+    // 2. 回退：AI_AGENT 宿主/注册名解析
+    const aiAgent = process.env.AI_AGENT || '';
+    // claude-code_2-1-218_agent → "Claude-Code"（取下划线前的框架名，分段首字母大写，保留 "-" 分隔）
+    let framework = '';
+    if (aiAgent) {
+        const m = aiAgent.match(/^([a-zA-Z]+(?:-[a-zA-Z]+)*)_/);
+        if (m) {
+            framework = m[1]
+                .split('-')
+                .map((s) => (s ? s.charAt(0).toUpperCase() + s.slice(1) : s))
+                .join('-');
+        }
+    }
+    // 都识别不出 → 使用产品名，避免向最终用户暴露历史内部 CLI 名称。
+    if (!framework)
+        framework = FALLBACK_DISPLAY;
+    return { framework: framework.toLowerCase(), display: framework };
+}
+/** GET /api/ai/agent/login/register 用 cookie 换 token（仿 curl 头）。失败抛带 e9kind/e9status 的错，供上层大声诊断。 */
+export async function registerToken(baseUrl, cookieString) {
+    const agent = getAgentInfo();
+    let resp;
+    try {
+        resp = await fetch(`${baseUrl}/api/ai/agent/login/register?aiAgentType=${encodeURIComponent(agent.display)}`, {
+            headers: {
+                Cookie: cookieString,
+                Accept: 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8',
+                'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/149.0.0.0 Safari/537.36',
+            },
+            signal: AbortSignal.timeout(15000),
+        });
+    }
+    catch (e) {
+        const err = new Error(`register 请求失败（${e.message}）。可能 baseUrl 不可达或网络不通。`);
+        err.e9kind = 'network';
+        throw err;
+    }
+    const status = resp.status;
+    const text = await resp.text();
+    if (status === 404) {
+        const err = new Error(`此 E9 无 /api/ai/agent/login/register 接口（HTTP 404），该环境不支持 aiAgentToken。`);
+        err.e9kind = 'unsupported';
+        err.e9status = status;
+        throw err;
+    }
+    let json;
+    try {
+        json = JSON.parse(text);
+    }
+    catch {
+        const err = new Error(`register 返回非 JSON（HTTP ${status}）: ${text.slice(0, 200)}`);
+        err.e9status = status;
+        throw err;
+    }
+    if (json.status === false || json.errorCode) {
+        const err = new Error(`register 失败（HTTP ${status}）: ${json.msg || JSON.stringify(json).slice(0, 200)}`);
+        err.e9status = status;
+        err.e9json = json;
+        throw err;
+    }
+    const data = json.data || {};
+    if (!data.aiAgentToken) {
+        const err = new Error(`register 未返回 aiAgentToken（HTTP ${status}）: ${text.slice(0, 200)}`);
+        err.e9status = status;
+        throw err;
+    }
+    return { token: data.aiAgentToken, expireTime: data.expireTime || '', expireSeconds: data.expireSeconds || 0 };
+}
+/**
+ * 当前环境的 token 会话（单一端点）。持有 cfg/endpoint（回写 cookie 到 config）、token 文件路径与缓存数据。
+ */
+export class AuthTokenSession {
+    cfg;
+    endpoint;
+    filePath;
+    data;
+    constructor(cfg, endpoint, filePath, data, profileName) {
+        this.cfg = cfg;
+        this.endpoint = endpoint;
+        this.filePath = filePath;
+        this.data = data || { ...EMPTY_DATA };
+        this.profileName = profileName || path.basename(filePath, '.json');
+    }
+    get token() {
+        return this.data.token || '';
+    }
+    get baseUrl() {
+        return this.endpoint.baseUrl.replace(/\/+$/, '');
+    }
+    get isExpired() {
+        if (!this.data.token)
+            return true;
+        const savedAt = this.data.cookieSavedAt || 0;
+        const ttl = (this.data.expireSeconds || 0) * 1000;
+        if (savedAt && ttl)
+            return Date.now() > savedAt + ttl - 60000;
+        if (this.data.expireTime)
+            return Date.now() > new Date(this.data.expireTime).getTime() - 60000;
+        return false; // 缺过期信息时信任本地 token，由 reactive 重试（requestWithRetry）兜底服务端吊销
+    }
+    static fromProfile(cfg) {
+        ensureDir(TOKEN_DIR);
+        const endpoint = endpointFor(cfg);
+        const profileName = profileNameFromBaseUrl(endpoint.baseUrl);
+        const filePath = tokenFilePath(profileName);
+        const data = loadTokenFile(filePath) || { ...EMPTY_DATA };
+        return new AuthTokenSession(cfg, endpoint, filePath, data, profileName);
+    }
+    /** 从磁盘重新加载 token 数据（跨进程锁检测需要最新快照，避免读到旧 data 而忽略别的进程的 acquiringAt）。 */
+    _reloadData() {
+        const fresh = loadTokenFile(this.filePath);
+        if (fresh)
+            this.data = { ...EMPTY_DATA, ...fresh };
+    }
+    /** 把浏览器登录拿到的刷新 cookie 写回 config.json 的 cookie 字段（供回退）。 */
+    saveCookieToProfile(cookieString) {
+        if (!cookieString)
+            return;
+        try {
+            if (process.env.E9_DEBUG)
+                console.error(`[COOKIE] saved ${cookieString.length} chars`);
+            this.cfg.cookie = cookieString;
+            saveConfig(this.cfg);
+        }
+        catch (e) {
+            console.error(`  [AUTH] 存 cookie 失败: ${e.message}`);
+        }
+    }
+    /** 申请/续期 token：loginForCookie → saveCookieToProfile → registerToken。register 失败标记 noToken 返回 null。
+     *  双层互斥防「同时弹很多个登录页」：
+     *    ① 进程内锁：同 profile 已有续期在跑 → 其余调用 await 同一个 promise（report collect 7 路并发只弹 1 个）；
+     *    ② 跨进程锁：token 文件写 acquiringAt 时间戳，其他进程见窗口内标记 → 跳过续期走 cookie。
+     *  reason: 'first'（cmdTokenLogin 首次登录）/ 'renew'（ensureValid/reactive 续期，默认）—— 区分文案。 */
+    async acquireToken(reason = 'renew') {
+        const key = this.profileName || 'default';
+        if (_renewInflight.has(key))
+            return _renewInflight.get(key); // 同进程已在续期：等同一个结果，不重复弹浏览器
+        const p = this._acquireTokenInner(reason);
+        _renewInflight.set(key, p);
+        try {
+            return await p;
+        }
+        finally {
+            _renewInflight.delete(key);
+        }
+    }
+    /** acquireToken 真实主体（持有跨进程锁时执行）；跳过续期/未拿到 token 均返回 null。 */
+    async _acquireTokenInner(reason = 'renew') {
+        // ② 跨进程锁：重读磁盘看别的进程是否正在续期（窗口内跳过）
+        this._reloadData();
+        const acquiringAt = this.data.acquiringAt || 0;
+        if (acquiringAt && Date.now() - acquiringAt < ACQUIRING_WINDOW_MS) {
+            console.error(`  [AUTH] 另一进程正在续期（${Math.round((Date.now() - acquiringAt) / 1000)}s 前开始），本进程跳过续期，走 cookie 回退。`);
+            return null;
+        }
+        // 抢跨进程锁
+        this.data.acquiringAt = Date.now();
+        this.save();
+        try {
+            const password = this.cfg.encPassword ? decrypt(this.cfg.encPassword) : '';
+            const username = this.cfg.username || '';
+            // ★ #15 文案区分：续期 vs 首登（loginForCookie 的"请在浏览器登录页输入账密"是共享等待语，这里先打场景横幅）
+            if (reason === 'first')
+                console.error('[AUTH] 首次登录：开浏览器拿 cookie → 换 aiAgentToken（点「确认授权」）。');
+            else
+                console.error('[AUTH] token 已过期，弹浏览器续期：用 cookie 换新 aiAgentToken（点「确认授权」）。');
+            // autoFill 失败已在 loginForCookie 内原地转手动登录（同一浏览器会话），不再二次重开浏览器
+            const cookieString = await loginForCookie(this.baseUrl, username, username ? password : '', { headless: false });
+            this.saveCookieToProfile(cookieString);
+            try {
+                const { token, expireTime, expireSeconds } = await registerToken(this.baseUrl, cookieString);
+                this.data = { token, expireTime, expireSeconds, cookieSavedAt: Date.now(), noToken: false, acquireFailedAt: 0, acquiringAt: 0 };
+                this.save();
+                return token;
+            }
+            catch (e) {
+                // 大声诊断：区分 404 不支持 / 网络不通 / 其它，不再含糊"系统可能不支持"
+                const kind = e?.e9kind || (e?.e9status === 404 ? 'unsupported' : 'other');
+                if (kind === 'unsupported')
+                    console.error(`  [AUTH] 此 E9 不支持 aiAgentToken（${e.message}）。已切到 cookie 鉴权备胎。`);
+                else if (kind === 'network')
+                    console.error(`  [AUTH] register 请求失败：${e.message}。已切到 cookie 鉴权备胎（请用 \`e9 auth status --check\` 排查 baseUrl 可达性）。`);
+                else
+                    console.error(`  [AUTH] register 拿 token 失败：${e.message}。已切到 cookie 鉴权备胎。`);
+                console.error(`  [AUTH] cookie 有效期由服务器定，过期需重新导入；运行 \`e9 auth status\` 查看当前模式。`);
+                this.data = { token: '', expireTime: '', expireSeconds: 0, cookieSavedAt: Date.now(), noToken: true, acquireFailedAt: Date.now(), acquiringAt: 0 };
+                this.save();
+                return null;
+            }
+        }
+        finally {
+            // 释放跨进程锁（reload 拿最新快照，避免覆盖续期期间写入的 token/acquireFailedAt）
+            this._reloadData();
+            this.data.acquiringAt = 0;
+            this.save();
+        }
+    }
+    /**
+     * 返回 true → 用 aiAgentToken 头；返回 false → 回退 cookie 头。
+     * 信任本地过期判定，**不做网络探测**：探测失败（服务器不可达/探测接口 404）会误触发
+     * acquireToken 弹浏览器并卡住 cron。token 被服务端提前吊销（未过期但失效）的 reactive
+     * 续期由 E9Api 的「登录信息超时」失效重试承担。
+     * noToken / 无 token → false（不弹浏览器，走 cookie）。
+     * 过期 → ①#12 cookie 可用直接回退 cookie（不弹浏览器，cookie 能用的接口照常工作；
+     *          aiAgent 专属接口的续期交由 requestWithRetry 的 401 reactive 兜底）；
+     *        ②#13 近期续期失败过（acquireFailedAt 退避窗口 10min）→ 回退 cookie 不反复弹；
+     *        ③非交互式环境（cron/CI/无显示/E9_NO_REAUTH）→ 回退 cookie；
+     *        ④以上都不满足（无 cookie + 交互式 + 未在退避）才 try acquireToken，失败→持久化 acquireFailedAt + false。
+     */
+    async ensureValid() {
+        if (this.data.noToken)
+            return false;
+        if (!this.data.token)
+            return false;
+        if (!this.isExpired)
+            return true;
+        // ★ #12 cookie 可用 → 走 cookie，不弹浏览器（token 续期交给 requestWithRetry 的 401 reactive）
+        if (this.cfg.cookie)
+            return false;
+        // ★ #13 近期续期失败过 → 退避窗口内回退 cookie，不反复弹浏览器
+        if (this.data.acquireFailedAt && Date.now() - this.data.acquireFailedAt < 10 * 60 * 1000)
+            return false;
+        // 非交互式环境不弹浏览器续期（必失败且会卡住），直接回退 cookie；服务端吊销由 reactive 重试兜底
+        if (looksNonInteractive())
+            return false;
+        try {
+            // 用 acquireToken 返回值判断：跨进程锁跳过（返回 null）→ false（走 cookie），不能看 data.token 旧值
+            const t = await this.acquireToken();
+            return !!t;
+        }
+        catch (e) {
+            console.error(`[AUTH] token 续期失败: ${e.message}`);
+            // ★ #13 持久化续期失败标记，10min 退避窗口内不再弹浏览器（避免每条命令重复弹）
+            try {
+                this.data.acquireFailedAt = Date.now();
+                this.save();
+            }
+            catch { /* 写盘失败不阻断当次回退 cookie */ }
+            return false;
+        }
+    }
+    /** 加密信封写 token 文件。 */
+    save() {
+        ensureDir(TOKEN_DIR);
+        const enc = encrypt(JSON.stringify(this.data));
+        fs.writeFileSync(this.filePath, JSON.stringify({ enc: true, v: 1, data: enc }, null, 2) + '\n', 'utf8');
+        try {
+            fs.chmodSync(this.filePath, 0o600);
+        }
+        catch {
+            /* Windows 忽略 */
+        }
+    }
+}