mcpsmgr 0.1.0 → 0.2.0

package/src/adapters/{codex-cli.ts → codex.ts}

@@ -87,9 +87,9 @@ async function writeTomlFile(
   await writeFile(filePath, stringifyToml(data) + "\n", "utf-8");
 }
 
-export const codexCliAdapter: AgentAdapter = {
-  id: "codex-cli",
-  name: "Codex CLI",
+export const codexAdapter: AgentAdapter = {
+  id: "codex",
+  name: "Codex",
   configPath: (projectDir) => join(projectDir, ".codex", "config.toml"),
   isGlobal: false,
 
@@ -108,7 +108,7 @@ export const codexCliAdapter: AgentAdapter = {
     const servers = (parsed["mcp_servers"] as Record<string, unknown>) ?? {};
     if (serverName in servers) {
       throw new Error(
-        `Conflict: "${serverName}" already exists in Codex CLI config`,
+        `Conflict: "${serverName}" already exists in Codex config`,
       );
     }
     const updated = {

package/src/adapters/index.ts

@@ -1,17 +1,19 @@
 import { existsSync } from "node:fs";
 import type { AgentAdapter, AgentId } from "../types.js";
 import { claudeCodeAdapter } from "./claude-code.js";
-import { codexCliAdapter } from "./codex-cli.js";
+import { codexAdapter } from "./codex.js";
 import { geminiCliAdapter } from "./gemini-cli.js";
 import { opencodeAdapter } from "./opencode.js";
 import { antigravityAdapter } from "./antigravity.js";
+import { openclawAdapter } from "./openclaw.js";
 
 export const allAdapters: readonly AgentAdapter[] = [
   claudeCodeAdapter,
-  codexCliAdapter,
+  codexAdapter,
   geminiCliAdapter,
   opencodeAdapter,
   antigravityAdapter,
+  openclawAdapter,
 ];
 
 export function getAdapter(id: AgentId): AgentAdapter {

package/src/adapters/json5-file.ts

@@ -0,0 +1,25 @@
+import { readFile, writeFile, mkdir } from "node:fs/promises";
+import { existsSync } from "node:fs";
+import { dirname } from "node:path";
+import JSON5 from "json5";
+
+export async function readJson5File(
+  filePath: string,
+): Promise<Record<string, unknown>> {
+  if (!existsSync(filePath)) {
+    return {};
+  }
+  const raw = await readFile(filePath, "utf-8");
+  return JSON5.parse(raw) as Record<string, unknown>;
+}
+
+export async function writeJson5File(
+  filePath: string,
+  data: Record<string, unknown>,
+): Promise<void> {
+  const dir = dirname(filePath);
+  if (!existsSync(dir)) {
+    await mkdir(dir, { recursive: true });
+  }
+  await writeFile(filePath, JSON.stringify(data, null, 2) + "\n", "utf-8");
+}

package/src/adapters/openclaw.ts

@@ -0,0 +1,113 @@
+import { homedir } from "node:os";
+import { join } from "node:path";
+import type { AgentAdapter, DefaultConfig } from "../types.js";
+import { readJson5File, writeJson5File } from "./json5-file.js";
+import { buildEnvArgs, parseEnvArgs, resolveEnvInArgs } from "./env-args.js";
+
+const GLOBAL_CONFIG_PATH = join(
+  homedir(),
+  ".openclaw",
+  "openclaw.json",
+);
+
+function toAgentFormat(config: DefaultConfig): Record<string, unknown> {
+  if (config.transport === "stdio") {
+    const { resolvedArgs, remainingEnv } = resolveEnvInArgs(
+      config.args,
+      config.env,
+    );
+    const envArgs = buildEnvArgs(remainingEnv);
+    if (envArgs.length > 0) {
+      return {
+        command: "env",
+        args: [...envArgs, config.command, ...resolvedArgs],
+      };
+    }
+    return {
+      command: config.command,
+      args: resolvedArgs,
+    };
+  }
+  return {
+    url: config.url,
+    headers: { ...config.headers },
+  };
+}
+
+function fromAgentFormat(
+  _name: string,
+  raw: Record<string, unknown>,
+): DefaultConfig | undefined {
+  if (raw["command"]) {
+    const command = raw["command"] as string;
+    const rawArgs = (raw["args"] as string[]) ?? [];
+    const legacyEnv = raw["env"] as Record<string, string> | undefined;
+
+    if (legacyEnv && Object.keys(legacyEnv).length > 0) {
+      return { transport: "stdio", command, args: rawArgs, env: legacyEnv };
+    }
+
+    if (command === "env") {
+      const { env, commandIndex } = parseEnvArgs(rawArgs);
+      return {
+        transport: "stdio",
+        command: rawArgs[commandIndex] ?? "",
+        args: rawArgs.slice(commandIndex + 1),
+        env,
+      };
+    }
+
+    return { transport: "stdio", command, args: rawArgs, env: {} };
+  }
+  if (raw["url"]) {
+    return {
+      transport: "http",
+      url: raw["url"] as string,
+      headers: (raw["headers"] as Record<string, string>) ?? {},
+    };
+  }
+  return undefined;
+}
+
+export const openclawAdapter: AgentAdapter = {
+  id: "openclaw",
+  name: "OpenClaw",
+  configPath: () => GLOBAL_CONFIG_PATH,
+  isGlobal: true,
+
+  toAgentFormat,
+  fromAgentFormat,
+
+  async read() {
+    const data = await readJson5File(GLOBAL_CONFIG_PATH);
+    return (data["mcpServers"] as Record<string, unknown>) ?? {};
+  },
+
+  async write(_projectDir, serverName, config) {
+    const data = await readJson5File(GLOBAL_CONFIG_PATH);
+    const servers = (data["mcpServers"] as Record<string, unknown>) ?? {};
+    if (serverName in servers) {
+      throw new Error(
+        `Conflict: "${serverName}" already exists in OpenClaw config`,
+      );
+    }
+    const updated = {
+      ...data,
+      mcpServers: { ...servers, [serverName]: toAgentFormat(config) },
+    };
+    await writeJson5File(GLOBAL_CONFIG_PATH, updated);
+  },
+
+  async remove(_projectDir, serverName) {
+    const data = await readJson5File(GLOBAL_CONFIG_PATH);
+    const servers = (data["mcpServers"] as Record<string, unknown>) ?? {};
+    const { [serverName]: _, ...rest } = servers;
+    await writeJson5File(GLOBAL_CONFIG_PATH, { ...data, mcpServers: rest });
+  },
+
+  async has(_projectDir, serverName) {
+    const data = await readJson5File(GLOBAL_CONFIG_PATH);
+    const servers = (data["mcpServers"] as Record<string, unknown>) ?? {};
+    return serverName in servers;
+  },
+};

package/src/services/system-prompt.ts

@@ -7,7 +7,7 @@ The 5 agents and their configuration differences:
    - HTTP: { "type": "http", "url": "...", "headers": {...} }
    - IMPORTANT: Do NOT use "env" field. Environment variables will be handled separately.
 
-2. **Codex CLI** (.codex/config.toml)
+2. **Codex** (.codex/config.toml)
    - TOML format: command = "...", args = [...]
    - Same key names as Claude Code but in TOML
    - IMPORTANT: Do NOT use "env" field.
@@ -53,7 +53,7 @@ After analyzing the documentation, return a JSON object with this exact structur
 
 Rules:
 - "name" should be a kebab-case identifier for the server
-- "default" should be the most common configuration (usually works for Claude Code, Codex CLI, Gemini CLI)
+- "default" should be the most common configuration (usually works for Claude Code, Codex, Gemini CLI)
 - Only add "overrides" for agents that need DIFFERENT configuration from the default
 - OpenCode usually needs an override because its command format differs (array vs string+args)
 - "requiredEnvVars" lists environment variable names the user needs to provide values for

package/src/types.ts

@@ -15,10 +15,11 @@ export type DefaultConfig = StdioConfig | HttpConfig;
 
 export type AgentId =
   | "claude-code"
-  | "codex-cli"
+  | "codex"
   | "gemini-cli"
   | "opencode"
-  | "antigravity";
+  | "antigravity"
+  | "openclaw";
 
 export interface ServerDefinition {
   readonly name: string;