cc 2 dni temu
rodzic
commit
7e70b1b697
28 zmienionych plików z 1364 dodań i 258 usunięć
  1. 128 0
      .zcode/plans/plan-sess_90e98c10-d82b-4751-81ed-dde2eb59b2d4.md
  2. 28 3
      ai-electron/electron/config/windowOptions.ts
  3. 43 2
      ai-electron/electron/controller/windowCtl.ts
  4. 44 0
      ai-electron/electron/service/window/permWindow.ts
  5. 18 187
      ai-electron/electron/service/window/smartWindow.ts
  6. 256 0
      ai-electron/electron/service/window/subWindow.ts
  7. 4 0
      ai-electron/frontend/src/core/components/Application/index.ts
  8. 10 8
      ai-electron/frontend/src/core/components/Application/src/AppDownloadManager.vue
  9. 35 0
      ai-electron/frontend/src/core/components/Application/src/AppPermCenterButton.vue
  10. 7 5
      ai-electron/frontend/src/core/components/Application/src/WindowControls.vue
  11. 2 0
      ai-electron/frontend/src/core/enums/pageEnum.ts
  12. 2 2
      ai-electron/frontend/src/core/hooks/desktop/useElectronWindow.ts
  13. 21 2
      ai-electron/frontend/src/core/layouts/default/header/components/user-dropdown/index.vue
  14. 10 1
      ai-electron/frontend/src/core/layouts/default/header/index.vue
  15. 8 5
      ai-electron/frontend/src/core/layouts/default/setting/index.vue
  16. 81 9
      ai-electron/frontend/src/core/logics/appWindow.ts
  17. 89 0
      ai-electron/frontend/src/core/logics/permWindow.ts
  18. 42 6
      ai-electron/frontend/src/core/logics/sessionSync.ts
  19. 48 4
      ai-electron/frontend/src/core/router/guard/index.ts
  20. 26 0
      ai-electron/frontend/src/core/router/routes/index.ts
  21. 6 1
      ai-electron/frontend/src/core/store/modules/permission.ts
  22. 4 1
      ai-electron/frontend/src/core/utils/desktop/ipcRenderer.ts
  23. 27 7
      ai-electron/frontend/src/core/utils/http/axios/unauthorized.ts
  24. 48 13
      ai-electron/frontend/src/main.ts
  25. 125 0
      ai-electron/frontend/src/perm/config.ts
  26. 245 0
      ai-electron/frontend/src/perm/layouts/PermWindowLayout.vue
  27. 4 1
      ai-electron/frontend/src/perm/views/menu/index.vue
  28. 3 1
      ai-electron/frontend/src/plat/views/case/case.vue

+ 128 - 0
.zcode/plans/plan-sess_90e98c10-d82b-4751-81ed-dde2eb59b2d4.md

@@ -0,0 +1,128 @@
+## Context
+
+当前权限管理的 5 个页面(用户/角色/菜单/部门/岗位)是主窗口内的普通动态路由,入口在左侧菜单。需求是把它们统一收敛到一个独立子窗口,用顶栏「设置」前的新图标打开,交互流程对齐现有「智能工作台」独立窗口;只有 Electron 下才开子窗口,浏览器降级为同窗口全屏页面。
+
+现有可复用机制(已确认):
+- 主进程单例窗口:`ai-electron/electron/service/window/smartWindow.ts` + `windowCtl.ts`(通道 `controller/windowCtl/*`)
+- 前端窗口能力:`frontend/src/core/logics/appWindow.ts`(`isDesktop()`、窗口角色、`openSmartWindow`)
+- 独立全屏路由:`WorkbenchRoute` 注册在 `basicRoutes`,路由守卫接管窗口角色
+- 权限页组件本身无布局依赖,可直接挂载到新布局
+- 权限码:`perm:user:list` / `perm:role:list` / `perm:menu:list` / `perm:dept:list` / `perm:post:list`(超管 `*:*:*`)
+
+已确认的产品决策:Electron 主窗口左侧菜单移除「权限管理」;图标仅对有权用户可见;浏览器下点击图标进入同窗口全屏权限中心。
+
+---
+
+## 实施内容
+
+### 一、主进程:抽出通用子窗口 + 新增权限窗口
+
+1. **新增 `ai-electron/electron/service/window/subWindow.ts`**
+   - 通用单例子窗口工厂 `createSubWindowController(definition)`,把 `smartWindow.ts` 现有逻辑原样抽出:单例、已存在时 focus/reload/navigate、bounds 落盘恢复(按 `boundsKey`)、render-process-gone 处理、dev `loadURL` / prod `loadFile({hash})`、可选 `stateChannel` 通知主窗口。
+   - 定义 `pathPrefix`、`minSize`、`navigateOnlyWhenQuery`(工作台保留「仅带 query 才导航」旧规则)。
+
+2. **改造 `ai-electron/electron/service/window/smartWindow.ts`**
+   - 内部改用上面的工厂,**保持全部现有导出与行为不变**(`getSmartWindow`、`isSmartWindowOpen`、`isSmartWindow`、`openSmartWindow`、`closeSmartWindow`、`focusSmartWindow`、`focusMainWindow`、`SMART_WINDOW_STATE_CHANNEL`)。
+   - 这是回归风险点,需人工验证智能窗口开/关/换案 reload/关闭确认。
+
+3. **新增 `ai-electron/electron/service/window/permWindow.ts`**
+   - 路径白名单 `/perm-window`,bounds key `permWindowBounds`,导出 `openPermWindow` / `closePermWindow` / `isPermWindowOpen` / `isPermWindow` / `focusPermWindow`。
+
+4. **`ai-electron/electron/config/windowOptions.ts`**
+   - 新增 `permWindowSize` 与 `getPermWindowOptions()`:标题「清鉴 · 权限管理」,沿用 `sharedWebPreferences`、`frame:false`、`show:false`、同 logo。
+   - 更新共用 webPreferences 注释(三个窗口一致)。
+
+5. **`ai-electron/electron/controller/windowCtl.ts`**
+   - 新增 `openPermWindow` / `closePermWindow` / `isPermWindowOpen`,参数 `{ fullPath?, reloadIfOpen?, navigateIfOpen? }`。
+   - `getWindowRole` 返回值扩展为 `'smart' | 'perm' | 'main'`。
+
+### 二、前端:路由、布局、入口
+
+6. **`frontend/src/core/enums/pageEnum.ts`**
+   - 新增 `BASE_PERM_WINDOW = '/perm-window'`。
+
+7. **新增 `frontend/src/perm/config.ts`**
+   - `PERM_CENTER_PAGES`:5 个页面的 `key / path('/perm-window/xxx') / routeName / title / icon / permission / legacyPath('/perm/xxx/index')`。
+   - `PERM_CENTER_COMPONENTS`:静态懒加载映射。
+   - `isPermWindowPath()`、`toPermWindowPath()`(`/perm/*` → `/perm-window/*`)。
+   - `isPermMenuGroup()` / `removePermMenuGroups()`:识别主菜单中的「权限管理」分组。
+
+8. **`frontend/src/core/router/routes/index.ts`**
+   - 新增 `PermWindowRoute`(独立全屏,不套 LAYOUT),`redirect: '/perm-window/user'`,5 个静态子路由;注册进 `basicRoutes`(保证 `resetRouter()` 不删除,菜单管理保存后仍在)。
+
+9. **新增 `frontend/src/perm/layouts/PermWindowLayout.vue`**
+   - `AppTopBar`(`logo-title="数剑 · 权限管理"`、`show-mode-switch=false`、`show-user-dropdown=true`、`show-user-logout=false`,窗口控制由 `AppTopBar` 自带)+ 左侧 `SimpleMenu` 五项导航 + `<router-view>`。
+   - 导航项按 `hasPermission(permission)` 过滤;当前地址无权时自动跳到第一个有权的页面;无任何权限时展示空状态(不挂载页面,避免 403 请求风暴)。
+   - 高度用 `100vh` flex 布局,保证权限页根节点的 `height:100%` 生效。
+
+10. **`frontend/src/core/logics/appWindow.ts`**
+    - 新增 `PERM_WINDOW_PATH`、`OpenPermWindowResult`。
+    - `AppWindowRole` 增加 `'perm'`;`initWindowRole` 解析 `'perm'`;`setPersistOnUnload(role === 'main')`。
+    - 新增 `isPermWindow()`、`openPermWindow()`(桌面走 IPC,浏览器 `router.push('/perm-window/...')`)、`closePermWindow()`、`isPermWindowOpen()`。
+    - `SyncEvent` 增加 `{ type: 'MENU_CHANGED' }`。
+
+11. **新增 `frontend/src/core/logics/permWindow.ts`**
+    - `openPermCenter({ fullPath?, navigateIfOpen? })`:调用 `openPermWindow`,沿用工作台的 Windows 前台抢占兜底(打开成功后 400ms 再聚焦一次)。
+
+12. **新增 `frontend/src/core/components/Application/src/AppPermCenterButton.vue`**
+    - 盾牌图标(`i-mdi:shield-account-outline`,已在 uno safelist),`Tooltip=权限管理`,`class="jeesite-header-action-button"`(主壳与案件页都已有该样式)。
+    - 用 `hasPermission(PERM_CENTER_PERMISSIONS)` 控制可见;点击打开第一个有权页面;失败弹错误提示。
+    - 从 `frontend/src/core/components/Application/index.ts` 导出。
+
+13. **接入两处顶栏**
+    - `frontend/src/core/layouts/default/header/index.vue`:`<AppPermCenterButton />` 放在 `<AppDownloadManager />` 与 `<SettingDrawer />` 之间。
+    - `frontend/src/plat/views/case/case.vue`:同样插在 `AppDownloadManager` 与 `SettingDrawer` 之间。
+
+### 三、路由守卫与窗口生命周期
+
+14. **`frontend/src/core/router/guard/index.ts`**(扩展现有 `createWorkbenchGuard`)
+    - 权限窗口:只允许 `/perm-window*` 与 `/authorization`,其余(含 `/perm/*`)映射/重定向到 `/perm-window`。
+    - Electron 主窗口:`/perm/*` 或 `/perm-window/*` 一律 `openPermCenter({ fullPath, navigateIfOpen: true })`,主窗口留在原页(`from.path` 是业务页则保留,否则回 `/case`)。
+    - 浏览器(`!isDesktop()`)直接放行,保持现有页面行为。
+
+15. **`frontend/src/core/utils/desktop/ipcRenderer.ts`**
+    - 新增通用 `isDesktopEnv()`(`isDesktopDialogAvailable` 复用同一实现),供 `appWindow.isDesktop` 与权限菜单过滤使用,避免 store 反向依赖窗口逻辑。
+
+16. **`frontend/src/core/store/modules/permission.ts`**
+    - `buildRoutesAction()` 中:桌面端构建 `backMenuList` 时用 `removePermMenuGroups()` 去掉「权限管理」分组(侧栏与顶栏搜索都不再出现),**路由本身保留**(浏览器仍需要,Electron 由守卫接管)。
+    - 浏览器不处理,保持原菜单。
+
+17. **`frontend/src/core/logics/sessionSync.ts`**
+    - 权限窗口:收到 `AUTH_INVALID` 或 `APP_RESET(account-logged-out)` 时关闭自己;`APP_RESET(case-exited)` 不关闭(权限管理与案件无关)。
+    - 智能窗口:保持原行为,但改为按事件类型处理,避免新增的 `MENU_CHANGED` 误关窗口。
+    - 主窗口收到 `MENU_CHANGED` → `refreshMenu()`(菜单管理在子窗口保存后,主窗口导航即时刷新)。
+
+18. **`frontend/src/core/utils/http/axios/unauthorized.ts`**
+    - `401` / license 失效时把 `isPermWindow()` 与智能窗口同等处理:广播 `AUTH_INVALID` + 聚焦主窗口 + 关闭自己。
+
+19. **`frontend/src/main.ts`**
+    - 三处二级窗口兜底(未绑定地址、后端不可达、凭据失效跳授权页)增加 `isPermWindow()`,统一关闭权限窗口并聚焦主窗口。
+
+20. **`frontend/src/core/components/Application/src/WindowControls.vue`**
+    - 权限窗口关闭按钮 tooltip 改为「关闭」(不能沿用主窗口的「最小化到托盘」文案)。
+
+21. **`frontend/src/perm/views/menu/index.vue`**
+    - `handleMenuChanged()` 在 `refreshMenu()` 后 `broadcastSync({ type: 'MENU_CHANGED' })`。
+
+---
+
+## 关键约束与说明
+
+- 不改后端、不改 `perm_menu` 数据;5 个页面组件与权限码完全复用。
+- 权限子窗口不需要已打开案件,案件管理页可直接打开;退出案件不关闭权限窗口,退出登录/凭据失效才关闭。
+- `/perm/*` 动态路由在 Electron 主窗口仍注册但不可达(守卫接管),浏览器仍按原方式渲染。
+- 子窗口为独立顶层窗口(不设 `parent`),与智能工作台一致,避免 Windows 下始终悬浮在主窗口之上。
+- 保持代码现有中文注释风格。
+
+## 验证
+
+1. `cd ai-electron && npm run typecheck`;`cd ai-electron/frontend && npm run type:check`。
+2. `cd ai-electron && npm run dev`(需后端/授权环境):
+   - 超管登录:案件管理页顶栏出现盾牌图标(设置按钮前);点击打开独立无边框「权限管理」窗口,默认用户管理,五项导航均可切换、弹窗正常、窗口位置可恢复、重复点击只聚焦。
+   - 打开案件进入自主模式:顶栏同样出现图标;侧栏不再出现「权限管理」分组,顶栏搜索也搜不到权限页。
+   - 主窗口直接访问 `/perm/user/index` 或 `/perm-window/role`:打开/导航权限子窗口,主窗口留在原页。
+   - 主窗口退出登录 → 权限窗口关闭;退出案件 → 权限窗口保持。
+   - 菜单管理保存后,主窗口侧栏即时刷新(`MENU_CHANGED`)。
+   - 非超管且无权限码账号:图标不渲染;直连 `/perm-window/user` 显示无权限空态且不刷接口。
+   - 回归智能工作台:开/关、换案 reload、模式切换、关闭确认均正常(验证 `subWindow` 抽取无回归)。
+3. 浏览器(`npm run dev-frontend` 后打开 `http://localhost:3100`):图标进入同窗口全屏权限中心,浏览器返回可回原页;左侧权限菜单保持原样。

+ 28 - 3
ai-electron/electron/config/windowOptions.ts

@@ -3,10 +3,10 @@ import { getBaseDir } from 'ee-core/ps';
 import type { BrowserWindowConstructorOptions } from 'electron';
 
 /**
- * 主窗口与智能工作台窗口共用的 webPreferences。
+ * 主窗口、智能工作台窗口、权限管理窗口共用的 webPreferences。
  *
- * 两个窗口必须一致:渲染进程目前依赖 nodeIntegration 直接 require('electron') 调 IPC,
- * 智能窗口若单独改成 contextIsolation,现有 preload 又没启用,行为会和主窗口不一致。
+ * 各窗口必须一致:渲染进程目前依赖 nodeIntegration 直接 require('electron') 调 IPC,
+ * 二级窗口若单独改成 contextIsolation,现有 preload 又没启用,行为会和主窗口不一致。
  */
 export const sharedWebPreferences = {
   // webSecurity: false,
@@ -39,3 +39,28 @@ export function getSmartWindowOptions(): BrowserWindowConstructorOptions {
     icon: path.join(getBaseDir(), 'public', 'images', 'logo-32.png'),
   };
 }
+
+/** 权限管理窗口的默认尺寸与下限(与智能工作台同规格,管理表格需要足够宽度) */
+export const permWindowSize = {
+  width: 1280,
+  height: 860,
+  minWidth: 1280,
+  minHeight: 860,
+};
+
+/**
+ * 权限管理窗口选项。
+ *
+ * <p>与智能工作台一致:独立顶层窗口,不设 parent(Windows 下带 parent 会始终悬浮在主窗口之上)。
+ */
+export function getPermWindowOptions(): BrowserWindowConstructorOptions {
+  return {
+    title: '清鉴 · 权限管理',
+    ...permWindowSize,
+    webPreferences: { ...sharedWebPreferences },
+    frame: false,
+    show: false,
+    backgroundColor: '#ffffff',
+    icon: path.join(getBaseDir(), 'public', 'images', 'logo-32.png'),
+  };
+}

+ 43 - 2
ai-electron/electron/controller/windowCtl.ts

@@ -8,6 +8,12 @@ import {
   isSmartWindowOpen,
   openSmartWindow,
 } from '../service/window/smartWindow';
+import {
+  closePermWindow,
+  isPermWindow,
+  isPermWindowOpen,
+  openPermWindow,
+} from '../service/window/permWindow';
 
 /** 主进程 → 渲染进程的跨窗口状态事件通道 */
 export const SYNC_EVENT_CHANNEL = 'app:state';
@@ -22,6 +28,8 @@ interface OpenSmartWindowParams {
   navigateIfOpen?: boolean;
 }
 
+type OpenPermWindowParams = OpenSmartWindowParams;
+
 interface SyncStateParams {
   event?: {
     type?: string;
@@ -71,7 +79,39 @@ class WindowCtl {
     return { success: true, data: { open: isSmartWindowOpen() } };
   }
 
-  /** 智能窗口遇到登录失效时,把主窗口拉到前台负责提示 */
+  /** 打开/聚焦权限管理窗口;params { fullPath?, reloadIfOpen?, navigateIfOpen? } */
+  async openPermWindow(params: OpenPermWindowParams = {}) {
+    try {
+      openPermWindow({
+        fullPath: params?.fullPath,
+        reloadIfOpen: params?.reloadIfOpen === true,
+        navigateIfOpen: params?.navigateIfOpen === true,
+      });
+      return { success: true, data: { open: true } };
+    } catch (e) {
+      const message = toMessage(e);
+      logger.error('[windowCtl] openPermWindow failed:', message);
+      return { success: false, message };
+    }
+  }
+
+  /** 关闭权限管理窗口(已关闭时是 no-op) */
+  async closePermWindow() {
+    try {
+      closePermWindow();
+      return { success: true };
+    } catch (e) {
+      const message = toMessage(e);
+      logger.error('[windowCtl] closePermWindow failed:', message);
+      return { success: false, message };
+    }
+  }
+
+  async isPermWindowOpen() {
+    return { success: true, data: { open: isPermWindowOpen() } };
+  }
+
+  /** 二级窗口遇到登录失效时,把主窗口拉到前台负责提示 */
   async focusMainWindow() {
     try {
       focusMainWindow();
@@ -91,7 +131,8 @@ class WindowCtl {
    */
   async getWindowRole(_params: unknown, event?: IpcEventLike) {
     const win = event?.sender ? BrowserWindow.fromWebContents(event.sender) : null;
-    return { success: true, data: { role: isSmartWindow(win) ? 'smart' : 'main' } };
+    const role = isSmartWindow(win) ? 'smart' : isPermWindow(win) ? 'perm' : 'main';
+    return { success: true, data: { role } };
   }
 
   /**

+ 44 - 0
ai-electron/electron/service/window/permWindow.ts

@@ -0,0 +1,44 @@
+import type { BrowserWindow } from 'electron';
+import { getPermWindowOptions, permWindowSize } from '../../config/windowOptions';
+import { createSubWindowController, type SubWindowOpenOptions } from './subWindow';
+
+/** 权限管理窗口只承载权限中心,非该路径一律改写 */
+const PERM_WINDOW_PATH = '/perm-window';
+
+export type OpenPermWindowOptions = SubWindowOpenOptions;
+
+/** 单例:应用内最多一个权限管理窗口 */
+const permWindowController = createSubWindowController({
+  pathPrefix: PERM_WINDOW_PATH,
+  boundsKey: 'permWindowBounds',
+  minSize: permWindowSize,
+  createWindowOptions: getPermWindowOptions,
+  // 五个页面是不同路径段(/perm-window/user 等),点击入口时按目标地址导航
+  navigateOnlyWhenQuery: false,
+});
+
+export function getPermWindow(): BrowserWindow | null {
+  return permWindowController.getWindow();
+}
+
+export function isPermWindowOpen(): boolean {
+  return permWindowController.isOpen();
+}
+
+/** 判断某个窗口是不是权限管理窗口(IPC 解析窗口角色用) */
+export function isPermWindow(win: BrowserWindow | null | undefined): boolean {
+  return permWindowController.matches(win);
+}
+
+export function openPermWindow(options: OpenPermWindowOptions = {}): BrowserWindow {
+  return permWindowController.open(options);
+}
+
+export function closePermWindow(): void {
+  permWindowController.close();
+}
+
+/** 把已打开的权限窗口拉到前台;没打开返回 false */
+export function focusPermWindow(): boolean {
+  return permWindowController.focus();
+}

+ 18 - 187
ai-electron/electron/service/window/smartWindow.ts

@@ -1,49 +1,38 @@
-import path from 'path';
-import { BrowserWindow, screen } from 'electron';
-import { getBaseDir, isDev } from 'ee-core/ps';
+import { BrowserWindow } from 'electron';
 import { logger } from 'ee-core/log';
 import { getMainWindow } from 'ee-core/electron';
 import { getSmartWindowOptions, smartWindowSize } from '../../config/windowOptions';
-import { localSettingsService } from '../setting/localSettings';
+import { createSubWindowController, focusWindow, type SubWindowOpenOptions } from './subWindow';
 
-/** 窗口 bounds 在本机设置里的键名 */
-const BOUNDS_KEY = 'smartWindowBounds';
 /** 智能窗口只承载工作台,非该路径一律改写 */
 const WORKBENCH_PATH = '/workbench';
 /** 主进程 → 主窗口的窗口开关状态通道 */
 export const SMART_WINDOW_STATE_CHANNEL = 'smart-window:state';
 
-export interface OpenSmartWindowOptions {
-  /** 完整路由(含 query),如 /workbench?newChat=1 */
-  fullPath?: string;
-  /** 窗口已存在时是否整窗重载(换案后需要重新读案件上下文) */
-  reloadIfOpen?: boolean;
-  /** 窗口已存在且目标带 query 时,是否导航到该地址(?newChat=1 / ?view=agent 这类明确意图) */
-  navigateIfOpen?: boolean;
-}
-
-interface SavedBounds {
-  x: number;
-  y: number;
-  width: number;
-  height: number;
-}
+export type OpenSmartWindowOptions = SubWindowOpenOptions;
 
 /** 单例:应用内最多一个智能工作台窗口 */
-let smartWindow: BrowserWindow | null = null;
+const smartWindowController = createSubWindowController({
+  pathPrefix: WORKBENCH_PATH,
+  boundsKey: 'smartWindowBounds',
+  minSize: smartWindowSize,
+  createWindowOptions: getSmartWindowOptions,
+  stateChannel: SMART_WINDOW_STATE_CHANNEL,
+  // 工作台普通打开只聚焦;?newChat=1 / ?view=agent 这类明确意图才导航
+  navigateOnlyWhenQuery: true,
+});
 
 export function getSmartWindow(): BrowserWindow | null {
-  return smartWindow && !smartWindow.isDestroyed() ? smartWindow : null;
+  return smartWindowController.getWindow();
 }
 
 export function isSmartWindowOpen(): boolean {
-  return !!getSmartWindow();
+  return smartWindowController.isOpen();
 }
 
 /** 判断某个窗口是不是智能工作台窗口(IPC 解析窗口角色用) */
 export function isSmartWindow(win: BrowserWindow | null | undefined): boolean {
-  const current = getSmartWindow();
-  return !!win && !!current && win.id === current.id;
+  return smartWindowController.matches(win);
 }
 
 /**
@@ -52,69 +41,16 @@ export function isSmartWindow(win: BrowserWindow | null | undefined): boolean {
  * 已存在时只做 restore/show/focus(reloadIfOpen 时再 reload),保证单例。
  */
 export function openSmartWindow(options: OpenSmartWindowOptions = {}): BrowserWindow {
-  const fullPath = normalizeFullPath(options.fullPath);
-  const existing = getSmartWindow();
-
-  if (existing) {
-    focusWindow(existing);
-
-    if (options.reloadIfOpen) {
-      // 刚由本次导航创建、还在加载时不用再刷一次;已加载完成的才需要按新案件重建
-      if (!existing.webContents.isLoading()) {
-        existing.webContents.reload();
-      }
-    } else if (options.navigateIfOpen && fullPath.includes('?')) {
-      // 显式带 query(?newChat=1 / ?view=agent)说明是明确的导航意图;
-      // 普通打开/聚焦不动它当前所在的视图
-      loadRenderer(existing, fullPath);
-    }
-    return existing;
-  }
-
-  const win = new BrowserWindow({
-    ...getSmartWindowOptions(),
-    ...restoreBounds(),
-  });
-  smartWindow = win;
-
-  win.once('ready-to-show', () => {
-    if (!win.isDestroyed()) {
-      focusWindow(win);
-    }
-  });
-
-  win.on('close', () => saveBounds(win));
-  win.on('closed', () => {
-    if (smartWindow === win) smartWindow = null;
-    notifyState(false);
-  });
-
-  // 渲染进程崩溃后留一个空壳没有意义:销毁它,下次点「智能」重新创建
-  win.webContents.on('render-process-gone', (_event, details) => {
-    logger.error('[smartWindow] render-process-gone:', details?.reason);
-    if (!win.isDestroyed()) {
-      saveBounds(win);
-      win.destroy();
-    }
-  });
-
-  loadRenderer(win, fullPath);
-  notifyState(true);
-  return win;
+  return smartWindowController.open(options);
 }
 
 export function closeSmartWindow(): void {
-  const win = getSmartWindow();
-  if (!win) return;
-  win.close();
+  smartWindowController.close();
 }
 
 /** 把已打开的智能窗口拉到前台;没打开返回 false */
 export function focusSmartWindow(): boolean {
-  const win = getSmartWindow();
-  if (!win) return false;
-  focusWindow(win);
-  return true;
+  return smartWindowController.focus();
 }
 
 /** 把主窗口拉到前台(智能窗口遇到登录/授权失效时,由主窗口负责提示) */
@@ -125,108 +61,3 @@ export function focusMainWindow(): void {
     logger.warn('[smartWindow] focusMainWindow failed:', e instanceof Error ? e.message : String(e));
   }
 }
-
-function focusWindow(win: BrowserWindow): void {
-  if (win.isMinimized()) win.restore();
-  win.show();
-  win.moveTop();
-  win.focus();
-}
-
-function normalizeFullPath(fullPath?: string): string {
-  const raw = typeof fullPath === 'string' ? fullPath.trim() : '';
-  if (!raw) return WORKBENCH_PATH;
-  // 只接受工作台地址,避免把业务页塞进智能窗口(如 /workbenchfoo 不算)
-  return /^\/workbench(\/|\?|$)/.test(raw) ? raw : WORKBENCH_PATH;
-}
-
-function loadRenderer(win: BrowserWindow, fullPath: string): void {
-  const devServerUrl = resolveDevServerUrl();
-  if (devServerUrl) {
-    win.loadURL(`${devServerUrl}${fullPath}`).catch((err) => {
-      logger.error('[smartWindow] loadURL failed:', err);
-    });
-    return;
-  }
-
-  // 生产是 file:// + hash 路由:hash 带上完整路径与 query
-  const indexPath = path.join(getBaseDir(), 'public', 'dist', 'index.html');
-  win.loadFile(indexPath, { hash: fullPath }).catch((err) => {
-    logger.error('[smartWindow] loadFile failed:', err);
-  });
-}
-
-/**
- * 开发环境的前端地址:与 ee-core 加载主窗口同口径,端口来自 cmd/bin.js 的 dev.frontend.port。
- * 生产环境(或读不到配置)返回 null,走 loadFile。
- */
-function resolveDevServerUrl(): string | null {
-  if (!isDev()) return null;
-
-  try {
-    // eslint-disable-next-line @typescript-eslint/no-var-requires
-    const binConfig = require(path.join(getBaseDir(), 'cmd', 'bin.js'));
-    const frontend = binConfig?.dev?.frontend || {};
-    const protocol = typeof frontend.protocol === 'string' ? frontend.protocol : 'http://';
-    if (protocol === 'file://') return null;
-    const hostname = typeof frontend.hostname === 'string' ? frontend.hostname : 'localhost';
-    const port = Number(frontend.port) || 3100;
-    return `${protocol}${hostname}:${port}`;
-  } catch (e) {
-    logger.warn('[smartWindow] 读取 cmd/bin.js 失败,回退 http://localhost:3100');
-    return 'http://localhost:3100';
-  }
-}
-
-function saveBounds(win: BrowserWindow): void {
-  try {
-    const { x, y, width, height } = win.getBounds();
-    localSettingsService.set(BOUNDS_KEY, JSON.stringify({ x, y, width, height }));
-  } catch (e) {
-    logger.warn('[smartWindow] 保存窗口位置失败:', e instanceof Error ? e.message : String(e));
-  }
-}
-
-/** 恢复上次的位置与大小;越界或尺寸不合法时交给 Electron 默认放置 */
-function restoreBounds(): Partial<SavedBounds> {
-  try {
-    const raw = localSettingsService.get(BOUNDS_KEY);
-    if (!raw) return {};
-
-    const parsed = JSON.parse(raw) as Partial<SavedBounds>;
-    const { x, y, width, height } = parsed || {};
-    if (![x, y, width, height].every((value) => typeof value === 'number' && Number.isFinite(value))) {
-      return {};
-    }
-    if ((width as number) < smartWindowSize.minWidth || (height as number) < smartWindowSize.minHeight) {
-      return {};
-    }
-
-    // 显示器拔掉/分辨率变化后,旧坐标可能落在屏幕外
-    const visible = screen.getAllDisplays().some((display) => {
-      const area = display.workArea;
-      return (
-        (x as number) < area.x + area.width &&
-        (x as number) + (width as number) > area.x &&
-        (y as number) < area.y + area.height &&
-        (y as number) + (height as number) > area.y
-      );
-    });
-
-    return visible ? { x, y, width, height } : {};
-  } catch (e) {
-    logger.warn('[smartWindow] 恢复窗口位置失败:', e instanceof Error ? e.message : String(e));
-    return {};
-  }
-}
-
-function notifyState(open: boolean): void {
-  try {
-    const main = getMainWindow();
-    if (!main.isDestroyed() && !main.webContents.isDestroyed()) {
-      main.webContents.send(SMART_WINDOW_STATE_CHANNEL, { open });
-    }
-  } catch {
-    // 主窗口尚未创建或应用正在退出:忽略
-  }
-}

+ 256 - 0
ai-electron/electron/service/window/subWindow.ts

@@ -0,0 +1,256 @@
+import path from 'path';
+import type { BrowserWindowConstructorOptions } from 'electron';
+import { BrowserWindow, screen } from 'electron';
+import { getBaseDir, isDev } from 'ee-core/ps';
+import { logger } from 'ee-core/log';
+import { getMainWindow } from 'ee-core/electron';
+import { localSettingsService } from '../setting/localSettings';
+
+export interface SubWindowOpenOptions {
+  /** 完整路由(含 query),如 /workbench?newChat=1 */
+  fullPath?: string;
+  /** 窗口已存在时是否整窗重载(换案后需要重新读案件上下文) */
+  reloadIfOpen?: boolean;
+  /** 窗口已存在时是否导航到目标地址(显式导航意图) */
+  navigateIfOpen?: boolean;
+}
+
+export interface SubWindowDefinition {
+  /** 允许的路径前缀,如 /workbench、/perm-window;其余地址一律改写到该前缀 */
+  pathPrefix: string;
+  /** 本机设置里保存 bounds 的键名 */
+  boundsKey: string;
+  /** 新建窗口与恢复 bounds 时的最小尺寸 */
+  minSize: { minWidth: number; minHeight: number };
+  /** 创建 BrowserWindow 的选项(标题 / 尺寸 / webPreferences 等) */
+  createWindowOptions: () => BrowserWindowConstructorOptions;
+  /** 打开 / 关闭时通知主窗口的通道;不传则不通知 */
+  stateChannel?: string;
+  /**
+   * 已存在窗口时,仅当目标带 query 才导航。
+   *
+   * <p>智能工作台沿用该旧规则:普通打开/聚焦不动它当前所在的视图,
+   * 只有 ?newChat=1 / ?view=agent 这类明确意图才跳转。
+   */
+  navigateOnlyWhenQuery?: boolean;
+}
+
+export interface SubWindowController {
+  getWindow(): BrowserWindow | null;
+  isOpen(): boolean;
+  /** 判断某个窗口是不是本控制器创建的单例窗口(IPC 解析窗口角色用) */
+  matches(win: BrowserWindow | null | undefined): boolean;
+  open(options?: SubWindowOpenOptions): BrowserWindow;
+  close(): void;
+  /** 把已打开的窗口拉到前台;没打开返回 false */
+  focus(): boolean;
+}
+
+interface SavedBounds {
+  x: number;
+  y: number;
+  width: number;
+  height: number;
+}
+
+function escapeRegExp(value: string): string {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+
+/** 把任意窗口拉到前台(最小化时先还原) */
+export function focusWindow(win: BrowserWindow): void {
+  if (win.isMinimized()) win.restore();
+  win.show();
+  win.moveTop();
+  win.focus();
+}
+
+/**
+ * 创建一个单例子窗口控制器。
+ *
+ * <p>把智能工作台窗口的既有行为原样抽出来(单例、聚焦、bounds 落盘、
+ * 渲染进程崩溃自愈、dev/prod 两套加载方式),供智能工作台与权限管理窗口共用。
+ */
+export function createSubWindowController(definition: SubWindowDefinition): SubWindowController {
+  const pathPattern = new RegExp(`^${escapeRegExp(definition.pathPrefix)}(?:/|\\?|$)`);
+  const logPrefix = `[${definition.pathPrefix}]`;
+  let win: BrowserWindow | null = null;
+
+  const getWindow = (): BrowserWindow | null => (win && !win.isDestroyed() ? win : null);
+
+  function normalizeFullPath(fullPath?: string): string {
+    const raw = typeof fullPath === 'string' ? fullPath.trim() : '';
+    if (!raw) return definition.pathPrefix;
+    // 只接受该窗口承载的地址,避免把业务页塞进来(如 /workbenchfoo 不算)
+    return pathPattern.test(raw) ? raw : definition.pathPrefix;
+  }
+
+  function open(options: SubWindowOpenOptions = {}): BrowserWindow {
+    const fullPath = normalizeFullPath(options.fullPath);
+    const existing = getWindow();
+
+    if (existing) {
+      focusWindow(existing);
+
+      if (options.reloadIfOpen) {
+        // 刚由本次导航创建、还在加载时不用再刷一次;已加载完成的才需要按新上下文重建
+        if (!existing.webContents.isLoading()) {
+          existing.webContents.reload();
+        }
+      } else if (
+        options.navigateIfOpen &&
+        (!definition.navigateOnlyWhenQuery || fullPath.includes('?'))
+      ) {
+        loadRenderer(existing, fullPath);
+      }
+      return existing;
+    }
+
+    const created = new BrowserWindow({
+      ...definition.createWindowOptions(),
+      ...restoreBounds(),
+    });
+    win = created;
+
+    created.once('ready-to-show', () => {
+      if (!created.isDestroyed()) {
+        focusWindow(created);
+      }
+    });
+
+    created.on('close', () => saveBounds(created));
+    created.on('closed', () => {
+      if (win === created) win = null;
+      notifyState(false);
+    });
+
+    // 渲染进程崩溃后留一个空壳没有意义:销毁它,下次点击重新创建
+    created.webContents.on('render-process-gone', (_event, details) => {
+      logger.error(`${logPrefix} render-process-gone:`, details?.reason);
+      if (!created.isDestroyed()) {
+        saveBounds(created);
+        created.destroy();
+      }
+    });
+
+    loadRenderer(created, fullPath);
+    notifyState(true);
+    return created;
+  }
+
+  function close(): void {
+    getWindow()?.close();
+  }
+
+  function focus(): boolean {
+    const current = getWindow();
+    if (!current) return false;
+    focusWindow(current);
+    return true;
+  }
+
+  function loadRenderer(target: BrowserWindow, fullPath: string): void {
+    const devServerUrl = resolveDevServerUrl();
+    if (devServerUrl) {
+      target.loadURL(`${devServerUrl}${fullPath}`).catch((err) => {
+        logger.error(`${logPrefix} loadURL failed:`, err);
+      });
+      return;
+    }
+
+    // 生产是 file:// + hash 路由:hash 带上完整路径与 query
+    const indexPath = path.join(getBaseDir(), 'public', 'dist', 'index.html');
+    target.loadFile(indexPath, { hash: fullPath }).catch((err) => {
+      logger.error(`${logPrefix} loadFile failed:`, err);
+    });
+  }
+
+  function saveBounds(target: BrowserWindow): void {
+    try {
+      const { x, y, width, height } = target.getBounds();
+      localSettingsService.set(definition.boundsKey, JSON.stringify({ x, y, width, height }));
+    } catch (e) {
+      logger.warn(`${logPrefix} 保存窗口位置失败:`, e instanceof Error ? e.message : String(e));
+    }
+  }
+
+  /** 恢复上次的位置与大小;越界或尺寸不合法时交给 Electron 默认放置 */
+  function restoreBounds(): Partial<SavedBounds> {
+    try {
+      const raw = localSettingsService.get(definition.boundsKey);
+      if (!raw) return {};
+
+      const parsed = JSON.parse(raw) as Partial<SavedBounds>;
+      const { x, y, width, height } = parsed || {};
+      if (![x, y, width, height].every((value) => typeof value === 'number' && Number.isFinite(value))) {
+        return {};
+      }
+      if ((width as number) < definition.minSize.minWidth || (height as number) < definition.minSize.minHeight) {
+        return {};
+      }
+
+      // 显示器拔掉/分辨率变化后,旧坐标可能落在屏幕外
+      const visible = screen.getAllDisplays().some((display) => {
+        const area = display.workArea;
+        return (
+          (x as number) < area.x + area.width &&
+          (x as number) + (width as number) > area.x &&
+          (y as number) < area.y + area.height &&
+          (y as number) + (height as number) > area.y
+        );
+      });
+
+      return visible ? { x, y, width, height } : {};
+    } catch (e) {
+      logger.warn(`${logPrefix} 恢复窗口位置失败:`, e instanceof Error ? e.message : String(e));
+      return {};
+    }
+  }
+
+  function notifyState(open: boolean): void {
+    const channel = definition.stateChannel;
+    if (!channel) return;
+    try {
+      const main = getMainWindow();
+      if (!main.isDestroyed() && !main.webContents.isDestroyed()) {
+        main.webContents.send(channel, { open });
+      }
+    } catch {
+      // 主窗口尚未创建或应用正在退出:忽略
+    }
+  }
+
+  return {
+    getWindow,
+    isOpen: () => !!getWindow(),
+    matches: (target) => {
+      const current = getWindow();
+      return !!target && !!current && target.id === current.id;
+    },
+    open,
+    close,
+    focus,
+  };
+}
+
+/**
+ * 开发环境的前端地址:与 ee-core 加载主窗口同口径,端口来自 cmd/bin.js 的 dev.frontend.port。
+ * 生产环境(或读不到配置)返回 null,走 loadFile。
+ */
+function resolveDevServerUrl(): string | null {
+  if (!isDev()) return null;
+
+  try {
+    // eslint-disable-next-line @typescript-eslint/no-var-requires
+    const binConfig = require(path.join(getBaseDir(), 'cmd', 'bin.js'));
+    const frontend = binConfig?.dev?.frontend || {};
+    const protocol = typeof frontend.protocol === 'string' ? frontend.protocol : 'http://';
+    if (protocol === 'file://') return null;
+    const hostname = typeof frontend.hostname === 'string' ? frontend.hostname : 'localhost';
+    const port = Number(frontend.port) || 3100;
+    return `${protocol}${hostname}:${port}`;
+  } catch (e) {
+    logger.warn('[subWindow] 读取 cmd/bin.js 失败,回退 http://localhost:3100');
+    return 'http://localhost:3100';
+  }
+}

+ 4 - 0
ai-electron/frontend/src/core/components/Application/index.ts

@@ -10,6 +10,7 @@ import appDarkModeToggle from './src/AppDarkModeToggle.vue';
 import appWorkbenchToggle from './src/AppWorkbenchToggle.vue';
 import appTopBar from './src/AppTopBar.vue';
 import appDownloadManager from './src/AppDownloadManager.vue';
+import appPermCenterButton from './src/AppPermCenterButton.vue';
 
 export { useAppProviderContext } from './src/useAppContext';
 
@@ -24,6 +25,9 @@ export const AppTopBar = withInstall(appTopBar);
 // 下载管理器(顶栏设置图标前):下载记录 + 下载目录设置
 export const AppDownloadManager = withInstall(appDownloadManager);
 
+// 权限管理(顶栏设置图标前):仅有权用户可见,打开独立权限中心窗口
+export const AppPermCenterButton = withInstall(appPermCenterButton);
+
 // 无边框窗口的标题栏:与主界面 LayoutHeader 同款外观(logo + 操作区 + 窗口控制)
 export const AppHeader = withInstall(appHeader);
 

+ 10 - 8
ai-electron/frontend/src/core/components/Application/src/AppDownloadManager.vue

@@ -1,12 +1,14 @@
 <template>
-  <div
-    :class="['jeesite-header-action-button', `${prefixCls}-trigger`, { 'is-busy': activeCount > 0 }]"
-    @click="openModal(true)"
-  >
-    <span class="dl-trigger__icon"><Icon icon="i-mdi:download-outline" :size="20" /></span>
-    <span v-if="activeCount > 0" class="dl-trigger__badge">{{ activeCount }}</span>
-    <span v-else-if="items.length" class="dl-trigger__dot"></span>
-  </div>
+  <Tooltip title="下载管理" placement="bottom" :mouseEnterDelay="0.5">
+    <div
+      :class="['jeesite-header-action-button', `${prefixCls}-trigger`, { 'is-busy': activeCount > 0 }]"
+      @click="openModal(true)"
+    >
+      <span class="dl-trigger__icon"><Icon icon="i-mdi:download-outline" :size="20" /></span>
+      <span v-if="activeCount > 0" class="dl-trigger__badge">{{ activeCount }}</span>
+      <span v-else-if="items.length" class="dl-trigger__dot"></span>
+    </div>
+  </Tooltip>
 
   <BasicModal v-bind="$attrs" title="下载管理" :width="720" :centered="true" :footer="null" @register="registerModal">
     <div :class="prefixCls">

+ 35 - 0
ai-electron/frontend/src/core/components/Application/src/AppPermCenterButton.vue

@@ -0,0 +1,35 @@
+<template>
+  <Tooltip v-if="visible" title="权限管理" placement="bottom" :mouseEnterDelay="0.5">
+    <Button type="text" class="jeesite-header-action-button" aria-label="权限管理" @click="handleClick">
+      <Icon icon="i-mdi:shield-account-outline" />
+    </Button>
+  </Tooltip>
+</template>
+
+<script lang="ts" setup name="AppPermCenterButton">
+  import { computed } from 'vue';
+  import { Button, Tooltip } from 'ant-design-vue';
+  import { Icon } from '@/core/components/Icon';
+  import { useMessage } from '@/core/hooks/web/useMessage';
+  import { usePermission } from '@/core/hooks/web/usePermission';
+  import { openPermCenter } from '@/core/logics/permWindow';
+  import { PERM_CENTER_PAGES, PERM_CENTER_PERMISSIONS } from '@/perm/config';
+
+  const { hasPermission } = usePermission();
+  const { createMessage } = useMessage();
+
+  /** 只对拥有任一权限管理页面权限的账号展示(超管 *:*:* 全量通过) */
+  const visible = computed(() => hasPermission(PERM_CENTER_PERMISSIONS));
+
+  /** 打开第一个有权页面;窗口已打开时只聚焦,不打断用户当前所在页 */
+  const defaultPath = computed(() => PERM_CENTER_PAGES.find((page) => hasPermission(page.permission))?.path);
+
+  async function handleClick() {
+    if (!defaultPath.value) return;
+    // 不加 loading 态:打开窗口是瞬时动作,主进程侧也是单例幂等,转圈反而打断点击反馈
+    const result = await openPermCenter({ fullPath: defaultPath.value });
+    if (result === 'failed') {
+      createMessage.error('打开权限管理失败,请重试');
+    }
+  }
+</script>

+ 7 - 5
ai-electron/frontend/src/core/components/Application/src/WindowControls.vue

@@ -38,16 +38,18 @@
   import { useDesign } from '@/core/hooks/web/useDesign';
   import { useMessage } from '@/core/hooks/web/useMessage';
   import { useElectronWindow } from '@/core/hooks/desktop/useElectronWindow';
-  import { isSmartWindow } from '@/core/logics/appWindow';
+  import { isPermWindow, isSmartWindow } from '@/core/logics/appWindow';
 
   const { prefixCls } = useDesign('window-controls');
   const { available, maximized, minimize, toggleMaximize, closeToTray } = useElectronWindow();
   const { createConfirm } = useMessage();
 
-  /** 主窗口关闭是收进托盘;智能窗口关闭就是真关闭,且会中止进行中的任务 */
-  const closeTitle = computed(() =>
-    isSmartWindow() ? '关闭(进行中的对话/任务会中止)' : '关闭(最小化到托盘)',
-  );
+  /** 主窗口关闭是收进托盘;智能窗口关闭会中止任务;权限窗口就是普通关闭 */
+  const closeTitle = computed(() => {
+    if (isSmartWindow()) return '关闭(进行中的对话/任务会中止)';
+    if (isPermWindow()) return '关闭';
+    return '关闭(最小化到托盘)';
+  });
 
   /**
    * 智能工作台的关闭要先确认:关窗会中止正在流式输出的对话/任务。

+ 2 - 0
ai-electron/frontend/src/core/enums/pageEnum.ts

@@ -7,6 +7,8 @@ export enum PageEnum {
   LEGACY_LOGIN = '/login',
   BASE_CASE = '/case',
   BASE_WORKBENCH = '/workbench',
+  // 权限管理独立窗口(Electron 下由子窗口承载;浏览器降级为同窗口全屏)
+  BASE_PERM_WINDOW = '/perm-window',
   // basic home path
   BASE_HOME = '/data/index',
   BASE_UPLOAD = '/data/upload',

+ 2 - 2
ai-electron/frontend/src/core/hooks/desktop/useElectronWindow.ts

@@ -26,8 +26,8 @@ function resolveIpcRenderer(): IpcRendererLike | null {
 /**
  * 无边框窗口(frame: false)的控制能力。
  *
- * <p>关闭语义按窗口区分:主窗口被 tray.js 拦截为「收进托盘」;智能工作台窗口没有该拦截,
- * close 即销毁(下次点「智能」重建)。主进程按 IPC 发起方定位窗口,见 osCtl.resolveSenderWindow。
+ * <p>关闭语义按窗口区分:主窗口被 tray.js 拦截为「收进托盘」;智能工作台 / 权限管理窗口
+ * 没有该拦截,close 即销毁(下次点入口重建)。主进程按 IPC 发起方定位窗口,见 osCtl.resolveSenderWindow。
  */
 export function useElectronWindow() {
   const ipcRenderer = resolveIpcRenderer();

+ 21 - 2
ai-electron/frontend/src/core/layouts/default/header/components/user-dropdown/index.vue

@@ -42,7 +42,14 @@
   import { DownOutlined, LockOutlined, PoweroffOutlined } from '@ant-design/icons-vue';
   import { PageEnum } from '@/core/enums/pageEnum';
   import { useMessage } from '@/core/hooks/web/useMessage';
-  import { broadcastSync } from '@/core/logics/appWindow';
+  import {
+    broadcastSync,
+    closePermWindow,
+    closeSmartWindow,
+    focusMainWindow,
+    isPermWindow,
+    isSmartWindow,
+  } from '@/core/logics/appWindow';
   import { useAccountStore } from '@/core/store/modules/account';
   import { useUserStore } from '@/core/store/modules/case';
 
@@ -88,8 +95,20 @@
       async function doLogout() {
         caseStore.resetState();
         await accountStore.logout();
-        // 智能窗口没有账号入口,收到后关闭自己;主窗口保持唯一的登录提示/跳转方
+        // 二级窗口收到后关闭自己;主窗口保持唯一的登录提示/跳转方
         broadcastSync({ type: 'APP_RESET', payload: { reason: 'account-logged-out' } });
+
+        // 二级窗口没有登录入口:改密/注销后关闭自己,把重新登录交给主窗口
+        if (isSmartWindow() || isPermWindow()) {
+          await focusMainWindow();
+          if (isSmartWindow()) {
+            void closeSmartWindow();
+          } else {
+            void closePermWindow();
+          }
+          return;
+        }
+
         await router.replace({ path: PageEnum.BASE_AUTHORIZATION });
       }
 

+ 10 - 1
ai-electron/frontend/src/core/layouts/default/header/index.vue

@@ -49,6 +49,9 @@
       <!-- 下载管理器:放在设置图标前面 -->
       <AppDownloadManager />
 
+      <!-- 权限管理:放在设置图标前面,仅有权用户可见 -->
+      <AppPermCenterButton />
+
       <SettingDrawer v-if="getShowSetting" />
     </template>
   </AppTopBar>
@@ -62,7 +65,12 @@
   import { useRoute } from 'vue-router';
   import { propTypes } from '@/core/utils/propTypes';
   import { Button, Tooltip } from 'ant-design-vue';
-  import { AppDownloadManager, AppTopBar, AppWorkbenchToggle } from '@/core/components/Application';
+  import {
+    AppDownloadManager,
+    AppPermCenterButton,
+    AppTopBar,
+    AppWorkbenchToggle,
+  } from '@/core/components/Application';
   import { AppSearch } from '@/core/components/Application';
   import { Icon } from '@/core/components/Icon';
   import { PageEnum } from '@/core/enums/pageEnum';
@@ -104,6 +112,7 @@
       AppSearch,
       ErrorAction,
       AppDownloadManager,
+      AppPermCenterButton,
       SettingDrawer,
       Tooltip,
       Icon,

+ 8 - 5
ai-electron/frontend/src/core/layouts/default/setting/index.vue

@@ -1,11 +1,14 @@
 <template>
-  <div class="jeesite-header-action-button" :class="{ 'is-active': drawerOpen }" @click="openDrawer(true)">
-    <Icon icon="i-ion:settings-outline" />
-    <SettingDrawer @register="register" />
-  </div>
+  <Tooltip title="设置" placement="bottom" :mouseEnterDelay="0.5">
+    <div class="jeesite-header-action-button" :class="{ 'is-active': drawerOpen }" @click="openDrawer(true)">
+      <Icon icon="i-ion:settings-outline" />
+      <SettingDrawer @register="register" />
+    </div>
+  </Tooltip>
 </template>
 <script lang="ts">
   import { defineComponent, computed, onBeforeUnmount, onMounted } from 'vue';
+  import { Tooltip } from 'ant-design-vue';
   import SettingDrawer from './SettingDrawer';
   import { Icon } from '@/core/components/Icon';
   import { OPEN_SETTING_DRAWER_EVENT } from '@/core/logics/caseConfigGuide';
@@ -14,7 +17,7 @@
 
   export default defineComponent({
     name: 'SettingButton',
-    components: { SettingDrawer, Icon },
+    components: { SettingDrawer, Tooltip, Icon },
     setup() {
       const [register, { openDrawer, getOpen }] = useDrawer();
       // useDrawer 的返回类型里 getOpen 可能为 undefined,这里做空值兜底

+ 81 - 9
ai-electron/frontend/src/core/logics/appWindow.ts

@@ -1,23 +1,30 @@
 import { nextTick } from 'vue';
 import { router } from '@/core/router';
 import { CASE_INFO_KEY } from '@/core/enums/cacheEnum';
+import { PageEnum } from '@/core/enums/pageEnum';
 import { getAuthCache } from '@/core/utils/auth';
 import { setPersistOnUnload } from '@/core/utils/cache/persistent';
-import { invokeIpc, onIpc, resolveIpcRenderer } from '@/core/utils/desktop/ipcRenderer';
+import { invokeIpc, isDesktopEnv, onIpc } from '@/core/utils/desktop/ipcRenderer';
 import type { CaseInfo } from '@/plat/api/case/caseApi';
 
 /** 智能工作台的全屏路由 */
 export const WORKBENCH_PATH = '/workbench';
+/** 权限管理独立窗口 / 同窗口全屏页的路由 */
+export const PERM_WINDOW_PATH = PageEnum.BASE_PERM_WINDOW;
 
-export type AppWindowRole = 'main' | 'smart';
+export type AppWindowRole = 'main' | 'smart' | 'perm';
 
 /** openSmartWindow 的结果:调用方据此决定提示或导航 */
 export type OpenSmartWindowResult = 'opened' | 'navigated' | 'no-case' | 'failed';
+/** openPermWindow 的结果:权限管理不依赖案件,没有 no-case */
+export type OpenPermWindowResult = 'opened' | 'navigated' | 'failed';
 
-/** 主进程 → 渲染进程的跨窗口状态事件(只保留两种语义) */
+/** 主进程 → 渲染进程的跨窗口状态事件(只保留语义,不承载业务数据) */
 export type SyncEvent =
   | { type: 'APP_RESET'; payload: { reason: 'case-exited' | 'account-logged-out' } }
-  | { type: 'AUTH_INVALID'; payload: { kind: 'unauthorized' | 'license'; message: string } };
+  | { type: 'AUTH_INVALID'; payload: { kind: 'unauthorized' | 'license'; message: string } }
+  /** 菜单管理保存/删除后通知主窗口重建导航 */
+  | { type: 'MENU_CHANGED' };
 
 export interface OpenSmartWindowOptions {
   /** 完整路由(含 query),默认 /workbench */
@@ -28,6 +35,15 @@ export interface OpenSmartWindowOptions {
   navigateIfOpen?: boolean;
 }
 
+export interface OpenPermWindowOptions {
+  /** 完整路由,默认 /perm-window */
+  fullPath?: string;
+  /** 窗口已存在时是否导航到目标页(点侧栏/直链进入指定权限页) */
+  navigateIfOpen?: boolean;
+  /** 窗口已存在时是否整窗重载 */
+  reloadIfOpen?: boolean;
+}
+
 const WINDOW_CTL = 'windowCtl';
 const SYNC_EVENT_CHANNEL = 'app:state';
 
@@ -38,7 +54,7 @@ let desktopAvailable: boolean | null = null;
 /** 是否在桌面客户端里(浏览器打开前端时所有窗口能力都退化为单窗口) */
 export function isDesktop(): boolean {
   if (desktopAvailable === null) {
-    desktopAvailable = !!resolveIpcRenderer();
+    desktopAvailable = isDesktopEnv();
   }
   return desktopAvailable;
 }
@@ -51,11 +67,16 @@ export function isSmartWindow(): boolean {
   return role === 'smart';
 }
 
+/** 权限管理窗口:只承载权限中心,账号/凭据失效时关闭自己 */
+export function isPermWindow(): boolean {
+  return role === 'perm';
+}
+
 /**
  * bootstrap 阶段解析一次窗口角色。
  *
  * <p>不靠 URL query 判断:路由会被 router.replace 改写,query 会丢;
- * 由主进程按 IPC 发起方和智能窗口单例比对,最稳。
+ * 由主进程按 IPC 发起方和二级窗口单例比对,最稳。
  */
 export async function initWindowRole(): Promise<AppWindowRole> {
   if (roleInitialized) return role;
@@ -67,7 +88,8 @@ export async function initWindowRole(): Promise<AppWindowRole> {
         undefined,
         WINDOW_CTL,
       );
-      role = res?.data?.role === 'smart' ? 'smart' : 'main';
+      const rawRole = res?.data?.role;
+      role = rawRole === 'smart' || rawRole === 'perm' ? rawRole : 'main';
     } catch (e) {
       // IPC 失败按主窗口处理:宁可少一个独立窗口,也不能让页面起不来
       console.warn('[appWindow] 解析窗口角色失败,按主窗口处理:', e);
@@ -76,8 +98,8 @@ export async function initWindowRole(): Promise<AppWindowRole> {
   }
 
   roleInitialized = true;
-  // 智能窗口是只读客户端:卸载时不能把旧快照写回共享缓存(会覆盖主窗口刚写入的新案件)
-  setPersistOnUnload(!isSmartWindow());
+  // 二级窗口是只读客户端:卸载时不能把旧快照写回共享缓存(会覆盖主窗口刚写入的新状态)
+  setPersistOnUnload(role === 'main');
   return role;
 }
 
@@ -172,6 +194,56 @@ export async function isSmartWindowOpen(): Promise<boolean> {
   }
 }
 
+/**
+ * 打开/聚焦权限管理窗口。
+ *
+ * <p>桌面端走 IPC 开独立窗口;浏览器端退化为同窗口全屏页。
+ * 权限管理不依赖案件;浏览器降级用 push 保留返回路径(权限中心没有模式开关可回主界面)。
+ */
+export async function openPermWindow(options: OpenPermWindowOptions = {}): Promise<OpenPermWindowResult> {
+  const fullPath = options.fullPath || PERM_WINDOW_PATH;
+
+  if (!isDesktop()) {
+    await router.push(fullPath);
+    return 'navigated';
+  }
+
+  try {
+    const res = await invokeIpc<{ success?: boolean }>(
+      'openPermWindow',
+      {
+        fullPath,
+        reloadIfOpen: options.reloadIfOpen === true,
+        navigateIfOpen: options.navigateIfOpen === true,
+      },
+      WINDOW_CTL,
+    );
+    return res?.success === false ? 'failed' : 'opened';
+  } catch (e) {
+    console.warn('[appWindow] 打开权限管理窗口失败:', e);
+    return 'failed';
+  }
+}
+
+export async function closePermWindow(): Promise<void> {
+  if (!isDesktop()) return;
+  try {
+    await invokeIpc('closePermWindow', undefined, WINDOW_CTL);
+  } catch (e) {
+    console.warn('[appWindow] 关闭权限管理窗口失败:', e);
+  }
+}
+
+export async function isPermWindowOpen(): Promise<boolean> {
+  if (!isDesktop()) return false;
+  try {
+    const res = await invokeIpc<{ data?: { open?: boolean } }>('isPermWindowOpen', undefined, WINDOW_CTL);
+    return res?.data?.open === true;
+  } catch {
+    return false;
+  }
+}
+
 /** 广播共享状态变化;主进程会转发给除自己外的所有窗口 */
 export function broadcastSync(event: SyncEvent): void {
   if (!isDesktop()) return;

+ 89 - 0
ai-electron/frontend/src/core/logics/permWindow.ts

@@ -0,0 +1,89 @@
+import { router } from '@/core/router';
+import { PageEnum } from '@/core/enums/pageEnum';
+import { isPermWindowPath } from '@/perm/config';
+import {
+  hasCurrentCase,
+  isDesktop,
+  isPermWindowOpen,
+  openPermWindow,
+  PERM_WINDOW_PATH,
+  type OpenPermWindowResult,
+} from './appWindow';
+
+/** 浏览器端进入权限中心前的页面;回到自主模式时按它返回(sessionStorage 跨刷新保留) */
+const RETURN_PATH_KEY = 'PERM_CENTER_RETURN_PATH__';
+
+/** 权限窗口延迟聚焦定时器:避免连续点击叠加多次聚焦 */
+let permWindowFocusTimer: ReturnType<typeof setTimeout> | null = null;
+
+/** 记住进入权限中心前的页面(只在浏览器降级时使用;权限中心内部导航不会覆盖) */
+function rememberReturnPath(): void {
+  const current = router.currentRoute.value;
+  if (!current?.fullPath || isPermWindowPath(current.path)) return;
+  try {
+    sessionStorage.setItem(RETURN_PATH_KEY, current.fullPath);
+  } catch {
+    // 存不进去就按「是否已开案」选择默认落点
+  }
+}
+
+/**
+ * 浏览器端从权限中心回自主模式的落点。
+ *
+ * <p>优先回到进入权限中心前的页面;直接打开权限中心(无来源)时,
+ * 已开案回业务首页,未开案回案件管理页。
+ */
+export function resolvePermCenterReturnPath(): string {
+  try {
+    const stored = sessionStorage.getItem(RETURN_PATH_KEY);
+    sessionStorage.removeItem(RETURN_PATH_KEY);
+    if (stored) return stored;
+  } catch {
+    // sessionStorage 不可用时走默认落点
+  }
+  return hasCurrentCase() ? PageEnum.BASE_HOME : PageEnum.BASE_CASE;
+}
+
+export interface OpenPermCenterOptions {
+  /** 目标页,默认权限中心根地址(路由会重定向到默认页) */
+  fullPath?: string;
+  /** 窗口已打开时是否导航到目标页(点侧栏/直链进入指定权限页) */
+  navigateIfOpen?: boolean;
+}
+
+/**
+ * 打开/聚焦权限中心。
+ *
+ * <p>与智能工作台同一套 Windows 前台抢占兜底:打开成功后稍后再聚焦一次。
+ * 浏览器降级时 {@link openPermWindow} 会直接同窗导航,不会走到这里。
+ */
+export async function openPermCenter(options: OpenPermCenterOptions = {}): Promise<OpenPermWindowResult> {
+  const fullPath = options.fullPath || PERM_WINDOW_PATH;
+
+  // 浏览器降级是同窗口导航:先记住来源页,回去时不再一律落到案件管理
+  if (!isDesktop()) {
+    rememberReturnPath();
+  }
+
+  const result = await openPermWindow({
+    fullPath,
+    navigateIfOpen: options.navigateIfOpen === true,
+  });
+
+  if (result === 'opened') {
+    if (permWindowFocusTimer) {
+      clearTimeout(permWindowFocusTimer);
+    }
+    permWindowFocusTimer = setTimeout(() => {
+      permWindowFocusTimer = null;
+      // 窗口已被用户关掉就不再复活;仍开着时只聚焦,不改变它当前所在页
+      void isPermWindowOpen().then((open) => {
+        if (open) {
+          void openPermWindow({ fullPath });
+        }
+      });
+    }, 400);
+  }
+
+  return result;
+}

+ 42 - 6
ai-electron/frontend/src/core/logics/sessionSync.ts

@@ -1,13 +1,19 @@
-import { closeSmartWindow, isSmartWindow, onSyncEvent } from './appWindow';
-import { handleLicenseRedirect, handleUnauthorizedRedirect } from '@/core/utils/http/axios/unauthorized';
+import { closePermWindow, closeSmartWindow, isPermWindow, isSmartWindow, onSyncEvent } from './appWindow';
+import {
+  handleLicenseRedirect,
+  handleRemoteAccountReset,
+  handleUnauthorizedRedirect,
+} from '@/core/utils/http/axios/unauthorized';
+import { usePermission } from '@/core/hooks/web/usePermission';
 
 let initialized = false;
 
 /**
  * 注册跨窗口共享状态的事件处理。
  *
- * <p>职责很薄:智能窗口是只读客户端,案件/账号/凭据任一失效就关闭自己;
- * 主窗口只负责转来的凭据失效事件,由它弹唯一的提示并跳授权页。
+ * <p>职责很薄:智能工作台是案件作用域的从属窗口,案件/账号/凭据任一失效就关闭自己;
+ * 权限管理与案件无关,只在账号退出/凭据失效时关闭。
+ * 主窗口只负责转来的凭据失效事件(弹唯一的提示并跳授权页)与菜单变更后的导航重建。
  * 不做事件重放:晚创建或错过事件时,bootstrap 从 localStorage/后端读到的事实本来就是新的。
  */
 export function initSessionSync(): void {
@@ -18,17 +24,47 @@ export function initSessionSync(): void {
     if (!event?.type) return;
 
     if (isSmartWindow()) {
-      void closeSmartWindow();
+      // 智能工作台跟随案件与账号生命周期;MENU_CHANGED 与它无关,忽略
+      if (event.type === 'APP_RESET' || event.type === 'AUTH_INVALID') {
+        void closeSmartWindow();
+      }
+      return;
+    }
+
+    if (isPermWindow()) {
+      // 退出案件不关闭权限中心(它与案件无关);退出登录/凭据失效才关闭
+      if (
+        event.type === 'AUTH_INVALID' ||
+        (event.type === 'APP_RESET' && event.payload.reason === 'account-logged-out')
+      ) {
+        void closePermWindow();
+      }
+      return;
+    }
+
+    // 二级窗口主动退出登录/改密:主窗口清理本地状态并回登录页
+    if (event.type === 'APP_RESET') {
+      if (event.payload.reason === 'account-logged-out') {
+        handleRemoteAccountReset();
+      }
       return;
     }
 
-    // 主窗口收到 AUTH_INVALID 只可能来自智能窗口:本地已由对方跳过提示,这里补上
+    // 主窗口收到 AUTH_INVALID 只可能来自二级窗口:本地已由对方跳过提示,这里补上
     if (event.type === 'AUTH_INVALID') {
       if (event.payload.kind === 'license') {
         handleLicenseRedirect(event.payload.message, { remote: true });
       } else {
         handleUnauthorizedRedirect(event.payload.message, { remote: true });
       }
+      return;
+    }
+
+    // 菜单管理在权限子窗口里保存/删除后,主窗口重建导航即时生效(保留当前页)
+    if (event.type === 'MENU_CHANGED') {
+      void usePermission()
+        .refreshMenu()
+        .catch((e) => console.warn('[sessionSync] 刷新菜单失败:', e));
     }
   });
 }

+ 48 - 4
ai-electron/frontend/src/core/router/guard/index.ts

@@ -16,12 +16,17 @@ import {
 import { createPermissionGuard } from './permissionGuard';
 import { createStateGuard } from './stateGuard';
 import {
+  PERM_WINDOW_PATH,
   WORKBENCH_PATH,
   isDesktop,
+  isPermWindow,
   isSmartWindow,
   openSmartWindow,
   type OpenSmartWindowResult,
+  type OpenPermWindowResult,
 } from '@/core/logics/appWindow';
+import { openPermCenter } from '@/core/logics/permWindow';
+import { isPermWindowPath, toPermWindowPath } from '@/perm/config';
 // import nProgress from 'nprogress';
 import projectSetting from '@/core/settings/projectSetting';
 // import { createParamMenuGuard } from './paramMenuGuard';
@@ -42,17 +47,18 @@ export function setupRouterGuard(router: Router) {
 
 /**
  * 主界面模式守卫:
- * - 智能窗口只承载工作台;授权页放行,其余路径拉回工作台;
+ * - 智能窗口只承载工作台;权限窗口只承载权限中心;授权页放行,其余路径拉回各自根地址;
  * - 主窗口遇到工作台地址 → 打开智能窗口,自己留在原页;
+ * - 主窗口遇到权限管理地址 → 打开权限窗口,自己留在原页;
  * - 浏览器(无 Electron)保持同窗行为。
  *
  * <p>守卫里开窗口是副作用,但主进程侧是单例 + 幂等,且 redirect 目标绝不会再是
- * /workbench,不会形成循环。这样数据页 CTA、清洗完成页等 `router.push('/workbench')`
- * 调用点都不用改。
+ * /workbench 或 /perm/*,不会形成循环。这样数据页 CTA、清洗完成页等
+ * `router.push('/workbench')` 调用点都不用改,权限管理旧链接也能平滑收敛到子窗口。
  */
 function createWorkbenchGuard(router: Router) {
   router.beforeEach(async (to, from) => {
-    // 浏览器里没有独立窗口:/workbench 同窗渲染
+    // 浏览器里没有独立窗口:/workbench、/perm-window 同窗渲染
     if (!isDesktop()) {
       return true;
     }
@@ -68,11 +74,26 @@ function createWorkbenchGuard(router: Router) {
       return { path: WORKBENCH_PATH, replace: true };
     }
 
+    if (isPermWindow()) {
+      if (to.path === PageEnum.BASE_AUTHORIZATION || isPermWindowPath(to.path)) {
+        return true;
+      }
+      // 旧地址 /perm/xxx 映射到权限中心对应页;其它地址回权限中心默认页
+      return { path: toPermWindowPath(to.path) || PERM_WINDOW_PATH, replace: true };
+    }
+
     // 主窗口:工作台地址(含 ?newChat=1 / ?view=agent)原样交给智能窗口
     if (to.path === WORKBENCH_PATH || to.path.startsWith(WORKBENCH_PATH + '/')) {
       const result = await openSmartWindow({ fullPath: to.fullPath, navigateIfOpen: true });
       return handleSmartWindowResult(result, from.path);
     }
+
+    // 主窗口:权限管理页面统一交给权限子窗口,自己留在原业务页
+    const permTarget = toPermWindowPath(to.path);
+    if (permTarget) {
+      const result = await openPermCenter({ fullPath: permTarget, navigateIfOpen: true });
+      return handlePermWindowResult(result, from.path);
+    }
   });
 }
 
@@ -97,6 +118,29 @@ function handleSmartWindowResult(result: OpenSmartWindowResult, fromPath: string
   };
 }
 
+/**
+ * 主窗口打开权限窗口后的落点:留在原业务页;从案件管理/授权页过来时回案件管理。
+ *
+ * <p>权限管理不依赖案件,主窗口停在案件管理页是合法状态,不需要像工作台那样回业务首页。
+ */
+function handlePermWindowResult(result: OpenPermWindowResult, fromPath: string) {
+  if (result === 'failed') {
+    notification.error({ message: '打开权限管理窗口失败,请重试' });
+  }
+
+  const isBusinessPage =
+    !!fromPath &&
+    fromPath !== WORKBENCH_PATH &&
+    !isPermWindowPath(fromPath) &&
+    !fromPath.startsWith('/perm/') &&
+    ![PageEnum.BASE_CASE, PageEnum.BASE_AUTHORIZATION, '/'].includes(fromPath);
+
+  return {
+    path: isBusinessPage ? fromPath : PageEnum.BASE_CASE,
+    replace: true,
+  };
+}
+
 /**
  * Hooks for handling page state
  */

+ 26 - 0
ai-electron/frontend/src/core/router/routes/index.ts

@@ -3,6 +3,7 @@ import type { AppRouteRecordRaw } from '@/core/router/types';
 import { PAGE_NOT_FOUND_ROUTE, REDIRECT_ROUTE } from '@/core/router/routes/basic';
 
 import { PageEnum } from '@/core/enums/pageEnum';
+import { PERM_CENTER_COMPONENTS, PERM_CENTER_PAGES, PERM_WINDOW_PATH } from '@/perm/config';
 
 export const asyncRoutes = [PAGE_NOT_FOUND_ROUTE];
 
@@ -151,6 +152,30 @@ export const CaseCleanProgressRoute: AppRouteRecordRaw = {
   },
 };
 
+/**
+ * 权限管理:独立于布局的全屏路由(不套 LAYOUT)。
+ *
+ * <p>Electron 下由权限管理子窗口承载,浏览器降级为同窗口全屏页。
+ * 子路由静态注册,不依赖后端动态菜单;菜单管理保存时 resetRouter 也不会删除它。
+ */
+export const PermWindowRoute: AppRouteRecordRaw = {
+  path: PERM_WINDOW_PATH,
+  name: 'PermWindow',
+  component: () => import('@/perm/layouts/PermWindowLayout.vue'),
+  redirect: `${PERM_WINDOW_PATH}/user`,
+  meta: {
+    title: '权限管理',
+    hideMenu: true,
+    hideTab: true,
+  },
+  children: PERM_CENTER_PAGES.map((page) => ({
+    path: page.key,
+    name: page.routeName,
+    component: PERM_CENTER_COMPONENTS[page.key],
+    meta: { title: page.title, icon: page.icon },
+  })),
+};
+
 /**
  * 智能工作台:独立于布局的全屏路由(不套 LAYOUT,覆盖包括菜单在内的整个视口)。
  * 「智能模式」的独立窗口入口;主窗口的「智能」开关会打开本路由。
@@ -302,6 +327,7 @@ export const basicRoutes = [
   AuthorizationRoute,
   CaseRoute,
   WorkbenchRoute,
+  PermWindowRoute,
   CaseUploadRoute,
   CaseEdsUploadRoute,
   CaseCleaningRoute,

+ 6 - 1
ai-electron/frontend/src/core/store/modules/permission.ts

@@ -15,6 +15,8 @@ import { ERROR_LOG_ROUTE } from '@/core/router/routes/basic';
 import { LAYOUT } from '@/core/router/constant';
 import { PageEnum } from '@/core/enums/pageEnum';
 import { getRoutersApi } from '@/api/perm/menu';
+import { removePermMenuGroups } from '@/perm/config';
+import { isDesktopEnv } from '@/core/utils/desktop/ipcRenderer';
 
 /** 账号没有任何菜单授权(主窗口与工作台都为空)时的错误名,守卫据此清理登录态 */
 export const EMPTY_MENU_ERROR_NAME = 'EmptyMenuError';
@@ -88,7 +90,10 @@ export const usePermissionStore = defineStore('app-permission', {
       // 每次都基于后端原始树重建,避免二次构建拿到已被 transformObjToRoute 修改过的组件函数
       let routeList: AppRouteRecordRaw[] = cloneDeep(mainTree) as unknown as AppRouteModule[];
       routeList = transformObjToRoute(routeList as AppRouteModule[]);
-      this.setBackMenuList(transformRouteToMenu(routeList));
+      const menuList = transformRouteToMenu(routeList);
+      // 桌面端主窗口不再显示权限管理菜单:入口收敛到顶栏图标 + 独立权限窗口。
+      // 路由本身保留:浏览器仍按普通页面渲染,Electron 下由路由守卫接管到子窗口。
+      this.setBackMenuList(isDesktopEnv() ? removePermMenuGroups(menuList) : menuList);
       routeList = flatMultiLevelRoutes(routeList);
       // 仅工作台角色:主窗口没有业务菜单,补一个空的主窗口首页,
       // 让开案后的既有跳转仍落在主窗口(侧栏为空),顶部仍可进入智能工作台。

+ 4 - 1
ai-electron/frontend/src/core/utils/desktop/ipcRenderer.ts

@@ -22,7 +22,10 @@ export function resolveIpcRenderer(): IpcRendererLike | null {
 }
 
 /** 当前是否在桌面客户端里(浏览器里读不了本机文件、也存不了本机设置) */
-export const isDesktopDialogAvailable = () => !!resolveIpcRenderer();
+export const isDesktopEnv = () => !!resolveIpcRenderer();
+
+/** 兼容旧命名:桌面端能力判断(文件选择、窗口控制等) */
+export const isDesktopDialogAvailable = isDesktopEnv;
 
 /**
  * 调主进程控制器方法;非桌面端抛错,调用方自己决定降级方式。

+ 27 - 7
ai-electron/frontend/src/core/utils/http/axios/unauthorized.ts

@@ -1,8 +1,16 @@
 import { useMessage } from '@/core/hooks/web/useMessage';
 import { PageEnum } from '@/core/enums/pageEnum';
 import { resetRouter, router } from '@/core/router';
-import { broadcastSync, closeSmartWindow, focusMainWindow, isSmartWindow } from '@/core/logics/appWindow';
+import {
+  broadcastSync,
+  closePermWindow,
+  closeSmartWindow,
+  focusMainWindow,
+  isPermWindow,
+  isSmartWindow,
+} from '@/core/logics/appWindow';
 import { useUserStoreWithOut } from '@/core/store/modules/case';
+import { useAccountStoreWithOut } from '@/core/store/modules/account';
 import { useMultipleTabWithOutStore } from '@/core/store/modules/multipleTab';
 import { usePermissionStoreWithOut } from '@/core/store/modules/permission';
 import { clearAuthCache } from '@/core/utils/auth';
@@ -21,6 +29,7 @@ let isHandlingLicense = false;
 /** 清理本地状态与动态路由(token 也会被清掉 —— 此时凭据已失效) */
 function clearLocalState() {
   useUserStoreWithOut().resetState();
+  useAccountStoreWithOut().resetState();
   usePermissionStoreWithOut().resetState();
   useMultipleTabWithOutStore().resetState();
   clearAuthCache();
@@ -33,6 +42,17 @@ function redirectTo(path: string, query?: Record<string, string>) {
   }
 }
 
+/**
+ * 二级窗口主动退出登录(含修改密码后的强制重新登录)后,主窗口接手清理并回登录页。
+ *
+ * <p>发送方已经广播过 APP_RESET,这里不再广播,避免两个窗口互相回声。
+ */
+export function handleRemoteAccountReset(message = '账号已退出登录,请重新登录') {
+  clearLocalState();
+  useMessage().createMessage.warning(message);
+  redirectTo(PageEnum.BASE_AUTHORIZATION);
+}
+
 /**
  * code=401:未登录 / token 失效 / 被顶下线 → 跳授权/登录入口页。
  *
@@ -40,15 +60,15 @@ function redirectTo(path: string, query?: Record<string, string>) {
  * 因此这里由 transformRequestHook 触发,而不是 axios 的 catch 分支。
  * <p>`/login` 已合并进 `/authorization`,入口页会根据授权状态自行显示登录卡片。
  *
- * <p>多窗口:智能窗口不弹框,只把事件转给主窗口并关闭自己;主窗口是唯一的提示方。
+ * <p>多窗口:智能窗口 / 权限窗口不弹框,只把事件转给主窗口并关闭自己;主窗口是唯一的提示方。
  */
 export function handleUnauthorizedRedirect(message = '登录状态已失效,请重新登录', options: RedirectOptions = {}) {
-  if (isSmartWindow()) {
+  if (isSmartWindow() || isPermWindow()) {
     if (isHandlingUnauthorized) return;
     isHandlingUnauthorized = true;
     broadcastSync({ type: 'AUTH_INVALID', payload: { kind: 'unauthorized', message } });
     void focusMainWindow();
-    void closeSmartWindow();
+    void (isSmartWindow() ? closeSmartWindow() : closePermWindow());
     return;
   }
 
@@ -84,15 +104,15 @@ export function handleUnauthorizedRedirect(message = '登录状态已失效,
  * 因为 401 的语义已归「未登录」。两者若共用 401,会出现「license 失效跳登录页、
  * 未登录跳授权页」互相打架的情况。
  *
- * <p>多窗口规则同 {@link handleUnauthorizedRedirect}:智能窗口只转发 + 关闭。
+ * <p>多窗口规则同 {@link handleUnauthorizedRedirect}:智能窗口 / 权限窗口只转发 + 关闭。
  */
 export function handleLicenseRedirect(message = '未授权,请先完成授权', options: RedirectOptions = {}) {
-  if (isSmartWindow()) {
+  if (isSmartWindow() || isPermWindow()) {
     if (isHandlingLicense) return;
     isHandlingLicense = true;
     broadcastSync({ type: 'AUTH_INVALID', payload: { kind: 'license', message } });
     void focusMainWindow();
-    void closeSmartWindow();
+    void (isSmartWindow() ? closeSmartWindow() : closePermWindow());
     return;
   }
 

+ 48 - 13
ai-electron/frontend/src/main.ts

@@ -31,7 +31,15 @@ import {
 } from '@/core/utils/license';
 import { setupAntdTabsListenerPatch } from './setupAntdTabsListenerPatch';
 import { setupAntdPopupBehavior } from './setupAntdPopupBehavior';
-import { closeSmartWindow, focusMainWindow, initWindowRole, isSmartWindow } from '@/core/logics/appWindow';
+import {
+  broadcastSync,
+  closePermWindow,
+  closeSmartWindow,
+  focusMainWindow,
+  initWindowRole,
+  isPermWindow,
+  isSmartWindow,
+} from '@/core/logics/appWindow';
 import { initSessionSync } from '@/core/logics/sessionSync';
 import { isServerSetupMissing } from '@/core/settings/serverSetting';
 
@@ -226,6 +234,16 @@ async function resolveStartupRoute() {
     return;
   }
 
+  // 二级窗口不重复做机器授权校验:主窗口是唯一的授权入口。
+  // 后端 checkAuthStatus 是 synchronized + OS 子进程,多个窗口同时启动会互相排队,
+  // 一旦超过 10s 请求超时就会被误判成「授权失效」,新窗口刚打开就自关闭。
+  // 授权在运行中失效时,接口会返回 40301,由统一拦截器关闭二级窗口并提示主窗口。
+  if (isSmartWindow() || isPermWindow()) {
+    // 仍要显式落到启动地址:首次导航由这里触发,否则 router.isReady() 会一直等待、页面停在 loading
+    await router.replace(fullPath);
+    return;
+  }
+
   try {
     const res = await checkAuthApi();
     if (res?.code === 200) {
@@ -285,8 +303,30 @@ async function ensureLoggedIn() {
   }
 }
 
+/**
+ * 二级窗口(智能工作台 / 权限管理)遇到地址、授权或登录问题时关闭自己,
+ * 并把主窗口拉到前台——提示与跳转统一由主窗口负责。
+ *
+ * @param authInvalidMessage 凭据/授权失效时传给主窗口的提示;其他原因(服务地址、后端不可达)不传
+ * @returns 当前窗口是否二级窗口(是则调用方应立即结束 bootstrap)
+ */
+async function leaveSecondaryWindowToMain(authInvalidMessage?: string): Promise<boolean> {
+  if (!isSmartWindow() && !isPermWindow()) return false;
+  if (authInvalidMessage) {
+    // 二级窗口自己吞掉了失效提示:把事件交给主窗口,由它弹唯一的登录/授权提示
+    broadcastSync({ type: 'AUTH_INVALID', payload: { kind: 'unauthorized', message: authInvalidMessage } });
+  }
+  await focusMainWindow();
+  if (isSmartWindow()) {
+    void closeSmartWindow();
+  } else {
+    void closePermWindow();
+  }
+  return true;
+}
+
 async function bootstrap() {
-  // 窗口角色必须先解析:路由守卫要靠它区分主窗口(传统壳)与智能工作台窗口。
+  // 窗口角色必须先解析:路由守卫要靠它区分主窗口(传统壳)与智能工作台 / 权限管理窗口。
   // 浏览器里没有 IPC,initWindowRole 会回落到 'main',一切保持单窗口行为。
   await initWindowRole();
 
@@ -319,9 +359,7 @@ async function bootstrap() {
   // 必须在 waitForBackendReady 之前判断,否则会在没有地址的情况下空等。
   // 地址卡片已并入 /authorization,由页面根据 isServerSetupMissing() 自己切换形态。
   if (isServerSetupMissing()) {
-    if (isSmartWindow()) {
-      await focusMainWindow();
-      void closeSmartWindow();
+    if (await leaveSecondaryWindowToMain()) {
       return;
     }
     await router.replace(PageEnum.BASE_AUTHORIZATION);
@@ -342,10 +380,8 @@ async function bootstrap() {
   // 后端不可达:停在 loading 页提供「重连 / 修改服务地址」,不先带着坏地址进入授权校验
   if (!backendReady) {
     showReconnectState(async () => {
-      // 智能窗口只承载工作台:地址/授权问题交回主窗口处理
-      if (isSmartWindow()) {
-        await focusMainWindow();
-        void closeSmartWindow();
+      // 二级窗口只承载各自页面:地址/授权问题交回主窗口处理
+      if (await leaveSecondaryWindowToMain()) {
         return;
       }
       await router.replace({ path: PageEnum.BASE_AUTHORIZATION, query: { error: 'unreachable' } });
@@ -368,11 +404,10 @@ async function bootstrap() {
   // 授权通过后再校验登录态:无 token 直接进授权/登录入口页
   await ensureLoggedIn();
 
-  // 智能窗口只承载工作台:bootstrap 若被判定到授权页,说明凭据/授权已失效。
+  // 二级窗口只承载各自页面:bootstrap 若被判定到授权页,说明凭据/授权已失效。
   // 关闭自己、把主窗口拉到前台,由主窗口做唯一的提示与跳转。
-  if (isSmartWindow() && router.currentRoute.value.path === PageEnum.BASE_AUTHORIZATION) {
-    await focusMainWindow();
-    void closeSmartWindow();
+  if ((isSmartWindow() || isPermWindow()) && router.currentRoute.value.path === PageEnum.BASE_AUTHORIZATION) {
+    await leaveSecondaryWindowToMain('登录状态已失效,请重新登录');
     return;
   }
 

+ 125 - 0
ai-electron/frontend/src/perm/config.ts

@@ -0,0 +1,125 @@
+import type { Menu } from '@/core/router/types';
+import { PageEnum } from '@/core/enums/pageEnum';
+
+/** 权限中心在独立窗口 / 同窗口全屏模式下的根地址 */
+export const PERM_WINDOW_PATH = PageEnum.BASE_PERM_WINDOW;
+
+export interface PermCenterPage {
+  /** 路径段,同时也是组件映射键 */
+  key: string;
+  /** 权限中心内的地址 */
+  path: string;
+  /** 静态路由名 */
+  routeName: string;
+  title: string;
+  icon: string;
+  /** 页面级权限码(与后端 list 接口使用的权限一致) */
+  permission: string;
+  /** 主窗口里的历史地址,用于把旧链接映射到权限中心 */
+  legacyPath: string;
+}
+
+/**
+ * 权限管理的全部页面。
+ *
+ * <p>入口统一由顶栏图标打开独立窗口(Electron)或同窗口全屏页(浏览器),
+ * 主窗口不再直接渲染这些页面。
+ */
+export const PERM_CENTER_PAGES: PermCenterPage[] = [
+  {
+    key: 'user',
+    path: `${PERM_WINDOW_PATH}/user`,
+    routeName: 'PermWindowUser',
+    title: '用户管理',
+    icon: 'i-mdi:account-group-outline',
+    permission: 'perm:user:list',
+    legacyPath: '/perm/user/index',
+  },
+  {
+    key: 'role',
+    path: `${PERM_WINDOW_PATH}/role`,
+    routeName: 'PermWindowRole',
+    title: '角色管理',
+    icon: 'i-mdi:shield-check-outline',
+    permission: 'perm:role:list',
+    legacyPath: '/perm/role/index',
+  },
+  {
+    key: 'menu',
+    path: `${PERM_WINDOW_PATH}/menu`,
+    routeName: 'PermWindowMenu',
+    title: '菜单管理',
+    icon: 'i-mdi:format-list-bulleted',
+    permission: 'perm:menu:list',
+    legacyPath: '/perm/menu/index',
+  },
+  {
+    key: 'dept',
+    path: `${PERM_WINDOW_PATH}/dept`,
+    routeName: 'PermWindowDept',
+    title: '部门管理',
+    icon: 'i-mdi:file-tree-outline',
+    permission: 'perm:dept:list',
+    legacyPath: '/perm/dept/index',
+  },
+  {
+    key: 'post',
+    path: `${PERM_WINDOW_PATH}/post`,
+    routeName: 'PermWindowPost',
+    title: '岗位管理',
+    icon: 'i-mdi:badge-account-outline',
+    permission: 'perm:post:list',
+    legacyPath: '/perm/post/index',
+  },
+];
+
+/** 图标可见性判断用:任一权限命中即可打开权限中心 */
+export const PERM_CENTER_PERMISSIONS = PERM_CENTER_PAGES.map((page) => page.permission);
+
+/** 静态路由组件映射:权限页组件在独立窗口与浏览器全屏两种形态下复用 */
+export const PERM_CENTER_COMPONENTS: Record<string, () => Promise<Recordable>> = {
+  user: () => import('@/perm/views/user/index.vue'),
+  role: () => import('@/perm/views/role/index.vue'),
+  menu: () => import('@/perm/views/menu/index.vue'),
+  dept: () => import('@/perm/views/dept/index.vue'),
+  post: () => import('@/perm/views/post/index.vue'),
+};
+
+/** 是否权限中心地址(/perm-window 或 /perm-window/xxx) */
+export function isPermWindowPath(path: string): boolean {
+  return path === PERM_WINDOW_PATH || path.startsWith(`${PERM_WINDOW_PATH}/`);
+}
+
+/**
+ * 把主窗口里的权限页地址映射到权限中心地址。
+ *
+ * <ul>
+ *   <li>已是权限中心地址:原样返回</li>
+ *   <li>/perm/user/index 等已知页面:映射到对应子页</li>
+ *   <li>其它 /perm/* 地址:落到权限中心默认页</li>
+ *   <li>非权限页:返回 null</li>
+ * </ul>
+ */
+export function toPermWindowPath(path: string): string | null {
+  if (isPermWindowPath(path)) return path;
+  if (!path.startsWith('/perm/')) return null;
+  const cleanPath = path.split('?')[0].replace(/\/+$/, '');
+  return PERM_CENTER_PAGES.find((page) => page.legacyPath === cleanPath)?.path || PERM_WINDOW_PATH;
+}
+
+/**
+ * 判断主菜单里的某个分组是否是「权限管理」。
+ *
+ * <p>以子项路径为准(/perm/ 开头);标题作为兜底,
+ * 避免后端把目录改名为别的文案后过滤失效。
+ */
+export function isPermMenuGroup(menu: Menu): boolean {
+  if (menu.name === '权限管理') return true;
+  const children = menu.children || [];
+  return children.length > 0 && children.every((child) => String(child.path || '').startsWith('/perm/'));
+}
+
+/** 桌面端主窗口不再显示权限管理菜单:入口统一收敛到顶栏图标 + 独立窗口 */
+export function removePermMenuGroups(menus: Menu[]): Menu[] {
+  return menus.filter((menu) => !isPermMenuGroup(menu));
+}

+ 245 - 0
ai-electron/frontend/src/perm/layouts/PermWindowLayout.vue

@@ -0,0 +1,245 @@
+<template>
+  <div class="perm-shell">
+    <AppTopBar
+      logo-title="数剑 · 权限管理"
+      :show-mode-switch="false"
+      :show-user-dropdown="true"
+      :show-user-logout="false"
+    >
+      <template #actions>
+        <!--
+          与智能工作台一致:按钮展示「将要去哪一侧」。
+          本窗口是权限侧,固定显示「自主」;点击把主窗口拉到前台,不关闭权限窗口(避免丢掉未保存的表单)。
+        -->
+        <AppWorkbenchToggle current="smart" @change="handleModeChange" />
+
+        <Tooltip title="模板库" placement="bottom" :mouseEnterDelay="0.5">
+          <Button
+            type="text"
+            class="jeesite-header-action-button"
+            aria-label="模板库"
+            @click="templateLibraryVisible = true"
+          >
+            <Icon icon="i-ant-design:book-outlined" />
+          </Button>
+        </Tooltip>
+
+        <AppDownloadManager />
+
+        <SettingDrawer v-if="showSetting" />
+      </template>
+    </AppTopBar>
+
+    <CaseTemplateLibraryModal v-model:open="templateLibraryVisible" />
+
+    <div class="perm-body">
+      <aside class="perm-sider">
+        <SimpleMenu :items="menuItems" theme="light" :force-expanded="true" @menu-click="handleMenuClick" />
+      </aside>
+
+      <main class="perm-main">
+        <!-- 无权限的页面不挂载:避免先发一轮注定 403 的请求,再被重定向 -->
+        <router-view v-if="currentPageAllowed" />
+        <div v-else-if="accountLoaded" class="perm-empty">
+          <p class="perm-empty__title">暂无权限管理权限</p>
+          <p class="perm-empty__desc">当前账号未被授予权限管理页面,请联系管理员分配角色菜单。</p>
+        </div>
+      </main>
+    </div>
+  </div>
+</template>
+
+<script lang="ts" setup name="PermWindowLayout">
+  import { computed, ref, watchEffect } from 'vue';
+  import { useRoute, useRouter } from 'vue-router';
+  import { Button, Tooltip } from 'ant-design-vue';
+  import type { Menu } from '@/core/router/types';
+  import AppTopBar from '@/core/components/Application/src/AppTopBar.vue';
+  import { AppDownloadManager, AppWorkbenchToggle } from '@/core/components/Application';
+  import { Icon } from '@/core/components/Icon';
+  import { SimpleMenu } from '@/core/components/SimpleMenu';
+  import { SettingDrawer } from '@/core/layouts/default/header/components';
+  import { useRootSetting } from '@/core/hooks/setting/useRootSetting';
+  import { usePermission } from '@/core/hooks/web/usePermission';
+  import { useAccountStore } from '@/core/store/modules/account';
+  import { focusMainWindow, isDesktop } from '@/core/logics/appWindow';
+  import { resolvePermCenterReturnPath } from '@/core/logics/permWindow';
+  import { useWorkbenchModeSwitch } from '@/core/logics/workbenchMode';
+  import { SettingButtonPositionEnum } from '@/core/enums/appEnum';
+  import type { WorkbenchMode } from '@/core/store/modules/app';
+  import { PERM_CENTER_PAGES } from '@/perm/config';
+  import CaseTemplateLibraryModal from '@/case/views/data/components/CaseTemplateLibraryModal.vue';
+
+  const route = useRoute();
+  const router = useRouter();
+  const { hasPermission } = usePermission();
+  const accountStore = useAccountStore();
+
+  /** 模板库弹框开关(与案件页/工作台同一个组件) */
+  const templateLibraryVisible = ref(false);
+
+  /** 设置入口与工作台同口径:跟随全局设置按钮配置 */
+  const { getShowSettingButton, getSettingButtonPosition } = useRootSetting();
+  const showSetting = computed(() => {
+    if (!getShowSettingButton.value) return false;
+    const position = getSettingButtonPosition.value;
+    return position === SettingButtonPositionEnum.AUTO || position === SettingButtonPositionEnum.HEADER;
+  });
+
+  /** 用户信息加载完成前不能把「无权限」当成结论 */
+  const accountLoaded = computed(() => !!accountStore.getUserInfo);
+  /** 当前账号可访问的权限页(超管 *:*:* 全量通过) */
+  const accessiblePages = computed(() => PERM_CENTER_PAGES.filter((page) => hasPermission(page.permission)));
+  const currentPageAllowed = computed(() => accessiblePages.value.some((page) => page.path === route.path));
+
+  const menuItems = computed<Menu[]>(() =>
+    accessiblePages.value.map((page) => ({
+      path: page.path,
+      name: page.title,
+      icon: page.icon,
+    })),
+  );
+
+  // 直链未授权页(或默认落在 user 但账号只有 role 权限)时,落到第一个可访问页
+  watchEffect(() => {
+    if (!accessiblePages.value.length || currentPageAllowed.value) return;
+    void router.replace(accessiblePages.value[0].path);
+  });
+
+  function handleMenuClick(path: string) {
+    if (path && path !== route.path) {
+      void router.push(path);
+    }
+  }
+
+  const { setMode } = useWorkbenchModeSwitch();
+
+  /** 回自主模式:桌面端聚焦主窗口;浏览器端回到进入权限中心前的页面 */
+  function handleModeChange(mode: WorkbenchMode) {
+    if (mode !== 'traditional') return;
+    if (!isDesktop()) {
+      void router.replace(resolvePermCenterReturnPath());
+      return;
+    }
+    void setMode(mode);
+    // setMode 只在智能窗口里负责聚焦主窗口,权限窗口需要显式补一次
+    void focusMainWindow();
+  }
+</script>
+
+<style lang="less" scoped>
+  .perm-shell {
+    display: flex;
+    flex-direction: column;
+    width: 100%;
+    height: 100vh;
+    overflow: hidden;
+    background: #f4f6fa;
+  }
+
+  .perm-body {
+    display: flex;
+    flex: 1 1 auto;
+    min-height: 0;
+  }
+
+  .perm-sider {
+    flex: 0 0 auto;
+    width: 208px;
+    min-width: 208px;
+    height: 100%;
+    overflow-x: hidden;
+    overflow-y: auto;
+    background: #f8fafc;
+    border-right: 1px solid #e7ebf3;
+    scrollbar-width: none;
+    -ms-overflow-style: none;
+
+    &::-webkit-scrollbar {
+      display: none;
+      width: 0;
+      height: 0;
+    }
+
+    :deep(.jeesite-simple-menu) {
+      padding: 8px 6px;
+      background: transparent;
+    }
+
+    :deep(.jeesite-menu-item) {
+      min-height: 34px;
+      padding: 0 14px !important;
+      color: #1f2937;
+      font-size: 14px;
+    }
+  }
+
+  .perm-main {
+    display: flex;
+    flex: 1 1 auto;
+    flex-direction: column;
+    min-width: 0;
+    min-height: 0;
+    padding: 12px 16px;
+    overflow: hidden;
+    background: #f4f6fa;
+
+    > * {
+      flex: 1 1 auto;
+      min-height: 0;
+    }
+  }
+
+  .perm-empty {
+    display: flex;
+    flex-direction: column;
+    align-items: center;
+    justify-content: center;
+    color: #667085;
+    background: #fff;
+    border: 1px solid #e2e8f0;
+    border-radius: 12px;
+
+    &__title {
+      margin: 0 0 8px;
+      font-size: 16px;
+      font-weight: 600;
+      color: #1f2937;
+    }
+
+    &__desc {
+      margin: 0;
+      font-size: 14px;
+    }
+  }
+</style>
+
+<style lang="less">
+  /* 权限窗口是独立全屏路由,不加载传统壳的顶栏样式:这里补一份与工作台一致的图标按钮规格 */
+  .perm-shell .app-topbar__actions .jeesite-header-action-button {
+    display: inline-flex;
+    align-items: center;
+    justify-content: center;
+    width: 30px;
+    min-width: 30px;
+    height: 28px;
+    padding: 0;
+    color: #475467;
+    background: transparent;
+    border: 0;
+    border-radius: 8px;
+    box-shadow: none;
+    cursor: pointer;
+    transition: background-color 0.15s ease;
+
+    &:hover {
+      color: #1f2937;
+      background: #f2f5fa;
+    }
+
+    .jeesite-icon,
+    .anticon {
+      font-size: 16px;
+    }
+  }
+</style>

+ 4 - 1
ai-electron/frontend/src/perm/views/menu/index.vue

@@ -85,6 +85,7 @@
   import { useModal } from '@/core/components/Modal';
   import { useMessage } from '@/core/hooks/web/useMessage';
   import { usePermission } from '@/core/hooks/web/usePermission';
+  import { broadcastSync } from '@/core/logics/appWindow';
   import { deletePermMenuApi, listPermMenusApi } from '@/api/perm/menu';
   import type { PermMenu } from '@/api/perm/menu';
   import MenuFormModal from './MenuFormModal.vue';
@@ -209,10 +210,12 @@
     });
   }
 
-  /** 菜单变更后刷新列表并重建主窗口导航(保留页签,无需重登) */
+  /** 菜单变更后刷新列表并重建导航(保留页签,无需重登) */
   async function handleMenuChanged() {
     await loadList();
     await refreshMenu();
+    // 权限管理已收敛到独立窗口:通知主窗口重建导航,业务菜单即时生效(浏览器下是 no-op)
+    broadcastSync({ type: 'MENU_CHANGED' });
   }
 
   const [registerMenuForm, { openModal: openMenuFormModal }] = useModal();

+ 3 - 1
ai-electron/frontend/src/plat/views/case/case.vue

@@ -16,6 +16,8 @@
 
         <AppDownloadManager />
 
+        <AppPermCenterButton />
+
         <SettingDrawer v-if="getShowSettingButton" />
 
         <UserDropdown />
@@ -188,7 +190,7 @@
   import { useModal } from '@/core/components/Modal';
   import { useLoading } from '@/core/components/Loading';
   import { EmptyState } from '@/core/components/EmptyState';
-  import { AppDownloadManager, AppHeader } from '@/core/components/Application';
+  import { AppDownloadManager, AppHeader, AppPermCenterButton } from '@/core/components/Application';
   import { Icon } from '@/core/components/Icon';
   import { createAsyncComponent } from '@/core/utils/factory/createAsyncComponent';
   import { useRootSetting } from '@/core/hooks/setting/useRootSetting';