jishushell 0.6.5 → 0.7.3

package/dist/services/integrations/openclaw/jishukb-shim.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"jishukb-shim.js","sourceRoot":"","sources":["../../../../src/services/integrations/openclaw/jishukb-shim.ts"],"names":[],"mappings":"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"}

package/dist/services/integrations/openclaw/mcporter-lite.js

@@ -0,0 +1,276 @@
+/**
+ * Lightweight mcporter-compatible wrapper used by OpenClaw instances.
+ *
+ * Why this exists:
+ *   - The agent-facing TOOLS.md has long instructed models to shell out to
+ *     `mcporter call ...`, but fresh / host-mode instances often do not carry
+ *     an actual mcporter npm install under `$OPENCLAW_HOME/.npm-global/`.
+ *   - We only need a tiny subset for built-in JishuShell shims:
+ *       1. `mcporter list --json`
+ *       2. `mcporter call <server>.<tool> key=value ...`
+ *   - A self-contained wrapper avoids depending on PATH, npm postinstalls,
+ *     or a third-party binary living in the right place.
+ *
+ * Scope:
+ *   - Reads `mcporter.json`
+ *   - Supports stdio-backed MCP servers
+ *   - Speaks NDJSON JSON-RPC 2.0 (same framing as our in-tree shims)
+ *
+ * Non-goals:
+ *   - Full mcporter CLI parity
+ *   - HTTP/SSE transports
+ *   - Interactive TUI flows
+ */
+export function renderStandaloneMcporterSource() {
+    return `#!/usr/bin/env node
+// jishushell-mcporter-lite — generated, do not edit by hand.
+// Source: src/services/integrations/openclaw/mcporter-lite.ts
+import { spawn } from "node:child_process";
+import { readFileSync } from "node:fs";
+import { resolve } from "node:path";
+import { createInterface } from "node:readline";
+
+const DEFAULT_TIMEOUT_MS = 30000;
+
+function fail(msg, code = 1) {
+  process.stderr.write(msg + "\\n");
+  process.exit(code);
+}
+
+function shellUsage() {
+  fail(
+    "usage: mcporter [--config PATH] list [--json]\\n" +
+    "       mcporter [--config PATH] call <server>.<tool> key=value ...",
+    2,
+  );
+}
+
+function parseCli(argv) {
+  let configPath = process.env.MCPORTER_CONFIG || "";
+  const rest = [];
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+    if (arg === "--config") {
+      i++;
+      if (i >= argv.length) shellUsage();
+      configPath = argv[i];
+      continue;
+    }
+    if (arg.startsWith("--config=")) {
+      configPath = arg.slice("--config=".length);
+      continue;
+    }
+    rest.push(arg);
+  }
+  if (!configPath) {
+    configPath = resolve(process.cwd(), "config", "mcporter.json");
+  }
+  return { configPath, rest };
+}
+
+function loadConfig(path) {
+  let raw;
+  try {
+    raw = JSON.parse(readFileSync(path, "utf-8"));
+  } catch (e) {
+    fail("mcporter: cannot read config " + path + ": " + (e && e.message ? e.message : e), 2);
+  }
+  if (!raw || typeof raw !== "object") {
+    fail("mcporter: config must be a JSON object", 2);
+  }
+  if (!raw.mcpServers || typeof raw.mcpServers !== "object") {
+    raw.mcpServers = {};
+  }
+  return raw;
+}
+
+function coerceValue(raw) {
+  if (raw === "true") return true;
+  if (raw === "false") return false;
+  if (raw === "null") return null;
+  if (/^-?\\d+(?:\\.\\d+)?$/.test(raw)) return Number(raw);
+  if ((raw.startsWith("{") && raw.endsWith("}")) || (raw.startsWith("[") && raw.endsWith("]"))) {
+    try { return JSON.parse(raw); } catch { /* keep string */ }
+  }
+  return raw;
+}
+
+function parseKeyValueArgs(argv) {
+  const out = {};
+  for (const token of argv) {
+    const eq = token.indexOf("=");
+    if (eq < 0) {
+      fail("mcporter: expected key=value argument, got: " + token, 2);
+    }
+    const key = token.slice(0, eq).trim();
+    const raw = token.slice(eq + 1);
+    if (!key) fail("mcporter: empty argument key", 2);
+    out[key] = coerceValue(raw);
+  }
+  return out;
+}
+
+function printableResult(result) {
+  const content = result && result.content;
+  if (Array.isArray(content)) {
+    const textBlocks = content
+      .filter((item) => item && item.type === "text")
+      .map((item) => typeof item.text === "string" ? item.text : "");
+    if (textBlocks.length > 0) return textBlocks.join("\\n\\n");
+  }
+  return JSON.stringify(result, null, 2);
+}
+
+async function callStdioServer(entry, toolName, toolArgs) {
+  if (!entry || typeof entry !== "object" || !entry.command) {
+    fail("mcporter: server entry is missing command", 2);
+  }
+  const command = entry.command === "node" ? process.execPath : String(entry.command);
+  const args = Array.isArray(entry.args) ? entry.args.map((v) => String(v)) : [];
+  const env = { ...process.env };
+  if (entry.env && typeof entry.env === "object") {
+    for (const [k, v] of Object.entries(entry.env)) {
+      if (v != null) env[k] = String(v);
+    }
+  }
+
+  const child = spawn(command, args, {
+    env,
+    stdio: ["pipe", "pipe", "pipe"],
+  });
+
+  let stderr = "";
+  child.stderr.on("data", (chunk) => {
+    stderr += chunk.toString("utf-8");
+  });
+
+  const rl = createInterface({ input: child.stdout });
+  const pending = new Map();
+  let nextId = 1;
+
+  const cleanup = () => {
+    try { child.stdin.end(); } catch {}
+    rl.close();
+    if (!child.killed) child.kill();
+  };
+
+  const request = (method, params, expectReply = true) => new Promise((resolveReq, rejectReq) => {
+    const id = expectReply ? nextId++ : undefined;
+    let timer = null;
+    if (expectReply) {
+      timer = setTimeout(() => {
+        pending.delete(id);
+        rejectReq(new Error("timeout waiting for " + method));
+      }, DEFAULT_TIMEOUT_MS);
+      pending.set(id, (msg) => {
+        clearTimeout(timer);
+        if (msg && msg.error) rejectReq(new Error(msg.error.message || JSON.stringify(msg.error)));
+        else resolveReq(msg ? msg.result : undefined);
+      });
+    }
+    const payload = { jsonrpc: "2.0", method };
+    if (id !== undefined) payload.id = id;
+    if (params !== undefined) payload.params = params;
+    child.stdin.write(JSON.stringify(payload) + "\\n");
+    if (!expectReply) resolveReq(undefined);
+  });
+
+  rl.on("line", (line) => {
+    let msg;
+    try { msg = JSON.parse(line); } catch { return; }
+    if (msg && msg.id !== undefined && pending.has(msg.id)) {
+      const done = pending.get(msg.id);
+      pending.delete(msg.id);
+      done(msg);
+    }
+  });
+
+  child.on("error", (err) => {
+    for (const [, done] of pending) done({ error: { message: err.message } });
+    pending.clear();
+  });
+
+  child.on("exit", (code, signal) => {
+    if (pending.size === 0) return;
+    const detail = stderr.trim() || ("upstream exited code=" + code + " signal=" + signal);
+    for (const [, done] of pending) done({ error: { message: detail } });
+    pending.clear();
+  });
+
+  try {
+    await request("initialize", {
+      protocolVersion: "2024-11-05",
+      capabilities: {},
+      clientInfo: { name: "jishushell-mcporter-lite", version: "0.1.0" },
+    });
+    await request("notifications/initialized", undefined, false);
+    const result = await request("tools/call", {
+      name: toolName,
+      arguments: toolArgs,
+    });
+    cleanup();
+    return result;
+  } catch (e) {
+    cleanup();
+    throw e;
+  }
+}
+
+async function main() {
+  const { configPath, rest } = parseCli(process.argv.slice(2));
+  if (rest.length === 0) shellUsage();
+  const cfg = loadConfig(configPath);
+  const cmd = rest[0];
+
+  if (cmd === "list") {
+    const asJson = rest.includes("--json");
+    const servers = Object.entries(cfg.mcpServers || {}).map(([name, entry]) => ({
+      name,
+      transport: entry && typeof entry === "object"
+        ? (entry.transport || (entry.command ? "stdio" : entry.url ? "http" : "unknown"))
+        : "unknown",
+      command: entry && typeof entry === "object" && entry.command ? String(entry.command) : undefined,
+      args: entry && typeof entry === "object" && Array.isArray(entry.args)
+        ? entry.args.map((v) => String(v))
+        : undefined,
+      url: entry && typeof entry === "object" && entry.url ? String(entry.url) : undefined,
+    }));
+    if (asJson) {
+      process.stdout.write(JSON.stringify({ servers }) + "\\n");
+      return;
+    }
+    for (const server of servers) {
+      process.stdout.write(server.name + "\\t" + server.transport + "\\n");
+    }
+    return;
+  }
+
+  if (cmd === "call") {
+    if (rest.length < 2) shellUsage();
+    const target = rest[1];
+    const dot = target.indexOf(".");
+    if (dot <= 0 || dot === target.length - 1) {
+      fail("mcporter: expected <server>.<tool>, got: " + target, 2);
+    }
+    const serverName = target.slice(0, dot);
+    const toolName = target.slice(dot + 1);
+    const entry = cfg.mcpServers[serverName];
+    if (!entry) fail("mcporter: unknown server '" + serverName + "'", 2);
+    if (entry.url && !entry.command) {
+      fail("mcporter: only stdio-backed servers are supported by this wrapper", 2);
+    }
+    const toolArgs = parseKeyValueArgs(rest.slice(2));
+    const result = await callStdioServer(entry, toolName, toolArgs);
+    process.stdout.write(printableResult(result) + "\\n");
+    return;
+  }
+
+  shellUsage();
+}
+
+main().catch((e) => {
+  fail("mcporter: " + (e && e.message ? e.message : e));
+});
+`;
+}
+//# sourceMappingURL=mcporter-lite.js.map

package/dist/services/integrations/openclaw/mcporter-lite.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mcporter-lite.js","sourceRoot":"","sources":["../../../../src/services/integrations/openclaw/mcporter-lite.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAEH,MAAM,UAAU,8BAA8B;IAC5C,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAyPR,CAAC;AACF,CAAC"}

package/dist/services/integrations/openclaw/mcporter.d.ts

@@ -0,0 +1,59 @@
+export type McporterSource = {
+    kind: "user";
+} | {
+    kind: "connection";
+    slot: string;
+    consumerInstanceId: string;
+};
+export interface McporterServerEntry {
+    command?: string;
+    args?: string[];
+    url?: string;
+    transport?: "sse" | "http" | "stdio";
+    env?: Record<string, string>;
+    __source?: McporterSource;
+    [key: string]: unknown;
+}
+interface McporterConfig {
+    mcpServers: Record<string, McporterServerEntry>;
+    imports?: any[];
+    [key: string]: unknown;
+}
+export declare function mcporterPath(instanceId: string): string;
+export declare function readMcporterConfig(instanceId: string): McporterConfig;
+export declare function writeMcporterConfig(instanceId: string, cfg: McporterConfig): void;
+/**
+ * Merge `servers` into the consumer's mcporter.json. Existing entries with
+ * the same name and matching `__source` get overwritten; entries with a
+ * different source (e.g. user-managed) are preserved untouched and the new
+ * entry's name is suffixed with a numeric tag (`-2`, `-3`, …) so the merge
+ * never silently overwrites user-managed servers.
+ *
+ * When user-managed and connection-managed entries collide on name, the
+ * conflict surfaces by having the connection-managed entry land under a
+ * suffixed key. Routes that later inspect the file can detect the
+ * suffix and surface a UI warning if needed.
+ */
+export declare function mergeMcporterServers(instanceId: string, servers: Record<string, McporterServerEntry>): void;
+export interface FixedMcporterUpsertResult {
+    ok: boolean;
+    reason?: "name-conflict";
+    existing?: McporterServerEntry;
+}
+/**
+ * Add or replace one connection-owned server at an exact name.
+ *
+ * This is intentionally stricter than mergeMcporterServers: a user-owned name
+ * collision fails closed instead of suffixing, because some managed contracts
+ * depend on a stable server prefix such as `kb.kb_*`.
+ */
+export declare function upsertFixedMcporterServer(instanceId: string, name: string, entry: McporterServerEntry): FixedMcporterUpsertResult;
+/**
+ * Remove all entries whose `__source` matches the given filter. If
+ * filter.source is omitted, removes every connection-managed entry
+ * (everything except `kind: "user"` / no marker).
+ */
+export declare function removeMcporterServers(instanceId: string, filter?: {
+    source?: McporterSource;
+}): void;
+export {};

package/dist/services/integrations/openclaw/mcporter.js

@@ -0,0 +1,143 @@
+/**
+ * Mcporter helper shared by OpenClaw integration routes and connection apply
+ * hooks so /mcporter/add and connection binding use the same read/merge/write
+ * code path.
+ *
+ * Connection-merged servers carry a `__source` object so we can later
+ * (un)bind precisely without touching user-managed entries:
+ *
+ *   { __source: { kind: "connection", slot, consumerInstanceId } }
+ *
+ * `__source: { kind: "user" }` (or no marker) means "user-managed via
+ * Mcporter UI"; never touched by connection apply hooks.
+ */
+import { existsSync, readFileSync } from "fs";
+import { join } from "path";
+import { getIntegration } from "../registry.js";
+import { ensureDirHost } from "../../../utils/fs.js";
+import { safeWriteJson } from "../../../utils/safe-json.js";
+const PROTO_KEYS = new Set(["__proto__", "constructor", "prototype"]);
+export function mcporterPath(instanceId) {
+    const integration = getIntegration("openclaw");
+    if (typeof integration.resolveAgentHome !== "function") {
+        throw new Error("OpenClaw integration does not expose its canonical home path");
+    }
+    const home = integration.resolveAgentHome(instanceId);
+    return join(home, ".openclaw", "workspace", "config", "mcporter.json");
+}
+export function readMcporterConfig(instanceId) {
+    const path = mcporterPath(instanceId);
+    if (!existsSync(path))
+        return { mcpServers: {}, imports: [] };
+    try {
+        const raw = JSON.parse(readFileSync(path, "utf-8"));
+        if (!raw || typeof raw !== "object")
+            return { mcpServers: {}, imports: [] };
+        if (!raw.mcpServers || typeof raw.mcpServers !== "object") {
+            raw.mcpServers = {};
+        }
+        return raw;
+    }
+    catch {
+        return { mcpServers: {}, imports: [] };
+    }
+}
+export function writeMcporterConfig(instanceId, cfg) {
+    const path = mcporterPath(instanceId);
+    ensureDirHost(join(path, ".."));
+    safeWriteJson(path, cfg);
+}
+/**
+ * Merge `servers` into the consumer's mcporter.json. Existing entries with
+ * the same name and matching `__source` get overwritten; entries with a
+ * different source (e.g. user-managed) are preserved untouched and the new
+ * entry's name is suffixed with a numeric tag (`-2`, `-3`, …) so the merge
+ * never silently overwrites user-managed servers.
+ *
+ * When user-managed and connection-managed entries collide on name, the
+ * conflict surfaces by having the connection-managed entry land under a
+ * suffixed key. Routes that later inspect the file can detect the
+ * suffix and surface a UI warning if needed.
+ */
+export function mergeMcporterServers(instanceId, servers) {
+    const cfg = readMcporterConfig(instanceId);
+    cfg.mcpServers = cfg.mcpServers ?? {};
+    for (const [rawName, entry] of Object.entries(servers)) {
+        if (PROTO_KEYS.has(rawName))
+            continue;
+        let name = rawName;
+        const existing = cfg.mcpServers[name];
+        if (existing && !sourceMatches(existing.__source, entry.__source)) {
+            // user-managed vs connection-managed collision — pick a suffixed key.
+            let i = 2;
+            while (cfg.mcpServers[`${rawName}-${i}`])
+                i++;
+            name = `${rawName}-${i}`;
+        }
+        cfg.mcpServers[name] = entry;
+    }
+    writeMcporterConfig(instanceId, cfg);
+}
+/**
+ * Add or replace one connection-owned server at an exact name.
+ *
+ * This is intentionally stricter than mergeMcporterServers: a user-owned name
+ * collision fails closed instead of suffixing, because some managed contracts
+ * depend on a stable server prefix such as `kb.kb_*`.
+ */
+export function upsertFixedMcporterServer(instanceId, name, entry) {
+    if (PROTO_KEYS.has(name)) {
+        throw new Error(`Invalid mcporter server name: ${name}`);
+    }
+    const cfg = readMcporterConfig(instanceId);
+    cfg.mcpServers = cfg.mcpServers ?? {};
+    const next = {};
+    for (const [existingName, existingEntry] of Object.entries(cfg.mcpServers)) {
+        if (sourceMatches(existingEntry.__source, entry.__source)) {
+            continue;
+        }
+        next[existingName] = existingEntry;
+    }
+    const existing = next[name];
+    if (existing && !sourceMatches(existing.__source, entry.__source)) {
+        cfg.mcpServers = next;
+        writeMcporterConfig(instanceId, cfg);
+        return { ok: false, reason: "name-conflict", existing };
+    }
+    next[name] = entry;
+    cfg.mcpServers = next;
+    writeMcporterConfig(instanceId, cfg);
+    return { ok: true };
+}
+/**
+ * Remove all entries whose `__source` matches the given filter. If
+ * filter.source is omitted, removes every connection-managed entry
+ * (everything except `kind: "user"` / no marker).
+ */
+export function removeMcporterServers(instanceId, filter = {}) {
+    const cfg = readMcporterConfig(instanceId);
+    if (!cfg.mcpServers)
+        return;
+    const keep = {};
+    for (const [name, entry] of Object.entries(cfg.mcpServers)) {
+        const src = entry.__source;
+        const matches = filter.source
+            ? sourceMatches(src, filter.source)
+            : src && src.kind === "connection";
+        if (!matches)
+            keep[name] = entry;
+    }
+    cfg.mcpServers = keep;
+    writeMcporterConfig(instanceId, cfg);
+}
+function sourceMatches(a, b) {
+    if (!a || !b)
+        return false;
+    if (a.kind !== b.kind)
+        return false;
+    if (a.kind === "connection" && b.kind === "connection") {
+        return a.slot === b.slot && a.consumerInstanceId === b.consumerInstanceId;
+    }
+    return true;
+}
+//# sourceMappingURL=mcporter.js.map

package/dist/services/integrations/openclaw/mcporter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mcporter.js","sourceRoot":"","sources":["../../../../src/services/integrations/openclaw/mcporter.ts"],"names":[],"mappings":"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"}

package/dist/services/integrations/openclaw/native-mcp.d.ts

@@ -0,0 +1,48 @@
+export type OpenclawMcpSource = {
+    kind: "user";
+} | {
+    kind: "connection";
+    slot: string;
+    consumerInstanceId: string;
+};
+export interface OpenclawMcpServerEntry {
+    command?: string;
+    args?: string[];
+    env?: Record<string, string | number | boolean>;
+    cwd?: string;
+    workingDirectory?: string;
+    url?: string;
+    transport?: "sse" | "streamable-http";
+    headers?: Record<string, string | number | boolean>;
+    connectionTimeoutMs?: number;
+    __source?: OpenclawMcpSource;
+    [key: string]: unknown;
+}
+/**
+ * Add or replace one JishuShell-managed native MCP server.
+ *
+ * If the preferred name is already user-managed, it is preserved and the
+ * managed server receives a stable numeric suffix. The selected name is
+ * returned so TOOLS.md can reference the actual native tool prefix.
+ */
+export declare function upsertOpenclawMcpServer(configPath: string, preferredName: string, entry: OpenclawMcpServerEntry): string | null;
+export interface FixedOpenclawMcpUpsertResult {
+    ok: boolean;
+    reason?: "missing-config" | "name-conflict";
+    existing?: OpenclawMcpServerEntry;
+}
+/**
+ * Add or replace one connection-owned native MCP server at an exact name.
+ *
+ * This is stricter than `upsertOpenclawMcpServer`: a user-owned collision fails
+ * closed instead of suffixing, because some managed OpenClaw tool contracts
+ * depend on a stable server prefix such as `kb__*`.
+ */
+export declare function upsertFixedOpenclawMcpServer(configPath: string, name: string, entry: OpenclawMcpServerEntry): FixedOpenclawMcpUpsertResult;
+/**
+ * Remove native MCP servers matching one JishuShell ownership source.
+ * User-managed entries and unrelated integrations are preserved.
+ */
+export declare function removeOpenclawMcpServers(configPath: string, filter: {
+    source: OpenclawMcpSource;
+}): void;

package/dist/services/integrations/openclaw/native-mcp.js

@@ -0,0 +1,125 @@
+/**
+ * Helpers for JishuShell-managed entries in OpenClaw's native MCP config.
+ *
+ * OpenClaw stores standard MCP servers under `openclaw.json -> mcp.servers`.
+ * Managed entries carry `__source` metadata so integration lifecycle hooks can
+ * update or remove only their own server without touching user-managed MCP
+ * configuration.
+ */
+import { existsSync, readFileSync } from "fs";
+import { safeWriteJson } from "../../../utils/safe-json.js";
+const PROTO_KEYS = new Set(["__proto__", "constructor", "prototype"]);
+function readOpenclawConfig(configPath) {
+    if (!existsSync(configPath))
+        return null;
+    const parsed = JSON.parse(readFileSync(configPath, "utf-8"));
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+        throw new Error(`OpenClaw config must be a JSON object: ${configPath}`);
+    }
+    return parsed;
+}
+function sourceMatches(a, b) {
+    if (!a || !b || a.kind !== b.kind)
+        return false;
+    if (a.kind === "connection" && b.kind === "connection") {
+        return a.slot === b.slot && a.consumerInstanceId === b.consumerInstanceId;
+    }
+    return true;
+}
+/**
+ * Add or replace one JishuShell-managed native MCP server.
+ *
+ * If the preferred name is already user-managed, it is preserved and the
+ * managed server receives a stable numeric suffix. The selected name is
+ * returned so TOOLS.md can reference the actual native tool prefix.
+ */
+export function upsertOpenclawMcpServer(configPath, preferredName, entry) {
+    if (PROTO_KEYS.has(preferredName)) {
+        throw new Error(`Invalid OpenClaw MCP server name: ${preferredName}`);
+    }
+    const config = readOpenclawConfig(configPath);
+    if (!config)
+        return null;
+    const mcp = config.mcp && typeof config.mcp === "object" && !Array.isArray(config.mcp)
+        ? config.mcp
+        : (config.mcp = {});
+    const servers = mcp.servers && typeof mcp.servers === "object" && !Array.isArray(mcp.servers)
+        ? mcp.servers
+        : (mcp.servers = {});
+    let name = Object.entries(servers).find(([, existing]) => sourceMatches(existing?.__source, entry.__source))?.[0];
+    if (!name) {
+        name = preferredName;
+        if (servers[name] && !sourceMatches(servers[name].__source, entry.__source)) {
+            let suffix = 2;
+            while (servers[`${preferredName}-${suffix}`])
+                suffix += 1;
+            name = `${preferredName}-${suffix}`;
+        }
+    }
+    servers[name] = entry;
+    safeWriteJson(configPath, config);
+    return name;
+}
+/**
+ * Add or replace one connection-owned native MCP server at an exact name.
+ *
+ * This is stricter than `upsertOpenclawMcpServer`: a user-owned collision fails
+ * closed instead of suffixing, because some managed OpenClaw tool contracts
+ * depend on a stable server prefix such as `kb__*`.
+ */
+export function upsertFixedOpenclawMcpServer(configPath, name, entry) {
+    if (PROTO_KEYS.has(name)) {
+        throw new Error(`Invalid OpenClaw MCP server name: ${name}`);
+    }
+    const config = readOpenclawConfig(configPath);
+    if (!config)
+        return { ok: false, reason: "missing-config" };
+    const mcp = config.mcp && typeof config.mcp === "object" && !Array.isArray(config.mcp)
+        ? config.mcp
+        : (config.mcp = {});
+    const servers = mcp.servers && typeof mcp.servers === "object" && !Array.isArray(mcp.servers)
+        ? mcp.servers
+        : (mcp.servers = {});
+    const next = {};
+    for (const [existingName, existingEntry] of Object.entries(servers)) {
+        if (sourceMatches(existingEntry?.__source, entry.__source)) {
+            continue;
+        }
+        next[existingName] = existingEntry;
+    }
+    const existing = next[name];
+    if (existing && !sourceMatches(existing.__source, entry.__source)) {
+        mcp.servers = next;
+        safeWriteJson(configPath, config);
+        return { ok: false, reason: "name-conflict", existing };
+    }
+    next[name] = entry;
+    mcp.servers = next;
+    safeWriteJson(configPath, config);
+    return { ok: true };
+}
+/**
+ * Remove native MCP servers matching one JishuShell ownership source.
+ * User-managed entries and unrelated integrations are preserved.
+ */
+export function removeOpenclawMcpServers(configPath, filter) {
+    const config = readOpenclawConfig(configPath);
+    if (!config)
+        return;
+    const servers = config?.mcp?.servers;
+    if (!servers || typeof servers !== "object" || Array.isArray(servers))
+        return;
+    let changed = false;
+    for (const [name, entry] of Object.entries(servers)) {
+        const source = entry && typeof entry === "object"
+            ? entry.__source
+            : undefined;
+        if (sourceMatches(source, filter.source)) {
+            delete servers[name];
+            changed = true;
+        }
+    }
+    if (changed)
+        safeWriteJson(configPath, config);
+}
+//# sourceMappingURL=native-mcp.js.map