@ziamana/bruine 0.1.0

package/dist/plugins/mcp.js

@@ -0,0 +1,275 @@
+// src/compat.ts
+import { existsSync } from "fs";
+import { homedir } from "os";
+import path from "path";
+function appEnv(suffix, env = process.env) {
+  return env[`BRUINE_${suffix}`] ?? env[`KUMO_${suffix}`];
+}
+function appHome(env = process.env, userHome = homedir(), pathMod = path, exists = existsSync) {
+  const explicit = appEnv("HOME", env);
+  if (explicit !== void 0) return explicit;
+  const current = pathMod.join(userHome, ".bruine");
+  const legacy = pathMod.join(userHome, ".kumo");
+  return exists(current) ? current : exists(legacy) ? legacy : current;
+}
+function runtimeHome(env = process.env, pathMod = path) {
+  return appEnv("HOME", env) ?? env.DSH_HOME ?? appHome(env, homedir(), pathMod);
+}
+function compatReadPath(currentPath, legacyPath) {
+  return existsSync(currentPath) || !existsSync(legacyPath) ? currentPath : legacyPath;
+}
+function configWritePath(home) {
+  return path.join(home, "bruine.json");
+}
+function configReadPath(home) {
+  return compatReadPath(configWritePath(home), path.join(home, "kumo.json"));
+}
+
+// src/mcp/config.ts
+import { createHash } from "crypto";
+import { readFileSync } from "fs";
+import path2 from "path";
+var PROJECT_MCP_FILE = ".mcp.json";
+function expandEnv(text, env, missing) {
+  return text.replace(/\$\{([A-Za-z_][A-Za-z0-9_]*)(?::-([^}]*))?\}/g, (_, name2, fallback) => {
+    const value = env[name2];
+    if (value !== void 0 && value !== "") return value;
+    if (fallback !== void 0) return fallback;
+    missing.add(name2);
+    return "";
+  });
+}
+function serverId(name2) {
+  const safe = name2.replace(/[^A-Za-z0-9_-]+/g, "_").replace(/^_+|_+$/g, "");
+  if (safe !== "" && safe.length <= 32 && safe === name2) return safe;
+  const hash = createHash("sha256").update(name2).digest("hex").slice(0, 6);
+  return `${(safe === "" ? "server" : safe).slice(0, 25)}_${hash}`;
+}
+var isRecord = (v) => v !== null && typeof v === "object" && !Array.isArray(v);
+function stringRecord(v) {
+  if (!isRecord(v)) return void 0;
+  const out = {};
+  for (const [k, value] of Object.entries(v)) if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") out[k] = String(value);
+  return out;
+}
+function parseMcpServers(raw, source, file, env = process.env) {
+  const servers = [];
+  const problems = [];
+  if (raw === void 0) return { servers, problems };
+  if (!isRecord(raw)) return { servers, problems: [`${file}: mcpServers must be an object of servers by name.`] };
+  for (const [name2, row] of Object.entries(raw)) {
+    if (!isRecord(row)) {
+      problems.push(`${name2} (${file}): not an object.`);
+      continue;
+    }
+    const missing = /* @__PURE__ */ new Set();
+    const x = (s) => expandEnv(s, env, missing);
+    const xRecord = (r) => r === void 0 ? void 0 : Object.fromEntries(Object.entries(r).map(([k, v]) => [k, x(v)]));
+    const type = typeof row.type === "string" ? row.type.toLowerCase() : row.url !== void 0 ? "http" : "stdio";
+    const common = {
+      name: name2,
+      id: serverId(name2),
+      source,
+      alwaysAllow: Array.isArray(row.alwaysAllow) ? row.alwaysAllow.filter((t) => typeof t === "string") : [],
+      readOnly: row.readOnly === true,
+      disabled: row.disabled === true,
+      ...typeof row.timeout === "number" && row.timeout > 0 ? { timeoutMs: Math.round(row.timeout) } : {}
+    };
+    if (type === "stdio") {
+      if (typeof row.command !== "string" || row.command.trim() === "") {
+        problems.push(`${name2} (${file}): a local server needs a "command".`);
+        continue;
+      }
+      const args = Array.isArray(row.args) ? row.args.filter((a) => typeof a === "string").map(x) : [];
+      servers.push({
+        ...common,
+        transport: "stdio",
+        command: x(row.command),
+        args,
+        ...stringRecord(row.env) !== void 0 ? { env: xRecord(stringRecord(row.env)) } : {},
+        ...typeof row.cwd === "string" ? { cwd: x(row.cwd) } : {}
+      });
+    } else if (type === "http" || type === "streamable-http") {
+      if (typeof row.url !== "string" || !/^https?:\/\//i.test(row.url)) {
+        problems.push(`${name2} (${file}): an HTTP server needs a "url" starting with http:// or https://.`);
+        continue;
+      }
+      servers.push({
+        ...common,
+        transport: "streamable-http",
+        url: x(row.url),
+        ...stringRecord(row.headers) !== void 0 ? { headers: xRecord(stringRecord(row.headers)) } : {}
+      });
+    } else if (type === "sse") {
+      problems.push(`${name2} (${file}): the old SSE transport is not supported; use the server's Streamable HTTP endpoint with "type": "http".`);
+      continue;
+    } else {
+      problems.push(`${name2} (${file}): unknown type "${String(row.type)}" (use "stdio" or "http").`);
+      continue;
+    }
+    if (missing.size > 0) problems.push(`${name2} (${file}): ${[...missing].join(", ")} ${missing.size === 1 ? "is" : "are"} not set in the environment.`);
+  }
+  return { servers, problems };
+}
+function readJson(file) {
+  let text;
+  try {
+    text = readFileSync(file, "utf8");
+  } catch {
+    return {};
+  }
+  try {
+    return { value: JSON.parse(text) };
+  } catch (error) {
+    return { error: `${file}: not valid JSON (${error.message}).` };
+  }
+}
+function readMcpServers(home, projectDir, env = process.env) {
+  const problems = [];
+  const userFile = configReadPath(home);
+  const user = readJson(userFile);
+  if (user.error !== void 0) problems.push(user.error);
+  const userRows = parseMcpServers(isRecord(user.value) ? user.value.mcpServers : void 0, "user", path2.basename(userFile), env);
+  const projectFile = path2.join(projectDir, PROJECT_MCP_FILE);
+  const project = readJson(projectFile);
+  if (project.error !== void 0) problems.push(project.error);
+  const projectRows = parseMcpServers(isRecord(project.value) ? project.value.mcpServers : void 0, "project", PROJECT_MCP_FILE, env);
+  problems.push(...userRows.problems, ...projectRows.problems);
+  const servers = [];
+  const names = /* @__PURE__ */ new Set();
+  const ids = /* @__PURE__ */ new Set();
+  for (const server of [...userRows.servers, ...projectRows.servers]) {
+    if (names.has(server.name)) continue;
+    if (ids.has(server.id)) {
+      problems.push(`${server.name}: its tool namespace "${server.id}" is already taken by another server; rename one of them.`);
+      continue;
+    }
+    names.add(server.name);
+    ids.add(server.id);
+    servers.push(server);
+  }
+  return { servers, problems };
+}
+function fingerprint(server) {
+  const what = server.transport === "stdio" ? { t: "stdio", command: server.command, args: server.args ?? [], env: server.env ?? {}, cwd: server.cwd ?? "" } : { t: "http", url: server.url, headers: server.headers ?? {} };
+  return createHash("sha256").update(JSON.stringify(what)).digest("hex").slice(0, 16);
+}
+function toDshConfig(server) {
+  const common = {
+    serverName: server.id,
+    // A server that cannot start must say so: the failure is shown in /mcp, never swallowed.
+    failOnStartupError: true,
+    ...server.timeoutMs !== void 0 ? { toolCallTimeoutMs: server.timeoutMs } : {}
+  };
+  if (server.transport === "stdio") {
+    return { ...common, transport: "stdio", command: server.command, args: server.args ?? [], env: server.env ?? {}, ...server.cwd !== void 0 ? { cwd: server.cwd } : {} };
+  }
+  return { ...common, transport: "streamable-http", url: server.url, headers: server.headers ?? {} };
+}
+var toolPrefix = (id) => `mcp__${id}__`;
+
+// src/mcp/state.ts
+import { mkdirSync, readFileSync as readFileSync2, renameSync, writeFileSync } from "fs";
+import path3 from "path";
+var MCP_STATE_FILE = "mcp-state.json";
+var empty = () => ({ user: { disabled: [] }, projects: {} });
+function projectKey(dir, platform = process.platform) {
+  const abs = path3.resolve(dir);
+  return platform === "win32" ? abs.toLowerCase() : abs;
+}
+function readMcpState(home) {
+  try {
+    const doc = JSON.parse(readFileSync2(path3.join(home, MCP_STATE_FILE), "utf8"));
+    return {
+      user: { disabled: Array.isArray(doc.user?.disabled) ? doc.user.disabled.filter((s) => typeof s === "string") : [] },
+      projects: doc.projects !== null && typeof doc.projects === "object" ? doc.projects : {}
+    };
+  } catch {
+    return empty();
+  }
+}
+function isApproved(state, dir, server) {
+  if (server.source === "user") return true;
+  return state.projects[projectKey(dir)]?.approved?.[server.name] === fingerprint(server);
+}
+function isDisabled(state, dir, server) {
+  if (server.disabled) return true;
+  if (server.source === "user") return state.user.disabled.includes(server.name);
+  return state.projects[projectKey(dir)]?.disabled?.includes(server.name) ?? false;
+}
+function planMcp(home, dir, env = process.env) {
+  const { servers, problems } = readMcpServers(home, dir, env);
+  const state = readMcpState(home);
+  return {
+    problems,
+    plan: servers.map((server) => ({
+      server,
+      state: isDisabled(state, dir, server) ? "disabled" : isApproved(state, dir, server) ? "ready" : "unapproved"
+    }))
+  };
+}
+
+// src/plugins/mcp.ts
+var name = "bruine-mcp";
+var BRUINE_MCP_SERVICE = "bruineMcp";
+var STARTUP_BUDGET_MS = 2e4;
+async function apply(ctx, config = {}) {
+  const planned = config.plan !== void 0 ? { plan: config.plan, problems: config.problems ?? [] } : planMcp(runtimeHome(), process.cwd());
+  const statuses = planned.plan.map(({ server, state }) => ({
+    server,
+    state: state === "ready" ? "starting" : state,
+    tools: []
+  }));
+  const toolsOf = (server) => {
+    try {
+      const schemas = ctx.get("tools")?.schemas?.() ?? [];
+      return schemas.map((s) => s.name ?? s.function?.name ?? "").filter((n) => n.startsWith(toolPrefix(server.id)));
+    } catch {
+      return [];
+    }
+  };
+  const service = {
+    problems: planned.problems,
+    status: () => statuses.map((s) => s.state === "connected" ? { ...s, tools: toolsOf(s.server) } : { ...s }),
+    serverOf: (tool) => planned.plan.find(({ server }) => tool.startsWith(toolPrefix(server.id)))?.server
+  };
+  ctx.provide(BRUINE_MCP_SERVICE, service);
+  for (const problem of planned.problems) ctx.logger?.warn?.(`mcp: ${problem}`);
+  const ready = statuses.filter((s) => s.state === "starting");
+  if (ready.length === 0) return;
+  if (typeof ctx.plugin !== "function") {
+    for (const s of ready) Object.assign(s, { state: "failed", error: "this dsh build cannot load plugins at runtime" });
+    return;
+  }
+  let client;
+  try {
+    client = await (config.load ?? (async () => await import("@deepseek-ai/dsh-mcp-client")))();
+  } catch (error) {
+    for (const s of ready) Object.assign(s, { state: "failed", error: `the MCP client could not be loaded: ${error.message}` });
+    return;
+  }
+  const started = ready.map(async (status) => {
+    try {
+      await Promise.resolve(ctx.plugin(client, toDshConfig(status.server)));
+      status.state = "connected";
+    } catch (error) {
+      status.state = "failed";
+      status.error = (error?.message ?? String(error)).split("\n")[0].slice(0, 200);
+    }
+  });
+  let timer;
+  await Promise.race([
+    Promise.allSettled(started),
+    new Promise((resolve) => {
+      timer = setTimeout(resolve, config.budgetMs ?? STARTUP_BUDGET_MS);
+      timer.unref?.();
+    })
+  ]);
+  if (timer !== void 0) clearTimeout(timer);
+}
+export {
+  BRUINE_MCP_SERVICE,
+  STARTUP_BUDGET_MS,
+  apply,
+  name
+};