@aalis/plugin-webui-server 0.4.1 → 0.5.0

package/dist/index.js

@@ -1,13 +1,13 @@
 // node:fs/node:path 仅用于发现前端 dist 静态目录（位于工作区外部），
 // 已在 biome.json noRestrictedImports 中作为基础设施例外列出。
 import { Buffer } from 'node:buffer';
-import { existsSync, readFileSync } from 'node:fs';
-import { readFile } from 'node:fs/promises';
+import { existsSync, readdirSync, readFileSync } from 'node:fs';
 import { createServer } from 'node:http';
 import { createRequire } from 'node:module';
 import { dirname, resolve } from 'node:path';
 import { fileURLToPath, pathToFileURL } from 'node:url';
 import { LogHub, parseLogLine } from '@aalis/core';
+import { listLLMModels } from '@aalis/plugin-llm-api';
 import { aggregatePlatformDetails, getPlatformAdapters, getPlatformNames, } from '@aalis/plugin-platform-api';
 import { createProcessGateway } from '@aalis/plugin-process-api';
 import { createStorageGateway } from '@aalis/plugin-storage-api';
@@ -15,6 +15,8 @@ import { DEFAULT_SUBSYSTEM_METADATA } from '@aalis/plugin-webui-api';
 import express from 'express';
 import { WebSocket, WebSocketServer } from 'ws';
 import { createAuthSystem, openBrowser } from './auth.js';
+import { collectLocalPackageDeps, discoverClients } from './client-discovery.js';
+import { renderClientSwitchPage } from './client-switch-page.js';
 import { createRouteGate } from './gate.js';
 import { registerFileRoutes } from './routes/files.js';
 import { registerMarketplaceRoutes } from './routes/marketplace.js';
@@ -64,9 +66,8 @@ export const configSchema = {
             { label: '每次启动随机生成（重启即轮换）', value: 'ephemeral' },
             { label: '首次生成后持久化（重启不掉登录）', value: 'persist' },
             { label: '使用下方固定 token', value: 'fixed' },
-            { label: '禁用 token 登录（仅账户密码；无账户时 token 兜底生效）', value: 'disabled' },
         ],
-        description: 'ephemeral=旧行为；persist=token 写入 data/.webui-token，读取复用；fixed=使用 fixedToken 字段；disabled=多用户部署收口——存在登录账户时 token 全面失效（防 root 后门），无账户时仍以 persist 语义兜底防锁死。所有模式下都会同时写出便利文件 data/webui-access.txt 包含访问 URL。',
+        description: 'ephemeral=每次启动随机；persist=token 写入 data/.webui-token，读取复用；fixed=使用 fixedToken 字段。所有模式都会写出便利文件 data/webui-access.txt 含访问 URL。',
     },
     fixedToken: {
         type: 'string',
@@ -86,12 +87,8 @@ export const configSchema = {
         default: 'https://registry.npmjs.org',
         description: '插件市场检索用的 npm registry 基址。注意 npm 的 search API 并非所有镜像都支持（淘宝等国内源不支持），默认官方源；国内可填支持 search 的镜像或代理。安装走 package-manager（遵循本机 npm 配置）。',
     },
-    client: {
-        type: 'string',
-        label: '活跃前端（多前端时选用）',
-        default: '',
-        description: '装了多个前端（aalis.client 包）时指定哪个为活跃前端，填包名（如 @aalis/plugin-webui-client）。留空 = 自动选第一个发现到的（默认前端优先）。插件主动 provide(webui-client) 仍优先于此。',
-    },
+    // 活跃前端不在此配置：前端即 `webui-client` 服务的多 provider，活跃者由「服务偏好」
+    // （servicePreferences['webui-client']）决定——在 WebUI「服务」页的下拉框切换。
 };
 export const defaultConfig = {
     port: 3000,
@@ -102,20 +99,27 @@ export const defaultConfig = {
     fixedToken: '',
     relationGraphDefaultSpacing: 120,
     marketplaceRegistry: 'https://registry.npmjs.org',
-    client: '',
 };
 // ===== WebSocket 消息协议 =====
 // 入站消息类型 + 校验 schema 见 ./protocol.ts（zod 强校验）
 import { WSIncomingSchema } from './protocol.js';
 export { WSIncomingSchema } from './protocol.js';
-// ===== 日志文件读取（与 src/runtime/file-logger.ts 的格式对偶）=====
+// ===== 日志文件读取（与 @aalis/runtime 的 file-logger 格式对偶）=====
 // 行格式契约（format ↔ parse）由 @aalis/core 的 parseLogLine 唯一持有，此处只负责
-// 读取 data/latest.log（启动覆盖的单一历史源）并按 cursor 尾读分页。
-const LOG_FILE_PATH = resolve(process.cwd(), 'data/latest.log');
-async function readAllLogEntries() {
-    if (!existsSync(LOG_FILE_PATH))
-        return [];
-    const raw = await readFile(LOG_FILE_PATH, 'utf8');
+// 读取「持久化日志单一数据源」并按 cursor 尾读分页。
+//
+// 路径（宿主目录布局）是「环境知识」，归 storage 的 logs 根所有；本插件只用 storage
+// URI 寻址、对 cwd/落盘位置无知。写入方（runtime/file-logger）跑在 storage 起来之前，
+// 是 bootstrap 期的合法 raw-fs 例外，不在此处管辖（默认 logs 根 = data/，与之对偶）。
+const LOG_FILE_URI = 'logs:/latest.log';
+async function readAllLogEntries(storage) {
+    let raw;
+    try {
+        raw = (await storage.readFile(LOG_FILE_URI, 'utf-8'));
+    }
+    catch {
+        return []; // 文件未就绪 / storage 暂不可用 → 无历史
+    }
     const out = [];
     for (const line of raw.split('\n')) {
         if (!line)
@@ -126,12 +130,12 @@ async function readAllLogEntries() {
     }
     return out;
 }
-async function readLogFileTail(limit) {
-    const all = await readAllLogEntries();
+async function readLogFileTail(storage, limit) {
+    const all = await readAllLogEntries(storage);
     return all.slice(-limit);
 }
-async function readLogFileBefore(beforeSeq, limit) {
-    const all = await readAllLogEntries();
+async function readLogFileBefore(storage, beforeSeq, limit) {
+    const all = await readAllLogEntries(storage);
     const filtered = all.filter(e => e.seq < beforeSeq);
     return filtered.slice(-limit);
 }
@@ -142,7 +146,7 @@ export async function apply(ctx, config) {
         host: config.host ?? '127.0.0.1',
         fileRoot: config.fileRoot || 'workspace',
         autoOpen: config.autoOpen ?? true,
-        tokenMode: ['ephemeral', 'fixed', 'disabled'].includes(config.tokenMode)
+        tokenMode: ['ephemeral', 'fixed'].includes(config.tokenMode)
             ? config.tokenMode
             : 'persist',
         fixedToken: config.fixedToken ?? '',
@@ -151,7 +155,6 @@ export async function apply(ctx, config) {
             return Number.isFinite(v) && v > 0 ? v : 120;
         })(),
         marketplaceRegistry: config.marketplaceRegistry?.trim() || 'https://registry.npmjs.org',
-        client: config.client?.trim() ?? '',
     };
     // 创建 storage gateway；所有文件读写（token、access、文件管理）都走这里
     const storage = createStorageGateway(ctx);
@@ -166,8 +169,7 @@ export async function apply(ctx, config) {
         if (uiConfig.tokenMode === 'fixed' && uiConfig.fixedToken.trim()) {
             return uiConfig.fixedToken.trim();
         }
-        // disabled 模式仍按 persist 语义产出 token：无账户时作为兜底登录方式
-        if (uiConfig.tokenMode === 'persist' || uiConfig.tokenMode === 'fixed' || uiConfig.tokenMode === 'disabled') {
+        if (uiConfig.tokenMode === 'persist' || uiConfig.tokenMode === 'fixed') {
             try {
                 const raw = await storage.readFile(tokenFileUri, 'utf-8');
                 const existing = (typeof raw === 'string' ? raw : raw.toString('utf-8')).trim();
@@ -209,28 +211,13 @@ export async function apply(ctx, config) {
         }
     }
     const authToken = await resolveAuthToken();
-    // 账户校验惰性委托 authority 服务（可能晚于本插件激活/被热替换），账户即
-    // platform='webui' 且带密码凭据的用户记录。
-    const auth = createAuthSystem(authToken, ctx.logger.child('auth'), {
-        verify: (username, password) => ctx.getService('authority')?.verifyPassword('webui', username, password) ?? false,
-        hasAccounts: () => (ctx.getService('authority')?.listUsers() ?? []).some(u => u.platform === 'webui' && u.hasPassword),
-    }, 
-    // disabled：存在账户时 token 全面失效（auth 内部留有"无账户兜底"防锁死）
-    () => uiConfig.tokenMode !== 'disabled');
+    const auth = createAuthSystem(authToken, ctx.logger.child('auth'));
     const expressApp = express();
     expressApp.use(express.json({ limit: '10mb' }));
     expressApp.use(auth.middleware);
-    // REST 路由权限闸（连接级认证之上的身份级裁决，见 gate.ts 分层说明）
-    const gate = createRouteGate(ctx, auth.identify);
-    // 当前调用者信息（middleware 已拦未认证；identity 必存在）
-    expressApp.get('/api/auth/me', (req, res) => {
-        const identity = auth.identify(req) ?? { platform: 'webui', userId: 'console' };
-        const authority = ctx.getService('authority');
-        res.json({
-            identity,
-            isOwner: authority?.isOwner(identity.platform, identity.userId) ?? false,
-        });
-    });
+    // REST 路由 owner 闸（连接级认证之上的显式 owner 复核，见 gate.ts）。
+    // 当前身份 / 登录态查询统一走 auth.ts 的 GET /api/auth/status（含 identity）。
+    const gate = createRouteGate(auth.identify);
     const server = createServer(expressApp);
     const wss = new WebSocketServer({
         server,
@@ -274,21 +261,27 @@ export async function apply(ctx, config) {
             ctx.logger.warn(`前端目录不存在: ${dir}`);
         }
     }
-    // 已发现的前端候选 + 当前活跃 id（供「切换活跃前端」UI 读/写；ready 时填充）。
+    // 已发现的前端候选（ready 时填充，逐个注册为 webui-client 服务 provider）。
     const clientCandidates = [];
-    let activeClientId = '';
-    /** 切换活跃前端：实时重挂静态目录 + 更新 SPA 回退 + 持久化 webui.client，下次启动沿用。 */
-    function activateClient(id) {
-        const c = clientCandidates.find(x => x.id === id);
-        if (!c)
-            return false;
-        clientDist = c.dir;
-        mountStaticDir(c.dir);
-        activeClientId = id;
-        ctx.config.setPluginConfig(name, { ...ctx.config.getPluginConfig(name), client: id });
-        ctx.config.save();
-        ctx.logger.info(`活跃前端切换为: ${c.label} (${id})`);
-        return true;
+    /** 当前活跃前端目录 = 解析后的 webui-client 服务（servicePreferences 偏好 > 优先级 > 注册顺序）。 */
+    function currentClientDir() {
+        return ctx.getService('webui-client')?.getClientDir?.();
+    }
+    /**
+     * 切换 webui-client 服务偏好后调用：重挂当前活跃前端 + 广播 'reload'——所有客户端进入
+     * 「正在切换前端，即将刷新」遮罩后自动 reload（复用现有刷新流程，平滑换前端、不重启进程）。
+     */
+    function remountActiveClient() {
+        const dir = currentClientDir();
+        if (dir) {
+            clientDist = dir;
+            mountStaticDir(dir);
+        }
+        const payload = { type: 'reload' };
+        const json = JSON.stringify(payload);
+        for (const ws of allClients)
+            if (ws.readyState === WebSocket.OPEN)
+                ws.send(json);
     }
     // 动态静态文件中间件（支持运行时切换前端）
     expressApp.use((req, res, next) => {
@@ -301,11 +294,11 @@ export async function apply(ctx, config) {
     });
     // ---------- REST API ----------
     // 获取系统状态
-    expressApp.get('/api/status', gate('webui:status:read', 'public'), (_req, res) => {
+    expressApp.get('/api/status', gate(), (_req, res) => {
         const persona = ctx.getService('persona');
         // 判断上传能力
         const hasMedia = ctx.hasService('media');
-        const llmHasVision = ctx.getServiceCapabilities('llm').includes('vision');
+        const llmHasVision = listLLMModels(ctx).some(e => e.instance.capabilities.includes('vision'));
         const hasFileReader = ctx.hasService('file-reader');
         res.json({
             name: persona?.getPersonaName() ?? ctx.config.get('name'),
@@ -339,13 +332,41 @@ export async function apply(ctx, config) {
         });
     });
     // ---------- 插件管理 + 全局配置 ----------
+    // fs 扫描 env：discoverClients（ready 时）与市场「已装」兜底共用一份，避免两处重复。
+    const fsScanEnv = {
+        existsSync,
+        readdirSync: (p) => {
+            try {
+                return readdirSync(p);
+            }
+            catch {
+                return [];
+            }
+        },
+        readJson: (p) => {
+            try {
+                return JSON.parse(readFileSync(p, 'utf-8'));
+            }
+            catch {
+                return undefined;
+            }
+        },
+        join: (...parts) => resolve(...parts),
+    };
     registerPluginRoutes(expressApp, ctx, getApp, getPluginMgr, auth.identify, gate);
-    registerMarketplaceRoutes(expressApp, ctx, getPluginMgr, gate, uiConfig.marketplaceRegistry);
+    // 市场「已装」判定 + 依赖图都吃这一份本地扫描（pnpm 工作区下 require.resolve 从仓库根解析不到工作区包）：
+    // 与 discoverClients 同套 scanDirs（monorepo packages/ 同级 + node_modules/@aalis），每请求懒扫（量小）。
+    // 返回 name→依赖名[]：keys=已装包名，values=依赖图边。
+    const localScanDirs = [
+        resolve(dirname(fileURLToPath(import.meta.url)), '../../'),
+        resolve(process.cwd(), 'node_modules/@aalis'),
+    ];
+    registerMarketplaceRoutes(expressApp, ctx, getPluginMgr, gate, uiConfig.marketplaceRegistry, () => collectLocalPackageDeps(localScanDirs, fsScanEnv));
     // 获取历史日志：从 data/latest.log 读尾部 N 条（lazy load）。
     // 单进程内 LogHub 不再缓存 buffer——历史以文件为单一数据源。
-    expressApp.get('/api/logs', gate('webui:logs:read', 'restricted'), async (_req, res) => {
+    expressApp.get('/api/logs', gate(), async (_req, res) => {
         try {
-            const entries = await readLogFileTail(200);
+            const entries = await readLogFileTail(storage, 200);
             res.json(entries);
         }
         catch (err) {
@@ -353,17 +374,17 @@ export async function apply(ctx, config) {
         }
     });
     // 尾部 N 条（首屏 / 显式刷新）
-    expressApp.get('/api/logs/tail', gate('webui:logs:read', 'restricted'), async (req, res) => {
+    expressApp.get('/api/logs/tail', gate(), async (req, res) => {
         const limit = Math.min(Math.max(Number(req.query.limit) || 200, 1), 5000);
         try {
-            res.json(await readLogFileTail(limit));
+            res.json(await readLogFileTail(storage, limit));
         }
         catch (err) {
             res.status(500).json({ error: err.message });
         }
     });
     // 历史分页：返回 seq < before 的最近 limit 条（向上滚动加载更早）
-    expressApp.get('/api/logs/range', gate('webui:logs:read', 'restricted'), async (req, res) => {
+    expressApp.get('/api/logs/range', gate(), async (req, res) => {
         const before = Number(req.query.before);
         const limit = Math.min(Math.max(Number(req.query.limit) || 200, 1), 5000);
         if (!Number.isFinite(before)) {
@@ -371,14 +392,14 @@ export async function apply(ctx, config) {
             return;
         }
         try {
-            res.json(await readLogFileBefore(before, limit));
+            res.json(await readLogFileBefore(storage, before, limit));
         }
         catch (err) {
             res.status(500).json({ error: err.message });
         }
     });
     // 获取服务列表（含提供者信息）
-    expressApp.get('/api/services', gate('webui:services:read', 'public'), async (_req, res) => {
+    expressApp.get('/api/services', gate(), async (_req, res) => {
         const pluginMgr = getPluginMgr();
         const pluginStatus = pluginMgr ? pluginMgr.getStatus() : [];
         const displayNameMap = new Map();
@@ -396,7 +417,6 @@ export async function apply(ctx, config) {
             services[svcName] = {
                 providers: entries.map(e => ({
                     contextId: e.contextId,
-                    capabilities: [...e.capabilities],
                     displayName: displayNameMap.get(e.contextId),
                     label: e.label,
                     priority: e.priority,
@@ -410,7 +430,7 @@ export async function apply(ctx, config) {
      * 设置服务偏好。body: { contextId: string }
      * 偏好语义：`preferred > priority > 注册顺序`。持久化到 aalis.config.yaml 的 servicePreferences。
      */
-    expressApp.post('/api/services/:name/prefer', gate('webui:services:manage', 'restricted'), async (req, res) => {
+    expressApp.post('/api/services/:name/prefer', gate(), async (req, res) => {
         const svcName = String(req.params.name);
         const contextId = String(req.body?.contextId ?? '').trim();
         if (!contextId) {
@@ -426,38 +446,30 @@ export async function apply(ctx, config) {
         ctx.preferService(svcName, contextId);
         ctx.config.setServicePreference(svcName, contextId);
         ctx.config.save();
+        // 切换前端：webui-client 是「前端」服务，偏好变更需重挂静态目录 + 通知客户端刷新。
+        if (svcName === 'webui-client')
+            remountActiveClient();
         res.json({ ok: true });
     });
     /** 清除服务偏好 */
-    expressApp.delete('/api/services/:name/prefer', gate('webui:services:manage', 'restricted'), async (req, res) => {
+    expressApp.delete('/api/services/:name/prefer', gate(), async (req, res) => {
         const svcName = String(req.params.name);
         ctx.unpreferService(svcName);
         ctx.config.removeServicePreference(svcName);
         ctx.config.save();
+        if (svcName === 'webui-client')
+            remountActiveClient();
         res.json({ ok: true });
     });
-    // 前端切换：列出已发现的前端 + 当前活跃（多前端时 UI 展示）。只回 id/label/active，不泄露 fs 路径。
-    expressApp.get('/api/clients', gate('webui:status:read', 'public'), (_req, res) => {
-        res.json({
-            clients: clientCandidates.map(c => ({ id: c.id, label: c.label, active: c.id === activeClientId })),
-            active: activeClientId,
-        });
-    });
-    // 设活跃前端（owner）：实时重挂 + 持久化；前端切完自行 reload 即加载新前端。
-    expressApp.post('/api/clients/active', gate('webui:clients:manage', 'restricted'), (req, res) => {
-        const id = String(req.body?.id ?? '').trim();
-        if (!activateClient(id)) {
-            res.status(404).json({ ok: false, error: `未找到已发现的前端 "${id}"` });
-            return;
-        }
-        res.json({ ok: true, active: id });
-    });
+    // 前端切换已统一到「服务偏好」：前端是 webui-client 服务的多 provider，切换走
+    // POST /api/services/webui-client/prefer（见上），webui-server 在该偏好变更时重挂 + 广播刷新。
+    // 故不再有独立的 /api/clients* 路由。
     // 获取所有平台适配器及其连接状态
-    expressApp.get('/api/platforms', gate('webui:status:read', 'public'), (_req, res) => {
+    expressApp.get('/api/platforms', gate(), (_req, res) => {
         res.json({ platforms: aggregatePlatformDetails(ctx) });
     });
     // 获取已注册的工具分组（含元数据 + 各组工具数量 + 贡献插件列表）
-    expressApp.get('/api/tool-groups', gate('webui:status:read', 'public'), (_req, res) => {
+    expressApp.get('/api/tool-groups', gate(), (_req, res) => {
         const groups = ctx.getService('tools')?.getGroups() ?? [];
         const allTools = ctx.getService('tools')?.getAll() ?? [];
         const knownNames = new Set(groups.map(g => g.name));
@@ -486,7 +498,7 @@ export async function apply(ctx, config) {
         res.json({ groups: result });
     });
     // 获取服务分组（manifest 驱动：每个插件自己声明 subsystem，本路由仅聚合）
-    expressApp.get('/api/service-groups', gate('webui:status:read', 'public'), (_req, res) => {
+    expressApp.get('/api/service-groups', gate(), (_req, res) => {
         const pluginMgr = getPluginMgr();
         const pluginStatus = pluginMgr ? pluginMgr.getStatus() : [];
         // 按插件 subsystem 归组（未声明 → 'external'）。subsystem 是 WebUI 展示概念、
@@ -527,12 +539,12 @@ export async function apply(ctx, config) {
         res.json({ groups });
     });
     // 获取所有 LLM 模型（枚举所有注册的 per-model entry）
-    expressApp.get('/api/llm-models', gate('webui:llm:read', 'restricted'), async (_req, res) => {
+    expressApp.get('/api/llm-models', gate(), async (_req, res) => {
         try {
             const entries = ctx.getAllServices('llm');
             const models = entries.map(e => ({
                 id: e.instance.id,
-                capabilities: e.capabilities,
+                capabilities: [...e.instance.capabilities],
                 provider: e.instance.providerId,
                 contextId: e.contextId,
             }));
@@ -543,7 +555,7 @@ export async function apply(ctx, config) {
         }
     });
     // LLM providers + per-provider models（供 schema type='llm-ref' 联动 select 使用）
-    expressApp.get('/api/llm-providers', gate('webui:llm:read', 'restricted'), async (_req, res) => {
+    expressApp.get('/api/llm-providers', gate(), async (_req, res) => {
         try {
             const entries = ctx.getAllServices('llm');
             const byProvider = new Map();
@@ -567,7 +579,7 @@ export async function apply(ctx, config) {
                 }
                 agg.models.push({
                     id: e.instance.id,
-                    capabilities: e.capabilities,
+                    capabilities: [...e.instance.capabilities],
                     contextLength: e.instance.contextLength,
                 });
             }
@@ -580,7 +592,7 @@ export async function apply(ctx, config) {
     // 触发指定 provider 重新探测远端模型列表（用于 webui 上的"刷新模型"按钮）
     // 仅对在 LLMModel 上实现了 refresh() 的 provider 生效（远端动态发现型，如 Ollama / OpenAI）。
     // 同 provider 下所有 model entries 共享同一份 refresh 闭包，调任一个 entry 即可。
-    expressApp.post('/api/llm-providers/:contextId/refresh', gate('webui:llm:manage', 'restricted'), async (req, res) => {
+    expressApp.post('/api/llm-providers/:contextId/refresh', gate(), async (req, res) => {
         const contextId = req.params.contextId;
         if (!contextId) {
             res.status(400).json({ error: 'contextId is required' });
@@ -603,7 +615,7 @@ export async function apply(ctx, config) {
         }
     });
     // 获取某个服务的可用模型/选项列表
-    expressApp.get('/api/models/:service', gate('webui:models:read', 'public'), async (req, res) => {
+    expressApp.get('/api/models/:service', gate(), async (req, res) => {
         const serviceName = req.params.service;
         // 特殊处理 platform：通过 helper 获取已注册的平台名称
         if (serviceName === 'platform') {
@@ -677,7 +689,7 @@ export async function apply(ctx, config) {
                     model: e.instance.id,
                     provider: e.label ?? e.contextId,
                     contextId: e.contextId,
-                    capabilities: e.capabilities,
+                    capabilities: [...e.instance.capabilities],
                 }));
                 res.json({ models: aggregated.map(a => a.value), providers: aggregated });
             }
@@ -704,9 +716,7 @@ export async function apply(ctx, config) {
                     for (const m of models) {
                         const isModelInfo = typeof m === 'object' && m !== null && 'id' in m;
                         const modelId = isModelInfo ? m.id : String(m);
-                        const modelCaps = isModelInfo
-                            ? m.capabilities
-                            : provider.capabilities;
+                        const modelCaps = isModelInfo ? m.capabilities : [];
                         aggregated.push({
                             value: modelId,
                             model: modelId,
@@ -727,57 +737,22 @@ export async function apply(ctx, config) {
             res.json({ models: [] });
         }
     });
-    // ---------- 受限操作交互式确认（内联对话式；restricted 能力的临时委托） ----------
-    const CONFIRM_TIMEOUT = 60_000; // 60 秒超时
-    const pendingSessionConfirms = new Map();
-    ctx.getService('authority')?.setConfirmHandler('webui', async (request) => {
-        const typeLabel = request.type === 'command' ? '指令' : '工具';
-        const nameStr = request.type === 'command' ? `/${request.name}` : request.name;
-        const prompt = `⚠️ ${typeLabel} ${nameStr} 是受限操作。回复 Y 仅允许本次；回复 YS 允许本会话 10 分钟；其他任意输入取消。`;
-        // 以确认消息形式发送（不影响客户端 loading/streaming 状态）
-        const payload = {
-            type: 'confirm',
-            content: prompt,
-            sessionId: request.sessionId,
-        };
-        const json = JSON.stringify(payload);
-        const sockets = sessions.get(request.sessionId);
-        const targets = sockets && sockets.size > 0 ? sockets : allClients;
-        let sent = false;
-        for (const ws of targets) {
-            if (ws.readyState === WebSocket.OPEN) {
-                ws.send(json);
-                sent = true;
+    // ---------- 受限操作交互式确认（复用 session-confirm 协调器；WebUI 传输=WS type:'confirm'，流式友好） ----------
+    // 协调器逻辑（待确认/超时/解析/文案）由 session-confirm 服务统一实现；WebUI 只注入自己的 WS 投递，
+    // 并保留 type:'confirm'（前端「确认模式」信号，抑制富客户端的「打字即打断」）。回复在 WS-onmessage 调 feed（下方）。
+    let confirmChannel;
+    ctx.whenService('session-confirm', confirmSvc => {
+        confirmChannel = confirmSvc.createChannel((request, text) => {
+            const payload = { type: 'confirm', content: text, sessionId: request.sessionId };
+            const json = JSON.stringify(payload);
+            const sockets = sessions.get(request.sessionId);
+            const targets = sockets && sockets.size > 0 ? sockets : allClients;
+            for (const ws of targets) {
+                if (ws.readyState === WebSocket.OPEN)
+                    ws.send(json);
             }
-        }
-        if (!sent)
-            return false;
-        // 同一 session 已有未决确认时，先取消旧的（清 timer + resolve false），避免新
-        // set 覆盖后旧 Promise 永远 pending 且旧 timer 误删新条目（审计 HIGH #7 竞态）。
-        const stale = pendingSessionConfirms.get(request.sessionId);
-        if (stale) {
-            clearTimeout(stale.timer);
-            pendingSessionConfirms.delete(request.sessionId);
-            stale.resolve(false);
-        }
-        return new Promise(resolve => {
-            const timer = setTimeout(() => {
-                pendingSessionConfirms.delete(request.sessionId);
-                // 超时后向会话发送提示
-                const timeoutPayload = {
-                    type: 'confirm',
-                    content: '⏰ 受限操作确认已超时，已自动取消。',
-                    sessionId: request.sessionId,
-                };
-                const timeoutJson = JSON.stringify(timeoutPayload);
-                for (const ws of targets) {
-                    if (ws.readyState === WebSocket.OPEN)
-                        ws.send(timeoutJson);
-                }
-                resolve(false);
-            }, CONFIRM_TIMEOUT);
-            pendingSessionConfirms.set(request.sessionId, { resolve, timer });
         });
+        ctx.getService('authority')?.setConfirmHandler('webui', confirmChannel.handler);
     });
     // ---------- 文件管理 API ----------
     registerFileRoutes(expressApp, ctx, { storage, fileRoot: uiConfig.fileRoot }, gate);
@@ -876,18 +851,9 @@ export async function apply(ctx, config) {
                     sessions.set(sessionId, new Set());
                 }
                 sessions.get(sessionId).add(ws);
-                // 检查是否有待确认的受限操作（拦截用户输入作为确认/取消）
-                const pending = pendingSessionConfirms.get(sessionId);
-                if (pending) {
-                    clearTimeout(pending.timer);
-                    pendingSessionConfirms.delete(sessionId);
-                    const answer = trimmed.toLowerCase();
-                    if (answer === 'ys' || answer === 'y session') {
-                        pending.resolve({ allowed: true, grant: { scope: 'session', durationSeconds: 600, maxUses: 30 } });
-                    }
-                    else {
-                        pending.resolve(answer === 'y');
-                    }
+                // 检查待确认的受限操作（拦截输入作为确认/取消；协调器逻辑由 session-confirm 服务统一处理）
+                // 传应答者身份：仅确认的触发者本人能应答（防第三方抢答；webui 同账户天然同人）。
+                if (confirmChannel?.feed(sessionId, trimmed, wsIdentity.userId)) {
                     // 不继续处理此消息，交给原始命令/工具执行流返回结果
                     return;
                 }
@@ -1210,6 +1176,13 @@ export async function apply(ctx, config) {
             }
         }
     });
+    // 前端切换「逃生页」：由 webui-server 直出、独立于任何可被切换的前端，故任意前端（哪怕
+    // 极简第三方前端无切换 UI）卡住时都能在此切回。受全局 auth 中间件登录保护；切换走既有 owner
+    // 闸的 POST /api/services/webui-client/prefer，本页零新增后端逻辑（见 client-switch-page.ts）。
+    // 注册在 SPA 兜底之前，故 `/__clients` 被本路由先接走、不落到前端 index.html。
+    expressApp.get('/__clients', (_req, res) => {
+        res.type('html').send(renderClientSwitchPage());
+    });
     // SPA fallback: 所有非 API 路径返回 index.html
     expressApp.get('{*path}', (_req, res) => {
         const indexPath = resolve(clientDist, 'index.html');
@@ -1222,90 +1195,67 @@ export async function apply(ctx, config) {
     });
     // 启动服务器
     ctx.on('ready', () => {
-        // 自动发现 webui-client 包并注册为 webui-client 服务提供者。
-        // 解析以「项目根 package.json」为基准（与 runtime 的 node-modules 加载器同源），
-        // 这样 npm 扁平 / pnpm 隔离 / monorepo 软链三种 node_modules 拓扑都自洽——
-        // client 是项目顶层依赖（create-aalis 选 WebUI 时自动带），从项目根能 resolve 到。
-        // 回退：webui-server 同级目录（cwd≠项目根等边角场景兜底）。
-        const __dirname = dirname(fileURLToPath(import.meta.url));
+        // 全动态发现前端：按 `aalis.client:true` 标记扫描，**不硬编码任何前端包名**
+        // （与 runtime 加载器的 marker 驱动一致；忒修斯之船——任意第三方前端带标记+dist 即被发现）。
+        // 覆盖三种拓扑：monorepo（扫 packages 同级目录）/ 独立项目（扫 node_modules/@aalis + 根 deps）。
+        const here = dirname(fileURLToPath(import.meta.url));
         const projectRequire = createRequire(pathToFileURL(resolve(process.cwd(), 'package.json')));
-        const resolveClientDir = (id) => {
-            try {
-                return resolve(dirname(projectRequire.resolve(`${id}/package.json`)), 'dist');
-            }
-            catch {
-                const sibling = resolve(__dirname, `../../${id.replace('@aalis/', '')}/dist`);
-                return existsSync(sibling) ? sibling : undefined;
-            }
-        };
-        const addCandidate = (id, label, dir) => {
-            if (!dir || clientCandidates.some(c => c.id === id))
-                return;
-            if (existsSync(dir) && existsSync(resolve(dir, 'index.html')))
-                clientCandidates.push({ id, label, dir });
-        };
-        // ① 已知 @aalis 前端（保证 monorepo/默认拓扑可用——根 deps 未必列 client）
-        addCandidate('@aalis/plugin-webui-client', 'Aalis 默认前端', resolveClientDir('@aalis/plugin-webui-client'));
-        addCandidate('@aalis/plugin-webui-client-napcat', 'NapCat 前端', resolveClientDir('@aalis/plugin-webui-client-napcat'));
-        // ② 追加发现：项目 deps 里任何带 aalis.client marker 的第三方前端（忒修斯之船可换）
-        try {
-            const rootPkg = JSON.parse(readFileSync(resolve(process.cwd(), 'package.json'), 'utf-8'));
-            const deps = Object.keys({ ...rootPkg.dependencies, ...rootPkg.optionalDependencies });
-            for (const dep of deps) {
-                if (clientCandidates.some(c => c.id === dep))
-                    continue;
+        const env = {
+            ...fsScanEnv,
+            dirname,
+            resolvePkgJson: id => {
                 try {
-                    const pkgPath = projectRequire.resolve(`${dep}/package.json`);
-                    const pkg = JSON.parse(readFileSync(pkgPath, 'utf-8'));
-                    if (pkg?.aalis?.client !== true)
-                        continue;
-                    addCandidate(dep, pkg.displayName ?? pkg.description ?? dep, resolve(dirname(pkgPath), 'dist'));
+                    return projectRequire.resolve(`${id}/package.json`);
                 }
                 catch {
-                    /* 该 dep 无法解析/读取，跳过 */
+                    return undefined;
                 }
-            }
+            },
+        };
+        // here = <pkg>/dist；其上两级即 monorepo 的 packages 目录。再加项目 node_modules/@aalis 作用域。
+        const scanDirs = [resolve(here, '../../'), resolve(process.cwd(), 'node_modules/@aalis')];
+        let depIds = [];
+        try {
+            const rootPkg = JSON.parse(readFileSync(resolve(process.cwd(), 'package.json'), 'utf-8'));
+            depIds = Object.keys({ ...rootPkg.dependencies, ...rootPkg.optionalDependencies });
         }
         catch {
-            /* 无项目根 package.json（如 monorepo 直跑），跳过 dep 扫描 */
+            /* 无项目根 package.json（如 monorepo 直跑），跳过 deps 扫描 */
         }
-        // 如果已有外部插件主动注册了 webui-client 服务（apply 覆盖路径），则跳过自动发现
-        const hasExternalClient = ctx.hasService('webui-client');
-        if (!hasExternalClient && clientCandidates.length > 0) {
-            // 活跃前端：config.client 指定者优先，否则取第一个（默认前端排在最前）
-            const preferred = uiConfig.client && clientCandidates.find(c => c.id === uiConfig.client);
-            const active = preferred || clientCandidates[0];
-            for (const candidate of clientCandidates) {
-                const childCtx = ctx.fork(candidate.id);
-                childCtx.provide('webui-client', { getClientDir: () => candidate.dir }, { label: candidate.label });
-                ctx.logger.info(`发现前端: ${candidate.label} (${candidate.dir})`);
-            }
-            clientDist = active.dir;
-            mountStaticDir(active.dir);
-            activeClientId = active.id;
-            ctx.logger.info(`活跃前端: ${active.label}${preferred ? '（config.client 指定）' : ''}`);
+        clientCandidates.push(...discoverClients(scanDirs, depIds, env));
+        // 把每个发现到的前端注册为 webui-client 服务的一个 provider（带 label，供「服务」页下拉切换）。
+        // 外部插件在 apply 里主动 provide('webui-client') 的也已在服务池中（注册更早 → 默认胜出，仍可被偏好切换）。
+        for (const candidate of clientCandidates) {
+            ctx.fork(candidate.id).provide('webui-client', { getClientDir: () => candidate.dir }, { label: candidate.label });
+            ctx.logger.info(`发现前端: ${candidate.label} (${candidate.dir})`);
         }
-        // 若已有外部 webui-client 服务，使用其提供的目录
-        if (hasExternalClient) {
-            const activeClient = ctx.getService('webui-client');
-            if (activeClient?.getClientDir) {
-                const dir = activeClient.getClientDir();
-                clientDist = dir;
-                mountStaticDir(dir);
-                ctx.logger.info(`活跃前端(服务): ${dir}`);
-            }
+        // 活跃前端 = 解析后的 webui-client 服务（servicePreferences 偏好 > 优先级 > 注册顺序）；零前端则 404。
+        const activeDir = currentClientDir();
+        if (activeDir) {
+            clientDist = activeDir;
+            mountStaticDir(activeDir);
+            ctx.logger.info(`活跃前端: ${activeDir}`);
+        }
+        else {
+            ctx.logger.warn('未发现任何前端（webui-client provider）；前端路由将 404，请安装一个 aalis.client 包');
         }
         server.listen(uiConfig.port, uiConfig.host, () => {
             const url = `http://${uiConfig.host}:${uiConfig.port}/`;
             const accessUrl = `${url}?token=${authToken}`;
             void writeAccessFile(url, authToken);
             ctx.logger.info(`WebUI 已启动: ${url}`);
+            // 多前端时提示恢复页 URL：万一切到无切换 UI 的前端被卡住，可在此切回（详见 client-switch-page.ts）。
+            if (clientCandidates.length > 1) {
+                ctx.logger.info(`检测到多个前端；若卡在某前端无切换入口，可访问恢复页切回: ${url}__clients`);
+            }
             const tokenHint = uiConfig.tokenMode === 'ephemeral'
                 ? 'token 仅本次启动有效，重启轮换'
                 : uiConfig.tokenMode === 'fixed'
                     ? 'token 来自配置 fixedToken，固定不变'
                     : 'token 已持久化到 storage data:/webui/token，重启沿用';
-            ctx.logger.info(`首次访问请使用以下 URL（${tokenHint}）: ${accessUrl}`);
+            // 不把 token 打进日志（会落 latest.log / 被 /api/logs 回放 / 贴日志求助时外泄）。
+            // 仅打不带 token 的 URL，完整一键登录链接见 access.txt（该文件应 0o600，见 token 落盘）。
+            ctx.logger.info(`首次访问 URL（${tokenHint}）: ${url} —— 完整一键登录链接见 ${accessFileUri}`);
             void (async () => {
                 let absHint = accessFileUri;
                 try {
@@ -1323,6 +1273,7 @@ export async function apply(ctx, config) {
         });
     });
     ctx.onDispose(() => {
+        confirmChannel?.dispose(); // 清 WebUI 确认通道里挂起的待确认（安全拒），避免 Promise 永挂
         removeLogListener();
         wss.close();
         server.close();
@@ -1363,7 +1314,7 @@ export async function apply(ctx, config) {
             }
         },
     };
-    ctx.provide('platform', adapter, { capabilities: ['webui', 'text', 'image', 'file'] });
+    ctx.provide('platform', adapter);
     // === 注册 WebUI 服务 ===
     const registeredPages = new Map();
     // 内建页面归属为 webui-server 本身
@@ -1405,6 +1356,6 @@ export async function apply(ctx, config) {
             registeredPages.delete(pluginName);
         },
     };
-    ctx.provide('webui-server', webuiService, { capabilities: ['api-v1'] });
+    ctx.provide('webui-server', webuiService);
 }
 //# sourceMappingURL=index.js.map