@amplitude/wizard 1.0.0-beta.0

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

@@ -0,0 +1,27 @@
+import z from 'zod';
+import { DefaultMCPClient, MCPServerConfig } from '../MCPClient';
+export declare const VisualStudioCodeMCPConfig: z.ZodObject<{
+    servers: 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<{
+        type: z.ZodEnum<{
+            http: "http";
+            sse: "sse";
+        }>;
+        url: z.ZodString;
+        headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    }, z.core.$strip>]>>;
+}, z.core.$loose>;
+export type VisualStudioCodeMCPConfig = z.infer<typeof VisualStudioCodeMCPConfig>;
+export declare class VisualStudioCodeClient extends DefaultMCPClient {
+    name: string;
+    getServerPropertyName(): string;
+    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/visual-studio-code.js

@@ -0,0 +1,101 @@
+"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;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VisualStudioCodeClient = exports.VisualStudioCodeMCPConfig = void 0;
+const zod_1 = __importDefault(require("zod"));
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+const MCPClient_1 = require("../MCPClient");
+const defaults_1 = require("../defaults");
+exports.VisualStudioCodeMCPConfig = zod_1.default
+    .object({
+    servers: zod_1.default.record(zod_1.default.string(), zod_1.default.union([
+        zod_1.default.object({
+            command: zod_1.default.string().optional(),
+            args: zod_1.default.array(zod_1.default.string()).optional(),
+            env: zod_1.default.record(zod_1.default.string(), zod_1.default.string()).optional(),
+        }),
+        zod_1.default.object({
+            type: zod_1.default.enum(['http', 'sse']),
+            url: zod_1.default.string(),
+            headers: zod_1.default.record(zod_1.default.string(), zod_1.default.string()).optional(),
+        }),
+    ])),
+})
+    .passthrough();
+class VisualStudioCodeClient extends MCPClient_1.DefaultMCPClient {
+    name = 'Visual Studio Code';
+    getServerPropertyName() {
+        return 'servers';
+    }
+    async isClientSupported() {
+        return Promise.resolve(process.platform === 'darwin' ||
+            process.platform === 'win32' ||
+            process.platform === 'linux');
+    }
+    async getConfigPath() {
+        const homeDir = os.homedir();
+        const isWindows = process.platform === 'win32';
+        const isMac = process.platform === 'darwin';
+        const isLinux = process.platform === 'linux';
+        if (isMac) {
+            return Promise.resolve(path.join(homeDir, 'Library', 'Application Support', 'Code', 'User', 'mcp.json'));
+        }
+        if (isWindows) {
+            return Promise.resolve(path.join(process.env.APPDATA || '', 'Code', 'User', 'mcp.json'));
+        }
+        if (isLinux) {
+            return Promise.resolve(path.join(homeDir, '.config', 'Code', 'User', 'mcp.json'));
+        }
+        throw new Error(`Unsupported platform: ${process.platform}`);
+    }
+    getServerConfig(apiKey, type, selectedFeatures, local) {
+        const config = {
+            type: 'http',
+            url: (0, defaults_1.buildMCPUrl)(type, selectedFeatures, local),
+        };
+        if (apiKey) {
+            config.headers = { Authorization: `Bearer ${apiKey}` };
+        }
+        return config;
+    }
+    async addServer(apiKey, selectedFeatures, local) {
+        return this._addServerType(apiKey, 'streamable-http', selectedFeatures, local);
+    }
+}
+exports.VisualStudioCodeClient = VisualStudioCodeClient;

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

@@ -0,0 +1,26 @@
+import z from 'zod';
+import { DefaultMCPClient, MCPServerConfig } from '../MCPClient';
+export declare const ZedMCPConfig: z.ZodObject<{
+    context_servers: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
+        enabled: z.ZodOptional<z.ZodBoolean>;
+        source: z.ZodOptional<z.ZodString>;
+        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<{
+        enabled: z.ZodOptional<z.ZodBoolean>;
+        url: z.ZodString;
+        headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    }, z.core.$strip>]>>;
+}, z.core.$loose>;
+export type ZedMCPConfig = z.infer<typeof ZedMCPConfig>;
+export declare class ZedClient extends DefaultMCPClient {
+    name: string;
+    getServerPropertyName(): string;
+    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/zed.js

@@ -0,0 +1,102 @@
+"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;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ZedClient = exports.ZedMCPConfig = void 0;
+const zod_1 = __importDefault(require("zod"));
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+const MCPClient_1 = require("../MCPClient");
+const defaults_1 = require("../defaults");
+exports.ZedMCPConfig = zod_1.default
+    .object({
+    context_servers: zod_1.default.record(zod_1.default.string(), zod_1.default.union([
+        zod_1.default.object({
+            enabled: zod_1.default.boolean().optional(),
+            source: zod_1.default.string().optional(),
+            command: zod_1.default.string().optional(),
+            args: zod_1.default.array(zod_1.default.string()).optional(),
+            env: zod_1.default.record(zod_1.default.string(), zod_1.default.string()).optional(),
+        }),
+        zod_1.default.object({
+            enabled: zod_1.default.boolean().optional(),
+            url: zod_1.default.string(),
+            headers: zod_1.default.record(zod_1.default.string(), zod_1.default.string()).optional(),
+        }),
+    ])),
+})
+    .passthrough();
+class ZedClient extends MCPClient_1.DefaultMCPClient {
+    name = 'Zed';
+    getServerPropertyName() {
+        return 'context_servers';
+    }
+    async isClientSupported() {
+        return Promise.resolve(process.platform === 'darwin' || process.platform === 'linux');
+    }
+    async getConfigPath() {
+        const homeDir = os.homedir();
+        const isMac = process.platform === 'darwin';
+        const isLinux = process.platform === 'linux';
+        if (isMac) {
+            return Promise.resolve(path.join(homeDir, '.config', 'zed', 'settings.json'));
+        }
+        if (isLinux) {
+            // https://zed.dev/docs/configuring-zed#settings-files
+            const xdgConfigHome = process.env.XDG_CONFIG_HOME;
+            if (xdgConfigHome) {
+                return Promise.resolve(path.join(xdgConfigHome, 'zed', 'settings.json'));
+            }
+            return Promise.resolve(path.join(homeDir, '.config', 'zed', 'settings.json'));
+        }
+        throw new Error(`Unsupported platform: ${process.platform}`);
+    }
+    getServerConfig(apiKey, type, selectedFeatures, local) {
+        const config = {
+            enabled: true,
+            url: (0, defaults_1.buildMCPUrl)(type, selectedFeatures, local),
+        };
+        if (apiKey) {
+            config.headers = { Authorization: `Bearer ${apiKey}` };
+        }
+        return config;
+    }
+    async addServer(apiKey, selectedFeatures, local) {
+        return this._addServerType(apiKey, 'streamable-http', selectedFeatures, local);
+    }
+}
+exports.ZedClient = ZedClient;

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

@@ -0,0 +1,44 @@
+import z from 'zod';
+export declare const DefaultMCPClientConfig: 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 declare const AVAILABLE_FEATURES: {
+    'Data & Analytics': {
+        value: string;
+        label: string;
+        hint: string;
+    }[];
+    'Development Tools': {
+        value: string;
+        label: string;
+        hint: string;
+    }[];
+    'Platform & Management': {
+        value: string;
+        label: string;
+        hint: string;
+    }[];
+};
+export declare const ALL_FEATURE_VALUES: string[];
+type MCPServerType = 'sse' | 'streamable-http';
+export declare const buildMCPUrl: (type: MCPServerType, selectedFeatures?: string[], local?: boolean) => string;
+export declare const getNativeHTTPServerConfig: (apiKey: string | undefined, type: MCPServerType, selectedFeatures?: string[], local?: boolean) => Record<string, unknown>;
+export declare const getDefaultServerConfig: (apiKey: string | undefined, type: MCPServerType, selectedFeatures?: string[], local?: boolean) => {
+    command: string;
+    args: string[];
+    env?: undefined;
+} | {
+    command: string;
+    args: string[];
+    env: {
+        AMPLITUDE_AUTH_HEADER: string;
+    };
+};
+export {};

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

@@ -0,0 +1,123 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDefaultServerConfig = exports.getNativeHTTPServerConfig = exports.buildMCPUrl = exports.ALL_FEATURE_VALUES = exports.AVAILABLE_FEATURES = exports.DefaultMCPClientConfig = void 0;
+const zod_1 = __importDefault(require("zod"));
+exports.DefaultMCPClientConfig = zod_1.default
+    .object({
+    mcpServers: zod_1.default.record(zod_1.default.string(), zod_1.default.union([
+        zod_1.default.object({
+            command: zod_1.default.string().optional(),
+            args: zod_1.default.array(zod_1.default.string()).optional(),
+            env: zod_1.default.record(zod_1.default.string(), zod_1.default.string()).optional(),
+        }),
+        zod_1.default.object({
+            url: zod_1.default.string(),
+            headers: zod_1.default.record(zod_1.default.string(), zod_1.default.string()).optional(),
+        }),
+    ])),
+})
+    .passthrough();
+exports.AVAILABLE_FEATURES = {
+    'Data & Analytics': [
+        {
+            value: 'dashboards',
+            label: 'Dashboards',
+            hint: 'Dashboard creation and management',
+        },
+        {
+            value: 'insights',
+            label: 'Insights',
+            hint: 'Analytics insights and SQL queries',
+        },
+        {
+            value: 'experiments',
+            label: 'Experiments',
+            hint: 'A/B testing experiments',
+        },
+        {
+            value: 'llm-analytics',
+            label: 'LLM Analytics',
+            hint: 'LLM usage and cost tracking',
+        },
+    ],
+    'Development Tools': [
+        {
+            value: 'error-tracking',
+            label: 'Error Tracking',
+            hint: 'Error monitoring and debugging',
+        },
+        { value: 'flags', label: 'Feature Flags', hint: 'Feature flag management' },
+    ],
+    'Platform & Management': [
+        {
+            value: 'workspace',
+            label: 'Workspace',
+            hint: 'Organization and project management',
+        },
+        {
+            value: 'docs',
+            label: 'Documentation',
+            hint: 'Amplitude documentation search',
+        },
+    ],
+};
+exports.ALL_FEATURE_VALUES = Object.values(exports.AVAILABLE_FEATURES)
+    .flat()
+    .map((feature) => feature.value);
+const buildMCPUrl = (type, selectedFeatures, local) => {
+    const host = local ? 'http://localhost:8787' : 'https://mcp.amplitude.com';
+    const baseUrl = `${host}/${type === 'sse' ? 'sse' : 'mcp'}`;
+    const isAllFeaturesSelected = selectedFeatures &&
+        selectedFeatures.length === exports.ALL_FEATURE_VALUES.length &&
+        exports.ALL_FEATURE_VALUES.every((feature) => selectedFeatures.includes(feature));
+    const params = [];
+    // Add features param if not all features selected
+    if (selectedFeatures &&
+        selectedFeatures.length > 0 &&
+        !isAllFeaturesSelected) {
+        params.push(`features=${selectedFeatures.join(',')}`);
+    }
+    return params.length > 0 ? `${baseUrl}?${params.join('&')}` : baseUrl;
+};
+exports.buildMCPUrl = buildMCPUrl;
+const getNativeHTTPServerConfig = (apiKey, type, selectedFeatures, local) => {
+    const config = {
+        url: (0, exports.buildMCPUrl)(type, selectedFeatures, local),
+    };
+    // Only add auth header if API key is provided (not OAuth mode)
+    if (apiKey) {
+        config.headers = {
+            Authorization: `Bearer ${apiKey}`,
+        };
+    }
+    return config;
+};
+exports.getNativeHTTPServerConfig = getNativeHTTPServerConfig;
+const getDefaultServerConfig = (apiKey, type, selectedFeatures, local) => {
+    const urlWithFeatures = (0, exports.buildMCPUrl)(type, selectedFeatures, local);
+    // OAuth mode: no auth header, let MCP handle OAuth
+    if (!apiKey) {
+        return {
+            command: 'npx',
+            args: ['-y', 'mcp-remote@latest', urlWithFeatures],
+        };
+    }
+    // API key mode: include auth header
+    return {
+        command: 'npx',
+        args: [
+            '-y',
+            'mcp-remote@latest',
+            urlWithFeatures,
+            '--header',
+            `Authorization:\${AMPLITUDE_AUTH_HEADER}`,
+        ],
+        env: {
+            AMPLITUDE_AUTH_HEADER: `Bearer ${apiKey}`,
+        },
+    };
+};
+exports.getDefaultServerConfig = getDefaultServerConfig;

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

@@ -0,0 +1,19 @@
+import type { Integration } from '../../lib/constants';
+import { MCPClient } from './MCPClient';
+export declare const getSupportedClients: () => Promise<MCPClient[]>;
+/**
+ * Add MCP server to clients. No prompts — pure orchestration.
+ * Prompts are handled by McpScreen (TUI) or auto-accepted (CI).
+ */
+export declare const addMCPServerToClientsStep: ({ integration, local, ci, }: {
+    integration?: Integration;
+    local?: boolean;
+    ci?: boolean;
+}) => Promise<string[]>;
+export declare const removeMCPServerFromClientsStep: ({ integration, local, }: {
+    integration?: Integration;
+    local?: boolean;
+}) => Promise<string[]>;
+export declare const getInstalledClients: (local?: boolean) => Promise<MCPClient[]>;
+export declare const addMCPServer: (clients: MCPClient[], personalApiKey?: string, selectedFeatures?: string[], local?: boolean) => Promise<void>;
+export declare const removeMCPServer: (clients: MCPClient[], local?: boolean) => Promise<void>;

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

@@ -0,0 +1,110 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.removeMCPServer = exports.addMCPServer = exports.getInstalledClients = exports.removeMCPServerFromClientsStep = exports.addMCPServerToClientsStep = exports.getSupportedClients = void 0;
+const telemetry_1 = require("../../telemetry");
+const analytics_1 = require("../../utils/analytics");
+const ui_1 = require("../../ui");
+const cursor_1 = require("./clients/cursor");
+const claude_1 = require("./clients/claude");
+const claude_code_1 = require("./clients/claude-code");
+const visual_studio_code_1 = require("./clients/visual-studio-code");
+const zed_1 = require("./clients/zed");
+const codex_1 = require("./clients/codex");
+const defaults_1 = require("./defaults");
+const debug_1 = require("../../utils/debug");
+const getSupportedClients = async () => {
+    const allClients = [
+        new cursor_1.CursorMCPClient(),
+        new claude_1.ClaudeMCPClient(),
+        new claude_code_1.ClaudeCodeMCPClient(),
+        new visual_studio_code_1.VisualStudioCodeClient(),
+        new zed_1.ZedClient(),
+        new codex_1.CodexMCPClient(),
+    ];
+    const supportedClients = [];
+    (0, debug_1.debug)('Checking for supported MCP clients...');
+    for (const client of allClients) {
+        const isSupported = await client.isClientSupported();
+        (0, debug_1.debug)(`${client.name}: ${isSupported ? '✓ supported' : '✗ not supported'}`);
+        if (isSupported) {
+            supportedClients.push(client);
+        }
+    }
+    (0, debug_1.debug)(`Found ${supportedClients.length} supported client(s): ${supportedClients
+        .map((c) => c.name)
+        .join(', ')}`);
+    return supportedClients;
+};
+exports.getSupportedClients = getSupportedClients;
+/**
+ * Add MCP server to clients. No prompts — pure orchestration.
+ * Prompts are handled by McpScreen (TUI) or auto-accepted (CI).
+ */
+const addMCPServerToClientsStep = async ({ integration, local = false, ci = false, }) => {
+    const ui = (0, ui_1.getUI)();
+    // CI mode: skip MCP installation entirely
+    if (ci) {
+        ui.log.info('Skipping MCP installation (CI mode)');
+        return [];
+    }
+    const supportedClients = await (0, exports.getSupportedClients)();
+    if (supportedClients.length === 0) {
+        ui.log.info('No supported MCP clients detected. Skipping MCP installation.');
+        return [];
+    }
+    // Auto-install to all supported clients
+    await (0, telemetry_1.traceStep)('adding mcp servers', async () => {
+        await (0, exports.addMCPServer)(supportedClients, undefined, [...defaults_1.ALL_FEATURE_VALUES], local);
+    });
+    ui.log.success(`Added the MCP server to:
+  ${supportedClients.map((c) => `- ${c.name}`).join('\n  ')} `);
+    analytics_1.analytics.wizardCapture('mcp servers added', {
+        clients: supportedClients.map((c) => c.name),
+        integration,
+    });
+    return supportedClients.map((c) => c.name);
+};
+exports.addMCPServerToClientsStep = addMCPServerToClientsStep;
+const removeMCPServerFromClientsStep = async ({ integration, local = false, }) => {
+    const installedClients = await (0, exports.getInstalledClients)(local);
+    if (installedClients.length === 0) {
+        analytics_1.analytics.wizardCapture('mcp no servers to remove', {
+            integration,
+        });
+        return [];
+    }
+    // Auto-remove from all installed clients
+    const results = await (0, telemetry_1.traceStep)('removing mcp servers', async () => {
+        await (0, exports.removeMCPServer)(installedClients, local);
+        return installedClients.map((c) => c.name);
+    });
+    analytics_1.analytics.wizardCapture('mcp servers removed', {
+        clients: results,
+        integration,
+    });
+    return results;
+};
+exports.removeMCPServerFromClientsStep = removeMCPServerFromClientsStep;
+const getInstalledClients = async (local) => {
+    const clients = await (0, exports.getSupportedClients)();
+    const installedClients = [];
+    for (const client of clients) {
+        if (await client.isServerInstalled(local)) {
+            installedClients.push(client);
+        }
+    }
+    return installedClients;
+};
+exports.getInstalledClients = getInstalledClients;
+const addMCPServer = async (clients, personalApiKey, selectedFeatures, local) => {
+    for (const client of clients) {
+        await client.addServer(personalApiKey, selectedFeatures, local);
+    }
+};
+exports.addMCPServer = addMCPServer;
+const removeMCPServer = async (clients, local) => {
+    for (const client of clients) {
+        await client.removeServer(local);
+    }
+};
+exports.removeMCPServer = removeMCPServer;

package/dist/src/steps/add-or-update-environment-variables.d.ts

@@ -0,0 +1,10 @@
+import type { Integration } from '../lib/constants';
+export declare function addOrUpdateEnvironmentVariablesStep({ installDir, variables, integration, }: {
+    installDir: string;
+    variables: Record<string, string>;
+    integration: Integration;
+}): Promise<{
+    relativeEnvFilePath: string;
+    addedEnvVariables: boolean;
+    addedGitignore: boolean;
+}>;