mingdao-harness 0.1.54

package/src/credentials.js

@@ -0,0 +1,69 @@
+// 凭证管理模块：模型 API Key 的独立存储与解析。
+//
+// 设计原则（借鉴 gh CLI 等成熟工具）：
+//   · Key 绝不进入项目仓库、绝不写入 config.json（config 可分享、可提交）；
+//   · 默认存储在 <mingdao-home>/credentials.json，文件权限 600（仅本人可读）；
+//   · 解析优先级：环境变量 > 本地凭证库 > config.json 显式字段（兼容旧版本）；
+//   · 提供独立的命令行管理：mingdao key status / set / remove / import。
+
+import fs from 'node:fs';
+import path from 'node:path';
+import { mingdaoHome, ensureHome } from './config.js';
+
+export function credentialsPath() {
+  return path.join(mingdaoHome(), 'credentials.json');
+}
+
+export function loadCredentials() {
+  try {
+    const data = JSON.parse(fs.readFileSync(credentialsPath(), 'utf8'));
+    return data && typeof data === 'object' ? data : {};
+  } catch {
+    return {};
+  }
+}
+
+export function saveCredentials(creds) {
+  ensureHome();
+  const p = credentialsPath();
+  fs.writeFileSync(p, JSON.stringify(creds, null, 2) + '\n', { mode: 0o600 });
+  // mode 只在创建时生效：对已存在但权限过宽的文件强制收权
+  try {
+    fs.chmodSync(p, 0o600);
+  } catch {}
+}
+
+export function getStoredKey(providerName) {
+  return loadCredentials()[providerName] || null;
+}
+
+export function setStoredKey(providerName, key) {
+  const creds = loadCredentials();
+  if (key) creds[providerName] = String(key);
+  else delete creds[providerName];
+  saveCredentials(creds);
+}
+
+export function removeStoredKey(providerName) {
+  setStoredKey(providerName, null);
+}
+
+// 脱敏展示：只显示首 6 位与末 4 位，永不输出完整 Key。
+export function maskKey(key) {
+  if (!key) return null;
+  const s = String(key);
+  if (s.length <= 10) return '******';
+  return s.slice(0, 6) + '…' + s.slice(-4);
+}
+
+// 统一的 Key 解析链：环境变量 → 本地凭证库 → config.json 显式字段
+export function resolveApiKey(cfg, providerName, envKeyHint) {
+  const envKeys = [envKeyHint, 'MINGDAO_API_KEY'].filter((k, i, a) => k && a.indexOf(k) === i);
+  for (const k of envKeys) {
+    const v = process.env[k];
+    if (v) return v;
+  }
+  const stored = getStoredKey(providerName);
+  if (stored) return stored;
+  return cfg?.apiKey || '';
+}

package/src/hooks.js

@@ -0,0 +1,123 @@
+// Hooks 生命周期钩子（借鉴 Claude Code PreToolUse/PostToolUse 设计）：
+//  config.hooks = {
+//    "PreToolUse":  [ { "matcher": "write|edit|bash", "cmd": "node ~/hooks/pre.js" } ],
+//    "PostToolUse": [ { "matcher": "*", "cmd": "curl -X POST http://localhost:9000/audit" } ]
+//  }
+//  - PreToolUse：向子进程 stdin 写入 JSON {hook_event_name, tool_name, tool_input}；
+//    子进程 stdout 输出 JSON {decision:"approve"|"block", reason} 可阻止工具执行。
+//  - PostToolUse：写入 {hook_event_name, tool_name, tool_input, tool_response}，结果仅记录不阻塞。
+//  - matcher 支持精确工具名、逗号分隔多个名、'*' 通配。
+
+import { spawn } from 'node:child_process';
+
+function normalize(list) {
+  if (!Array.isArray(list)) return [];
+  return list.filter((h) => h && typeof h.cmd === 'string' && h.cmd.trim());
+}
+
+function match(hook, toolName) {
+  const m = String(hook.matcher || '*').trim();
+  if (!m || m === '*') return true;
+  return m.split(',').some((part) => {
+    const p = part.trim();
+    if (p.endsWith('*')) return toolName.startsWith(p.slice(0, -1));
+    return p === toolName;
+  });
+}
+
+export function createHooks(hooksCfg = {}, workingDir) {
+  const pre = normalize(hooksCfg?.PreToolUse);
+  const post = normalize(hooksCfg?.PostToolUse);
+
+  function run(hook, payload) {
+    return new Promise((resolve) => {
+      const child = spawn(hook.cmd, {
+        shell: true,
+        cwd: workingDir,
+        env: process.env,
+        stdio: ['pipe', 'pipe', 'pipe'],
+      });
+      let out = '';
+      let err = '';
+      const MAX_HOOK_OUT = 64 * 1024;
+      const cap = (acc, d) => {
+        const t = acc + d;
+        return t.length > MAX_HOOK_OUT ? t.slice(-MAX_HOOK_OUT) : t;
+      };
+      let settled = false;
+      const finish = (result) => {
+        if (settled) return;
+        settled = true;
+        resolve(result);
+      };
+      const timer = setTimeout(() => {
+        // 审计质量项：超时杀整组（shell:true 的孙进程不成孤儿）
+        try {
+          process.kill(-child.pid, 'SIGKILL');
+        } catch {
+          child.kill('SIGKILL');
+        }
+        finish({ ok: false, error: 'hook 执行超时（10s）' });
+      }, 10000);
+      child.stdout.on('data', (d) => (out = cap(out, d)));
+      child.stderr.on('data', (d) => (err = cap(err, d)));
+      child.on('error', (e) => {
+        clearTimeout(timer);
+        finish({ ok: false, error: `hook 启动失败：${e.message}` });
+      });
+      child.on('close', (code) => {
+        clearTimeout(timer);
+        finish({ ok: true, exitCode: code, output: out, stderr: err });
+      });
+      try {
+        child.stdin.write(JSON.stringify(payload));
+        child.stdin.end();
+      } catch {}
+    });
+  }
+
+  return {
+    async pre(toolName, args) {
+      let decision = 'approve';
+      let reason = '';
+      for (const h of pre) {
+        if (!match(h, toolName)) continue;
+        const r = await run(h, { hook_event_name: 'PreToolUse', tool_name: toolName, tool_input: args });
+        if (!r.ok) {
+          decision = 'block';
+          reason = r.error;
+          break;
+        }
+        const out = String(r.output || '').trim();
+        if (!out) continue; // 空输出 = 放行
+        try {
+          const j = JSON.parse(out);
+          if (j && j.decision === 'block') {
+            decision = 'block';
+            reason = j.reason || '被 PreToolUse 钩子阻止';
+            break;
+          }
+        } catch {
+          // fail-closed：输出不是合法 JSON（日志/报错混入）时按阻止处理，避免策略被静默绕过
+          decision = 'block';
+          reason = `PreToolUse 钩子输出无法解析（前 80 字）：${out.slice(0, 80)}`;
+          break;
+        }
+      }
+      return { decision, reason };
+    },
+    async post(toolName, args, result) {
+      for (const h of post) {
+        if (!match(h, toolName)) continue;
+        try {
+          await run(h, {
+            hook_event_name: 'PostToolUse',
+            tool_name: toolName,
+            tool_input: args,
+            tool_response: result,
+          });
+        } catch {}
+      }
+    },
+  };
+}

package/src/index.js

@@ -0,0 +1,42 @@
+// MingDao-Harness 公共 API：供第三方程序/插件以库形式复用核心能力。
+
+export { createAgent } from './agent.js';
+export { createProvider, resolveProviderConfig } from './providers/index.js';
+export { toolSchemas, dispatch } from './tools/index.js';
+export { trimMessages, approxTokens, clampText, TOOL_RESULT_LIMIT } from './context.js';
+export { compactConversation, summarizeConversation } from './compact.js';
+export { createPermission } from './permissions.js';
+export { MODELS, PROVIDERS, modelPreset, providerPreset } from './models.js';
+export { createIO, style, C } from './ui.js';
+export {
+  mingdaoHome,
+  ensureHome,
+  loadConfig,
+  saveConfig,
+  runWizard,
+  effectiveApiKey,
+} from './config.js';
+export {
+  credentialsPath,
+  loadCredentials,
+  saveCredentials,
+  getStoredKey,
+  setStoredKey,
+  removeStoredKey,
+  maskKey,
+  resolveApiKey,
+} from './credentials.js';
+export { estimateCost, estimateCostLabel, isPeakHour, PRICE_DATA_AS_OF } from './pricing.js';
+export { countTokens, heuristicTokens, makeTokenCounter, isTokenizable } from './tokenizer.js';
+export { updateCheck, mingdaoUpdate, mingdaoRollback, findRepoRoot } from './update.js';
+export { writeAudit, listAudit, redactSecrets, auditFile } from './audit.js';
+export { trustSkill, skillDirHash, readSourceMeta } from './skill-lib.js';
+export { tamperedSkillNames } from './skills.js';
+export { McpClient, startMcpServers } from './mcp.js';
+export {
+  createSession,
+  latestSession,
+  listSessions,
+  appendMessages,
+  loadSession,
+} from './session.js';

package/src/mcp-presets.js

@@ -0,0 +1,78 @@
+// MCP 生态预设包：官方常用 MCP 服务器的一键接入目录。
+// 命令：mingdao mcp preset list / add <名称> [参数]
+// 预设以 npx 运行（无需预装），add 时合并进 config.json 的 mcpServers（重启 WebUI 生效）。
+
+export const MCP_PRESETS = {
+  filesystem: {
+    label: '文件系统（读写指定目录）',
+    command: 'npx',
+    args: ['-y', '@modelcontextprotocol/server-filesystem', '{dir}'],
+    argLabel: '目录（默认当前工作目录）',
+  },
+  fetch: {
+    label: '网页抓取（把网页内容转 Markdown）',
+    command: 'npx',
+    args: ['-y', 'mcp-server-fetch'],
+  },
+  everything: {
+    label: 'Everything 测试服务器（echo/环境/资源演示）',
+    command: 'npx',
+    args: ['-y', '@modelcontextprotocol/server-everything'],
+  },
+  git: {
+    label: 'Git 操作（状态/提交/日志/分支）',
+    command: 'npx',
+    args: ['-y', 'mcp-server-git', '--repository', '{dir}'],
+    argLabel: '仓库目录（默认当前工作目录）',
+  },
+  memory: {
+    label: '知识图谱记忆（持久化实体关系记忆）',
+    command: 'npx',
+    args: ['-y', '@modelcontextprotocol/server-memory'],
+  },
+  'sequential-thinking': {
+    label: '结构化分步思考（复杂推理辅助）',
+    command: 'npx',
+    args: ['-y', '@modelcontextprotocol/server-sequential-thinking'],
+  },
+  playwright: {
+    label: '浏览器自动化（页面操作/截图/测试）',
+    command: 'npx',
+    args: ['-y', '@playwright/mcp@latest'],
+  },
+  sqlite: {
+    label: 'SQLite 数据库查询',
+    command: 'npx',
+    args: ['-y', 'mcp-server-sqlite', '--db-path', '{dir}'],
+    argLabel: '数据库文件路径（必填）',
+  },
+  time: {
+    label: '时间与时区查询',
+    command: 'npx',
+    args: ['-y', '@modelcontextprotocol/server-time'],
+  },
+};
+
+export function presetList() {
+  return Object.entries(MCP_PRESETS).map(([name, p]) => ({
+    name,
+    label: p.label,
+    argLabel: p.argLabel || null,
+    args: p.args,
+    command: p.command,
+  }));
+}
+
+export function buildPreset(name, arg, cwd) {
+  const p = MCP_PRESETS[name];
+  if (!p) return { error: `未知预设 ${name}（mingdao mcp preset list 查看）` };
+  if (p.argLabel && !arg) {
+    if (p.args.includes('{dir}')) {
+      arg = cwd; // 目录类参数默认当前工作目录
+    } else {
+      return { error: `该预设需要参数：${p.argLabel}` };
+    }
+  }
+  const args = p.args.map((a) => (a === '{dir}' ? arg : a));
+  return { config: { command: p.command, args } };
+}

package/src/mcp.js

@@ -0,0 +1,284 @@
+// MCP (Model Context Protocol) 客户端 —— 零依赖实现 stdio 传输 + JSON-RPC 2.0。
+// 配置（config.json）：
+//   "mcpServers": {
+//     "filesystem": { "command": "npx", "args": ["-y", "@modelcontextprotocol/server-filesystem", "/tmp"] },
+//     "fetch":      { "command": "npx", "args": ["-y", "mcp-server-fetch"] }
+//   }
+// 工具命名：mcp__<服务器>__<工具>，与内置工具合并后交给模型；/mcp 查看状态。
+
+import fs from 'node:fs';
+import { spawn } from 'node:child_process';
+
+// 客户端版本读 package.json（评估 P3-9：此前硬编码 '0.6.0' 与真实版本脱节）
+const CLIENT_VERSION = (() => {
+  try {
+    const pkg = JSON.parse(fs.readFileSync(new URL('../package.json', import.meta.url), 'utf8'));
+    return pkg.version || '0.0.0';
+  } catch {
+    return '0.0.0';
+  }
+})();
+
+const REQUEST_TIMEOUT_MS = 60000;
+const HANDSHAKE_TIMEOUT_MS = 20000;
+
+let nextId = 1;
+
+export class McpClient {
+  constructor(name, { command, args = [], env = {} }, workingDir) {
+    this.name = name;
+    this.command = command;
+    this.args = args;
+    this.env = env;
+    this.workingDir = workingDir;
+    this.tools = [];
+    this.child = null;
+    this.pending = new Map();
+    this.buf = '';
+    this.ready = false;
+    this.error = null;
+    this.stderrTail = '';
+  }
+
+  async start() {
+    if (this.child) return this;
+    this.child = spawn(this.command, this.args, {
+      cwd: this.workingDir,
+      env: { ...process.env, ...this.env },
+      stdio: ['pipe', 'pipe', 'pipe'],
+      detached: true, // 自成进程组：stop 时整组清理（npx 孙进程不成孤儿）
+    });
+    this.child.stdout.on('data', (d) => this._onData(d));
+    this.child.stderr.on('data', (d) => {
+      this.stderrTail = (this.stderrTail + d.toString()).slice(-2000);
+    });
+    this.child.on('error', (err) => {
+      this.error = `启动失败：${err.message}`;
+      this._failAll(this.error);
+    });
+    this.child.on('close', (code) => {
+      if (!this.stopped) {
+        this.error = this.error || `进程退出（code ${code}）${this.stderrTail ? '：' + this.stderrTail.slice(-300) : ''}`;
+        this._failAll(this.error);
+      }
+    });
+    try {
+      await this._handshake();
+      await this._listTools();
+    } catch (err) {
+      this.error = String(err?.message || err);
+      this.stop(); // 审计 P1-3：握手/列工具失败时清理 detached 子进程树，防孤儿
+      throw err;
+    }
+    return this;
+  }
+
+  _onData(d) {
+    this.buf += d.toString('utf8');
+    if (this.buf.length > 20 * 1024 * 1024) {
+      // 恶意/异常服务器灌入超量数据：放弃解析，避免内存膨胀
+      this.error = this.error || 'MCP 服务器输出超限';
+      this.buf = '';
+      this.stop();
+      return;
+    }
+    let nl;
+    while ((nl = this.buf.indexOf('\n')) >= 0) {
+      const line = this.buf.slice(0, nl).trim();
+      this.buf = this.buf.slice(nl + 1);
+      if (!line) continue;
+      let msg;
+      try {
+        msg = JSON.parse(line);
+      } catch {
+        continue;
+      }
+      if (msg.id != null && this.pending.has(msg.id)) {
+        const p = this.pending.get(msg.id);
+        clearTimeout(p.timer);
+        this.pending.delete(msg.id);
+        if (msg.error) p.reject(new Error(`MCP [${this.name}] ${msg.error.message || JSON.stringify(msg.error)}`));
+        else p.resolve(msg.result);
+      }
+      // 通知类消息（如 notifications/*）忽略
+    }
+  }
+
+  _failAll(reason) {
+    for (const [, p] of this.pending) {
+      clearTimeout(p.timer);
+      p.reject(new Error(reason));
+    }
+    this.pending.clear();
+  }
+
+  request(method, params = {}) {
+    if (!this.child || this.child.killed) {
+      return Promise.reject(new Error(`MCP 服务器 ${this.name} 未运行`));
+    }
+    const id = nextId++;
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        this.pending.delete(id);
+        reject(new Error(`MCP [${this.name}] 请求超时：${method}`));
+      }, REQUEST_TIMEOUT_MS);
+      this.pending.set(id, { resolve, reject, timer });
+      try {
+        this.child.stdin.write(JSON.stringify({ jsonrpc: '2.0', id, method, params }) + '\n');
+      } catch (err) {
+        clearTimeout(timer);
+        this.pending.delete(id);
+        reject(new Error(`MCP [${this.name}] 写入失败：${err.message}`));
+      }
+    });
+  }
+
+  notify(method, params = {}) {
+    try {
+      this.child?.stdin?.write(JSON.stringify({ jsonrpc: '2.0', method, params }) + '\n');
+    } catch {}
+  }
+
+  async _handshake() {
+    await new Promise((resolve, reject) => {
+      const timer = setTimeout(() => reject(new Error(`MCP [${this.name}] 握手超时`)), HANDSHAKE_TIMEOUT_MS);
+      this.request('initialize', {
+        protocolVersion: '2025-03-26',
+        capabilities: {},
+        clientInfo: { name: 'mingdao', version: CLIENT_VERSION },
+      })
+        .then(() => {
+          this.notify('notifications/initialized');
+          this.ready = true;
+          clearTimeout(timer);
+          resolve();
+        })
+        .catch((err) => {
+          clearTimeout(timer);
+          reject(err);
+        });
+    });
+  }
+
+  async _listTools() {
+    const res = await this.request('tools/list', {});
+    this.tools = Array.isArray(res?.tools) ? res.tools : [];
+  }
+
+  prefixedName(toolName) {
+    return `mcp__${this.name}__${toolName}`;
+  }
+
+  toolSchemas() {
+    return this.tools
+      .filter((t) => t && t.name)
+      .map((t) => ({
+        type: 'function',
+        function: {
+          name: this.prefixedName(t.name),
+          description: `[MCP:${this.name}] ${t.description || t.name}`,
+          parameters: t.inputSchema || { type: 'object', properties: {} },
+        },
+      }));
+  }
+
+  isReadonly(toolName) {
+    const t = this.tools.find((x) => x.name === toolName);
+    return Boolean(t?.annotations?.readOnlyHint);
+  }
+
+  async callTool(toolName, args) {
+    const res = await this.request('tools/call', { name: toolName, arguments: args });
+    if (res?.isError) {
+      const text = (res.content || []).map((c) => c.text || '').join('\n');
+      return { ok: false, error: text || 'MCP 工具返回错误' };
+    }
+    let parts = (res?.content || []).map((c) => (c.type === 'text' ? c.text : `[${c.type}] ${JSON.stringify(c)}`));
+    let text = parts.join('\n') || '(无输出)';
+    if (text.length > 100 * 1024) text = text.slice(0, 100 * 1024) + `\n…[MCP 输出过长已截断，原文共 ${text.length} 字符]`;
+    return { ok: true, output: text };
+  }
+
+  stop() {
+    this.stopped = true;
+    try {
+      // 整组清理：npx 等命令拉起的孙进程不成孤儿
+      if (this.child?.pid) process.kill(-this.child.pid, 'SIGKILL');
+    } catch {
+      try {
+        this.child?.kill('SIGKILL');
+      } catch {}
+    }
+    this._failAll('MCP 服务器已停止');
+  }
+}
+
+// 多服务器管理器：部分服务器启动失败不影响其余
+export async function startMcpServers(mcpCfg, workingDir) {
+  const clients = new Map();
+  const entries = Object.entries(mcpCfg || {});
+  await Promise.all(
+    entries.map(async ([name, cfg]) => {
+      if (!cfg || typeof cfg.command !== 'string' || !cfg.command.trim()) return;
+      const client = new McpClient(name, cfg, workingDir);
+      clients.set(name, client);
+      try {
+        await client.start();
+      } catch (err) {
+        client.error = String(err?.message || err);
+      }
+    })
+  );
+  // 精确工具名映射：名字含 __ 的服务器/工具也不会被贪婪正则切错
+  const managerExact = new Map();
+  for (const [serverName, c] of clients) {
+    if (c.error) continue;
+    for (const t of c.tools || []) {
+      if (t?.name) managerExact.set(`mcp__${serverName}__${t.name}`, { server: serverName, tool: t.name });
+    }
+  }
+  const manager = {
+    clients,
+    toolSchemas() {
+      const out = [];
+      for (const c of clients.values()) {
+        if (!c.error) out.push(...c.toolSchemas());
+      }
+      return out;
+    },
+    lookup(prefixedName) {
+      const exact = managerExact.get(prefixedName);
+      if (exact) {
+        const c = clients.get(exact.server);
+        if (!c || c.error) return null;
+        return { client: c, toolName: exact.tool };
+      }
+      return null;
+    },
+    async call(prefixedName, args) {
+      const found = this.lookup(prefixedName);
+      if (!found) return { ok: false, error: `MCP 工具不可用：${prefixedName}` };
+      return found.client.callTool(found.toolName, args);
+    },
+    isReadonly(prefixedName) {
+      const found = this.lookup(prefixedName);
+      return found ? found.client.isReadonly(found.toolName) : false;
+    },
+    status() {
+      const rows = [];
+      for (const [name, c] of clients) {
+        rows.push({
+          name,
+          ok: !c.error,
+          tools: c.tools.length,
+          error: c.error || '',
+        });
+      }
+      return rows;
+    },
+    stop() {
+      for (const c of clients.values()) c.stop();
+    },
+  };
+  return manager;
+}