@dollhousemcp/mcp-server 2.0.1 → 2.0.3

package/dist/web/routes/setupRoutes.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Setup Routes — Auto-install DollhouseMCP to MCP clients
+ *
+ * Uses `install-mcp` (https://github.com/supermemoryai/install-mcp)
+ * to inject server configuration into supported MCP client config files.
+ *
+ * Security: localhost-only binding (enforced by server.ts), rate-limited,
+ * and command arguments are hardcoded — no user-supplied shell input.
+ */
+import type { Request, Response } from 'express';
+export declare function createSetupRoutes(): {
+    installHandler: (req: Request, res: Response) => Promise<void>;
+    openConfigHandler: (req: Request, res: Response) => Promise<void>;
+    versionHandler: (req: Request, res: Response) => Promise<void>;
+    mcpbRedirectHandler: (req: Request, res: Response) => Promise<void>;
+    detectHandler: (req: Request, res: Response) => Promise<void>;
+};
+//# sourceMappingURL=setupRoutes.d.ts.map

package/dist/web/routes/setupRoutes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"setupRoutes.d.ts","sourceRoot":"","sources":["../../../src/web/routes/setupRoutes.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AA4LjD,wBAAgB,iBAAiB,IAAI;IACnC,cAAc,EAAE,CAAC,GAAG,EAAE,OAAO,EAAE,GAAG,EAAE,QAAQ,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IAC/D,iBAAiB,EAAE,CAAC,GAAG,EAAE,OAAO,EAAE,GAAG,EAAE,QAAQ,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IAClE,cAAc,EAAE,CAAC,GAAG,EAAE,OAAO,EAAE,GAAG,EAAE,QAAQ,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IAC/D,mBAAmB,EAAE,CAAC,GAAG,EAAE,OAAO,EAAE,GAAG,EAAE,QAAQ,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IACpE,aAAa,EAAE,CAAC,GAAG,EAAE,OAAO,EAAE,GAAG,EAAE,QAAQ,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;CAC/D,CA0JA"}

package/dist/web/routes/setupRoutes.js

@@ -0,0 +1,360 @@
+/**
+ * Setup Routes — Auto-install DollhouseMCP to MCP clients
+ *
+ * Uses `install-mcp` (https://github.com/supermemoryai/install-mcp)
+ * to inject server configuration into supported MCP client config files.
+ *
+ * Security: localhost-only binding (enforced by server.ts), rate-limited,
+ * and command arguments are hardcoded — no user-supplied shell input.
+ */
+import { execFile } from 'node:child_process';
+import { accessSync, constants as fsConstants } from 'node:fs';
+import { access, mkdir, readFile, writeFile } from 'node:fs/promises';
+import { join, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { homedir, platform } from 'node:os';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+import { logger } from '../../utils/logger.js';
+import { UnicodeValidator } from '../../security/validators/unicodeValidator.js';
+import { PACKAGE_VERSION } from '../../generated/version.js';
+const GITHUB_REPO = 'DollhouseMCP/mcp-server';
+const MCPB_ASSET_PATTERN = /^dollhousemcp-.*\.mcpb$/;
+import { SlidingWindowRateLimiter } from '../../utils/SlidingWindowRateLimiter.js';
+/** Allowed client identifiers — must match install-mcp's --client values */
+const ALLOWED_CLIENTS = new Set([
+    'claude',
+    'claude-code',
+    'cursor',
+    'vscode',
+    'cline',
+    'roo-cline',
+    'windsurf',
+    'witsy',
+    'enconvo',
+    'gemini-cli',
+    'goose',
+    'zed',
+    'warp',
+    'codex',
+]);
+/** Rate limit: 5 installs per minute */
+const installLimiter = new SlidingWindowRateLimiter(5, 60_000);
+/**
+ * Known config file paths per client.
+ * Returns the absolute path for the current platform.
+ */
+function getConfigPath(client) {
+    const home = homedir();
+    const plat = platform();
+    const paths = {
+        'claude': () => {
+            if (plat === 'darwin')
+                return join(home, 'Library', 'Application Support', 'Claude', 'claude_desktop_config.json');
+            if (plat === 'win32')
+                return join(process.env.APPDATA || join(home, 'AppData', 'Roaming'), 'Claude', 'claude_desktop_config.json');
+            return join(home, '.config', 'Claude', 'claude_desktop_config.json');
+        },
+        'claude-code': () => join(home, '.claude.json'),
+        'cursor': () => join(home, '.cursor', 'mcp.json'),
+        'windsurf': () => join(home, '.codeium', 'windsurf', 'mcp_config.json'),
+        'lmstudio': () => join(home, '.lmstudio', 'mcp.json'),
+        'gemini-cli': () => join(home, '.gemini', 'settings.json'),
+        'codex': () => join(home, '.codex', 'config.toml'),
+    };
+    const resolver = paths[client];
+    return resolver ? resolver() : null;
+}
+/**
+ * Open a file in the system's default text editor.
+ */
+function openInEditor(filePath) {
+    return new Promise((resolve, reject) => {
+        const plat = platform();
+        let cmd;
+        let args;
+        if (plat === 'darwin') {
+            cmd = 'open';
+            args = ['-t', filePath];
+        }
+        else if (plat === 'win32') {
+            cmd = 'notepad';
+            args = [filePath];
+        }
+        else {
+            cmd = 'xdg-open';
+            args = [filePath];
+        }
+        execFile(cmd, args, { timeout: 10_000 }, (err) => {
+            if (err) {
+                reject(new Error(`Could not open editor: ${err.message}`));
+                return;
+            }
+            resolve('Opened in editor.');
+        });
+    });
+}
+/** Clients whose config files we can locate and open */
+const OPENABLE_CLIENTS = new Set([
+    'claude', 'claude-code', 'cursor', 'windsurf', 'lmstudio', 'gemini-cli', 'codex',
+]);
+/** Parse a TOML config file for a DollhouseMCP server entry */
+function parseTomlConfig(raw) {
+    if (!raw.toLowerCase().includes('dollhousemcp')) {
+        return { installed: false };
+    }
+    const tomlConfig = {};
+    const sectionMatch = /\[mcp_servers\.([^\]]*dollhousemcp[^\]]*)\]/i.exec(raw);
+    if (!sectionMatch)
+        return { installed: true, currentConfig: tomlConfig, serverKey: 'mcp_servers' };
+    tomlConfig.serverName = sectionMatch[1];
+    const sectionStart = sectionMatch.index + sectionMatch[0].length;
+    const nextSection = raw.indexOf('\n[', sectionStart);
+    const sectionContent = nextSection > -1 ? raw.slice(sectionStart, nextSection) : raw.slice(sectionStart);
+    const commandMatch = /command\s*=\s*"([^"]+)"/.exec(sectionContent);
+    const argsMatch = /args\s*=\s*\[([^\]]*)\]/.exec(sectionContent);
+    if (commandMatch)
+        tomlConfig.command = commandMatch[1];
+    if (argsMatch) {
+        tomlConfig.args = argsMatch[1].split(',').map(s => s.trim().replaceAll('"', ''));
+    }
+    return { installed: true, currentConfig: tomlConfig, serverKey: 'mcp_servers' };
+}
+/** Parse a JSON config file for a DollhouseMCP server entry */
+function parseJsonConfig(raw) {
+    const parsed = JSON.parse(raw);
+    for (const key of ['mcpServers', 'servers']) {
+        if (parsed[key]?.dollhousemcp) {
+            return { installed: true, currentConfig: parsed[key].dollhousemcp, serverKey: key };
+        }
+    }
+    return { installed: false };
+}
+/** Check a single client config file for an existing DollhouseMCP entry */
+async function detectClient(client) {
+    const configPath = getConfigPath(client);
+    if (!configPath)
+        return null;
+    try {
+        await access(configPath);
+    }
+    catch {
+        return { installed: false, configPath };
+    }
+    try {
+        const raw = await readFile(configPath, 'utf-8');
+        const result = configPath.endsWith('.toml') ? parseTomlConfig(raw) : parseJsonConfig(raw);
+        return { configPath, ...result };
+    }
+    catch {
+        return { installed: false, configPath };
+    }
+}
+/**
+ * Validate and normalize a client name from request body.
+ * Returns the normalized client name or null (with error response sent).
+ */
+function validateClient(req, res, allowedSet) {
+    const { client } = req.body;
+    if (!client || typeof client !== 'string') {
+        res.status(400).json({ error: 'Missing required field: client' });
+        return null;
+    }
+    const normalized = UnicodeValidator.normalize(client).normalizedContent.toLowerCase().trim();
+    if (!allowedSet.has(normalized)) {
+        res.status(400).json({
+            error: `Unsupported client: ${client}`,
+            supported: Array.from(allowedSet),
+        });
+        return null;
+    }
+    return normalized;
+}
+export function createSetupRoutes() {
+    // ── Detect existing installations ───────────────────────────────────
+    const detectHandler = async (_req, res) => {
+        const clients = [
+            { id: 'claude', name: 'Claude Desktop' },
+            { id: 'claude-code', name: 'Claude Code' },
+            { id: 'cursor', name: 'Cursor' },
+            { id: 'windsurf', name: 'Windsurf' },
+            { id: 'lmstudio', name: 'LM Studio' },
+            { id: 'gemini-cli', name: 'Gemini CLI' },
+            { id: 'codex', name: 'Codex' },
+        ];
+        const results = {};
+        await Promise.all(clients.map(async ({ id, name }) => {
+            const detection = await detectClient(id);
+            if (detection) {
+                results[id] = { name, ...detection };
+            }
+        }));
+        res.json(results);
+    };
+    // ── Open config file in editor ──────────────────────────────────────
+    const openConfigHandler = async (req, res) => {
+        const normalizedClient = validateClient(req, res, OPENABLE_CLIENTS);
+        if (!normalizedClient)
+            return;
+        const configPath = getConfigPath(normalizedClient);
+        if (!configPath) {
+            res.status(400).json({ error: `Config path unknown for: ${normalizedClient}` });
+            return;
+        }
+        // Create the file with empty content if it doesn't exist yet
+        try {
+            await access(configPath);
+        }
+        catch {
+            try {
+                await mkdir(dirname(configPath), { recursive: true });
+                const content = configPath.endsWith('.toml') ? '' : '{}';
+                await writeFile(configPath, content + '\n', 'utf-8');
+                logger.info(`[Setup] Created empty config: ${configPath}`);
+            }
+            catch (mkErr) {
+                const msg = mkErr instanceof Error ? mkErr.message : String(mkErr);
+                res.status(500).json({ error: `Could not create config file: ${msg}` });
+                return;
+            }
+        }
+        logger.info(`[Setup] Opening config for ${normalizedClient}: ${configPath}`);
+        try {
+            await openInEditor(configPath);
+            res.json({ success: true, path: configPath });
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            res.status(500).json({ success: false, error: message, path: configPath });
+        }
+    };
+    // ── Auto-install via install-mcp ────────────────────────────────────
+    const installHandler = async (req, res) => {
+        if (!installLimiter.tryAcquire()) {
+            res.status(429).json({ error: 'Too many install requests. Try again in a minute.' });
+            return;
+        }
+        const normalizedClient = validateClient(req, res, ALLOWED_CLIENTS);
+        if (!normalizedClient)
+            return;
+        // Validate version if provided — must be semver-like (no shell injection)
+        const { version } = req.body;
+        const normalizedVersion = version ? UnicodeValidator.normalize(version).normalizedContent : undefined;
+        if (normalizedVersion && !/^\d+\.\d+\.\d+/.test(normalizedVersion)) {
+            res.status(400).json({ error: 'Invalid version format. Expected semver (e.g., 2.0.2)' });
+            return;
+        }
+        const tag = normalizedVersion ? `@${normalizedVersion}` : '@latest';
+        logger.info(`[Setup] Installing DollhouseMCP${tag} to client: ${normalizedClient}`);
+        try {
+            const output = await runInstallMcp(normalizedClient, normalizedVersion);
+            logger.info(`[Setup] Successfully installed to ${normalizedClient}`);
+            res.json({ success: true, output, client: normalizedClient, version: normalizedVersion || 'latest' });
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            logger.warn(`[Setup] Install failed for ${normalizedClient}: ${message}`);
+            res.status(500).json({ success: false, error: message, client: normalizedClient });
+        }
+    };
+    // ── Version info ─────────────────────────────────────────────────────
+    const versionHandler = async (_req, res) => {
+        const local = {
+            version: PACKAGE_VERSION,
+            mcpbUrl: `https://github.com/${GITHUB_REPO}/releases/download/v${PACKAGE_VERSION}/dollhousemcp-${PACKAGE_VERSION}.mcpb`,
+        };
+        // Query GitHub for the actual latest release
+        let latest = local;
+        try {
+            const ghRes = await fetch(`https://api.github.com/repos/${GITHUB_REPO}/releases/latest`, {
+                headers: { 'Accept': 'application/vnd.github+json', 'User-Agent': 'DollhouseMCP-Setup' },
+                signal: AbortSignal.timeout(5000),
+            });
+            if (ghRes.ok) {
+                const release = await ghRes.json();
+                const mcpbAsset = release.assets.find(a => MCPB_ASSET_PATTERN.test(a.name));
+                latest = {
+                    version: release.tag_name.replace(/^v/, ''),
+                    mcpbUrl: mcpbAsset?.browser_download_url ||
+                        `https://github.com/${GITHUB_REPO}/releases/download/${release.tag_name}/dollhousemcp-${release.tag_name.replace(/^v/, '')}.mcpb`,
+                };
+            }
+        }
+        catch {
+            // GitHub unreachable — use local version info
+        }
+        res.json({
+            running: local,
+            latest,
+            isLatest: local.version === latest.version,
+        });
+    };
+    // ── .mcpb download redirect ─────────────────────────────────────────
+    const mcpbRedirectHandler = async (_req, res) => {
+        // Try GitHub API for the actual latest .mcpb asset URL
+        try {
+            const ghRes = await fetch(`https://api.github.com/repos/${GITHUB_REPO}/releases/latest`, {
+                headers: { 'Accept': 'application/vnd.github+json', 'User-Agent': 'DollhouseMCP-Setup' },
+                signal: AbortSignal.timeout(5000),
+            });
+            if (ghRes.ok) {
+                const release = await ghRes.json();
+                const mcpbAsset = release.assets.find(a => MCPB_ASSET_PATTERN.test(a.name));
+                if (mcpbAsset) {
+                    res.redirect(mcpbAsset.browser_download_url);
+                    return;
+                }
+            }
+        }
+        catch {
+            // Fall through to constructed URL
+        }
+        // Fallback: construct URL from running version
+        const url = `https://github.com/${GITHUB_REPO}/releases/download/v${PACKAGE_VERSION}/dollhousemcp-${PACKAGE_VERSION}.mcpb`;
+        res.redirect(url);
+    };
+    return { installHandler, openConfigHandler, versionHandler, mcpbRedirectHandler, detectHandler };
+}
+/**
+ * Resolve the install-mcp binary path.
+ * Uses the local dependency (node_modules/.bin/install-mcp) first,
+ * falls back to npx if not found.
+ */
+function resolveInstallMcpBin() {
+    const localBin = join(dirname(dirname(dirname(__dirname))), 'node_modules', '.bin', 'install-mcp');
+    try {
+        accessSync(localBin, fsConstants.X_OK);
+        return { cmd: localBin, prefixArgs: [] };
+    }
+    catch {
+        return { cmd: 'npx', prefixArgs: ['install-mcp'] };
+    }
+}
+/**
+ * Run install-mcp to configure a specific MCP client.
+ *
+ * Uses the bundled install-mcp dependency (MIT, https://github.com/supermemoryai/install-mcp).
+ * Command arguments are fully hardcoded — no user input reaches the shell.
+ * execFile is used (not exec) to prevent shell injection.
+ */
+function runInstallMcp(client, version) {
+    return new Promise((resolve, reject) => {
+        const { cmd, prefixArgs } = resolveInstallMcpBin();
+        const tag = version ? `@${version}` : '@latest';
+        const args = [
+            ...prefixArgs,
+            `@dollhousemcp/mcp-server${tag}`,
+            '--client', client,
+            '--name', 'dollhousemcp',
+            '--yes',
+        ];
+        execFile(cmd, args, { timeout: 30_000 }, (err, stdout, stderr) => {
+            if (err) {
+                reject(new Error(stderr || err.message));
+                return;
+            }
+            resolve(stdout || 'Installation completed.');
+        });
+    });
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"setupRoutes.js","sourceRoot":"","sources":["../../../src/web/routes/setupRoutes.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Setup Routes — Auto-install DollhouseMCP to MCP clients\n *\n * Uses `install-mcp` (https://github.com/supermemoryai/install-mcp)\n * to inject server configuration into supported MCP client config files.\n *\n * Security: localhost-only binding (enforced by server.ts), rate-limited,\n * and command arguments are hardcoded — no user-supplied shell input.\n */\n\nimport type { Request, Response } from 'express';\nimport { execFile } from 'node:child_process';\nimport { accessSync, constants as fsConstants } from 'node:fs';\nimport { access, mkdir, readFile, writeFile } from 'node:fs/promises';\nimport { join, dirname } from 'node:path';\nimport { fileURLToPath } from 'node:url';\nimport { homedir, platform } from 'node:os';\n\nconst __filename = fileURLToPath(import.meta.url);\nconst __dirname = dirname(__filename);\nimport { logger } from '../../utils/logger.js';\nimport { UnicodeValidator } from '../../security/validators/unicodeValidator.js';\nimport { PACKAGE_VERSION } from '../../generated/version.js';\n\nconst GITHUB_REPO = 'DollhouseMCP/mcp-server';\nconst MCPB_ASSET_PATTERN = /^dollhousemcp-.*\\.mcpb$/;\nimport { SlidingWindowRateLimiter } from '../../utils/SlidingWindowRateLimiter.js';\n\n/** Allowed client identifiers — must match install-mcp's --client values */\nconst ALLOWED_CLIENTS = new Set([\n  'claude',\n  'claude-code',\n  'cursor',\n  'vscode',\n  'cline',\n  'roo-cline',\n  'windsurf',\n  'witsy',\n  'enconvo',\n  'gemini-cli',\n  'goose',\n  'zed',\n  'warp',\n  'codex',\n]);\n\n/** Rate limit: 5 installs per minute */\nconst installLimiter = new SlidingWindowRateLimiter(5, 60_000);\n\n/**\n * Known config file paths per client.\n * Returns the absolute path for the current platform.\n */\nfunction getConfigPath(client: string): string | null {\n  const home = homedir();\n  const plat = platform();\n\n  const paths: Record<string, () => string | null> = {\n    'claude': () => {\n      if (plat === 'darwin') return join(home, 'Library', 'Application Support', 'Claude', 'claude_desktop_config.json');\n      if (plat === 'win32') return join(process.env.APPDATA || join(home, 'AppData', 'Roaming'), 'Claude', 'claude_desktop_config.json');\n      return join(home, '.config', 'Claude', 'claude_desktop_config.json');\n    },\n    'claude-code': () => join(home, '.claude.json'),\n    'cursor': () => join(home, '.cursor', 'mcp.json'),\n    'windsurf': () => join(home, '.codeium', 'windsurf', 'mcp_config.json'),\n    'lmstudio': () => join(home, '.lmstudio', 'mcp.json'),\n    'gemini-cli': () => join(home, '.gemini', 'settings.json'),\n    'codex': () => join(home, '.codex', 'config.toml'),\n  };\n\n  const resolver = paths[client];\n  return resolver ? resolver() : null;\n}\n\n/**\n * Open a file in the system's default text editor.\n */\nfunction openInEditor(filePath: string): Promise<string> {\n  return new Promise((resolve, reject) => {\n    const plat = platform();\n    let cmd: string;\n    let args: string[];\n\n    if (plat === 'darwin') {\n      cmd = 'open';\n      args = ['-t', filePath];\n    } else if (plat === 'win32') {\n      cmd = 'notepad';\n      args = [filePath];\n    } else {\n      cmd = 'xdg-open';\n      args = [filePath];\n    }\n\n    execFile(cmd, args, { timeout: 10_000 }, (err) => {\n      if (err) {\n        reject(new Error(`Could not open editor: ${err.message}`));\n        return;\n      }\n      resolve('Opened in editor.');\n    });\n  });\n}\n\n/** Clients whose config files we can locate and open */\nconst OPENABLE_CLIENTS = new Set([\n  'claude', 'claude-code', 'cursor', 'windsurf', 'lmstudio', 'gemini-cli', 'codex',\n]);\n\n/**\n * Create setup handlers (Express 5 compatible — plain handler functions, not Router).\n */\ninterface DetectResult {\n  installed: boolean;\n  configPath: string | null;\n  currentConfig?: Record<string, unknown>;\n  serverKey?: string;\n}\n\n/** Parse a TOML config file for a DollhouseMCP server entry */\nfunction parseTomlConfig(raw: string): Omit<DetectResult, 'configPath'> {\n  if (!raw.toLowerCase().includes('dollhousemcp')) {\n    return { installed: false };\n  }\n\n  const tomlConfig: Record<string, unknown> = {};\n  const sectionMatch = /\\[mcp_servers\\.([^\\]]*dollhousemcp[^\\]]*)\\]/i.exec(raw);\n  if (!sectionMatch) return { installed: true, currentConfig: tomlConfig, serverKey: 'mcp_servers' };\n\n  tomlConfig.serverName = sectionMatch[1];\n  const sectionStart = sectionMatch.index + sectionMatch[0].length;\n  const nextSection = raw.indexOf('\\n[', sectionStart);\n  const sectionContent = nextSection > -1 ? raw.slice(sectionStart, nextSection) : raw.slice(sectionStart);\n\n  const commandMatch = /command\\s*=\\s*\"([^\"]+)\"/.exec(sectionContent);\n  const argsMatch = /args\\s*=\\s*\\[([^\\]]*)\\]/.exec(sectionContent);\n  if (commandMatch) tomlConfig.command = commandMatch[1];\n  if (argsMatch) {\n    tomlConfig.args = argsMatch[1].split(',').map(s => s.trim().replaceAll('\"', ''));\n  }\n  return { installed: true, currentConfig: tomlConfig, serverKey: 'mcp_servers' };\n}\n\n/** Parse a JSON config file for a DollhouseMCP server entry */\nfunction parseJsonConfig(raw: string): Omit<DetectResult, 'configPath'> {\n  const parsed = JSON.parse(raw);\n  for (const key of ['mcpServers', 'servers']) {\n    if (parsed[key]?.dollhousemcp) {\n      return { installed: true, currentConfig: parsed[key].dollhousemcp, serverKey: key };\n    }\n  }\n  return { installed: false };\n}\n\n/** Check a single client config file for an existing DollhouseMCP entry */\nasync function detectClient(client: string): Promise<DetectResult | null> {\n  const configPath = getConfigPath(client);\n  if (!configPath) return null;\n\n  try {\n    await access(configPath);\n  } catch {\n    return { installed: false, configPath };\n  }\n\n  try {\n    const raw = await readFile(configPath, 'utf-8');\n    const result = configPath.endsWith('.toml') ? parseTomlConfig(raw) : parseJsonConfig(raw);\n    return { configPath, ...result };\n  } catch {\n    return { installed: false, configPath };\n  }\n}\n\n/**\n * Validate and normalize a client name from request body.\n * Returns the normalized client name or null (with error response sent).\n */\nfunction validateClient(\n  req: Request, res: Response, allowedSet: Set<string>,\n): string | null {\n  const { client } = req.body as { client?: string };\n  if (!client || typeof client !== 'string') {\n    res.status(400).json({ error: 'Missing required field: client' });\n    return null;\n  }\n  const normalized = UnicodeValidator.normalize(client).normalizedContent.toLowerCase().trim();\n  if (!allowedSet.has(normalized)) {\n    res.status(400).json({\n      error: `Unsupported client: ${client}`,\n      supported: Array.from(allowedSet),\n    });\n    return null;\n  }\n  return normalized;\n}\n\nexport function createSetupRoutes(): {\n  installHandler: (req: Request, res: Response) => Promise<void>;\n  openConfigHandler: (req: Request, res: Response) => Promise<void>;\n  versionHandler: (req: Request, res: Response) => Promise<void>;\n  mcpbRedirectHandler: (req: Request, res: Response) => Promise<void>;\n  detectHandler: (req: Request, res: Response) => Promise<void>;\n} {\n  // ── Detect existing installations ───────────────────────────────────\n  const detectHandler = async (_req: Request, res: Response): Promise<void> => {\n    const clients = [\n      { id: 'claude', name: 'Claude Desktop' },\n      { id: 'claude-code', name: 'Claude Code' },\n      { id: 'cursor', name: 'Cursor' },\n      { id: 'windsurf', name: 'Windsurf' },\n      { id: 'lmstudio', name: 'LM Studio' },\n      { id: 'gemini-cli', name: 'Gemini CLI' },\n      { id: 'codex', name: 'Codex' },\n    ];\n\n    const results: Record<string, unknown> = {};\n    await Promise.all(clients.map(async ({ id, name }) => {\n      const detection = await detectClient(id);\n      if (detection) {\n        results[id] = { name, ...detection };\n      }\n    }));\n\n    res.json(results);\n  };\n\n  // ── Open config file in editor ──────────────────────────────────────\n  const openConfigHandler = async (req: Request, res: Response): Promise<void> => {\n    const normalizedClient = validateClient(req, res, OPENABLE_CLIENTS);\n    if (!normalizedClient) return;\n\n    const configPath = getConfigPath(normalizedClient);\n    if (!configPath) {\n      res.status(400).json({ error: `Config path unknown for: ${normalizedClient}` });\n      return;\n    }\n\n    // Create the file with empty content if it doesn't exist yet\n    try {\n      await access(configPath);\n    } catch {\n      try {\n        await mkdir(dirname(configPath), { recursive: true });\n        const content = configPath.endsWith('.toml') ? '' : '{}';\n        await writeFile(configPath, content + '\\n', 'utf-8');\n        logger.info(`[Setup] Created empty config: ${configPath}`);\n      } catch (mkErr) {\n        const msg = mkErr instanceof Error ? mkErr.message : String(mkErr);\n        res.status(500).json({ error: `Could not create config file: ${msg}` });\n        return;\n      }\n    }\n\n    logger.info(`[Setup] Opening config for ${normalizedClient}: ${configPath}`);\n\n    try {\n      await openInEditor(configPath);\n      res.json({ success: true, path: configPath });\n    } catch (err) {\n      const message = err instanceof Error ? err.message : String(err);\n      res.status(500).json({ success: false, error: message, path: configPath });\n    }\n  };\n\n  // ── Auto-install via install-mcp ────────────────────────────────────\n  const installHandler = async (req: Request, res: Response): Promise<void> => {\n    if (!installLimiter.tryAcquire()) {\n      res.status(429).json({ error: 'Too many install requests. Try again in a minute.' });\n      return;\n    }\n\n    const normalizedClient = validateClient(req, res, ALLOWED_CLIENTS);\n    if (!normalizedClient) return;\n\n    // Validate version if provided — must be semver-like (no shell injection)\n    const { version } = req.body as { version?: string };\n    const normalizedVersion = version ? UnicodeValidator.normalize(version).normalizedContent : undefined;\n    if (normalizedVersion && !/^\\d+\\.\\d+\\.\\d+/.test(normalizedVersion)) {\n      res.status(400).json({ error: 'Invalid version format. Expected semver (e.g., 2.0.2)' });\n      return;\n    }\n\n    const tag = normalizedVersion ? `@${normalizedVersion}` : '@latest';\n    logger.info(`[Setup] Installing DollhouseMCP${tag} to client: ${normalizedClient}`);\n\n    try {\n      const output = await runInstallMcp(normalizedClient, normalizedVersion);\n      logger.info(`[Setup] Successfully installed to ${normalizedClient}`);\n      res.json({ success: true, output, client: normalizedClient, version: normalizedVersion || 'latest' });\n    } catch (err) {\n      const message = err instanceof Error ? err.message : String(err);\n      logger.warn(`[Setup] Install failed for ${normalizedClient}: ${message}`);\n      res.status(500).json({ success: false, error: message, client: normalizedClient });\n    }\n  };\n\n  // ── Version info ─────────────────────────────────────────────────────\n  const versionHandler = async (_req: Request, res: Response): Promise<void> => {\n    const local = {\n      version: PACKAGE_VERSION,\n      mcpbUrl: `https://github.com/${GITHUB_REPO}/releases/download/v${PACKAGE_VERSION}/dollhousemcp-${PACKAGE_VERSION}.mcpb`,\n    };\n\n    // Query GitHub for the actual latest release\n    let latest = local;\n    try {\n      const ghRes = await fetch(`https://api.github.com/repos/${GITHUB_REPO}/releases/latest`, {\n        headers: { 'Accept': 'application/vnd.github+json', 'User-Agent': 'DollhouseMCP-Setup' },\n        signal: AbortSignal.timeout(5000),\n      });\n      if (ghRes.ok) {\n        const release = await ghRes.json() as { tag_name: string; assets: Array<{ name: string; browser_download_url: string }> };\n        const mcpbAsset = release.assets.find(a => MCPB_ASSET_PATTERN.test(a.name));\n        latest = {\n          version: release.tag_name.replace(/^v/, ''),\n          mcpbUrl: mcpbAsset?.browser_download_url ||\n            `https://github.com/${GITHUB_REPO}/releases/download/${release.tag_name}/dollhousemcp-${release.tag_name.replace(/^v/, '')}.mcpb`,\n        };\n      }\n    } catch {\n      // GitHub unreachable — use local version info\n    }\n\n    res.json({\n      running: local,\n      latest,\n      isLatest: local.version === latest.version,\n    });\n  };\n\n  // ── .mcpb download redirect ─────────────────────────────────────────\n  const mcpbRedirectHandler = async (_req: Request, res: Response): Promise<void> => {\n    // Try GitHub API for the actual latest .mcpb asset URL\n    try {\n      const ghRes = await fetch(`https://api.github.com/repos/${GITHUB_REPO}/releases/latest`, {\n        headers: { 'Accept': 'application/vnd.github+json', 'User-Agent': 'DollhouseMCP-Setup' },\n        signal: AbortSignal.timeout(5000),\n      });\n      if (ghRes.ok) {\n        const release = await ghRes.json() as { tag_name: string; assets: Array<{ name: string; browser_download_url: string }> };\n        const mcpbAsset = release.assets.find(a => MCPB_ASSET_PATTERN.test(a.name));\n        if (mcpbAsset) {\n          res.redirect(mcpbAsset.browser_download_url);\n          return;\n        }\n      }\n    } catch {\n      // Fall through to constructed URL\n    }\n\n    // Fallback: construct URL from running version\n    const url = `https://github.com/${GITHUB_REPO}/releases/download/v${PACKAGE_VERSION}/dollhousemcp-${PACKAGE_VERSION}.mcpb`;\n    res.redirect(url);\n  };\n\n  return { installHandler, openConfigHandler, versionHandler, mcpbRedirectHandler, detectHandler };\n}\n\n/**\n * Resolve the install-mcp binary path.\n * Uses the local dependency (node_modules/.bin/install-mcp) first,\n * falls back to npx if not found.\n */\nfunction resolveInstallMcpBin(): { cmd: string; prefixArgs: string[] } {\n  const localBin = join(dirname(dirname(dirname(__dirname))), 'node_modules', '.bin', 'install-mcp');\n  try {\n    accessSync(localBin, fsConstants.X_OK);\n    return { cmd: localBin, prefixArgs: [] };\n  } catch {\n    return { cmd: 'npx', prefixArgs: ['install-mcp'] };\n  }\n}\n\n/**\n * Run install-mcp to configure a specific MCP client.\n *\n * Uses the bundled install-mcp dependency (MIT, https://github.com/supermemoryai/install-mcp).\n * Command arguments are fully hardcoded — no user input reaches the shell.\n * execFile is used (not exec) to prevent shell injection.\n */\nfunction runInstallMcp(client: string, version?: string): Promise<string> {\n  return new Promise((resolve, reject) => {\n    const { cmd, prefixArgs } = resolveInstallMcpBin();\n    const tag = version ? `@${version}` : '@latest';\n    const args = [\n      ...prefixArgs,\n      `@dollhousemcp/mcp-server${tag}`,\n      '--client', client,\n      '--name', 'dollhousemcp',\n      '--yes',\n    ];\n\n    execFile(cmd, args, { timeout: 30_000 }, (err, stdout, stderr) => {\n      if (err) {\n        reject(new Error(stderr || err.message));\n        return;\n      }\n      resolve(stdout || 'Installation completed.');\n    });\n  });\n}\n"]}

package/dist/web/routes.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"routes.d.ts","sourceRoot":"","sources":["../../src/web/routes.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAgB,EAAE,MAAM,EAAE,MAAM,SAAS,CAAC;AAM1C,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,sCAAsC,CAAC;AAgd1E,wBAAgB,eAAe,CAAC,YAAY,EAAE,MAAM,GAAG,MAAM,CAiJ5D;AAqBD;;;;;;GAMG;AACH,wBAAgB,sBAAsB,CAAC,OAAO,EAAE,aAAa,EAAE,YAAY,EAAE,MAAM,GAAG,MAAM,CA0H3F"}
+{"version":3,"file":"routes.d.ts","sourceRoot":"","sources":["../../src/web/routes.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAgB,EAAE,MAAM,EAAE,MAAM,SAAS,CAAC;AAM1C,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,sCAAsC,CAAC;AAid1E,wBAAgB,eAAe,CAAC,YAAY,EAAE,MAAM,GAAG,MAAM,CAiJ5D;AAqBD;;;;;;GAMG;AACH,wBAAgB,sBAAsB,CAAC,OAAO,EAAE,aAAa,EAAE,YAAY,EAAE,MAAM,GAAG,MAAM,CA0H3F"}