@shaohui_jin/git-cockpit-mcp-server 0.1.0

package/README.md

@@ -0,0 +1,75 @@
+# @shaohui_jin/git-cockpit-mcp-server
+
+Git Cockpit —— 基于 **MCP（Model Context Protocol）** 的 Git 可视化操作工具。一个包同时提供三种形态：**MCP Server**（供 AI 客户端调用 Git 操作）、**Web 管理界面**（浏览器可视化操作）、**CLI**（命令行启动）。支持多仓库管理、权限审批与 dry-run 预览等安全机制。
+
+## 环境要求
+
+- Node.js **>= 22.5.0**（底层 core 包使用 `node:sqlite`）
+
+## 安装
+
+```bash
+# 全局安装（提供 git-cockpit 命令）
+pnpm add -g @shaohui_jin/git-cockpit-mcp-server
+# 或
+npm install -g @shaohui_jin/git-cockpit-mcp-server
+```
+
+包为纯 ESM，内置 Web 前端（`dist/web`），无需额外安装静态资源。
+
+## 快速开始
+
+```bash
+git-cockpit start   # 启动常驻服务：Web UI + MCP Server（Streamable HTTP），默认 http://localhost:3000
+git-cockpit mcp     # 以 stdio 模式运行 MCP Server（供 Claude Desktop / Cursor 等客户端连接）
+git-cockpit version # 输出版本号
+```
+
+启动后浏览器访问 `http://localhost:3000` 即可使用 Web 界面；`/mcp` 端点提供 MCP Streamable HTTP 接入。
+
+### 接入 MCP 客户端（stdio）
+
+以 Claude Desktop / Cursor 为例，在 MCP 配置中加入：
+
+```json
+{
+  "mcpServers": {
+    "git-cockpit": {
+      "command": "git-cockpit",
+      "args": ["mcp"]
+    }
+  }
+}
+```
+
+### 环境变量
+
+| 变量 | 说明 | 默认 |
+| --- | --- | --- |
+| `GIT_COCKPIT_DATA_DIR` | 数据目录（仓库列表、审计日志、备份） | `~/.git-cockpit` |
+| `GIT_COCKPIT_PORT` | Web 服务端口 | `3000` |
+| `GIT_COCKPIT_HOST` | 监听地址 | `localhost` |
+
+## 主要特性
+
+- **多仓库管理**：统一打开/移除仓库，跨仓库操作
+- **安全机制**：工具按风险分级（readonly / write / dangerous），写操作 dry-run 预览 → 确认 → 执行；高危操作可配置人工审批
+- **内置 Web UI**：状态 / 历史 / 日志 / 设置视图，支持提交、分支、stash、pull/push、硬重置等操作
+- **审计日志**：所有工具调用记录落库，可回溯
+- **备份**：高危操作前自动备份分支引用与 stash 快照
+
+## 发布说明（维护者）
+
+版本号维护在 `packages/mcp-server/package.json`，发布由仓库根目录 `.github/workflows/release-mcp-server.yml` 负责：
+
+- **判据**：远程不存在 `mcp-server-v{version}` tag 才发布
+- **流程**：构建 web → 构建 mcp-server（`prepublishOnly` 自动把 web/dist 内嵌进 `dist/web`）→ `pnpm publish` → 成功后才推送 tag `mcp-server-v{version}`
+- **依赖**：mcp-server 依赖 `@shaohui_jin/git-cockpit-core`（`workspace:^`，发布时转为 `^0.1.0`），workflow 会先确保 core 已发布（缺失则顺带发布）
+- **触发**：push 到 `master`/`main`，或 GitHub Actions 手动 `workflow_dispatch`
+- **需要仓库 Secret**：`NPM_TOKEN`（npm Automation token）
+
+完整发布手册（含 tag 协议、版本管理、本地发布注意事项）见仓库内 [docs/release.md](../../docs/release.md)。
+
+## License
+
+MIT

package/dist/chunk-4XYICSW4.js

@@ -0,0 +1,544 @@
+import {
+  McpHttpHandler,
+  TOOL_DEF_MAP,
+  executeTool,
+  toolSummaries
+} from "./chunk-HAXZI36Y.js";
+
+// src/webServer.ts
+import * as path3 from "path";
+import * as fs2 from "fs";
+import { fileURLToPath } from "url";
+import Fastify from "fastify";
+import cors from "@fastify/cors";
+import fastifyStatic from "@fastify/static";
+import {
+  GitOperationError,
+  PermissionManager as PermissionManager2,
+  RepoNotFoundError as RepoNotFoundError2
+} from "@shaohui_jin/git-cockpit-core";
+
+// src/runtime.ts
+import { EventEmitter as EventEmitter2 } from "events";
+import {
+  AuditLogger,
+  PermissionManager,
+  RepoStore as RepoStore2,
+  openDatabase
+} from "@shaohui_jin/git-cockpit-core";
+
+// src/config.ts
+import * as fs from "fs";
+import * as path from "path";
+import { DEFAULT_CONFIG, expandHome } from "@shaohui_jin/git-cockpit-core";
+function deepMerge(target, source) {
+  if (source === null || source === void 0) return target;
+  if (Array.isArray(source)) {
+    return source;
+  }
+  if (typeof source === "object" && typeof target === "object" && target !== null) {
+    const out = { ...target };
+    for (const [k, v] of Object.entries(source)) {
+      if (v !== void 0) out[k] = deepMerge(out[k], v);
+    }
+    return out;
+  }
+  return source;
+}
+function isPlainObject(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+var ConfigStore = class {
+  constructor(dataDir, overrides) {
+    this.dataDir = dataDir;
+    const dir = expandHome(dataDir);
+    const file = path.join(dir, "config.json");
+    this.config = {
+      ...this.load(file, overrides),
+      storage: { dataDir: dir }
+    };
+  }
+  dataDir;
+  config;
+  load(file, overrides) {
+    let fileConfig = {};
+    try {
+      if (fs.existsSync(file)) {
+        fileConfig = JSON.parse(fs.readFileSync(file, "utf8"));
+      }
+    } catch (err) {
+      console.warn(`[git-cockpit] \u914D\u7F6E\u6587\u4EF6 ${file} \u65E0\u6CD5\u89E3\u6790\uFF0C\u5DF2\u4F7F\u7528\u9ED8\u8BA4\u914D\u7F6E:`, err.message);
+    }
+    let merged = deepMerge(structuredClone(DEFAULT_CONFIG), fileConfig);
+    if (overrides) merged = deepMerge(merged, overrides);
+    return merged;
+  }
+  get() {
+    return this.config;
+  }
+  /** 合并并持久化；返回新配置 */
+  update(patch) {
+    this.config = deepMerge(this.config, patch);
+    this.save();
+    return this.config;
+  }
+  save() {
+    const dir = expandHome(this.config.storage.dataDir);
+    fs.mkdirSync(dir, { recursive: true });
+    const file = path.join(dir, "config.json");
+    fs.writeFileSync(file, JSON.stringify(this.config, null, 2), "utf8");
+  }
+  /** 供日志/调试：仅返回脱敏后的配置快照（隐藏敏感键名） */
+  snapshot() {
+    const copy = structuredClone(this.config);
+    const redact = (v) => {
+      if (isPlainObject(v)) {
+        const out = {};
+        for (const [k, val] of Object.entries(v)) {
+          const lower = k.toLowerCase();
+          if (/password|token|secret|authorization|url/i.test(lower)) out[k] = "[REDACTED]";
+          else out[k] = redact(val);
+        }
+        return out;
+      }
+      if (Array.isArray(v)) return v.map(redact);
+      return v;
+    };
+    return redact(copy);
+  }
+};
+
+// src/repoManager.ts
+import "events";
+import * as path2 from "path";
+import {
+  GitService,
+  RepoNotFoundError
+} from "@shaohui_jin/git-cockpit-core";
+var RepoManager = class {
+  constructor(options) {
+    this.options = options;
+    this.eventBus = options.eventBus;
+    for (const repo of options.repoStore.list()) {
+      this.pathToId.set(normalizePath(repo.path), repo.id);
+    }
+  }
+  options;
+  /** repo 根路径（规范化绝对路径） -> repoId */
+  pathToId = /* @__PURE__ */ new Map();
+  idToService = /* @__PURE__ */ new Map();
+  eventBus;
+  list() {
+    return this.options.repoStore.list().map((r) => ({
+      ...r,
+      available: r.path === "" || true
+    }));
+  }
+  /** 取最近打开的仓库（懒创建服务） */
+  async getCurrent() {
+    const record = this.options.repoStore.list()[0];
+    return record ? this.getByRecord(record) : null;
+  }
+  /** 按 id 取仓库（懒创建服务） */
+  async getById(id) {
+    const record = this.options.repoStore.getById(id);
+    if (!record) return null;
+    try {
+      return await this.getByRecord(record);
+    } catch (err) {
+      if (err instanceof Error && /NOT_A_GIT_REPO|REPO_NOT_FOUND/.test(err.message)) {
+        return null;
+      }
+      throw err;
+    }
+  }
+  /** 打开仓库：校验并记录；重复打开返回既有实例 */
+  async open(repoPath) {
+    const service = await GitService.open(repoPath);
+    const root = service.repoPath;
+    const key = normalizePath(root);
+    const existingId = this.pathToId.get(key);
+    if (existingId !== void 0 && existingId !== 0) {
+      const record2 = this.options.repoStore.getById(existingId);
+      if (record2) {
+        this.options.repoStore.open(root);
+        this.idToService.set(record2.id, service);
+        this.attach(service);
+        return { service, record: this.options.repoStore.getById(record2.id) ?? record2 };
+      }
+    }
+    const record = this.options.repoStore.open(root);
+    this.pathToId.set(key, record.id);
+    this.idToService.set(record.id, service);
+    this.attach(service);
+    return { service, record };
+  }
+  /** 按路径取服务，未打开则报错（避免隐式副作用） */
+  getByPath(repoPath) {
+    const key = normalizePath(repoPath);
+    const id = this.pathToId.get(key);
+    if (id !== void 0 && id !== 0) {
+      const record = this.options.repoStore.getById(id);
+      if (record) {
+        const service = this.idToService.get(id);
+        if (service) return { service, record };
+      }
+    }
+    throw new RepoNotFoundError(`\u4ED3\u5E93\u672A\u6253\u5F00: ${repoPath}\u3002\u8BF7\u5148\u6253\u5F00\u4ED3\u5E93\uFF08POST /api/repos/open\uFF09\u3002`);
+  }
+  /** 关闭：仅从内存服务池移除；保留历史记录 */
+  close(id) {
+    const record = this.options.repoStore.getById(id);
+    if (record) this.pathToId.delete(normalizePath(record.path));
+    const svc = this.idToService.get(id);
+    if (svc) svc.removeAllListeners("changed");
+    this.idToService.delete(id);
+  }
+  /** 从历史记录中删除并关闭 */
+  remove(id) {
+    this.close(id);
+    this.options.repoStore.remove(id);
+  }
+  dispose() {
+    for (const id of [...this.idToService.keys()]) this.close(id);
+  }
+  /** 按记录取句柄；服务缺失时（合法）创建并缓存 */
+  async getByRecord(record) {
+    let service = this.idToService.get(record.id);
+    if (!service) {
+      service = await GitService.open(record.path);
+      this.pathToId.set(normalizePath(service.repoPath), record.id);
+      this.idToService.set(record.id, service);
+      this.attach(service);
+    }
+    return { service, record };
+  }
+  attach(service) {
+    service.on("changed", (payload) => {
+      this.eventBus.emit("repo-changed", {
+        repoPath: payload.repoPath,
+        command: payload.command,
+        at: (/* @__PURE__ */ new Date()).toISOString()
+      });
+    });
+  }
+};
+function normalizePath(p) {
+  let normalized = path2.resolve(p);
+  if (process.platform === "win32") normalized = normalized.toLowerCase();
+  return normalized;
+}
+
+// src/runtime.ts
+function createRuntime(options = {}) {
+  const configStore = new ConfigStore(options.dataDir ?? "~/.git-cockpit", options.configOverrides);
+  const config = configStore.get();
+  const db = options.db ?? openDatabase(config.storage.dataDir);
+  const eventBus = new EventEmitter2();
+  eventBus.setMaxListeners(200);
+  const auditLogger = new AuditLogger(db, config.logging);
+  const permissions = new PermissionManager(config);
+  const repoStore = new RepoStore2(db);
+  const repoManager = new RepoManager({ repoStore, eventBus, config });
+  return {
+    configStore,
+    config,
+    db,
+    auditLogger,
+    permissions,
+    repoStore,
+    repoManager,
+    eventBus
+  };
+}
+function disposeRuntime(runtime) {
+  try {
+    runtime.eventBus.removeAllListeners();
+    runtime.repoManager.dispose();
+  } catch {
+  }
+  try {
+    runtime.db.close();
+  } catch {
+  }
+}
+
+// src/webServer.ts
+function resolveWebDist() {
+  const here = path3.resolve(path3.dirname(fileURLToPath(import.meta.url)));
+  const candidates = [
+    path3.resolve(here, "..", "..", "web", "dist"),
+    // packages/mcp-server/dist → ../../web/dist
+    path3.resolve(here, "web", "dist"),
+    // 发布布局：dist/web（若产物直接打入包内）
+    path3.resolve(here, "..", "web", "dist"),
+    // 已安装于 node_modules/@shaohui_jin/git-cockpit-mcp-server/dist 时
+    path3.resolve(process.cwd(), "dist", "web"),
+    path3.resolve(process.cwd(), "..", "web", "dist"),
+    path3.resolve(process.cwd(), "node_modules", "@shaohui_jin", "git-cockpit-web", "dist")
+  ];
+  for (const c of candidates) {
+    if (fs2.existsSync(path3.join(c, "index.html"))) return c;
+  }
+  return null;
+}
+async function createWebServer(runtime, options = {}) {
+  const app = Fastify({ logger: false, bodyLimit: 2 * 1024 * 1024 });
+  await app.register(cors, {
+    origin: true,
+    methods: ["GET", "POST", "PUT", "DELETE", "OPTIONS"],
+    allowedHeaders: ["Content-Type", "Mcp-Session-Id", "Authorization"]
+  });
+  const staticDir = options.staticDir !== void 0 ? options.staticDir : resolveWebDist();
+  if (staticDir && fs2.existsSync(staticDir)) {
+    await app.register(fastifyStatic, { root: staticDir, prefix: "/" });
+  }
+  const mcpHttp = new McpHttpHandler(runtime);
+  app.get("/api/health", async () => ({
+    ok: true,
+    service: "git-cockpit",
+    version: "0.1.0",
+    uptimeMs: process.uptime() * 1e3
+  }));
+  app.get("/api/repos", async () => ({
+    repos: runtime.repoManager.list()
+  }));
+  app.post("/api/repos/open", async (req, reply) => {
+    const target = req.body?.path?.trim();
+    if (!target) {
+      return reply.code(400).send({ error: "\u7F3A\u5C11 path \u53C2\u6570" });
+    }
+    try {
+      const handle = await runtime.repoManager.open(target);
+      return { repo: handle.record };
+    } catch (err) {
+      return reply.code(400).send({ error: toError(err) });
+    }
+  });
+  app.delete("/api/repos/:id", async (req, reply) => {
+    const id = Number(req.params.id);
+    if (!Number.isInteger(id)) {
+      return reply.code(400).send({ error: "\u975E\u6CD5\u4ED3\u5E93 id" });
+    }
+    runtime.repoManager.remove(id);
+    return { ok: true };
+  });
+  async function withRepo(req, reply, fn) {
+    const id = Number(req.params.id);
+    const handle = await runtime.repoManager.getById(id);
+    if (!handle) {
+      await reply.code(404).send({ error: "\u4ED3\u5E93\u4E0D\u5B58\u5728\u6216\u5DF2\u5931\u6548" });
+      return void 0;
+    }
+    try {
+      return await fn(handle);
+    } catch (err) {
+      await reply.code(400).send({ error: toError(err) });
+      return void 0;
+    }
+  }
+  app.get(
+    "/api/repos/:id/status",
+    async (req, reply) => withRepo(req, reply, async ({ service }) => service.getStatus())
+  );
+  app.get(
+    "/api/repos/:id/log",
+    async (req, reply) => withRepo(req, reply, async ({ service }) => {
+      const q = req.query;
+      return service.getLog({
+        maxCount: q.maxCount ? Math.min(Number(q.maxCount) || 100, 1e4) : void 0,
+        from: q.from,
+        to: q.to,
+        author: q.author,
+        path: q.path,
+        all: q.all === "true"
+      });
+    })
+  );
+  app.get(
+    "/api/repos/:id/diff",
+    async (req, reply) => withRepo(req, reply, async ({ service }) => {
+      const q = req.query;
+      return service.getDiff({
+        from: q.from,
+        to: q.to,
+        path: q.path,
+        staged: q.staged === "true",
+        maxPatchBytes: q.maxPatchBytes ? Number(q.maxPatchBytes) : void 0
+      });
+    })
+  );
+  app.get(
+    "/api/repos/:id/show/:commit",
+    async (req, reply) => withRepo(
+      req,
+      reply,
+      async ({ service }) => service.getShow(req.params.commit, {
+        path: req.query.path,
+        maxPatchBytes: req.query.maxPatchBytes ? Number(req.query.maxPatchBytes) : void 0
+      })
+    )
+  );
+  app.get(
+    "/api/repos/:id/branches",
+    async (req, reply) => withRepo(req, reply, async ({ service }) => service.listBranches())
+  );
+  app.get(
+    "/api/repos/:id/tags",
+    async (req, reply) => withRepo(req, reply, async ({ service }) => service.listTags())
+  );
+  app.get(
+    "/api/repos/:id/remotes",
+    async (req, reply) => withRepo(req, reply, async ({ service }) => service.listRemotes())
+  );
+  app.get(
+    "/api/repos/:id/graph",
+    async (req, reply) => withRepo(req, reply, async ({ service }) => service.getGraph(req.query.maxCount ? Number(req.query.maxCount) : 500))
+  );
+  app.get(
+    "/api/repos/:id/file",
+    async (req, reply) => withRepo(req, reply, async ({ service }) => {
+      if (!req.query.commit || !req.query.path) {
+        return { error: "\u9700\u8981 commit \u4E0E path \u53C2\u6570" };
+      }
+      return service.getFileContent(req.query.commit, req.query.path);
+    })
+  );
+  app.post(
+    "/api/repos/:id/tools/:tool",
+    async (req, reply) => {
+      const def = TOOL_DEF_MAP.get(req.params.tool);
+      if (!def) return reply.code(404).send({ error: `\u672A\u77E5\u5DE5\u5177: ${req.params.tool}` });
+      const params = req.body?.params ?? {};
+      const exec = await executeTool(def, params, {
+        runtime,
+        source: "web",
+        repoId: Number(req.params.id)
+      });
+      if (!exec.success) {
+        const status = exec.error?.requiredApproval ? 403 : 400;
+        return reply.code(status).send({ error: exec.error?.message, requiredApproval: exec.error?.requiredApproval, code: exec.error?.code });
+      }
+      return { ...exec };
+    }
+  );
+  app.get("/api/tools", async () => ({
+    tools: toolSummaries().map((t) => ({
+      ...t,
+      riskLevel: runtime.permissions.getRiskLevel(t.name),
+      enabled: runtime.permissions.isEnabled(t.name)
+    }))
+  }));
+  app.get("/api/logs", async (req) => {
+    const q = req.query;
+    return {
+      logs: runtime.auditLogger.list({
+        limit: q.limit ? Number(q.limit) : void 0,
+        offset: q.offset ? Number(q.offset) : void 0,
+        tool: q.tool,
+        source: q.source ?? void 0
+      })
+    };
+  });
+  app.get("/api/settings", async () => ({
+    config: runtime.configStore.snapshot(),
+    permissions: {
+      disabledTools: runtime.config.permissions.disabledTools,
+      requireApprovalFor: runtime.config.permissions.requireApprovalFor,
+      dryRunDefault: runtime.config.permissions.dryRunDefault
+    },
+    tools: toolSummaries().map((t) => ({
+      name: t.name,
+      description: t.description,
+      riskLevel: runtime.permissions.getRiskLevel(t.name),
+      enabled: runtime.permissions.isEnabled(t.name)
+    }))
+  }));
+  app.put("/api/settings", async (req, reply) => {
+    const patch = req.body ?? {};
+    if (patch.permissions === void 0) {
+      return reply.code(400).send({ error: "\u4EC5\u652F\u6301\u66F4\u65B0 permissions \u6BB5" });
+    }
+    runtime.configStore.update({ permissions: patch.permissions });
+    runtime.config = runtime.configStore.get();
+    runtime.permissions = new PermissionManager2(runtime.config);
+    return { ok: true, config: runtime.configStore.snapshot() };
+  });
+  app.get("/api/events", async (req, reply) => {
+    reply.hijack();
+    const raw = reply.raw;
+    raw.writeHead(200, {
+      "Content-Type": "text/event-stream; charset=utf-8",
+      "Cache-Control": "no-cache, no-transform",
+      Connection: "keep-alive",
+      "X-Accel-Buffering": "no"
+    });
+    raw.write(": connected\n\n");
+    const listener = (payload) => {
+      raw.write(`event: repo-changed
+data: ${JSON.stringify(payload)}
+
+`);
+    };
+    const logListener = () => {
+      raw.write("event: log\ndata: {}\n\n");
+    };
+    runtime.eventBus.on("repo-changed", listener);
+    runtime.eventBus.on("log", logListener);
+    const keepAlive = setInterval(() => raw.write(": ping\n\n"), 15e3);
+    req.raw.on("close", () => {
+      clearInterval(keepAlive);
+      runtime.eventBus.off("repo-changed", listener);
+      runtime.eventBus.off("log", logListener);
+    });
+  });
+  app.get("/mcp", async (req, reply) => {
+    reply.hijack();
+    await mcpHttp.handle(req.raw, reply.raw);
+  });
+  app.post("/mcp", async (req, reply) => {
+    reply.hijack();
+    await mcpHttp.handle(req.raw, reply.raw);
+  });
+  if (staticDir) {
+    app.setNotFoundHandler(async (req, reply) => {
+      if (req.url.startsWith("/api") || req.url.startsWith("/mcp")) {
+        return reply.code(404).send({ error: "Not Found" });
+      }
+      const index = path3.join(staticDir, "index.html");
+      if (fs2.existsSync(index)) {
+        reply.type("text/html").send(fs2.readFileSync(index, "utf8"));
+        return;
+      }
+      return reply.code(404).send({ error: "Not Found" });
+    });
+  }
+  const port = options.port ?? runtime.config.server.port;
+  const host = options.host ?? runtime.config.server.host;
+  if (!options.noListen) {
+    await app.listen({ port, host });
+  }
+  return {
+    app,
+    close: async () => {
+      mcpHttp.dispose();
+      await app.close();
+      disposeRuntime(runtime);
+    }
+  };
+}
+function toError(err) {
+  if (err instanceof GitOperationError) return { code: err.code, message: err.message };
+  if (err instanceof RepoNotFoundError2) return { code: "REPO_NOT_FOUND", message: err.message };
+  if (err instanceof Error) return { code: "INTERNAL_ERROR", message: err.message.slice(0, 500) };
+  return { code: "INTERNAL_ERROR", message: String(err) };
+}
+
+export {
+  ConfigStore,
+  RepoManager,
+  createRuntime,
+  disposeRuntime,
+  createWebServer
+};
+//# sourceMappingURL=chunk-4XYICSW4.js.map