@hubspot/cli 8.0.1-experimental.0 → 8.0.3-experimental.0

package/lib/accountAuth.js

@@ -0,0 +1,105 @@
+import { updateConfigAccount, createEmptyConfigFile, getConfigFilePath, localConfigFileExists, globalConfigFileExists, setConfigAccountAsDefault, } from '@hubspot/local-dev-lib/config';
+import { getAccessToken, updateConfigWithAccessToken, } from '@hubspot/local-dev-lib/personalAccessKey';
+import { toKebabCase } from '@hubspot/local-dev-lib/text';
+import { handleMerge, handleMigration } from './configMigrate.js';
+import { debugError, logError } from './errorHandlers/index.js';
+import { personalAccessKeyPrompt } from './prompts/personalAccessKeyPrompt.js';
+import { cliAccountNamePrompt } from './prompts/accountNamePrompt.js';
+import { setAsDefaultAccountPrompt } from './prompts/setAsDefaultAccountPrompt.js';
+import { commands } from '../lang/en.js';
+import { uiLogger } from './ui/logger.js';
+async function updateConfigWithNewAccount(env, configAlreadyExists, providedPersonalAccessKey, accountId) {
+    try {
+        const { personalAccessKey } = providedPersonalAccessKey
+            ? { personalAccessKey: providedPersonalAccessKey }
+            : await personalAccessKeyPrompt({
+                env,
+                account: accountId,
+            });
+        const token = await getAccessToken(personalAccessKey, env);
+        const defaultAccountName = token.hubName
+            ? toKebabCase(token.hubName)
+            : undefined;
+        const accountName = configAlreadyExists
+            ? undefined
+            : (await cliAccountNamePrompt(defaultAccountName)).name;
+        const updatedConfig = await updateConfigWithAccessToken(token, personalAccessKey, env, accountName, !configAlreadyExists);
+        if (!updatedConfig)
+            return null;
+        // Can happen if the user is re-authenticating an account with no name
+        if (configAlreadyExists && !updatedConfig.name) {
+            updatedConfig.name = (await cliAccountNamePrompt(defaultAccountName)).name;
+            updateConfigAccount({
+                ...updatedConfig,
+            });
+        }
+        return updatedConfig;
+    }
+    catch (e) {
+        debugError(e);
+        return null;
+    }
+}
+async function handleConfigMigration() {
+    const deprecatedConfigExists = localConfigFileExists();
+    const globalConfigExists = globalConfigFileExists();
+    if (!deprecatedConfigExists) {
+        return true;
+    }
+    if (globalConfigExists) {
+        try {
+            const mergeConfirmed = await handleMerge();
+            if (!mergeConfirmed) {
+                uiLogger.log('');
+                uiLogger.log(commands.account.subcommands.auth.errors.mergeNotConfirmed);
+            }
+            return mergeConfirmed;
+        }
+        catch (error) {
+            logError(error);
+            return false;
+        }
+    }
+    try {
+        const migrationConfirmed = await handleMigration();
+        if (!migrationConfirmed) {
+            uiLogger.log('');
+            uiLogger.log(commands.account.subcommands.auth.errors.migrationNotConfirmed);
+        }
+        return migrationConfirmed;
+    }
+    catch (error) {
+        logError(error);
+        return false;
+    }
+}
+export async function authenticateNewAccount({ env, providedPersonalAccessKey, accountId, setAsDefaultAccount, }) {
+    const configMigrationSuccess = await handleConfigMigration();
+    if (!configMigrationSuccess) {
+        return null;
+    }
+    const configAlreadyExists = globalConfigFileExists();
+    if (!configAlreadyExists) {
+        createEmptyConfigFile(true);
+    }
+    const updatedConfig = await updateConfigWithNewAccount(env, configAlreadyExists, providedPersonalAccessKey, accountId);
+    if (!updatedConfig) {
+        uiLogger.error(commands.account.subcommands.auth.errors.failedToUpdateConfig);
+        return null;
+    }
+    const { accountId: newAccountId, name } = updatedConfig;
+    if (!configAlreadyExists) {
+        uiLogger.log('');
+        uiLogger.success(commands.account.subcommands.auth.success.configFileCreated(getConfigFilePath()));
+        uiLogger.success(commands.account.subcommands.auth.success.configFileUpdated(newAccountId));
+    }
+    else if (setAsDefaultAccount) {
+        setConfigAccountAsDefault(name);
+        uiLogger.log('');
+        uiLogger.success(commands.account.subcommands.auth.success.configFileUpdated(newAccountId));
+    }
+    else {
+        await setAsDefaultAccountPrompt(name);
+    }
+    return updatedConfig;
+}

package/lib/app/urls.d.ts

@@ -13,4 +13,5 @@ type PublicAppInstallUrlArgs = {
 };
 export declare function getOauthAppInstallUrl({ targetAccountId, env, clientId, scopes, redirectUrls, }: PublicAppInstallUrlArgs): string;
 export declare function getStaticAuthAppInstallUrl({ targetAccountId, env, appId, }: PrivateAppInstallUrlArgs): string;
+export declare function getAppCardSetupUrl({ targetAccountId, env, appId, }: PrivateAppInstallUrlArgs): string;
 export {};

package/lib/app/urls.js

@@ -10,3 +10,7 @@ export function getStaticAuthAppInstallUrl({ targetAccountId, env, appId, }) {
     const websiteOrigin = getHubSpotWebsiteOrigin(env);
     return `${websiteOrigin}/static-token/${targetAccountId}/authorize?appId=${appId}`;
 }
+export function getAppCardSetupUrl({ targetAccountId, env, appId, }) {
+    const websiteOrigin = getHubSpotWebsiteOrigin(env);
+    return `${websiteOrigin}/integrations-settings/${targetAccountId}/installed/framework/${appId}/app-cards?tourId=get-started`;
+}

package/lib/commandSuggestion.d.ts

@@ -0,0 +1,3 @@
+import { Argv } from 'yargs';
+export declare const commandSuggestionMappings: Record<string, string>;
+export declare function addCommandSuggestions(yargsInstance: Argv): Argv;

package/lib/commandSuggestion.js

@@ -0,0 +1,45 @@
+import { uiLogger } from './ui/logger.js';
+import { uiCommandReference } from './ui/index.js';
+import { EXIT_CODES } from './enums/exitCodes.js';
+export const commandSuggestionMappings = {
+    create: 'hs cms app|theme|module|webpack|function|template create',
+    fetch: 'hs cms fetch',
+    lint: 'hs cms lint',
+    list: 'hs cms list',
+    mv: 'hs cms mv',
+    remove: 'hs cms delete',
+    upload: 'hs cms upload',
+    watch: 'hs cms watch',
+    'function deploy': 'hs cms function deploy',
+    'function list': 'hs cms function list',
+    'function server': 'hs cms function server',
+    logs: 'hs cms function logs',
+    'module marketplace-validate': 'hs cms module marketplace-validate',
+    'theme generate-selectors': 'hs cms theme generate-selectors',
+    'theme marketplace-validate': 'hs cms theme marketplace-validate',
+    'theme preview': 'hs cms theme preview',
+    'custom-object schema create': 'hs custom-object create-schema',
+    'custom-object schema delete': 'hs custom-object delete-schema',
+    'custom-object schema fetch-all': 'hs custom-object fetch-all-schemas',
+    'custom-object schema fetch': 'hs custom-object fetch-schema',
+    'custom-object schema list': 'hs custom-object list-schemas',
+    'custom-object schema update': 'hs custom-object update-schema',
+};
+function createCommandSuggestionHandler(newCommand) {
+    return () => {
+        uiLogger.error(`Did you mean ${uiCommandReference(newCommand)}?`);
+        process.exit(EXIT_CODES.ERROR);
+    };
+}
+function createCommandSuggestion(oldCommand, newCommand) {
+    return {
+        command: oldCommand,
+        builder: async (yargs) => {
+            return yargs.strict(false);
+        },
+        handler: createCommandSuggestionHandler(newCommand),
+    };
+}
+export function addCommandSuggestions(yargsInstance) {
+    return Object.entries(commandSuggestionMappings).reduce((yargs, [oldCommand, newCommand]) => yargs.command(createCommandSuggestion(oldCommand, newCommand)), yargsInstance);
+}

package/lib/constants.d.ts

@@ -94,7 +94,6 @@ export declare const LOCAL_DEV_UI_MESSAGE_SEND_TYPES: {
     UPDATE_APP_DATA: string;
     UPDATE_PROJECT_DATA: string;
     UPDATE_UPLOAD_WARNINGS: string;
-    CLI_METADATA: string;
     DEV_SERVERS_STARTED: string;
 };
 export declare const LOCAL_DEV_UI_MESSAGE_RECEIVE_TYPES: {

package/lib/constants.js

@@ -86,7 +86,6 @@ export const LOCAL_DEV_UI_MESSAGE_SEND_TYPES = {
     UPDATE_APP_DATA: 'server:updateAppData',
     UPDATE_PROJECT_DATA: 'server:updateProjectData',
     UPDATE_UPLOAD_WARNINGS: 'server:updateUploadWarnings',
-    CLI_METADATA: 'server:cliMetadata',
     DEV_SERVERS_STARTED: 'server:devServersStarted',
 };
 export const LOCAL_DEV_UI_MESSAGE_RECEIVE_TYPES = {

package/lib/errors/ProjectErrors.d.ts

@@ -0,0 +1,15 @@
+export declare class ProjectNestingError extends Error {
+    constructor(message: string);
+}
+export declare class ProjectConfigNotFoundError extends Error {
+    constructor(message: string);
+}
+export declare class ProjectValidationError extends Error {
+    constructor(message: string);
+}
+export declare class ProjectUploadError extends Error {
+    constructor(message: string, cause?: unknown);
+}
+export declare class ProjectBuildDeployError extends Error {
+    constructor(message: string);
+}

package/lib/errors/ProjectErrors.js

@@ -0,0 +1,30 @@
+export class ProjectNestingError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'ProjectNestingError';
+    }
+}
+export class ProjectConfigNotFoundError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'ProjectConfigNotFoundError';
+    }
+}
+export class ProjectValidationError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'ProjectValidationError';
+    }
+}
+export class ProjectUploadError extends Error {
+    constructor(message, cause) {
+        super(message, { cause });
+        this.name = 'ProjectUploadError';
+    }
+}
+export class ProjectBuildDeployError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'ProjectBuildDeployError';
+    }
+}

package/lib/getStarted/getStartedV2.d.ts

@@ -0,0 +1,7 @@
+import { CommonArgs } from '../../types/Yargs.js';
+type GetStartedV2Args = CommonArgs & {
+    name?: string;
+    dest?: string;
+};
+export declare function runGetStartedV2({ derivedAccountId, name, dest, }: GetStartedV2Args): Promise<void>;
+export {};

package/lib/getStarted/getStartedV2.js

@@ -0,0 +1,18 @@
+import { LOG_LEVEL, setLogLevel } from '@hubspot/local-dev-lib/logger';
+import { trackGetStartedUsage } from '../../lib/getStartedV2Actions.js';
+import { renderInteractive } from '../../ui/render.js';
+import { getGetStartedFlow } from '../../ui/components/getStarted/GetStartedFlow.js';
+export async function runGetStartedV2({ derivedAccountId, name, dest, }) {
+    setLogLevel(LOG_LEVEL.NONE);
+    try {
+        await renderInteractive(getGetStartedFlow({
+            derivedAccountId,
+            initialName: name,
+            initialDest: dest,
+        }), { fullScreen: true });
+        await trackGetStartedUsage({ successful: true, step: 'command-completed' }, derivedAccountId);
+    }
+    finally {
+        setLogLevel(LOG_LEVEL.LOG);
+    }
+}

package/lib/getStartedV2Actions.d.ts

@@ -0,0 +1,37 @@
+import { type ProjectMetadata } from '@hubspot/project-parsing-lib/projects';
+import { type IntermediateRepresentationNode } from '@hubspot/project-parsing-lib/translate';
+export type CreateProjectResult = {
+    projectName: string;
+    projectDest: string;
+};
+export type AppConfig = {
+    name?: string;
+    uid?: string;
+    distribution?: string;
+    auth?: {
+        type?: string;
+        requiredScopes?: string[];
+        optionalScopes?: string[];
+    };
+};
+export type AppIRNode = IntermediateRepresentationNode & {
+    config: AppConfig;
+};
+export declare function createProjectAction({ projectName, projectDest, }: {
+    projectName: string;
+    projectDest: string;
+}): Promise<CreateProjectResult>;
+export type UploadAndDeployResult = {
+    appId: number;
+    projectId: number;
+    installUrl: string;
+    projectDir: string;
+    app: AppIRNode;
+    projectName: string;
+    projectMetadata: ProjectMetadata;
+};
+export declare function uploadAndDeployAction({ accountId, projectDest, }: {
+    accountId: number;
+    projectDest: string;
+}): Promise<UploadAndDeployResult>;
+export declare function trackGetStartedUsage(params: Record<string, unknown>, accountId: number): Promise<void>;

package/lib/getStartedV2Actions.js

@@ -0,0 +1,146 @@
+import fs from 'fs-extra';
+import path from 'path';
+import { fetchPublicAppsForPortal } from '@hubspot/local-dev-lib/api/appsDev';
+import { fetchProject } from '@hubspot/local-dev-lib/api/projects';
+import { getConfigAccountEnvironment } from '@hubspot/local-dev-lib/config';
+import { cloneGithubRepo } from '@hubspot/local-dev-lib/github';
+import { getCwd } from '@hubspot/local-dev-lib/path';
+import { getProjectMetadata, } from '@hubspot/project-parsing-lib/projects';
+import { translate, } from '@hubspot/project-parsing-lib/translate';
+import { commands, lib } from '../lang/en.js';
+import { getStaticAuthAppInstallUrl } from '../lib/app/urls.js';
+import { HUBSPOT_PROJECT_COMPONENTS_GITHUB_PATH, PROJECT_CONFIG_FILE, } from '../lib/constants.js';
+import { ProjectNestingError, ProjectConfigNotFoundError, ProjectValidationError, ProjectUploadError, ProjectBuildDeployError, } from './errors/ProjectErrors.js';
+import { getProjectConfig, validateProjectConfig, writeProjectConfig, } from '../lib/projects/config.js';
+import { isV2Project } from '../lib/projects/platformVersion.js';
+import { pollProjectBuildAndDeploy } from '../lib/projects/pollProjectBuildAndDeploy.js';
+import { handleProjectUpload } from '../lib/projects/upload.js';
+import { validateProjectDirectory } from '../lib/prompts/projectNameAndDestPrompt.js';
+import { trackCommandMetadataUsage } from './usageTracking.js';
+export async function createProjectAction({ projectName, projectDest, }) {
+    if (!projectName || projectName.trim() === '') {
+        throw new Error(lib.prompts.projectNameAndDestPrompt.errors.nameRequired);
+    }
+    const validationResult = validateProjectDirectory(projectDest);
+    if (validationResult !== true) {
+        throw new Error(typeof validationResult === 'string'
+            ? validationResult
+            : 'Invalid project directory');
+    }
+    const projectDestAbsolute = path.resolve(getCwd(), projectDest);
+    const { projectConfig: existingProjectConfig, projectDir: existingProjectDir, } = await getProjectConfig(projectDestAbsolute);
+    if (existingProjectConfig &&
+        existingProjectDir &&
+        projectDestAbsolute.startsWith(existingProjectDir)) {
+        throw new ProjectNestingError(commands.project.create.errors.cannotNestProjects(existingProjectDir));
+    }
+    try {
+        await cloneGithubRepo(HUBSPOT_PROJECT_COMPONENTS_GITHUB_PATH, projectDestAbsolute, {
+            sourceDir: '2025.2/private-app-get-started-template',
+            hideLogs: true,
+        });
+        const projectConfigPath = path.join(projectDestAbsolute, PROJECT_CONFIG_FILE);
+        const parsedConfigFile = JSON.parse(fs.readFileSync(projectConfigPath, 'utf8'));
+        writeProjectConfig(projectConfigPath, {
+            ...parsedConfigFile,
+            name: projectName,
+        });
+        return { projectName, projectDest: projectDestAbsolute };
+    }
+    catch (error) {
+        throw new Error(commands.project.create.errors.failedToDownloadProject, {
+            cause: error,
+        });
+    }
+}
+async function fetchAppAfterDeploy(accountId, env) {
+    const { data: { results }, } = await fetchPublicAppsForPortal(accountId);
+    const lastCreatedApp = results.sort((a, b) => b.createdAt - a.createdAt)[0];
+    if (!lastCreatedApp) {
+        throw new Error(commands.getStarted.errors.noAppsFound);
+    }
+    const installUrl = getStaticAuthAppInstallUrl({
+        targetAccountId: accountId,
+        env,
+        appId: lastCreatedApp.id,
+    });
+    return {
+        appId: lastCreatedApp.id,
+        installUrl,
+    };
+}
+async function buildProjectMetadata(projectDir, projectConfig, accountId) {
+    const srcDir = path.join(projectDir, projectConfig.srcDir);
+    const projectMetadata = await getProjectMetadata(srcDir);
+    const intermediateRepresentation = await translate({
+        projectSourceDir: srcDir,
+        platformVersion: projectConfig.platformVersion,
+        accountId,
+    }, { skipValidation: false });
+    const apps = Object.values(intermediateRepresentation.intermediateNodesIndexedByUid).filter(node => node.componentType === 'APPLICATION');
+    if (apps.length === 0) {
+        throw new Error(commands.getStarted.errors.noAppsFound);
+    }
+    return {
+        projectMetadata,
+        app: apps[0],
+    };
+}
+export async function uploadAndDeployAction({ accountId, projectDest, }) {
+    const { projectConfig, projectDir } = await getProjectConfig(projectDest);
+    if (!projectConfig || !projectDir) {
+        throw new ProjectConfigNotFoundError(commands.getStarted.errors.configFileNotFound);
+    }
+    try {
+        validateProjectConfig(projectConfig, projectDir);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new ProjectValidationError(message);
+    }
+    const env = getConfigAccountEnvironment(accountId);
+    try {
+        const { result, uploadError } = await handleProjectUpload({
+            accountId,
+            projectConfig,
+            projectDir,
+            callbackFunc: pollProjectBuildAndDeploy,
+            uploadMessage: commands.getStarted.logs.initialUploadMessage,
+            forceCreate: true,
+            isUploadCommand: false,
+            sendIR: isV2Project(projectConfig.platformVersion),
+            skipValidation: false,
+        });
+        if (uploadError) {
+            throw new ProjectUploadError(commands.getStarted.errors.uploadActionFailed, uploadError);
+        }
+        if (!result || !result.succeeded) {
+            throw new ProjectBuildDeployError(commands.getStarted.errors.buildOrDeployFailed);
+        }
+        const { data: projectData } = await fetchProject(accountId, projectConfig.name);
+        const projectId = projectData.id;
+        const { appId, installUrl } = await fetchAppAfterDeploy(accountId, env);
+        const { projectMetadata, app } = await buildProjectMetadata(projectDir, projectConfig, accountId);
+        return {
+            appId,
+            projectId,
+            installUrl,
+            projectDir,
+            app,
+            projectName: projectConfig.name,
+            projectMetadata,
+        };
+    }
+    catch (error) {
+        if (error instanceof ProjectUploadError ||
+            error instanceof ProjectBuildDeployError) {
+            throw error;
+        }
+        throw new Error(commands.getStarted.errors.failedToUploadAndDeploy, {
+            cause: error,
+        });
+    }
+}
+export function trackGetStartedUsage(params, accountId) {
+    return trackCommandMetadataUsage('get-started', params, accountId);
+}

package/lib/marketplaceValidate.d.ts

@@ -2,7 +2,7 @@ import { GetValidationResultsResponse } from '@hubspot/local-dev-lib/types/Marke
 export declare function kickOffValidation(accountId: number, assetType: string, src: string): Promise<number>;
 export declare function pollForValidationFinish(accountId: number, validationId: number): Promise<void>;
 export declare function fetchValidationResults(accountId: number, validationId: number): Promise<GetValidationResultsResponse>;
-export declare function processValidationErrors(invalidPathError: (path: string) => string, validationResults: GetValidationResultsResponse): void;
+export declare function hasProcessValidationErrors(invalidPathError: (path: string) => string, validationResults: GetValidationResultsResponse): boolean;
 type ResultsCopy = {
     noErrors: string;
     required: string;

package/lib/marketplaceValidate.js

@@ -1,54 +1,35 @@
 import chalk from 'chalk';
 import { requestValidation, getValidationStatus, getValidationResults, } from '@hubspot/local-dev-lib/api/marketplaceValidation';
 import { uiLogger } from './ui/logger.js';
-import { EXIT_CODES } from './enums/exitCodes.js';
 const SLEEP_TIME = 2000;
 export async function kickOffValidation(accountId, assetType, src) {
     const requestGroup = 'EXTERNAL_DEVELOPER';
-    try {
-        const { data: requestResult } = await requestValidation(accountId, {
-            path: src,
-            assetType,
-            requestGroup,
-        });
-        return requestResult;
-    }
-    catch (err) {
-        uiLogger.debug(err);
-        process.exit(EXIT_CODES.ERROR);
-    }
+    const { data: requestResult } = await requestValidation(accountId, {
+        path: src,
+        assetType,
+        requestGroup,
+    });
+    return requestResult;
 }
 export async function pollForValidationFinish(accountId, validationId) {
-    try {
-        const checkValidationStatus = async () => {
-            const { data: validationStatus } = await getValidationStatus(accountId, {
-                validationId,
-            });
-            if (validationStatus === 'REQUESTED') {
-                await new Promise(resolve => setTimeout(resolve, SLEEP_TIME));
-                await checkValidationStatus();
-            }
-        };
-        await checkValidationStatus();
-    }
-    catch (err) {
-        uiLogger.debug(err);
-        process.exit(EXIT_CODES.ERROR);
-    }
-}
-export async function fetchValidationResults(accountId, validationId) {
-    try {
-        const { data: validationResults } = await getValidationResults(accountId, {
+    async function checkValidationStatus() {
+        const { data: validationStatus } = await getValidationStatus(accountId, {
             validationId,
         });
-        return validationResults;
-    }
-    catch (err) {
-        uiLogger.debug(err);
-        process.exit(EXIT_CODES.ERROR);
+        if (validationStatus === 'REQUESTED') {
+            await new Promise(resolve => setTimeout(resolve, SLEEP_TIME));
+            await checkValidationStatus();
+        }
     }
+    await checkValidationStatus();
+}
+export async function fetchValidationResults(accountId, validationId) {
+    const { data: validationResults } = await getValidationResults(accountId, {
+        validationId,
+    });
+    return validationResults;
 }
-export function processValidationErrors(invalidPathError, validationResults) {
+export function hasProcessValidationErrors(invalidPathError, validationResults) {
     if (validationResults.errors.length) {
         const { assetPath, errors } = validationResults;
         errors.forEach(err => {
@@ -56,11 +37,12 @@ export function processValidationErrors(invalidPathError, validationResults) {
                 uiLogger.error(invalidPathError(assetPath));
             }
             else {
-                uiLogger.error(`${err.context}`);
+                uiLogger.error(err.context);
             }
         });
-        process.exit(EXIT_CODES.ERROR);
+        return true;
     }
+    return false;
 }
 function displayFileInfo(file, line, resultsCopy) {
     if (file) {

package/lib/mcp/__tests__/setup.test.js

@@ -132,23 +132,6 @@ describe('lib/mcp/setup', () => {
             });
             expect(mockedLogError).toHaveBeenCalledWith(error);
         });
-        it('should pass through environment variables in command', async () => {
-            const mockMcpCommandWithEnv = {
-                command: 'test-command',
-                args: ['--arg1'],
-                env: { HUBSPOT_MCP_STANDALONE: 'true' },
-            };
-            mockedExecAsync.mockResolvedValueOnce({
-                stdout: 'codex version 1.0.0',
-                stderr: '',
-            });
-            mockedExecAsync.mockResolvedValueOnce({ stdout: '', stderr: '' });
-            const result = await setupCodex(mockMcpCommandWithEnv);
-            expect(result).toBe(true);
-            // The env is passed through buildCommandWithAgentString, but not used in the command string
-            // This is expected as env vars are set by the client when starting the MCP server
-            expect(mockedExecAsync).toHaveBeenCalledWith('codex mcp add "HubSpotDev" -- test-command --arg1 --ai-agent codex');
-        });
     });
     describe('setupGemini', () => {
         const mockMcpCommand = {

package/lib/mcp/setup.d.ts

@@ -5,7 +5,6 @@ export declare const supportedTools: {
 interface McpCommand {
     command: string;
     args: string[];
-    env?: Record<string, string>;
 }
 export declare function addMcpServerToConfig(targets: string[] | undefined): Promise<string[]>;
 export declare function setupVsCode(mcpCommand?: McpCommand): Promise<boolean>;