cli-claw-kit 0.0.1

package/dist/routes/mcp-servers.js

@@ -0,0 +1,320 @@
+// MCP Servers management routes
+import { Hono } from 'hono';
+import fs from 'fs/promises';
+import path from 'path';
+import os from 'os';
+import { authMiddleware } from '../middleware/auth.js';
+import { DATA_DIR } from '../config.js';
+import { checkMcpServerLimit } from '../billing.js';
+// --- Utility Functions ---
+function getUserMcpServersDir(userId) {
+    return path.join(DATA_DIR, 'mcp-servers', userId);
+}
+function getServersFilePath(userId) {
+    return path.join(getUserMcpServersDir(userId), 'servers.json');
+}
+function getHostSyncManifestPath(userId) {
+    return path.join(getUserMcpServersDir(userId), '.host-sync.json');
+}
+function validateServerId(id) {
+    return /^[\w\-]+$/.test(id) && id !== 'cli-claw';
+}
+async function readMcpServersFile(userId) {
+    try {
+        const data = await fs.readFile(getServersFilePath(userId), 'utf-8');
+        return JSON.parse(data);
+    }
+    catch {
+        return { servers: {} };
+    }
+}
+async function writeMcpServersFile(userId, data) {
+    const dir = getUserMcpServersDir(userId);
+    await fs.mkdir(dir, { recursive: true });
+    await fs.writeFile(getServersFilePath(userId), JSON.stringify(data, null, 2));
+}
+async function readHostSyncManifest(userId) {
+    try {
+        const data = await fs.readFile(getHostSyncManifestPath(userId), 'utf-8');
+        return JSON.parse(data);
+    }
+    catch {
+        return { syncedServers: [], lastSyncAt: '' };
+    }
+}
+async function writeHostSyncManifest(userId, manifest) {
+    const dir = getUserMcpServersDir(userId);
+    await fs.mkdir(dir, { recursive: true });
+    await fs.writeFile(getHostSyncManifestPath(userId), JSON.stringify(manifest, null, 2));
+}
+// --- Routes ---
+const mcpServersRoutes = new Hono();
+// GET / — list all MCP servers for the current user
+mcpServersRoutes.get('/', authMiddleware, async (c) => {
+    const authUser = c.get('user');
+    const file = await readMcpServersFile(authUser.id);
+    const servers = Object.entries(file.servers).map(([id, entry]) => ({
+        id,
+        ...entry,
+    }));
+    return c.json({ servers });
+});
+// POST / — add a new MCP server
+mcpServersRoutes.post('/', authMiddleware, async (c) => {
+    const authUser = c.get('user');
+    const body = await c.req.json().catch(() => ({}));
+    const { id, command, args, env, description, type, url, headers } = body;
+    if (!id || typeof id !== 'string') {
+        return c.json({ error: 'id is required and must be a string' }, 400);
+    }
+    if (!validateServerId(id)) {
+        return c.json({
+            error: 'Invalid server ID: must match /^[\\w\\-]+$/ and cannot be "cli-claw"',
+        }, 400);
+    }
+    // Billing: check MCP server limit
+    const existingServers = await readMcpServersFile(authUser.id);
+    const currentCount = Object.keys(existingServers.servers).length;
+    if (!existingServers.servers[id]) {
+        // Only check limit for new servers, not updates
+        const limit = checkMcpServerLimit(authUser.id, authUser.role, currentCount);
+        if (!limit.allowed) {
+            return c.json({ error: limit.reason }, 403);
+        }
+    }
+    const isHttpType = type === 'http' || type === 'sse';
+    if (isHttpType) {
+        if (!url || typeof url !== 'string') {
+            return c.json({ error: 'url is required for http/sse type' }, 400);
+        }
+        if (headers !== undefined &&
+            (typeof headers !== 'object' ||
+                headers === null ||
+                Array.isArray(headers))) {
+            return c.json({ error: 'headers must be a plain object' }, 400);
+        }
+    }
+    else {
+        if (!command || typeof command !== 'string') {
+            return c.json({ error: 'command is required and must be a string' }, 400);
+        }
+        if (args !== undefined && !Array.isArray(args)) {
+            return c.json({ error: 'args must be an array of strings' }, 400);
+        }
+        if (env !== undefined &&
+            (typeof env !== 'object' || env === null || Array.isArray(env))) {
+            return c.json({ error: 'env must be a plain object' }, 400);
+        }
+    }
+    const file = await readMcpServersFile(authUser.id);
+    if (file.servers[id]) {
+        return c.json({ error: `Server "${id}" already exists` }, 409);
+    }
+    const entry = {
+        enabled: true,
+        ...(description ? { description } : {}),
+        addedAt: new Date().toISOString(),
+    };
+    if (isHttpType) {
+        entry.type = type;
+        entry.url = url;
+        if (headers && Object.keys(headers).length > 0)
+            entry.headers = headers;
+    }
+    else {
+        entry.command = command;
+        if (args && args.length > 0)
+            entry.args = args;
+        if (env && Object.keys(env).length > 0)
+            entry.env = env;
+    }
+    file.servers[id] = entry;
+    await writeMcpServersFile(authUser.id, file);
+    return c.json({ success: true, server: { id, ...file.servers[id] } });
+});
+// PATCH /:id — update config / enable / disable
+mcpServersRoutes.patch('/:id', authMiddleware, async (c) => {
+    const authUser = c.get('user');
+    const id = c.req.param('id');
+    if (!validateServerId(id)) {
+        return c.json({ error: 'Invalid server ID' }, 400);
+    }
+    const body = await c.req.json().catch(() => ({}));
+    const { command, args, env, enabled, description, url, headers } = body;
+    const file = await readMcpServersFile(authUser.id);
+    const entry = file.servers[id];
+    if (!entry) {
+        return c.json({ error: 'Server not found' }, 404);
+    }
+    // stdio fields
+    if (command !== undefined) {
+        if (typeof command !== 'string' || !command) {
+            return c.json({ error: 'command must be a non-empty string' }, 400);
+        }
+        entry.command = command;
+    }
+    if (args !== undefined) {
+        if (!Array.isArray(args)) {
+            return c.json({ error: 'args must be an array of strings' }, 400);
+        }
+        entry.args = args;
+    }
+    if (env !== undefined) {
+        if (typeof env !== 'object' || env === null || Array.isArray(env)) {
+            return c.json({ error: 'env must be a plain object' }, 400);
+        }
+        entry.env = env;
+    }
+    // http/sse fields
+    if (url !== undefined) {
+        if (typeof url !== 'string' || !url) {
+            return c.json({ error: 'url must be a non-empty string' }, 400);
+        }
+        entry.url = url;
+    }
+    if (headers !== undefined) {
+        if (typeof headers !== 'object' ||
+            headers === null ||
+            Array.isArray(headers)) {
+            return c.json({ error: 'headers must be a plain object' }, 400);
+        }
+        entry.headers = headers;
+    }
+    // common fields
+    if (enabled !== undefined) {
+        if (typeof enabled !== 'boolean') {
+            return c.json({ error: 'enabled must be a boolean' }, 400);
+        }
+        entry.enabled = enabled;
+    }
+    if (description !== undefined) {
+        entry.description =
+            typeof description === 'string' ? description : undefined;
+    }
+    await writeMcpServersFile(authUser.id, file);
+    return c.json({ success: true, server: { id, ...entry } });
+});
+// DELETE /:id — delete a server
+mcpServersRoutes.delete('/:id', authMiddleware, async (c) => {
+    const authUser = c.get('user');
+    const id = c.req.param('id');
+    if (!validateServerId(id)) {
+        return c.json({ error: 'Invalid server ID' }, 400);
+    }
+    const file = await readMcpServersFile(authUser.id);
+    if (!file.servers[id]) {
+        return c.json({ error: 'Server not found' }, 404);
+    }
+    delete file.servers[id];
+    await writeMcpServersFile(authUser.id, file);
+    return c.json({ success: true });
+});
+// POST /sync-host — sync from host MCP configs (admin only)
+// Reads from both ~/.claude/settings.json and ~/.claude.json
+mcpServersRoutes.post('/sync-host', authMiddleware, async (c) => {
+    const authUser = c.get('user');
+    if (authUser.role !== 'admin') {
+        return c.json({ error: 'Only admin can sync host MCP servers' }, 403);
+    }
+    // Read MCP servers from both config file locations
+    let hostServers = {};
+    // Source 1: ~/.claude/settings.json
+    const settingsPath = path.join(os.homedir(), '.claude', 'settings.json');
+    try {
+        const raw = await fs.readFile(settingsPath, 'utf-8');
+        const settings = JSON.parse(raw);
+        if (settings.mcpServers) {
+            hostServers = { ...hostServers, ...settings.mcpServers };
+        }
+    }
+    catch {
+        // File may not exist, that's OK
+    }
+    // Source 2: ~/.claude.json (global Claude Code config, stores per-user MCP settings)
+    // When both files define the same server ID, ~/.claude.json wins because it's
+    // the primary user-facing config file where Claude Code persists MCP settings.
+    const globalConfigPath = path.join(os.homedir(), '.claude.json');
+    try {
+        const raw = await fs.readFile(globalConfigPath, 'utf-8');
+        const config = JSON.parse(raw);
+        if (config.mcpServers) {
+            hostServers = { ...hostServers, ...config.mcpServers };
+        }
+    }
+    catch {
+        // File may not exist, that's OK
+    }
+    if (Object.keys(hostServers).length === 0) {
+        return c.json({
+            added: 0,
+            updated: 0,
+            deleted: 0,
+            skipped: 0,
+            message: 'No MCP servers found in host config files',
+        });
+    }
+    const file = await readMcpServersFile(authUser.id);
+    const manifest = await readHostSyncManifest(authUser.id);
+    const previouslySynced = new Set(manifest.syncedServers);
+    const hostServerIds = new Set(Object.keys(hostServers));
+    const stats = { added: 0, updated: 0, deleted: 0, skipped: 0 };
+    const newSyncedList = [];
+    // Add/update from host
+    for (const [id, hostEntry] of Object.entries(hostServers)) {
+        if (!validateServerId(id)) {
+            stats.skipped++;
+            continue;
+        }
+        const existsInUser = !!file.servers[id];
+        const wasSynced = previouslySynced.has(id);
+        // Skip manually added entries
+        if (existsInUser && !wasSynced) {
+            stats.skipped++;
+            continue;
+        }
+        const isHttpType = hostEntry.type === 'http' || hostEntry.type === 'sse';
+        const entry = {
+            enabled: true,
+            syncedFromHost: true,
+            addedAt: existsInUser
+                ? file.servers[id].addedAt || new Date().toISOString()
+                : new Date().toISOString(),
+        };
+        if (isHttpType) {
+            entry.type = hostEntry.type;
+            entry.url = hostEntry.url || '';
+            if (hostEntry.headers)
+                entry.headers = hostEntry.headers;
+        }
+        else {
+            entry.command = hostEntry.command || '';
+            if (hostEntry.args)
+                entry.args = hostEntry.args;
+            if (hostEntry.env)
+                entry.env = hostEntry.env;
+        }
+        if (existsInUser) {
+            stats.updated++;
+        }
+        else {
+            stats.added++;
+        }
+        file.servers[id] = entry;
+        newSyncedList.push(id);
+    }
+    // Delete servers that were synced before but no longer on host
+    for (const id of previouslySynced) {
+        if (!hostServerIds.has(id) && file.servers[id]?.syncedFromHost) {
+            delete file.servers[id];
+            stats.deleted++;
+        }
+    }
+    await writeMcpServersFile(authUser.id, file);
+    await writeHostSyncManifest(authUser.id, {
+        syncedServers: newSyncedList,
+        lastSyncAt: new Date().toISOString(),
+    });
+    return c.json(stats);
+});
+export { getUserMcpServersDir, readMcpServersFile };
+export default mcpServersRoutes;