dsh-github-flow 0.1.8 → 0.2.0

package/lib/api/routes-proxy.d.ts

@@ -0,0 +1,18 @@
+/**
+ * 网络代理设置路由（驾驶舱「网络代理」设置分区的后端入口）。
+ * 为什么独立于 Cordis Config：代理设置变更若走 Loader 会触发插件全量 reload
+ * （工具注销重注册、面板断流），而代理是高频试错型设置，必须保存即生效。
+ */
+import type { UpdateChecker } from '../updater.js';
+import { type RouteDeps } from './route-helpers.js';
+/** ProxyManager 的路由侧最小接口：避免路由层直接依赖实现细节，测试可注入 mock */
+export interface ProxyRouteManager {
+    save: (input: any) => {
+        ok: boolean;
+        error?: string;
+        state: any;
+    };
+    probe: () => Promise<any>;
+    snapshot: () => any;
+}
+export declare function registerProxyRoutes(deps: RouteDeps, checker: UpdateChecker, proxyManager?: ProxyRouteManager): void;

package/lib/api/routes-proxy.js

@@ -0,0 +1,63 @@
+import { sendJson, readJsonBody } from './route-helpers.js';
+export function registerProxyRoutes(deps, checker, proxyManager) {
+    const { bindRoute } = deps;
+    // 1. 代理配置：GET 读取状态 / POST 保存并立即生效（写 proxy.json + 重应用 dispatcher，零插件重载）
+    bindRoute({
+        kind: 'exact',
+        path: '/api/github/proxy',
+        handler: async (req, res) => {
+            if (req.method === 'GET') {
+                if (!proxyManager) {
+                    sendJson(res, 200, { ok: true, state: null, message: '当前运行环境未启用代理管理器' });
+                    return;
+                }
+                sendJson(res, 200, { ok: true, state: proxyManager.snapshot() });
+                return;
+            }
+            if (req.method !== 'POST') {
+                sendJson(res, 405, { ok: false, message: '仅支持 GET / POST 请求' });
+                return;
+            }
+            if (!proxyManager) {
+                sendJson(res, 503, { ok: false, message: '当前运行环境未启用代理管理器' });
+                return;
+            }
+            try {
+                const body = await readJsonBody(req);
+                const result = proxyManager.save(body || {});
+                if (!result.ok) {
+                    sendJson(res, 400, { ok: false, message: result.error, state: result.state });
+                    return;
+                }
+                // 配置变更后同步刷新 updater 的 fetch dispatcher（npm 探测链路）
+                checker.applyProxy(proxyManager);
+                sendJson(res, 200, { ok: true, state: result.state });
+            }
+            catch (err) {
+                sendJson(res, 500, { ok: false, message: err.message || '代理配置保存失败' });
+            }
+        },
+    });
+    // 2. 手动触发连通性探测（2.5s 超时，结果持久化到 lastProbe 供 UI 展示）
+    bindRoute({
+        kind: 'exact',
+        path: '/api/github/proxy/probe',
+        handler: async (req, res) => {
+            if (req.method !== 'POST') {
+                sendJson(res, 405, { ok: false, message: '仅支持 POST 请求' });
+                return;
+            }
+            if (!proxyManager) {
+                sendJson(res, 503, { ok: false, message: '当前运行环境未启用代理管理器' });
+                return;
+            }
+            try {
+                const probe = await proxyManager.probe();
+                sendJson(res, 200, { ok: true, probe, state: proxyManager.snapshot() });
+            }
+            catch (err) {
+                sendJson(res, 500, { ok: false, message: err.message || '代理探测失败' });
+            }
+        },
+    });
+}

package/lib/api/routes.d.ts

@@ -1,9 +1,19 @@
+/**
+ * API 路由注册器（纯装配骨架）。
+ *
+ * 架构说明：具体 handler 按领域拆分在 routes-overview / routes-actions /
+ * routes-lifecycle / routes-proxy 四个分组文件中，本文件只负责：
+ * 1. 解析 ctx/webServer 与可选依赖（缺省时给默认实现，保持向后兼容）；
+ * 2. 构造共享闭包（缓存实例 + bindRoute 生命周期绑定）；
+ * 3. 按固定顺序装配各分组。
+ *
+ * 为什么 bindRoute 必须在这里定义：它闭包引用 ctx（effect 纳管）与 webServer
+ * （自愈清理），分组文件只消费注入的 RouteDeps，不感知 Cordis 上下文。
+ */
 import type { GhExecutor } from '../executor.js';
 import { UpdateChecker } from '../updater.js';
 import { UpgradeManager } from '../upgrade-manager.js';
-/**
- * 由用户配置推导全局驾驶舱的缓存时长。
- * 抽成导出的纯函数：TTL 的推导规则是测试断言的对象，埋在闭包里就只能靠猜。
- */
-export declare function globalCacheTtlMs(cacheTtlMs: number): number;
-export declare function registerApiRoutes(ctxOrWebServer: any, executor: GhExecutor, workspaceRegistry?: any, cacheTtlMs?: number, updateChecker?: UpdateChecker, upgradeManager?: UpgradeManager): void;
+import { globalCacheTtlMs } from './route-helpers.js';
+import { type ProxyRouteManager } from './routes-proxy.js';
+export { globalCacheTtlMs };
+export declare function registerApiRoutes(ctxOrWebServer: any, executor: GhExecutor, workspaceRegistry?: any, cacheTtlMs?: number, updateChecker?: UpdateChecker, upgradeManager?: UpgradeManager, proxyManager?: ProxyRouteManager): void;

package/lib/api/routes.js

@@ -1,102 +1,14 @@
-import path from 'node:path';
 import { TtlCache } from '../cache.js';
-import { mapLimit, tryReadWorkspaces, findWorkspacePathBySession, findMostRecentWorkspacePath, hasGitDir } from '../workspace.js';
 import { UpdateChecker } from '../updater.js';
 import { UpgradeManager } from '../upgrade-manager.js';
-/**
- * 依据当前登录账号判定 Issue 的归属身份维度 (可多选):
- * - reported: 用户提起的 (属于当前账号名下仓库，但作者不是本人)
- * - assigned: 被分配的 (指派列表中包含当前账号)
- * - created: 我创建的 (作者是当前账号)
- *
- * 为什么这样划分：
- * 在真实工程实践中，Maintainer 不仅要关注自己创建的任务，更要对社区/用户提交的 Bug 反馈负责，
- * 同时还要处理他人指派的待办任务。这三个维度互补且可能重叠。
- */
-function resolveIssueCategories(issue, currentUser, explicitRepoOwner) {
-    const categories = [];
-    if (!currentUser)
-        return categories;
-    const currentLower = currentUser.toLowerCase();
-    const authorLogin = issue.author?.login?.toLowerCase();
-    const isAuthor = Boolean(authorLogin && authorLogin === currentLower);
-    const isAssignee = Array.isArray(issue.assignees) &&
-        issue.assignees.some((a) => a.login?.toLowerCase() === currentLower);
-    // 仓库 owner 判定：优先从 repository.nameWithOwner 提取，兜底使用 explicitRepoOwner
-    let repoOwner = explicitRepoOwner?.toLowerCase();
-    if (!repoOwner && issue.repository?.nameWithOwner) {
-        repoOwner = issue.repository.nameWithOwner.split('/')[0]?.toLowerCase();
-    }
-    const isOwnerRepo = Boolean(repoOwner && repoOwner === currentLower);
-    if (isAuthor)
-        categories.push('created');
-    if (isAssignee)
-        categories.push('assigned');
-    // 如果是当前用户维护的仓库，且作者不是本人，则明确归为「用户提起的」
-    if (isOwnerRepo && !isAuthor)
-        categories.push('reported');
-    return categories;
-}
-function calculateIssueStats(issues) {
-    let reported = 0;
-    let assigned = 0;
-    let created = 0;
-    for (const item of issues) {
-        const cats = item.categories || [];
-        if (cats.includes('reported'))
-            reported++;
-        if (cats.includes('assigned'))
-            assigned++;
-        if (cats.includes('created'))
-            created++;
-    }
-    return {
-        total: issues.length,
-        reported,
-        assigned,
-        created,
-    };
-}
-/** path.basename 在空串/异常输入上会抛错，工作区路径来自磁盘文件，必须防御 */
-function basenameSafe(p) {
-    try {
-        return path.basename(p) || p;
-    }
-    catch {
-        return p;
-    }
-}
-/** 探测单个工作区时在途的 gh 进程数上限；libuv 线程池默认 4，留出余量给其他请求 */
-const WORKSPACE_PROBE_CONCURRENCY = 3;
-/**
- * 全局驾驶舱的缓存时长下限。
- * 这个端点要 spawn 十几次 gh，比单仓库概览重得多，因此不直接沿用 cacheTtlMs（默认 15s）。
- * 定在 5 分钟的依据：它展示的是「我的仓库 / 待办 PR / Issues」这类分钟级不变的数据，
- * 而每次刷新本机实测要 8-13 秒。缓存太短等于让用户反复等这段延迟——实测 60 秒缓存下，
- * 用户 65 秒后再打开面板仍需等 9.7 秒。仍随 cacheTtlMs 缩放，用户调大时这里同步变长。
- */
-const GLOBAL_CACHE_MIN_TTL_MS = 300_000;
-/**
- * 由用户配置推导全局驾驶舱的缓存时长。
- * 抽成导出的纯函数：TTL 的推导规则是测试断言的对象，埋在闭包里就只能靠猜。
- */
-export function globalCacheTtlMs(cacheTtlMs) {
-    const base = Number.isFinite(cacheTtlMs) && cacheTtlMs >= 0 ? cacheTtlMs : 15_000;
-    return Math.max(base * 20, GLOBAL_CACHE_MIN_TTL_MS);
-}
-/** open_browser 只允许 http/https，杜绝 file:// 与自定义协议被当作打开目标 */
-function isSafeExternalUrl(raw) {
-    if (typeof raw !== 'string' || raw.length === 0 || raw.length > 2048)
-        return false;
-    try {
-        const parsed = new URL(raw);
-        return parsed.protocol === 'http:' || parsed.protocol === 'https:';
-    }
-    catch {
-        return false;
-    }
-}
-export function registerApiRoutes(ctxOrWebServer, executor, workspaceRegistry, cacheTtlMs = 15_000, updateChecker, upgradeManager) {
+import { globalCacheTtlMs, sendJson, readJsonBody } from './route-helpers.js';
+import { registerOverviewRoutes } from './routes-overview.js';
+import { registerActionRoutes } from './routes-actions.js';
+import { registerLifecycleRoutes } from './routes-lifecycle.js';
+import { registerProxyRoutes } from './routes-proxy.js';
+// 再导出历史公共接口：globalCacheTtlMs 曾被测试直接 import，保持路径稳定避免破坏消费方
+export { globalCacheTtlMs };
+export function registerApiRoutes(ctxOrWebServer, executor, workspaceRegistry, cacheTtlMs = 15_000, updateChecker, upgradeManager, proxyManager) {
     const ctx = ctxOrWebServer;
     const webServer = ctx?.webServer || ctx;
     if (!webServer || typeof webServer.register !== 'function')
@@ -105,12 +17,6 @@ export function registerApiRoutes(ctxOrWebServer, executor, workspaceRegistry, c
     const upgrader = upgradeManager || new UpgradeManager();
     const cacheMap = new TtlCache(cacheTtlMs);
     const globalCache = new TtlCache(globalCacheTtlMs(cacheTtlMs));
-    function sendJson(res, status, data) {
-        res.statusCode = status;
-        res.setHeader('Content-Type', 'application/json; charset=utf-8');
-        res.setHeader('Cache-Control', 'no-store');
-        res.end(JSON.stringify(data));
-    }
     /**
      * 注册单个路由并返回注销器。
      * 为什么需要前置探测与清理：Cordis 插件在经历热重载、异常崩溃或重新启用时，若先前的 disposer
@@ -140,406 +46,10 @@ export function registerApiRoutes(ctxOrWebServer, executor, workspaceRegistry, c
             registerOneRoute(route);
         }
     };
-    // 1. 获取全局与当前仓库的 GitHub 概览
-    bindRoute({
-        kind: 'exact',
-        path: '/api/github/overview',
-        handler: async (req, res) => {
-            if (req.method !== 'GET') {
-                sendJson(res, 405, { ok: false, message: '仅支持 GET 请求' });
-                return;
-            }
-            try {
-                const url = new URL(req.url || '', 'http://127.0.0.1');
-                let cwd = url.searchParams.get('cwd');
-                const sessionId = url.searchParams.get('sessionId');
-                // 会话 ID → 物理路径，以及「最近活跃工作区」兜底，统一由 workspace 模块提供
-                if (!cwd && sessionId) {
-                    cwd = findWorkspacePathBySession(sessionId) || null;
-                }
-                if (!cwd) {
-                    cwd = findMostRecentWorkspacePath() || null;
-                }
-                if (!cwd) {
-                    cwd = process.cwd();
-                }
-                const now = Date.now();
-                const cachedData = cacheMap.get(cwd, now);
-                if (cachedData) {
-                    sendJson(res, 200, {
-                        ok: true,
-                        data: { ...cachedData, updateInfo: checker.getQuickStatus() },
-                        fromCache: true,
-                        cwd,
-                    });
-                    return;
-                }
-                const auth = await executor.checkAuth(cwd);
-                const repo = await executor.getRepoMetadata(cwd);
-                let pullRequests = [];
-                let issues = [];
-                let runs = [];
-                if (repo && auth.loggedIn) {
-                    // 并发拉取当前文件夹仓库的 PRs、Issues 和 Runs
-                    const [prsRes, issuesRes, runsRes] = await Promise.all([
-                        executor.run(['pr', 'list', '--json', 'number,title,state,author,headRefName,baseRefName,isDraft,mergeable,reviewDecision,statusCheckRollup,url,updatedAt', '-L', '10'], { cwd, timeoutMs: 8_000 }),
-                        executor.run(['issue', 'list', '--json', 'number,title,state,author,labels,assignees,url,updatedAt', '-L', '10'], { cwd, timeoutMs: 8_000 }),
-                        executor.run(['run', 'list', '--json', 'databaseId,name,status,conclusion,event,headBranch,url,createdAt', '-L', '5'], { cwd, timeoutMs: 8_000 }),
-                    ]);
-                    if (prsRes.ok && Array.isArray(prsRes.data))
-                        pullRequests = prsRes.data;
-                    if (issuesRes.ok && Array.isArray(issuesRes.data)) {
-                        const currentUser = auth.user;
-                        const repoOwner = repo?.owner || repo?.nameWithOwner?.split('/')[0];
-                        issues = issuesRes.data.map((item) => {
-                            const categories = resolveIssueCategories(item, currentUser, repoOwner);
-                            return {
-                                ...item,
-                                categories,
-                            };
-                        });
-                    }
-                    if (runsRes.ok && Array.isArray(runsRes.data))
-                        runs = runsRes.data;
-                }
-                const issueStats = calculateIssueStats(issues);
-                const freshData = {
-                    auth,
-                    repo: repo || undefined,
-                    pullRequests,
-                    issues,
-                    issueStats,
-                    runs,
-                    lastUpdated: new Date().toISOString(),
-                    updateInfo: checker.getQuickStatus(),
-                };
-                cacheMap.set(cwd, freshData, now);
-                sendJson(res, 200, { ok: true, data: freshData, fromCache: false, cwd });
-            }
-            catch (err) {
-                sendJson(res, 500, { ok: false, error: err.message || '获取 GitHub 概览失败' });
-            }
-        },
-    });
-    // 2. 强制刷新缓存
-    bindRoute({
-        kind: 'exact',
-        path: '/api/github/refresh',
-        handler: async (req, res) => {
-            cacheMap.clear();
-            globalCache.clear();
-            sendJson(res, 200, { ok: true, message: '缓存已清空，下次读取将拉取最新数据' });
-        },
-    });
-    // 3. 右侧栏快捷操作代理接口
-    bindRoute({
-        kind: 'exact',
-        path: '/api/github/action',
-        handler: async (req, res) => {
-            if (req.method !== 'POST') {
-                sendJson(res, 405, { ok: false, message: '仅支持 POST 请求' });
-                return;
-            }
-            let body = '';
-            req.on('data', (chunk) => { body += chunk; });
-            req.on('end', async () => {
-                try {
-                    const payload = body ? JSON.parse(body) : {};
-                    const cwd = payload.cwd || process.cwd();
-                    switch (payload.action) {
-                        case 'create_pr': {
-                            const cmd = ['pr', 'create', '--title', payload.title || 'Update', '--body', payload.body || 'Created from DSH Rightbar'];
-                            if (payload.draft)
-                                cmd.push('--draft');
-                            const r = await executor.run(cmd, { cwd });
-                            if (!r.ok)
-                                throw new Error(r.error);
-                            sendJson(res, 200, { ok: true, message: 'PR 创建成功', url: r.rawOutput });
-                            break;
-                        }
-                        case 'create_issue': {
-                            const cmd = ['issue', 'create', '--title', payload.title || 'New Issue', '--body', payload.body || 'Created from DSH Rightbar'];
-                            const r = await executor.run(cmd, { cwd });
-                            if (!r.ok)
-                                throw new Error(r.error);
-                            sendJson(res, 200, { ok: true, message: 'Issue 创建成功', url: r.rawOutput });
-                            break;
-                        }
-                        case 'open_browser': {
-                            // 原实现把 payload.url 直接拼进 shell 字符串再交给 exec()，
-                            // 形如 https://x" & calc & " 的 URL 可闭合引号并追加任意命令——本机任意页面
-                            // 都能通过 POST 这个端点触发命令执行。
-                            // 现在改为：先用 URL 解析白名单协议，再用 execFile 参数数组传递，全程不经过 shell。
-                            if (!isSafeExternalUrl(payload.url)) {
-                                throw new Error('url 参数无效：只允许 http/https 开头的完整地址');
-                            }
-                            const { execFile } = await import('node:child_process');
-                            const [bin, args] = process.platform === 'win32'
-                                ? ['cmd', ['/c', 'start', '', payload.url]]
-                                : process.platform === 'darwin'
-                                    ? ['open', [payload.url]]
-                                    : ['xdg-open', [payload.url]];
-                            // 不 await，也不让打开失败反向影响接口语义；仅记录以便排查
-                            execFile(bin, args, (err) => {
-                                if (err)
-                                    console.warn('[dsh-github-flow] 打开浏览器失败:', err?.message || err);
-                            });
-                            sendJson(res, 200, { ok: true, message: '已在浏览器打开' });
-                            break;
-                        }
-                        case 'open_terminal': {
-                            const command = typeof payload.command === 'string' ? payload.command.trim() : 'gh auth login';
-                            // 严格白名单过滤，严防任意命令注入
-                            const allowedCommands = [
-                                'gh auth login',
-                                'winget install --id GitHub.cli',
-                                'brew install gh',
-                                'sudo apt install gh',
-                                'sudo dnf install gh',
-                            ];
-                            if (!allowedCommands.includes(command)) {
-                                throw new Error(`不支持唤起该指令: ${command}`);
-                            }
-                            const { execFile } = await import('node:child_process');
-                            let bin = 'cmd';
-                            let args = [];
-                            if (process.platform === 'win32') {
-                                bin = 'cmd';
-                                args = ['/c', 'start', 'powershell', '-NoExit', '-Command', command];
-                            }
-                            else if (process.platform === 'darwin') {
-                                bin = 'osascript';
-                                args = ['-e', `tell application "Terminal" to do script "${command}"`, '-e', 'tell application "Terminal" to activate'];
-                            }
-                            else {
-                                bin = 'x-terminal-emulator';
-                                args = ['-e', command];
-                            }
-                            execFile(bin, args, (err) => {
-                                if (err)
-                                    console.warn('[dsh-github-flow] 唤起终端失败:', err?.message || err);
-                            });
-                            sendJson(res, 200, { ok: true, message: '已请求唤起系统终端' });
-                            break;
-                        }
-                        default:
-                            sendJson(res, 400, { ok: false, message: `未知的操作类型: ${payload.action}` });
-                    }
-                }
-                catch (err) {
-                    sendJson(res, 500, { ok: false, error: err.message || '操作执行失败' });
-                }
-            });
-        },
-    });
-    // 4. 获取全局视角的驾驶舱概览数据 (不绑定单一项目)
-    bindRoute({
-        kind: 'exact',
-        path: '/api/github/global-overview',
-        handler: async (req, res) => {
-            if (req.method !== 'GET') {
-                sendJson(res, 405, { ok: false, message: '仅支持 GET 请求' });
-                return;
-            }
-            // 全局驾驶舱要 spawn 十几次 gh（认证 + 仓库 + PR + Issue + 每个工作区探测），
-            // 实测冷启动曾达 18.9 秒。缓存是这里唯一的解药：面板每次挂载都会来取一次。
-            const now = Date.now();
-            const cachedGlobal = globalCache.get('global', now);
-            if (cachedGlobal) {
-                sendJson(res, 200, {
-                    ok: true,
-                    data: { ...cachedGlobal, updateInfo: checker.getQuickStatus() },
-                    fromCache: true,
-                });
-                return;
-            }
-            try {
-                const auth = await executor.checkAuth();
-                let userRepos = [];
-                let myPrs = [];
-                let myIssues = [];
-                let issueStats = { total: 0, reported: 0, assigned: 0, created: 0 };
-                let workspaceMatrix = [];
-                let workspaceError;
-                if (auth.loggedIn) {
-                    // 并发执行：1. 账号下仓库列表 2. 个人 PRs 3. 三维 Issue 检索（名下仓库用户提单 + 指派待办 + 我创建的）
-                    // 为什么三路并发搜索：
-                    // - --owner=@me: 捕获用户/访客在当前用户所有仓库下提的 Issue (如反馈 Bug、Feature Request)，解决外部提单看不见的问题
-                    // - --assignee=@me: 捕获团队成员或自己指派给当前账号的待办任务 (含跨组织/第三方项目)
-                    // - --author=@me: 捕获当前账号亲自发起的任务与向外部提起的议题
-                    // 3 个轻量进程与 repo/prs 同步 spawn，经 OS 并发调度实测仅耗时 3 秒出头，完全满足 8 秒超时门限。
-                    const issueFields = 'number,title,repository,author,assignees,labels,url,updatedAt';
-                    const queryResults = await Promise.allSettled([
-                        executor.run(['repo', 'list', '--limit', '20', '--json', 'name,nameWithOwner,description,defaultBranchRef,isPrivate,stargazerCount,updatedAt,url'], { timeoutMs: 8_000 }),
-                        executor.run(['search', 'prs', '--author=@me', '--state=open', '--limit', '10', '--json', 'number,title,repository,url,updatedAt'], { timeoutMs: 8_000 }),
-                        executor.run(['search', 'issues', '--owner=@me', '--state=open', '--sort=updated', '--limit', '15', '--json', issueFields], { timeoutMs: 8_000 }),
-                        executor.run(['search', 'issues', '--assignee=@me', '--state=open', '--sort=updated', '--limit', '15', '--json', issueFields], { timeoutMs: 8_000 }),
-                        executor.run(['search', 'issues', '--author=@me', '--state=open', '--sort=updated', '--limit', '15', '--json', issueFields], { timeoutMs: 8_000 }),
-                    ]);
-                    const reposRes = queryResults[0].status === 'fulfilled' ? queryResults[0].value : { ok: false };
-                    const prsRes = queryResults[1].status === 'fulfilled' ? queryResults[1].value : { ok: false };
-                    const ownerIssuesRes = queryResults[2].status === 'fulfilled' ? queryResults[2].value : { ok: false };
-                    const assignedIssuesRes = queryResults[3].status === 'fulfilled' ? queryResults[3].value : { ok: false };
-                    const authorIssuesRes = queryResults[4].status === 'fulfilled' ? queryResults[4].value : { ok: false };
-                    if (reposRes.ok && Array.isArray(reposRes.data)) {
-                        userRepos = reposRes.data.map((r) => ({
-                            name: r.name || '',
-                            nameWithOwner: r.nameWithOwner || '',
-                            description: r.description || '',
-                            defaultBranch: r.defaultBranchRef?.name || 'main',
-                            isPrivate: Boolean(r.isPrivate),
-                            stargazerCount: r.stargazerCount || 0,
-                            updatedAt: r.updatedAt || '',
-                            url: r.url || `https://github.com/${r.nameWithOwner}`,
-                        }));
-                    }
-                    if (prsRes.ok && Array.isArray(prsRes.data)) {
-                        myPrs = prsRes.data;
-                    }
-                    // 多源 Issues 聚合、按 URL 唯一去重并排序
-                    const issueMap = new Map();
-                    const collectIssues = (res) => {
-                        if (res.ok && Array.isArray(res.data)) {
-                            for (const item of res.data) {
-                                if (item.url && !issueMap.has(item.url)) {
-                                    issueMap.set(item.url, item);
-                                }
-                            }
-                        }
-                    };
-                    collectIssues(ownerIssuesRes);
-                    collectIssues(assignedIssuesRes);
-                    collectIssues(authorIssuesRes);
-                    const rawList = Array.from(issueMap.values());
-                    // 统一按最后更新时间降序排列
-                    rawList.sort((a, b) => new Date(b.updatedAt || 0).getTime() - new Date(a.updatedAt || 0).getTime());
-                    const currentUser = auth.user;
-                    myIssues = rawList.map((raw) => {
-                        const categories = resolveIssueCategories(raw, currentUser);
-                        return {
-                            number: raw.number,
-                            title: raw.title || '',
-                            repository: raw.repository || { nameWithOwner: '' },
-                            author: raw.author ? { login: raw.author.login } : undefined,
-                            assignees: Array.isArray(raw.assignees) ? raw.assignees.map((a) => ({ login: a.login })) : [],
-                            labels: Array.isArray(raw.labels) ? raw.labels.map((l) => ({ name: l.name, color: l.color })) : [],
-                            url: raw.url || '',
-                            updatedAt: raw.updatedAt || '',
-                            state: raw.state || 'OPEN',
-                            categories,
-                        };
-                    });
-                    issueStats = calculateIssueStats(myIssues);
-                }
-                // 解析本地所有工作区与 GitHub 关联矩阵
-                const wsRead = tryReadWorkspaces();
-                workspaceError = wsRead.error;
-                if (!workspaceError) {
-                    const wsEntries = wsRead.workspaces.filter((ws) => ws.path);
-                    // 有界并发探测：每个工作区最多 spawn 2 个 gh 进程，无上限并发会让它们全挤进
-                    // libuv 默认 4 线程的队列里排队，延迟随工作区数量线性劣化。
-                    // 这里刻意只用本地 .git/config 识别身份、不发网络请求——全局矩阵只需要「属于哪个仓库」，
-                    // 每次网络往返都要秒级，5 个工作区就足以把该端点拖到 20 秒。
-                    workspaceMatrix = await mapLimit(wsEntries, WORKSPACE_PROBE_CONCURRENCY, async (ws) => {
-                        const hasGit = hasGitDir(ws.path);
-                        return {
-                            id: ws.id,
-                            title: ws.title || basenameSafe(ws.path),
-                            path: ws.path,
-                            hasGit,
-                            repo: hasGit ? executor.getRepoIdentityFromLocal(ws.path) || undefined : undefined,
-                            sessionCount: ws.sessionIds.length,
-                        };
-                    });
-                }
-                const globalData = {
-                    auth,
-                    userRepos,
-                    workspaceMatrix,
-                    myPrs,
-                    myIssues,
-                    issueStats,
-                    lastUpdated: new Date().toISOString(),
-                    updateInfo: checker.getQuickStatus(),
-                    ...(workspaceError ? { workspaceError } : {}),
-                };
-                globalCache.set('global', globalData, now);
-                sendJson(res, 200, { ok: true, data: globalData, fromCache: false });
-            }
-            catch (err) {
-                sendJson(res, 500, { ok: false, error: err.message || '获取全局驾驶舱数据失败' });
-            }
-        },
-    });
-    // 5. 闲时静默检查更新端点（前端在 gh 业务数据完全拉取就绪后，由 idle 延时静默触发）
-    bindRoute({
-        kind: 'exact',
-        path: '/api/github/check-update',
-        handler: async (req, res) => {
-            if (req.method !== 'GET') {
-                sendJson(res, 405, { ok: false, message: '仅支持 GET 请求' });
-                return;
-            }
-            try {
-                const url = new URL(req.url || '', 'http://127.0.0.1');
-                const force = url.searchParams.get('force') === 'true';
-                const info = await checker.check(force);
-                sendJson(res, 200, { ok: true, data: info });
-            }
-            catch (err) {
-                sendJson(res, 500, { ok: false, error: err.message || '检查更新失败' });
-            }
-        },
-    });
-    // 6. 一键自动升级触发端点（用户点击操作横幅按钮后发起）
-    bindRoute({
-        kind: 'exact',
-        path: '/api/github/upgrade',
-        handler: async (req, res) => {
-            if (req.method !== 'POST') {
-                sendJson(res, 405, { ok: false, message: '仅支持 POST 请求' });
-                return;
-            }
-            try {
-                const info = await checker.check(false);
-                const result = await upgrader.executeUpgrade(info.latestVersion);
-                sendJson(res, result.ok ? 200 : 500, result);
-            }
-            catch (err) {
-                sendJson(res, 500, { ok: false, message: err.message || '执行自动升级异常' });
-            }
-        },
-    });
-    // 7. 升级状态与实时日志查询端点
-    bindRoute({
-        kind: 'exact',
-        path: '/api/github/upgrade-status',
-        handler: async (req, res) => {
-            if (req.method !== 'GET') {
-                sendJson(res, 405, { ok: false, message: '仅支持 GET 请求' });
-                return;
-            }
-            sendJson(res, 200, { ok: true, data: upgrader.getStatus() });
-        },
-    });
-    // 8. 快速认证状态轻量探针 (耗时 < 500ms，专供登录自愈检测与快速恢复)
-    bindRoute({
-        kind: 'exact',
-        path: '/api/github/auth',
-        handler: async (req, res) => {
-            if (req.method !== 'GET') {
-                sendJson(res, 405, { ok: false, message: '仅支持 GET 请求' });
-                return;
-            }
-            try {
-                const url = new URL(req.url || '', 'http://127.0.0.1');
-                const force = url.searchParams.get('force') === 'true';
-                const auth = await executor.checkAuth(undefined, force);
-                sendJson(res, 200, { ok: true, auth });
-            }
-            catch (err) {
-                sendJson(res, 500, { ok: false, error: err.message || '认证检测失败' });
-            }
-        },
-    });
+    // 各分组共享的依赖包：分组内部不再触碰 ctx/webServer 全局
+    const deps = { bindRoute, sendJson, readJsonBody };
+    registerOverviewRoutes(deps, executor, cacheMap, globalCache, checker);
+    registerActionRoutes(deps, executor, cacheMap, globalCache);
+    registerLifecycleRoutes(deps, executor, checker, upgrader);
+    registerProxyRoutes(deps, checker, proxyManager);
 }