@amplitude/wizard 1.0.0-beta.0

package/dist/src/steps/add-mcp-server-to-clients/MCPClient.d.ts

@@ -0,0 +1,30 @@
+export type MCPServerConfig = Record<string, unknown>;
+export declare abstract class MCPClient {
+    name: string;
+    abstract getConfigPath(): Promise<string>;
+    abstract getServerPropertyName(): string;
+    abstract isServerInstalled(local?: boolean): Promise<boolean>;
+    abstract addServer(apiKey?: string, selectedFeatures?: string[], local?: boolean): Promise<{
+        success: boolean;
+    }>;
+    abstract removeServer(local?: boolean): Promise<{
+        success: boolean;
+    }>;
+    abstract isClientSupported(): Promise<boolean>;
+}
+export declare abstract class DefaultMCPClient extends MCPClient {
+    name: string;
+    constructor();
+    getServerPropertyName(): string;
+    getServerConfig(apiKey: string | undefined, type: 'sse' | 'streamable-http', selectedFeatures?: string[], local?: boolean): MCPServerConfig;
+    isServerInstalled(local?: boolean): Promise<boolean>;
+    addServer(apiKey?: string, selectedFeatures?: string[], local?: boolean): Promise<{
+        success: boolean;
+    }>;
+    _addServerType(apiKey: string | undefined, type: 'sse' | 'streamable-http', selectedFeatures?: string[], local?: boolean): Promise<{
+        success: boolean;
+    }>;
+    removeServer(local?: boolean): Promise<{
+        success: boolean;
+    }>;
+}

package/dist/src/steps/add-mcp-server-to-clients/MCPClient.js

@@ -0,0 +1,141 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DefaultMCPClient = exports.MCPClient = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const jsonc = __importStar(require("jsonc-parser"));
+const zod_1 = require("zod");
+const defaults_1 = require("./defaults");
+const MCPConfigSchema = zod_1.z.record(zod_1.z.string(), zod_1.z.record(zod_1.z.string(), zod_1.z.unknown()));
+class MCPClient {
+    name;
+}
+exports.MCPClient = MCPClient;
+class DefaultMCPClient extends MCPClient {
+    name = 'Default';
+    constructor() {
+        super();
+    }
+    getServerPropertyName() {
+        return 'mcpServers';
+    }
+    getServerConfig(apiKey, type, selectedFeatures, local) {
+        return (0, defaults_1.getDefaultServerConfig)(apiKey, type, selectedFeatures, local);
+    }
+    async isServerInstalled(local) {
+        try {
+            const configPath = await this.getConfigPath();
+            if (!fs.existsSync(configPath)) {
+                return false;
+            }
+            const configContent = await fs.promises.readFile(configPath, 'utf8');
+            const parsed = MCPConfigSchema.safeParse(jsonc.parse(configContent));
+            const config = parsed.success ? parsed.data : {};
+            const serverPropertyName = this.getServerPropertyName();
+            const serverName = local ? 'amplitude-local' : 'amplitude';
+            return (serverPropertyName in config && serverName in config[serverPropertyName]);
+        }
+        catch {
+            return false;
+        }
+    }
+    async addServer(apiKey, selectedFeatures, local) {
+        return this._addServerType(apiKey, 'sse', selectedFeatures, local);
+    }
+    async _addServerType(apiKey, type, selectedFeatures, local) {
+        try {
+            const configPath = await this.getConfigPath();
+            const configDir = path.dirname(configPath);
+            await fs.promises.mkdir(configDir, { recursive: true });
+            const serverPropertyName = this.getServerPropertyName();
+            let configContent = '';
+            let existingConfig = {};
+            if (fs.existsSync(configPath)) {
+                configContent = await fs.promises.readFile(configPath, 'utf8');
+                const parsed = MCPConfigSchema.safeParse(jsonc.parse(configContent));
+                existingConfig = parsed.success ? parsed.data : {};
+            }
+            const newServerConfig = this.getServerConfig(apiKey, type, selectedFeatures, local);
+            if (!existingConfig[serverPropertyName]) {
+                existingConfig[serverPropertyName] = {};
+            }
+            const serverName = local ? 'amplitude-local' : 'amplitude';
+            existingConfig[serverPropertyName][serverName] = newServerConfig;
+            const edits = jsonc.modify(configContent, [serverPropertyName, serverName], newServerConfig, {
+                formattingOptions: {
+                    tabSize: 2,
+                    insertSpaces: true,
+                },
+            });
+            const modifiedContent = jsonc.applyEdits(configContent, edits);
+            await fs.promises.writeFile(configPath, modifiedContent, 'utf8');
+            return { success: true };
+        }
+        catch {
+            return { success: false };
+        }
+    }
+    async removeServer(local) {
+        try {
+            const configPath = await this.getConfigPath();
+            if (!fs.existsSync(configPath)) {
+                return { success: false };
+            }
+            const configContent = await fs.promises.readFile(configPath, 'utf8');
+            const parsed = MCPConfigSchema.safeParse(jsonc.parse(configContent));
+            const config = parsed.success ? parsed.data : {};
+            const serverPropertyName = this.getServerPropertyName();
+            const serverName = local ? 'amplitude-local' : 'amplitude';
+            if (serverPropertyName in config &&
+                serverName in config[serverPropertyName]) {
+                const edits = jsonc.modify(configContent, [serverPropertyName, serverName], undefined, {
+                    formattingOptions: {
+                        tabSize: 2,
+                        insertSpaces: true,
+                    },
+                });
+                const modifiedContent = jsonc.applyEdits(configContent, edits);
+                await fs.promises.writeFile(configPath, modifiedContent, 'utf8');
+                return { success: true };
+            }
+        }
+        catch {
+            //
+        }
+        return { success: false };
+    }
+}
+exports.DefaultMCPClient = DefaultMCPClient;

package/dist/src/steps/add-mcp-server-to-clients/clients/claude-code.d.ts

@@ -0,0 +1,29 @@
+import { DefaultMCPClient } from '../MCPClient';
+import { DefaultMCPClientConfig } from '../defaults';
+import { z } from 'zod';
+export declare const ClaudeCodeMCPConfig: z.ZodObject<{
+    mcpServers: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
+        command: z.ZodOptional<z.ZodString>;
+        args: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    }, z.core.$strip>, z.ZodObject<{
+        url: z.ZodString;
+        headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    }, z.core.$strip>]>>;
+}, z.core.$loose>;
+export type ClaudeCodeMCPConfig = z.infer<typeof DefaultMCPClientConfig>;
+export declare class ClaudeCodeMCPClient extends DefaultMCPClient {
+    name: string;
+    private claudeBinaryPath;
+    constructor();
+    private findClaudeBinary;
+    isClientSupported(): Promise<boolean>;
+    isServerInstalled(local?: boolean): Promise<boolean>;
+    getConfigPath(): Promise<string>;
+    addServer(apiKey?: string, selectedFeatures?: string[], local?: boolean): Promise<{
+        success: boolean;
+    }>;
+    removeServer(local?: boolean): Promise<{
+        success: boolean;
+    }>;
+}

package/dist/src/steps/add-mcp-server-to-clients/clients/claude-code.js

@@ -0,0 +1,180 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ClaudeCodeMCPClient = exports.ClaudeCodeMCPConfig = void 0;
+const MCPClient_1 = require("../MCPClient");
+const defaults_1 = require("../defaults");
+const child_process_1 = require("child_process");
+const analytics_1 = require("../../../utils/analytics");
+const debug_1 = require("../../../utils/debug");
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const fs = __importStar(require("fs"));
+exports.ClaudeCodeMCPConfig = defaults_1.DefaultMCPClientConfig;
+class ClaudeCodeMCPClient extends MCPClient_1.DefaultMCPClient {
+    name = 'Claude Code';
+    claudeBinaryPath = null;
+    constructor() {
+        super();
+    }
+    findClaudeBinary() {
+        if (this.claudeBinaryPath) {
+            return this.claudeBinaryPath;
+        }
+        // Common installation paths for Claude Code CLI
+        const possiblePaths = [
+            path.join(os.homedir(), '.local', 'bin', 'claude'),
+            path.join(os.homedir(), '.claude', 'local', 'claude'),
+            '/usr/local/bin/claude',
+            '/opt/homebrew/bin/claude',
+        ];
+        for (const claudePath of possiblePaths) {
+            if (fs.existsSync(claudePath)) {
+                (0, debug_1.debug)(`  Found claude binary at: ${claudePath}`);
+                this.claudeBinaryPath = claudePath;
+                return claudePath;
+            }
+        }
+        // Search PATH directories manually — no exec, no tainted strings passed
+        // to child_process.
+        const pathDirs = (process.env.PATH ?? '').split(path.delimiter);
+        for (const dir of pathDirs) {
+            if (!dir)
+                continue;
+            const candidate = path.join(dir, 'claude');
+            if (fs.existsSync(candidate)) {
+                (0, debug_1.debug)(`  Found claude in PATH: ${candidate}`);
+                this.claudeBinaryPath = candidate;
+                return candidate;
+            }
+        }
+        return null;
+    }
+    isClientSupported() {
+        try {
+            (0, debug_1.debug)('  Checking for Claude Code...');
+            const claudeBinary = this.findClaudeBinary();
+            if (!claudeBinary) {
+                (0, debug_1.debug)('  Claude Code not found. Installation paths checked:');
+                (0, debug_1.debug)(`    - ${path.join(os.homedir(), '.local', 'bin', 'claude')}`);
+                (0, debug_1.debug)(`    - ${path.join(os.homedir(), '.claude', 'local', 'claude')}`);
+                (0, debug_1.debug)(`    - /usr/local/bin/claude`);
+                (0, debug_1.debug)(`    - /opt/homebrew/bin/claude`);
+                (0, debug_1.debug)(`    - PATH`);
+                return Promise.resolve(false);
+            }
+            const result = (0, child_process_1.spawnSync)(claudeBinary, ['--version'], { stdio: 'pipe' });
+            if (result.status !== 0) {
+                return Promise.resolve(false);
+            }
+            const version = result.stdout.toString().trim();
+            (0, debug_1.debug)(`  Claude Code detected: ${version}`);
+            return Promise.resolve(true);
+        }
+        catch (error) {
+            (0, debug_1.debug)(`  Claude Code check failed: ${error instanceof Error ? error.message : String(error)}`);
+            return Promise.resolve(false);
+        }
+    }
+    isServerInstalled(local) {
+        try {
+            const claudeBinary = this.findClaudeBinary();
+            if (!claudeBinary) {
+                return Promise.resolve(false);
+            }
+            const result = (0, child_process_1.spawnSync)(claudeBinary, ['mcp', 'list'], {
+                stdio: 'pipe',
+            });
+            const serverName = local ? 'amplitude-local' : 'amplitude';
+            if (result.stdout.toString().includes(serverName)) {
+                return Promise.resolve(true);
+            }
+        }
+        catch {
+            //
+        }
+        return Promise.resolve(false);
+    }
+    getConfigPath() {
+        throw new Error('Not implemented');
+    }
+    addServer(apiKey, selectedFeatures, local) {
+        const binary = this.findClaudeBinary();
+        if (!binary) {
+            return Promise.resolve({ success: false });
+        }
+        const serverName = local ? 'amplitude-local' : 'amplitude';
+        const url = (0, defaults_1.buildMCPUrl)('streamable-http', selectedFeatures, local);
+        // Build args array — no shell interpolation, no injection risk
+        const addArgs = ['mcp', 'add', '--transport', 'http', serverName, url];
+        if (apiKey) {
+            addArgs.push('--header', `Authorization: Bearer ${apiKey}`);
+        }
+        addArgs.push('-s', 'user');
+        let addResult = (0, child_process_1.spawnSync)(binary, addArgs, { stdio: 'pipe' });
+        if (addResult.status !== 0) {
+            const stderr = addResult.stderr?.toString() ?? '';
+            // If the server already exists, remove and re-add so the config stays
+            // current (e.g. URL params or auth changes).
+            if (stderr.includes('already exists')) {
+                const removeResult = (0, child_process_1.spawnSync)(binary, ['mcp', 'remove', '--scope', 'user', serverName], { stdio: 'pipe' });
+                if (removeResult.status !== 0) {
+                    analytics_1.analytics.captureException(new Error(`Failed to remove existing Claude Code MCP entry: ${removeResult.stderr?.toString()}`));
+                    return Promise.resolve({ success: false });
+                }
+                addResult = (0, child_process_1.spawnSync)(binary, addArgs, { stdio: 'pipe' });
+            }
+            if (addResult.status !== 0) {
+                analytics_1.analytics.captureException(new Error(`Failed to add server to Claude Code: ${addResult.stderr?.toString()}`));
+                return Promise.resolve({ success: false });
+            }
+        }
+        return Promise.resolve({ success: true });
+    }
+    removeServer(local) {
+        const binary = this.findClaudeBinary();
+        if (!binary) {
+            return Promise.resolve({ success: false });
+        }
+        const serverName = local ? 'amplitude-local' : 'amplitude';
+        const result = (0, child_process_1.spawnSync)(binary, ['mcp', 'remove', '--scope', 'user', serverName], { stdio: 'pipe' });
+        if (result.status !== 0) {
+            analytics_1.analytics.captureException(new Error(`Failed to remove server from Claude Code: ${result.stderr?.toString()}`));
+            return Promise.resolve({ success: false });
+        }
+        return Promise.resolve({ success: true });
+    }
+}
+exports.ClaudeCodeMCPClient = ClaudeCodeMCPClient;

package/dist/src/steps/add-mcp-server-to-clients/clients/claude.d.ts

@@ -0,0 +1,20 @@
+import { DefaultMCPClient } from '../MCPClient';
+import { DefaultMCPClientConfig } from '../defaults';
+import { z } from 'zod';
+export declare const ClaudeMCPConfig: z.ZodObject<{
+    mcpServers: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
+        command: z.ZodOptional<z.ZodString>;
+        args: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    }, z.core.$strip>, z.ZodObject<{
+        url: z.ZodString;
+        headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    }, z.core.$strip>]>>;
+}, z.core.$loose>;
+export type ClaudeMCPConfig = z.infer<typeof DefaultMCPClientConfig>;
+export declare class ClaudeMCPClient extends DefaultMCPClient {
+    name: string;
+    constructor();
+    isClientSupported(): Promise<boolean>;
+    getConfigPath(): Promise<string>;
+}

package/dist/src/steps/add-mcp-server-to-clients/clients/claude.js

@@ -0,0 +1,63 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ClaudeMCPClient = exports.ClaudeMCPConfig = void 0;
+const MCPClient_1 = require("../MCPClient");
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+const defaults_1 = require("../defaults");
+exports.ClaudeMCPConfig = defaults_1.DefaultMCPClientConfig;
+class ClaudeMCPClient extends MCPClient_1.DefaultMCPClient {
+    name = 'Claude Desktop';
+    constructor() {
+        super();
+    }
+    async isClientSupported() {
+        return Promise.resolve(process.platform === 'darwin' || process.platform === 'win32');
+    }
+    async getConfigPath() {
+        const homeDir = os.homedir();
+        const isWindows = process.platform === 'win32';
+        const isMac = process.platform === 'darwin';
+        if (isMac) {
+            return Promise.resolve(path.join(homeDir, 'Library', 'Application Support', 'Claude', 'claude_desktop_config.json'));
+        }
+        if (isWindows) {
+            return Promise.resolve(path.join(process.env.APPDATA || '', 'Claude', 'claude_desktop_config.json'));
+        }
+        throw new Error(`Unsupported platform: ${process.platform}`);
+    }
+}
+exports.ClaudeMCPClient = ClaudeMCPClient;

package/dist/src/steps/add-mcp-server-to-clients/clients/codex.d.ts

@@ -0,0 +1,28 @@
+import { z } from 'zod';
+import { DefaultMCPClient } from '../MCPClient';
+import { DefaultMCPClientConfig } from '../defaults';
+export declare const CodexMCPConfig: z.ZodObject<{
+    mcpServers: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
+        command: z.ZodOptional<z.ZodString>;
+        args: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    }, z.core.$strip>, z.ZodObject<{
+        url: z.ZodString;
+        headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    }, z.core.$strip>]>>;
+}, z.core.$loose>;
+export type CodexMCPConfig = z.infer<typeof DefaultMCPClientConfig>;
+export declare class CodexMCPClient extends DefaultMCPClient {
+    name: string;
+    constructor();
+    isClientSupported(): Promise<boolean>;
+    getConfigPath(): Promise<string>;
+    isServerInstalled(local?: boolean): Promise<boolean>;
+    addServer(apiKey?: string, selectedFeatures?: string[], local?: boolean): Promise<{
+        success: boolean;
+    }>;
+    removeServer(local?: boolean): Promise<{
+        success: boolean;
+    }>;
+}
+export default CodexMCPClient;

package/dist/src/steps/add-mcp-server-to-clients/clients/codex.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CodexMCPClient = exports.CodexMCPConfig = void 0;
+const zod_1 = require("zod");
+const node_child_process_1 = require("node:child_process");
+const MCPClient_1 = require("../MCPClient");
+const defaults_1 = require("../defaults");
+const analytics_1 = require("../../../utils/analytics");
+exports.CodexMCPConfig = defaults_1.DefaultMCPClientConfig;
+class CodexMCPClient extends MCPClient_1.DefaultMCPClient {
+    name = 'Codex';
+    constructor() {
+        super();
+    }
+    isClientSupported() {
+        try {
+            (0, node_child_process_1.execSync)('codex --version', { stdio: 'ignore' });
+            return Promise.resolve(true);
+        }
+        catch {
+            return Promise.resolve(false);
+        }
+    }
+    getConfigPath() {
+        throw new Error('Not implemented');
+    }
+    isServerInstalled(local) {
+        const serverName = local ? 'amplitude-local' : 'amplitude';
+        try {
+            const result = (0, node_child_process_1.spawnSync)('codex', ['mcp', 'list', '--json'], {
+                encoding: 'utf-8',
+            });
+            if (result.error || result.status !== 0) {
+                return Promise.resolve(false);
+            }
+            const stdout = result.stdout?.trim();
+            if (!stdout) {
+                return Promise.resolve(false);
+            }
+            const CodexServerListSchema = zod_1.z.array(zod_1.z.object({ name: zod_1.z.string() }).passthrough());
+            const servers = CodexServerListSchema.parse(JSON.parse(stdout));
+            return Promise.resolve(servers.some((server) => server.name === serverName));
+        }
+        catch {
+            return Promise.resolve(false);
+        }
+    }
+    addServer(apiKey, selectedFeatures, local) {
+        const serverName = local ? 'amplitude-local' : 'amplitude';
+        const url = (0, defaults_1.buildMCPUrl)('streamable-http', selectedFeatures, local);
+        const args = ['mcp', 'add', serverName, '--url', url];
+        const env = { ...process.env };
+        if (apiKey) {
+            env.AMPLITUDE_API_KEY = apiKey;
+            args.push('--bearer-token-env-var', 'AMPLITUDE_API_KEY');
+        }
+        const result = (0, node_child_process_1.spawnSync)('codex', args, { stdio: 'ignore', env });
+        if (result.error || result.status !== 0) {
+            analytics_1.analytics.captureException(new Error('Failed to add server to Codex CLI.'));
+            return Promise.resolve({ success: false });
+        }
+        return Promise.resolve({ success: true });
+    }
+    removeServer(local) {
+        const serverName = local ? 'amplitude-local' : 'amplitude';
+        const result = (0, node_child_process_1.spawnSync)('codex', ['mcp', 'remove', serverName], {
+            stdio: 'ignore',
+        });
+        if (result.error || result.status !== 0) {
+            analytics_1.analytics.captureException(new Error('Failed to remove server from Codex CLI.'));
+            return Promise.resolve({ success: false });
+        }
+        return Promise.resolve({ success: true });
+    }
+}
+exports.CodexMCPClient = CodexMCPClient;
+exports.default = CodexMCPClient;

package/dist/src/steps/add-mcp-server-to-clients/clients/cursor.d.ts

@@ -0,0 +1,24 @@
+import { DefaultMCPClient, MCPServerConfig } from '../MCPClient';
+import { DefaultMCPClientConfig } from '../defaults';
+import { z } from 'zod';
+export declare const CursorMCPConfig: z.ZodObject<{
+    mcpServers: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
+        command: z.ZodOptional<z.ZodString>;
+        args: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    }, z.core.$strip>, z.ZodObject<{
+        url: z.ZodString;
+        headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    }, z.core.$strip>]>>;
+}, z.core.$loose>;
+export type CursorMCPConfig = z.infer<typeof DefaultMCPClientConfig>;
+export declare class CursorMCPClient extends DefaultMCPClient {
+    name: string;
+    constructor();
+    isClientSupported(): Promise<boolean>;
+    getConfigPath(): Promise<string>;
+    getServerConfig(apiKey: string | undefined, type: 'sse' | 'streamable-http', selectedFeatures?: string[], local?: boolean): MCPServerConfig;
+    addServer(apiKey?: string, selectedFeatures?: string[], local?: boolean): Promise<{
+        success: boolean;
+    }>;
+}

package/dist/src/steps/add-mcp-server-to-clients/clients/cursor.js

@@ -0,0 +1,60 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CursorMCPClient = exports.CursorMCPConfig = void 0;
+const MCPClient_1 = require("../MCPClient");
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+const defaults_1 = require("../defaults");
+exports.CursorMCPConfig = defaults_1.DefaultMCPClientConfig;
+class CursorMCPClient extends MCPClient_1.DefaultMCPClient {
+    name = 'Cursor';
+    constructor() {
+        super();
+    }
+    async isClientSupported() {
+        return Promise.resolve(process.platform === 'darwin' || process.platform === 'win32');
+    }
+    async getConfigPath() {
+        return Promise.resolve(path.join(os.homedir(), '.cursor', 'mcp.json'));
+    }
+    getServerConfig(apiKey, type, selectedFeatures, local) {
+        return (0, defaults_1.getNativeHTTPServerConfig)(apiKey, type, selectedFeatures, local);
+    }
+    async addServer(apiKey, selectedFeatures, local) {
+        return this._addServerType(apiKey, 'streamable-http', selectedFeatures, local);
+    }
+}
+exports.CursorMCPClient = CursorMCPClient;