dsh-github-flow 0.1.7 → 0.2.0

package/lib/api/route-helpers.d.ts

@@ -0,0 +1,47 @@
+import type { IssueCategory, IssueStats } from '../types.js';
+/**
+ * 依据当前登录账号判定 Issue 的归属身份维度 (可多选):
+ * - reported: 用户提起的 (属于当前账号名下仓库，但作者不是本人)
+ * - assigned: 被分配的 (指派列表中包含当前账号)
+ * - created: 我创建的 (作者是当前账号)
+ *
+ * 为什么这样划分：
+ * 在真实工程实践中，Maintainer 不仅要关注自己创建的任务，更要对社区/用户提交的 Bug 反馈负责，
+ * 同时还要处理他人指派的待办任务。这三个维度互补且可能重叠。
+ */
+export declare function resolveIssueCategories(issue: {
+    author?: {
+        login?: string;
+    } | null;
+    assignees?: Array<{
+        login?: string;
+    }> | null;
+    repository?: {
+        nameWithOwner?: string;
+    } | null;
+}, currentUser?: string, explicitRepoOwner?: string): IssueCategory[];
+export declare function calculateIssueStats(issues: Array<{
+    categories?: IssueCategory[];
+}>): IssueStats;
+/** path.basename 在空串/异常输入上会抛错，工作区路径来自磁盘文件，必须防御 */
+export declare function basenameSafe(p: string): string;
+/**
+ * 由用户配置推导全局驾驶舱的缓存时长。
+ * 抽成导出的纯函数：TTL 的推导规则是测试断言的对象，埋在闭包里就只能靠猜。
+ */
+export declare function globalCacheTtlMs(cacheTtlMs: number): number;
+/** open_browser 只允许 http/https，杜绝 file:// 与自定义协议被当作打开目标 */
+export declare function isSafeExternalUrl(raw: unknown): raw is string;
+/** JSON 响应统一出口：no-store 防代理/浏览器缓存干扰面板数据新鲜度语义 */
+export declare function sendJson(res: any, status: number, data: any): void;
+/**
+ * 读取并解析请求 JSON body（带默认 256KB 上限防护）。
+ * 集中处理超限/畸形 JSON 的错误语义，避免每个 handler 复制流收集样板。
+ */
+export declare function readJsonBody(req: any, maxBytes?: number): Promise<any>;
+/** 各路由分组共享的依赖包类型：注册器装配时一次性注入，分组内不再触碰全局 */
+export interface RouteDeps {
+    bindRoute: (route: any) => void;
+    sendJson: typeof sendJson;
+    readJsonBody: typeof readJsonBody;
+}

package/lib/api/route-helpers.js

@@ -0,0 +1,134 @@
+/**
+ * API 路由共享工具层。
+ *
+ * 为什么从 routes.ts 拆出：这些工具被全部路由分组文件消费（sendJson/readJsonBody/
+ * issue 聚合/TTL 推导），放在任何一个分组文件里都会造成分组之间的横向依赖；
+ * 独立成无状态模块后，各分组只依赖它，注册器只装配。
+ */
+import path from 'node:path';
+/**
+ * 依据当前登录账号判定 Issue 的归属身份维度 (可多选):
+ * - reported: 用户提起的 (属于当前账号名下仓库，但作者不是本人)
+ * - assigned: 被分配的 (指派列表中包含当前账号)
+ * - created: 我创建的 (作者是当前账号)
+ *
+ * 为什么这样划分：
+ * 在真实工程实践中，Maintainer 不仅要关注自己创建的任务，更要对社区/用户提交的 Bug 反馈负责，
+ * 同时还要处理他人指派的待办任务。这三个维度互补且可能重叠。
+ */
+export 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;
+}
+export 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 在空串/异常输入上会抛错，工作区路径来自磁盘文件，必须防御 */
+export function basenameSafe(p) {
+    try {
+        return path.basename(p) || p;
+    }
+    catch {
+        return p;
+    }
+}
+/**
+ * 全局驾驶舱的缓存时长下限。
+ * 这个端点要 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:// 与自定义协议被当作打开目标 */
+export 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;
+    }
+}
+/** JSON 响应统一出口：no-store 防代理/浏览器缓存干扰面板数据新鲜度语义 */
+export 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));
+}
+/**
+ * 读取并解析请求 JSON body（带默认 256KB 上限防护）。
+ * 集中处理超限/畸形 JSON 的错误语义，避免每个 handler 复制流收集样板。
+ */
+export function readJsonBody(req, maxBytes = 256 * 1024) {
+    return new Promise((resolve, reject) => {
+        let body = '';
+        let size = 0;
+        req.on('data', (chunk) => {
+            size += chunk.length;
+            if (size > maxBytes) {
+                reject(new Error(`请求体超过 ${maxBytes} 字节上限`));
+                req.destroy();
+                return;
+            }
+            body += chunk;
+        });
+        req.on('end', () => {
+            try {
+                resolve(body ? JSON.parse(body) : {});
+            }
+            catch {
+                reject(new Error('请求体不是合法 JSON'));
+            }
+        });
+        req.on('error', reject);
+    });
+}

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

@@ -0,0 +1,9 @@
+/**
+ * 动作类路由：缓存强制刷新 + 右侧栏快捷操作（create_pr/create_issue/open_browser/open_terminal）。
+ * 共同特征：POST 触发、读少写多、无缓存语义，与概览类路由的演进方向不同。
+ */
+import type { GhExecutor } from '../executor.js';
+import { TtlCache } from '../cache.js';
+import type { GitHubOverviewData, GlobalOverviewData } from '../types.js';
+import { type RouteDeps } from './route-helpers.js';
+export declare function registerActionRoutes(deps: RouteDeps, executor: GhExecutor, cacheMap: TtlCache<GitHubOverviewData>, globalCache: TtlCache<GlobalOverviewData>): void;

package/lib/api/routes-actions.js

@@ -0,0 +1,115 @@
+import { isSafeExternalUrl, sendJson } from './route-helpers.js';
+export function registerActionRoutes(deps, executor, cacheMap, globalCache) {
+    const { bindRoute } = deps;
+    // 1. 强制刷新缓存
+    bindRoute({
+        kind: 'exact',
+        path: '/api/github/refresh',
+        handler: async (req, res) => {
+            cacheMap.clear();
+            globalCache.clear();
+            sendJson(res, 200, { ok: true, message: '缓存已清空，下次读取将拉取最新数据' });
+        },
+    });
+    // 2. 右侧栏快捷操作代理接口
+    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 || '操作执行失败' });
+                }
+            });
+        },
+    });
+}

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

@@ -0,0 +1,9 @@
+/**
+ * 生命周期类路由：版本检查 / 一键升级 / 升级状态轮询 / 认证轻量探针。
+ * 共同特征：服务插件自身状态而非 GitHub 业务数据，故障语义独立于概览链路。
+ */
+import type { GhExecutor } from '../executor.js';
+import type { UpdateChecker } from '../updater.js';
+import type { UpgradeManager } from '../upgrade-manager.js';
+import { type RouteDeps } from './route-helpers.js';
+export declare function registerLifecycleRoutes(deps: RouteDeps, executor: GhExecutor, checker: UpdateChecker, upgrader: UpgradeManager): void;

package/lib/api/routes-lifecycle.js

@@ -0,0 +1,75 @@
+import { sendJson } from './route-helpers.js';
+export function registerLifecycleRoutes(deps, executor, checker, upgrader) {
+    const { bindRoute } = deps;
+    // 1. 闲时静默检查更新端点（前端在 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 || '检查更新失败' });
+            }
+        },
+    });
+    // 2. 一键自动升级触发端点（用户点击操作横幅按钮后发起）
+    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 || '执行自动升级异常' });
+            }
+        },
+    });
+    // 3. 升级状态与实时日志查询端点
+    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() });
+        },
+    });
+    // 4. 快速认证状态轻量探针 (耗时 < 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 || '认证检测失败' });
+            }
+        },
+    });
+}

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

@@ -0,0 +1,11 @@
+/**
+ * 概览类路由：单仓库 overview + 全局驾驶舱 global-overview。
+ * 这两个端点是面板首屏关键路径（也是项目里最重的两个 handler），单独成组
+ * 便于按「读密集」特征统一演进（缓存策略、字段投影、并发控制）。
+ */
+import type { GhExecutor } from '../executor.js';
+import { TtlCache } from '../cache.js';
+import type { UpdateChecker } from '../updater.js';
+import type { GitHubOverviewData, GlobalOverviewData } from '../types.js';
+import { type RouteDeps } from './route-helpers.js';
+export declare function registerOverviewRoutes(deps: RouteDeps, executor: GhExecutor, cacheMap: TtlCache<GitHubOverviewData>, globalCache: TtlCache<GlobalOverviewData>, checker: UpdateChecker): void;

package/lib/api/routes-overview.js

@@ -0,0 +1,227 @@
+import { mapLimit, tryReadWorkspaces, findWorkspacePathBySession, findMostRecentWorkspacePath, hasGitDir } from '../workspace.js';
+import { resolveIssueCategories, calculateIssueStats, basenameSafe, sendJson } from './route-helpers.js';
+/** 探测单个工作区时在途的 gh 进程数上限；libuv 线程池默认 4，留出余量给其他请求 */
+const WORKSPACE_PROBE_CONCURRENCY = 3;
+export function registerOverviewRoutes(deps, executor, cacheMap, globalCache, checker) {
+    const { bindRoute } = deps;
+    // 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/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 || '获取全局驾驶舱数据失败' });
+            }
+        },
+    });
+}

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;