dsh-github-flow 0.1.3 → 0.1.5

package/lib/client.js

@@ -304,6 +304,80 @@ body[data-ds-dark-theme] .dsh-github-action-btn:hover {
   color: #58a6ff;
 }
 
+/* 组合式快捷操作按钮 (AI 智能装填主操作 + 官方外链直达) */
+.dsh-github-split-btn {
+  display: flex;
+  align-items: stretch;
+  border-radius: 6px;
+  border: 1px solid var(--dsw-alias-border-l2, #e1e4e8);
+  background: var(--dsw-alias-bg-module-platform, #f6f8fa);
+  overflow: hidden;
+  transition: all 0.15s ease;
+}
+.dsh-github-split-btn:hover {
+  border-color: var(--dsw-alias-link, #0969da);
+}
+body[data-ds-dark-theme] .dsh-github-split-btn {
+  border-color: var(--dsw-alias-border-l1, #444);
+  background: var(--dsw-alias-bg-layer-2, #28282b);
+}
+body[data-ds-dark-theme] .dsh-github-split-btn:hover {
+  border-color: #58a6ff;
+}
+.dsh-github-split-main {
+  flex: 1;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  gap: 5px;
+  padding: 8px 8px;
+  border: 0;
+  background: transparent;
+  color: var(--dsw-alias-label-primary, #1f2328);
+  font-size: 12px;
+  font-weight: 500;
+  cursor: pointer;
+  transition: all 0.15s ease;
+  white-space: nowrap;
+}
+.dsh-github-split-main:hover {
+  background: var(--dsw-alias-interactive-bg-hover, #ebeef2);
+  color: var(--dsw-alias-link, #0969da);
+}
+body[data-ds-dark-theme] .dsh-github-split-main {
+  color: var(--dsw-alias-label-primary, #fff);
+}
+body[data-ds-dark-theme] .dsh-github-split-main:hover {
+  background: var(--dsw-alias-interactive-bg-hover, #343438);
+  color: #58a6ff;
+}
+.dsh-github-split-link {
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  padding: 0 8px;
+  border-left: 1px solid var(--dsw-alias-border-l2, #e1e4e8);
+  background: transparent;
+  color: var(--dsw-alias-label-tertiary, #656d76);
+  font-size: 12px;
+  font-weight: bold;
+  text-decoration: none !important;
+  cursor: pointer;
+  transition: all 0.15s ease;
+}
+.dsh-github-split-link:hover {
+  background: var(--dsw-alias-interactive-bg-hover, #ebeef2);
+  color: var(--dsw-alias-link, #0969da);
+}
+body[data-ds-dark-theme] .dsh-github-split-link {
+  border-left-color: var(--dsw-alias-border-l1, #444);
+  color: var(--dsw-alias-label-secondary, #9ca3af);
+}
+body[data-ds-dark-theme] .dsh-github-split-link:hover {
+  background: var(--dsw-alias-interactive-bg-hover, #343438);
+  color: #58a6ff;
+}
+
 /* 9. 模块分区与列表 */
 .dsh-github-section {
   margin-bottom: 20px;
@@ -609,23 +683,6 @@ body[data-ds-dark-theme] .dsh-github-subheading {
                 onClick: onRefresh,
                 disabled: loading,
             }, loading ? "刷新中..." : "🔄 刷新"));
-            // 操作执行函数
-            const runAction = async (action, extra = {}) => {
-                try {
-                    const res = await fetch("/api/github/action", {
-                        method: "POST",
-                        headers: { "Content-Type": "application/json" },
-                        body: JSON.stringify({ action, ...extra }),
-                    });
-                    const json = await res.json();
-                    alert(json.ok ? `✅ ${json.message || "操作已完成"}` : `❌ ${json.error || "操作失败"}`);
-                    if (json.ok)
-                        onRefresh();
-                }
-                catch (err) {
-                    alert(`网络异常: ${err.message}`);
-                }
-            };
             // 仓库基础卡片
             var repoCardEl = h("div", { className: "dsh-github-card" }, h("div", { className: "dsh-github-card-title" }, "当前工作区 GitHub 仓库"), h("div", { className: "dsh-github-card-value" }, repo
                 ? h("a", { href: repo.url, target: "_blank", className: "dsh-github-repo-link" }, repo.nameWithOwner)
@@ -636,40 +693,46 @@ body[data-ds-dark-theme] .dsh-github-subheading {
                 : null, !repo
                 ? h("div", { className: "dsh-github-card-subtext" }, "若本地已有 git 仓库，请运行 `git remote add github <url>` 或 `git remote add origin <url>` 关联远程仓库。")
                 : null);
-            // 快捷操作栏
-            var actionsBarEl = h("div", { className: "dsh-github-quick-actions" }, h("button", {
+            // 快捷操作栏 (方案 1: 官方黄金功能直达)
+            var actionsBarEl = h("div", { className: "dsh-github-quick-actions" }, 
+            // 1. 浏览器打开仓库主页
+            h("button", {
                 className: "dsh-github-action-btn",
+                title: "在系统默认浏览器中打开当前仓库主页",
                 onClick: () => {
                     if (repo?.url) {
                         window.open(repo.url, "_blank", "noopener,noreferrer");
                     }
-                    else {
-                        alert("当前工作区尚未关联 GitHub 仓库");
-                    }
                 },
-            }, "🌐 浏览器打开"), h("button", {
+            }, "🌐 浏览器打开"), 
+            // 2. 查看所有 PRs
+            h("button", {
                 className: "dsh-github-action-btn",
+                title: "在系统默认浏览器中查看所有 Pull Requests",
                 onClick: () => {
                     if (repo?.url) {
                         window.open(`${repo.url}/pulls`, "_blank", "noopener,noreferrer");
                     }
-                    else {
-                        alert("当前工作区尚未关联 GitHub 仓库");
-                    }
                 },
-            }, "🔀 查看所有 PRs"), h("button", {
+            }, "🔀 查看所有 PRs"), 
+            // 3. 🚀 快速创建 PR (官方对比与创建页直达)
+            h("button", {
                 className: "dsh-github-action-btn",
+                title: "在系统默认浏览器中打开 GitHub 官方对比与创建 Pull Request 页面",
                 onClick: () => {
-                    var title = prompt("请输入要创建的 PR 标题:");
-                    if (title)
-                        runAction("create_pr", { title });
+                    if (repo?.url) {
+                        window.open(`${repo.url}/compare`, "_blank", "noopener,noreferrer");
+                    }
                 },
-            }, "🚀 快速创建 PR"), h("button", {
+            }, "🚀 快速创建 PR"), 
+            // 4. 📝 新建 Issue (官方 Issue 模板页直达)
+            h("button", {
                 className: "dsh-github-action-btn",
+                title: "在系统默认浏览器中打开 GitHub 官方新建 Issue 页面",
                 onClick: () => {
-                    var title = prompt("请输入 Issue 标题:");
-                    if (title)
-                        runAction("create_issue", { title });
+                    if (repo?.url) {
+                        window.open(`${repo.url}/issues/new`, "_blank", "noopener,noreferrer");
+                    }
                 },
             }, "📝 新建 Issue"));
             // PR 列表
@@ -720,6 +783,11 @@ body[data-ds-dark-theme] .dsh-github-subheading {
                         url += "?" + params.join("&");
                     }
                     var res = await fetch(url);
+                    if (!res.ok) {
+                        var errText = await res.text().catch(() => "");
+                        setError(`后端服务未就绪 (${res.status}): ${errText || res.statusText}`);
+                        return;
+                    }
                     var json = await res.json();
                     if (json.ok && json.data) {
                         setData(json.data);
@@ -769,20 +837,43 @@ body[data-ds-dark-theme] .dsh-github-subheading {
             var loadData = React.useCallback(async (forceRefresh = false) => {
                 setLoading(true);
                 setError(null);
+                // 全局驾驶舱要 spawn 十几次 gh，冷启动可能超过 10 秒。
+                // 不设显式超时的话浏览器会抛一个与真实原因无关的网络错误，
+                // 早先这里会把所有失败都归因成「后端服务未就绪或接口不存在」——归因错误比没有报错更糟。
+                var controller = new AbortController();
+                var timedOut = false;
+                var timer = setTimeout(function () { timedOut = true; controller.abort(); }, 30000);
                 try {
                     if (forceRefresh)
                         await fetch("/api/github/refresh", { method: "POST" }).catch(() => { });
-                    var res = await fetch("/api/github/global-overview");
+                    var res = await fetch("/api/github/global-overview", { signal: controller.signal });
+                    if (!res.ok) {
+                        var errText = await res.text().catch(() => "");
+                        setError(`获取全局数据失败（HTTP ${res.status}）${errText ? ": " + errText : ""}`);
+                        return;
+                    }
                     var json = await res.json();
-                    if (json.ok && json.data)
+                    if (json.ok && json.data) {
                         setData(json.data);
-                    else
+                        // 工作区矩阵单独失败时不能静默：否则界面显示「暂无工作区」，把故障伪装成空状态
+                        if (json.data.workspaceError) {
+                            setError("工作区列表读取失败：" + json.data.workspaceError);
+                        }
+                    }
+                    else {
                         setError(json.error || "获取全局数据失败");
+                    }
                 }
                 catch (err) {
-                    setError(err.message);
+                    if (timedOut || err.name === "AbortError") {
+                        setError("获取超时（30 秒）：本机 gh 命令响应过慢，通常是网络或工作区数量较多所致。可稍后重试，或减少同时打开的工作区。");
+                    }
+                    else {
+                        setError("无法连接后端服务：" + (err.message || err));
+                    }
                 }
                 finally {
+                    clearTimeout(timer);
                     setLoading(false);
                 }
             }, []);

package/lib/commands/gh.js

@@ -7,7 +7,9 @@ export function registerGhCommand(commandsService, executor) {
         async handler({ rawInput }) {
             const trimmed = (rawInput || '').trim();
             if (!trimmed || trimmed === 'status') {
-                const auth = await executor.checkAuth();
+                // 人类显式诊断必须绕过缓存：用户敲 /gh status 往往正是为了确认
+                // 「我刚 gh auth login 到底成没成」，给他 30 秒前的缓存等于答非所问。
+                const auth = await executor.checkAuth(undefined, true);
                 const repo = await executor.getRepoMetadata();
                 let md = `### GitHub 集成状态\n\n`;
                 if (auth.loggedIn) {

package/lib/executor.d.ts

@@ -1,10 +1,31 @@
 import type { GhExecutionOptions, GhResult, AuthStatus, RepoMetadata, PluginConfig } from './types.js';
+/**
+ * 按「字符数 + UTF-8 字节数」双口径截断输出。
+ * 抽成纯函数是刻意的：截断逻辑是崩溃高发区（切碎多字节字符、误伤 JSON、把二进制流截成垃圾），
+ * 但通过真实 gh 命令很难稳定复现超限输出，抽出来才能用单元测试覆盖边界。
+ */
+export declare function truncateOutput(input: string, maxChars: number, maxBytes: number): {
+    text: string;
+    truncated: boolean;
+};
 export declare class GhExecutor {
     ghPath: string;
     defaultTimeoutMs: number;
     maxOutputChars: number;
+    /** UTF-8 字节口径的硬上限；未配置时按 maxOutputChars × 4 推导（覆盖 CJK 3 字节与 emoji 4 字节） */
+    maxOutputBytes: number;
+    /** 认证状态缓存。`gh auth status` 实测 5.4 秒，而它位于全局驾驶舱关键路径的最前面 */
+    private authCache;
     constructor(config?: PluginConfig);
     updateConfig(config?: PluginConfig): void;
+    /**
+     * 智能解析最可靠的工作区物理路径：
+     * 1. 优先使用显式指定的有效 cwd（若包含 .git 目录）
+     * 2. 读取当前进程/会话的 DSH_SESSION_ID 并匹配 ~/.dsh/storages/workspace.json
+     * 3. 匹配 ~/.dsh/storages/workspace.json 中最近活跃的工作区
+     * 4. 回退到 process.cwd()
+     */
+    resolveWorkspaceCwd(explicitCwd?: string): string;
     /**
      * 安全执行 gh 命令
      * 采用 execFile 参数数组隔离，彻底杜绝 Shell 字符串拼接注入漏洞
@@ -12,8 +33,24 @@ export declare class GhExecutor {
     run<T = unknown>(args: string[], options?: GhExecutionOptions): Promise<GhResult<T>>;
     /**
      * 检查宿主机当前 GitHub CLI 的认证状态与账号信息
+     *
+     * @param cwd 解析工作区用的路径
+     * @param bypassCache 跳过进程内缓存。`/gh status` 这类人类显式发起的诊断必须看到实时结果，
+     *   而 Web 面板每次挂载都会来问一次，重复执行实测要 5.4 秒，属于纯浪费。
+     */
+    checkAuth(cwd?: string, bypassCache?: boolean): Promise<AuthStatus>;
+    /** 实际执行 `gh auth status` 并解析结果，不含缓存逻辑 */
+    private probeAuth;
+    /**
+     * 仅从本地 .git/config 解析仓库身份，绝不发起网络请求。
+     *
+     * 为什么需要它：全局驾驶舱要为每个工作区认识别仓库，而 getRepoMetadata 会调用
+     * `gh repo view` 走网络。实测 5 个工作区时该端点冷启动 20.5 秒，其中绝大部分耗在这 5 次
+     * 网络往返上——而有界并发根本救不了它，因为瓶颈是网络延迟而不是进程排队。
+     * 工作区矩阵只需要「这个目录属于哪个仓库」这一身份信息，本地 .git/config 已经完整具备，
+     * 描述/star 数等富字段是当前仓库详情才需要的。这一步把每个工作区从 1 次网络往返降为 0。
      */
-    checkAuth(cwd?: string): Promise<AuthStatus>;
+    getRepoIdentityFromLocal(cwd?: string): RepoMetadata | null;
     /**
      * 获取当前目录（工作区）关联的远程仓库元数据
      * 采用 gh repo view + 本地 git remote 双保险机制，彻底杜绝已配置远程却误判未关联的问题

package/lib/executor.js

@@ -1,29 +1,151 @@
 import { execFile } from 'node:child_process';
 import { promisify } from 'node:util';
+import fs from 'node:fs';
+import path from 'node:path';
+import { findMostRecentWorkspacePath, findWorkspacePathBySession, hasGitDir } from './workspace.js';
 const execFileAsync = promisify(execFile);
+/** 认证状态缓存时长。用户手动 `gh auth login/logout` 后最多 30 秒内面板才会反映，属可接受代价 */
+const AUTH_CACHE_TTL_MS = 30_000;
+/**
+ * 按码点安全截取字符串，等价于 String.prototype.slice 但对孤立的代理对（surrogate pair）做占位替换。
+ * 为什么必须这样截：本文件末尾会按 UTF-8 字节数截断，而 node:child_process 把 stdout 按字节缓冲区
+ * 切分后再 toString('utf8')，一个汉字被从中间切开时会变成 U+FFFD 替换字符。直接用 slice 会把半截
+ * 代理对留在结果里，导致下游 JSON.stringify 产出孤立转义序列、写入文件时编码报错。
+ */
+function safeSlice(input, start, end) {
+    const chars = Array.from(input);
+    const from = Math.max(0, start);
+    const to = end === undefined ? chars.length : Math.max(from, end);
+    return chars.slice(from, to).map((c) => (c.length === 1 && c.charCodeAt(0) >= 0xd800 && c.charCodeAt(0) <= 0xdfff ? '\ufffd' : c)).join('');
+}
+/**
+ * 以 UTF-8 字节数（而非字符串长度）为口径，从两端保留内容。
+ * 为什么需要：maxOutputChars 数的是字符，中文一个字占 3 字节。只按字符限长时，
+ * 中文环境下真实放行的字节量可达标称值的数倍，Token 预算保护会失真。
+ * 采用二分查找定位截断点，避免对超大输出逐字符累加造成 O(n) 反复编码。
+ */
+function cutByUtf8Bytes(input, headBytes, tailBytes) {
+    const encoder = new TextEncoder();
+    const totalBytes = encoder.encode(input).length;
+    if (totalBytes <= headBytes + tailBytes) {
+        return { head: input, tail: '', keptHeadBytes: totalBytes, keptTailBytes: 0, truncated: false };
+    }
+    const chars = Array.from(input);
+    const atByte = (limit, fromEnd) => {
+        let lo = 0;
+        let hi = chars.length;
+        let bytes = 0;
+        while (lo < hi) {
+            const mid = (lo + hi + 1) >> 1;
+            const slice = fromEnd ? chars.slice(chars.length - mid) : chars.slice(0, mid);
+            const size = encoder.encode(slice.join('')).length;
+            if (size <= limit) {
+                lo = mid;
+                bytes = size;
+            }
+            else {
+                hi = mid - 1;
+            }
+        }
+        return { count: lo, bytes };
+    };
+    const headPart = atByte(headBytes, false);
+    const tailPart = atByte(tailBytes, true);
+    return {
+        head: safeSlice(input, 0, headPart.count),
+        tail: safeSlice(input, chars.length - tailPart.count),
+        keptHeadBytes: headPart.bytes,
+        keptTailBytes: tailPart.bytes,
+        truncated: true,
+    };
+}
+/**
+ * 按「字符数 + UTF-8 字节数」双口径截断输出。
+ * 抽成纯函数是刻意的：截断逻辑是崩溃高发区（切碎多字节字符、误伤 JSON、把二进制流截成垃圾），
+ * 但通过真实 gh 命令很难稳定复现超限输出，抽出来才能用单元测试覆盖边界。
+ */
+export function truncateOutput(input, maxChars, maxBytes) {
+    // 双重口径限长：字符数守住 Token 预算，字节数守住真实传输量。
+    // 中文场景下两者会分别触发，因此两条路径的提示文案必须区分，避免用户按错误的配置项去调参。
+    if (input.length > maxChars) {
+        // 保留前 1/3 字符和尾部 1/2 字符，保留开头上下文和错误尾部
+        const headLen = Math.floor(maxChars * 0.35);
+        const tailLen = Math.floor(maxChars * 0.55);
+        const head = safeSlice(input, 0, headLen);
+        const tail = safeSlice(input, input.length - tailLen);
+        return {
+            text: `${head}\n\n... [⚠️ 提示：内容过长已由 DSH GitHub 插件截断中间部分，当前截取前 ${Math.round(headLen / 1024)}KB 与后 ${Math.round(tailLen / 1024)}KB] ...\n\n${tail}`,
+            truncated: true,
+        };
+    }
+    const byteCut = cutByUtf8Bytes(input, Math.floor(maxBytes * 0.35), Math.floor(maxBytes * 0.55));
+    if (byteCut.truncated) {
+        // 这里必须用「实际保留的字节数」而非 maxChars 推导值：字节口径触发时 maxChars 往往远大于
+        // 字节上限，早先版本照抄字符分支的算法，会报出与实际严重不符的「已保留 100KB」（实际仅数百字节）。
+        return {
+            text: `${byteCut.head}\n\n... [⚠️ 提示：内容超出 UTF-8 字节上限 (${maxBytes} bytes) 已截断中间部分，实际保留前 ${byteCut.keptHeadBytes} 字节与后 ${byteCut.keptTailBytes} 字节；如需放宽请调大配置项 maxOutputBytes] ...\n\n${byteCut.tail}`,
+            truncated: true,
+        };
+    }
+    return { text: input, truncated: false };
+}
 export class GhExecutor {
     ghPath;
     defaultTimeoutMs;
     maxOutputChars;
+    /** UTF-8 字节口径的硬上限；未配置时按 maxOutputChars × 4 推导（覆盖 CJK 3 字节与 emoji 4 字节） */
+    maxOutputBytes;
+    /** 认证状态缓存。`gh auth status` 实测 5.4 秒，而它位于全局驾驶舱关键路径的最前面 */
+    authCache = null;
     constructor(config = {}) {
         this.ghPath = config.ghPath || 'gh';
         this.defaultTimeoutMs = config.defaultTimeoutMs || 30_000;
         this.maxOutputChars = config.maxOutputChars || 24_000;
+        this.maxOutputBytes = config.maxOutputBytes || this.maxOutputChars * 4;
     }
     updateConfig(config = {}) {
         if (config.ghPath)
             this.ghPath = config.ghPath;
         if (config.defaultTimeoutMs)
             this.defaultTimeoutMs = config.defaultTimeoutMs;
-        if (config.maxOutputChars)
+        if (config.maxOutputChars) {
             this.maxOutputChars = config.maxOutputChars;
+            if (!config.maxOutputBytes)
+                this.maxOutputBytes = config.maxOutputChars * 4;
+        }
+        if (config.maxOutputBytes)
+            this.maxOutputBytes = config.maxOutputBytes;
+    }
+    /**
+     * 智能解析最可靠的工作区物理路径：
+     * 1. 优先使用显式指定的有效 cwd（若包含 .git 目录）
+     * 2. 读取当前进程/会话的 DSH_SESSION_ID 并匹配 ~/.dsh/storages/workspace.json
+     * 3. 匹配 ~/.dsh/storages/workspace.json 中最近活跃的工作区
+     * 4. 回退到 process.cwd()
+     */
+    resolveWorkspaceCwd(explicitCwd) {
+        // 显式路径优先，但只认真正含 .git 的目录：调用方传进来的可能是会话根目录而非仓库目录，
+        // 此时继续往下走按会话/最近活跃反查，比盲信传入值更准。
+        if (explicitCwd && hasGitDir(explicitCwd)) {
+            return explicitCwd;
+        }
+        const sessionId = process.env.DSH_SESSION_ID;
+        if (sessionId) {
+            const bySession = findWorkspacePathBySession(sessionId);
+            if (bySession)
+                return bySession;
+        }
+        const recent = findMostRecentWorkspacePath();
+        if (recent)
+            return recent;
+        return explicitCwd || process.cwd();
     }
     /**
      * 安全执行 gh 命令
      * 采用 execFile 参数数组隔离，彻底杜绝 Shell 字符串拼接注入漏洞
      */
     async run(args, options = {}) {
-        const cwd = options.cwd || process.cwd();
+        const cwd = this.resolveWorkspaceCwd(options.cwd);
         const timeout = options.timeoutMs || this.defaultTimeoutMs;
         try {
             const { stdout, stderr } = await execFileAsync(this.ghPath, args, {
@@ -41,16 +163,9 @@ export class GhExecutor {
             if (!rawOutput && stderr) {
                 rawOutput = stderr.trim();
             }
-            let truncated = false;
-            if (rawOutput.length > this.maxOutputChars) {
-                // 保留前 1/3 字符和尾部 1/2 字符，保留开头上下文和错误尾部
-                const headLen = Math.floor(this.maxOutputChars * 0.35);
-                const tailLen = Math.floor(this.maxOutputChars * 0.55);
-                const head = rawOutput.slice(0, headLen);
-                const tail = rawOutput.slice(-tailLen);
-                rawOutput = `${head}\n\n... [⚠️ 提示：内容过长已由 DSH GitHub 插件截断中间部分，当前截取前 ${Math.round(headLen / 1024)}KB 与后 ${Math.round(tailLen / 1024)}KB] ...\n\n${tail}`;
-                truncated = true;
-            }
+            const outcome = truncateOutput(rawOutput, this.maxOutputChars, this.maxOutputBytes);
+            rawOutput = outcome.text;
+            const truncated = outcome.truncated;
             // 如果未被截断且命令带有 --json 或包含 api，尝试解析为 JSON
             if (!options.rawText && !truncated && (args.includes('--json') || args.includes('api'))) {
                 try {
@@ -89,8 +204,26 @@ export class GhExecutor {
     }
     /**
      * 检查宿主机当前 GitHub CLI 的认证状态与账号信息
+     *
+     * @param cwd 解析工作区用的路径
+     * @param bypassCache 跳过进程内缓存。`/gh status` 这类人类显式发起的诊断必须看到实时结果，
+     *   而 Web 面板每次挂载都会来问一次，重复执行实测要 5.4 秒，属于纯浪费。
      */
-    async checkAuth(cwd) {
+    async checkAuth(cwd, bypassCache = false) {
+        const now = Date.now();
+        if (!bypassCache && this.authCache && now - this.authCache.at < AUTH_CACHE_TTL_MS) {
+            return this.authCache.value;
+        }
+        const value = await this.probeAuth(cwd);
+        // 只缓存确定的结果：出错时（未安装/未登录/网络异常）不缓存，
+        // 否则用户 `gh auth login` 之后还要再等满一个 TTL 才能看到面板恢复。
+        if (value.loggedIn) {
+            this.authCache = { at: now, value };
+        }
+        return value;
+    }
+    /** 实际执行 `gh auth status` 并解析结果，不含缓存逻辑 */
+    async probeAuth(cwd) {
         const res = await this.run(['auth', 'status'], { cwd, timeoutMs: 10_000, rawText: true });
         const raw = (res.rawOutput || '') + '\n' + (res.error || '');
         const loggedIn = raw.includes('Logged in to') || raw.includes('✓');
@@ -139,12 +272,48 @@ export class GhExecutor {
             raw,
         };
     }
+    /**
+     * 仅从本地 .git/config 解析仓库身份，绝不发起网络请求。
+     *
+     * 为什么需要它：全局驾驶舱要为每个工作区认识别仓库，而 getRepoMetadata 会调用
+     * `gh repo view` 走网络。实测 5 个工作区时该端点冷启动 20.5 秒，其中绝大部分耗在这 5 次
+     * 网络往返上——而有界并发根本救不了它，因为瓶颈是网络延迟而不是进程排队。
+     * 工作区矩阵只需要「这个目录属于哪个仓库」这一身份信息，本地 .git/config 已经完整具备，
+     * 描述/star 数等富字段是当前仓库详情才需要的。这一步把每个工作区从 1 次网络往返降为 0。
+     */
+    getRepoIdentityFromLocal(cwd) {
+        const targetCwd = cwd || this.resolveWorkspaceCwd();
+        try {
+            const gitConfigPath = path.join(targetCwd, '.git', 'config');
+            if (!fs.existsSync(gitConfigPath))
+                return null;
+            const configText = fs.readFileSync(gitConfigPath, 'utf8');
+            const match = configText.match(/github\.com[:/]([a-zA-Z0-9_.-]+)\/([a-zA-Z0-9_.-]+?)(?:\.git)?(?:\s|\r|\n|$)/i);
+            if (!match)
+                return null;
+            const owner = match[1];
+            const repoName = match[2];
+            const nameWithOwner = `${owner}/${repoName}`;
+            return {
+                nameWithOwner,
+                name: repoName,
+                owner,
+                defaultBranch: 'main',
+                description: '',
+                isPrivate: false,
+                url: `https://github.com/${nameWithOwner}`,
+            };
+        }
+        catch {
+            return null;
+        }
+    }
     /**
      * 获取当前目录（工作区）关联的远程仓库元数据
      * 采用 gh repo view + 本地 git remote 双保险机制，彻底杜绝已配置远程却误判未关联的问题
      */
     async getRepoMetadata(cwd) {
-        const targetCwd = cwd || process.cwd();
+        const targetCwd = this.resolveWorkspaceCwd(cwd);
         // 1. 优先尝试由 gh 直接根据当前上下文识别
         const res = await this.run(['repo', 'view', '--json', 'nameWithOwner,name,owner,defaultBranchRef,description,isPrivate,url'], { cwd: targetCwd, timeoutMs: 10_000 });
         if (res.ok && res.data && res.data.nameWithOwner) {
@@ -159,20 +328,17 @@ export class GhExecutor {
                 url: d.url || `https://github.com/${d.nameWithOwner}`,
             };
         }
-        // 2. 双保险兜底：如果 gh 未能自动推断（如当前分支未推送到 upstream），直接解析本地 git remote
+        // 2. 原生文件解析：直接读取本地 .git/config 文件（0 子进程开销、免疫沙箱 EPERM）
         try {
-            const { execFile } = await import('node:child_process');
-            const { promisify } = await import('node:util');
-            const execAsync = promisify(execFile);
-            const { stdout: remoteOut } = await execAsync('git', ['remote', '-v'], { cwd: targetCwd });
-            if (remoteOut) {
-                // 匹配 github.com 格式：git@github.com:owner/repo.git 或 https://github.com/owner/repo.git
-                const match = remoteOut.match(/github\.com[:/]([a-zA-Z0-9_.-]+)\/([a-zA-Z0-9_.-]+?)(?:\.git)?(?:\s|\()/i);
+            const gitConfigPath = path.join(targetCwd, '.git', 'config');
+            if (fs.existsSync(gitConfigPath)) {
+                const configText = fs.readFileSync(gitConfigPath, 'utf8');
+                const match = configText.match(/github\.com[:/]([a-zA-Z0-9_.-]+)\/([a-zA-Z0-9_.-]+?)(?:\.git)?(?:\s|\r|\n|$)/i);
                 if (match) {
                     const owner = match[1];
                     const repoName = match[2];
                     const nameWithOwner = `${owner}/${repoName}`;
-                    // 使用提取出的精确 owner/repo 向 gh 获取元数据
+                    // 使用精确的 owner/repo 向 gh 获取元数据（显式传参，不依赖无上下文的探测）
                     const directRes = await this.run(['repo', 'view', nameWithOwner, '--json', 'nameWithOwner,name,owner,defaultBranchRef,description,isPrivate,url'], { cwd: targetCwd, timeoutMs: 10_000 });
                     if (directRes.ok && directRes.data && directRes.data.nameWithOwner) {
                         const d = directRes.data;
@@ -199,9 +365,7 @@ export class GhExecutor {
                 }
             }
         }
-        catch {
-            // 本地无 git 或无 remote 配置
-        }
+        catch { }
         return null;
     }
 }

package/lib/github-service.d.ts

@@ -0,0 +1,26 @@
+/**
+ * `ctx.github` 服务的 TypeScript 声明合并。
+ *
+ * 为什么需要这个文件：README 教生态插件这样复用本插件的能力——
+ *   export const inject = ['github']
+ *   export function apply(ctx) { await ctx.github.checkAuth() }
+ * 但在此之前项目里没有任何 `declare module` 声明合并，消费方拿到的 `ctx.github`
+ * 类型是 unknown，照文档写会直接编译不过，也没有任何自动补全。
+ * 官方每个服务包（如 @deepseek-ai/dsh-workspace、dsh-commands）都做这件事，这里补齐。
+ *
+ * 消费方用法：import type {} from 'dsh-github-flow/host' —— 或直接 import 本插件导出的任一名，
+ * 只要类型被加载，`ctx.github` 就有完整类型。
+ */
+import type { Context } from '@deepseek-ai/cordis';
+import type { GhExecutor } from './executor.js';
+declare module '@deepseek-ai/cordis' {
+    interface Context {
+        /** 由 dsh-github-flow 提供的 GitHub CLI 执行引擎 */
+        github: GhExecutor;
+    }
+}
+/**
+ * 供消费方做类型引用的空导出。
+ * 目的是让 `import type {} from 'dsh-github-flow'` 能顺带加载上面的声明合并。
+ */
+export type { Context };

package/lib/github-service.js

@@ -0,0 +1 @@
+export {};

package/lib/index.d.ts

@@ -1,4 +1,2 @@
-export declare const name = "dsh-github-flow";
-export declare const inject: readonly ['tools', 'commands', 'webServer', 'workspaceRegistry'];
-export declare function apply(ctx: any): void;
-export * from './types.js';
+export * from './main.js';
+export { apply as default } from './main.js';

package/lib/index.js

@@ -1,30 +1,2 @@
-import { GhExecutor } from './executor.js';
-import { createPrTool } from './tools/pr.js';
-import { createIssueTool } from './tools/issue.js';
-import { createRunTool } from './tools/run.js';
-import { createRepoTool } from './tools/repo.js';
-import { createApiTool } from './tools/api.js';
-import { registerGhCommand } from './commands/gh.js';
-import { registerApiRoutes } from './api/routes.js';
-export const name = 'dsh-github-flow';
-export const inject = ['tools', 'commands', 'webServer', 'workspaceRegistry'];
-export function apply(ctx) {
-    const executor = new GhExecutor();
-    // 1. 注册人类 Slash 命令 (/gh status, /gh help)
-    if (ctx.commands) {
-        registerGhCommand(ctx.commands, executor);
-    }
-    // 2. 注册 Agent 模型工具集（5 大核心领域工具）
-    if (ctx.tools) {
-        ctx.tools.register(createPrTool(executor));
-        ctx.tools.register(createIssueTool(executor));
-        ctx.tools.register(createRunTool(executor));
-        ctx.tools.register(createRepoTool(executor));
-        ctx.tools.register(createApiTool(executor));
-    }
-    // 3. 注册面向 Client 端的 WebServer HTTP 路由
-    if (ctx.webServer) {
-        registerApiRoutes(ctx.webServer, executor, ctx.workspaceRegistry);
-    }
-}
-export * from './types.js';
+export * from './main.js';
+export { apply as default } from './main.js';