@hubspot/cli 8.2.0-experimental.0 → 8.2.0-experimental.2

package/lib/accountTargetDiscovery.js

@@ -0,0 +1,175 @@
+import path from 'path';
+import { getConfigAccountIfExists, getConfigDefaultAccountIfExists, } from '@hubspot/local-dev-lib/config';
+import { getHsSettingsFileIfExists } from '@hubspot/local-dev-lib/config/hsSettings';
+import { ENVIRONMENT_VARIABLES } from '@hubspot/local-dev-lib/constants/config';
+import { getAllHsProfiles, loadHsProfileFile, } from '@hubspot/project-parsing-lib/profiles';
+import { isTestAccountOrSandbox } from './accountTypes.js';
+import { isDirectoryLinked } from './link/linkUtils.js';
+import { lib } from '../lang/en.js';
+import { ACCOUNT_TARGET_CATEGORIES, ACCOUNT_TARGET_SELECTION_SOURCES, } from '../types/AccountTargets.js';
+function categorizeAccount(account) {
+    if (isTestAccountOrSandbox(account)) {
+        return ACCOUNT_TARGET_CATEGORIES.RECOMMENDED_TESTING;
+    }
+    if (!account.accountType) {
+        return ACCOUNT_TARGET_CATEGORIES.UNKNOWN;
+    }
+    return ACCOUNT_TARGET_CATEGORIES.PRODUCTION_WITH_CARE;
+}
+function candidateFromAccount(account, source, profileName) {
+    return {
+        accountId: account.accountId,
+        accountName: account.name,
+        accountType: account.accountType,
+        environment: account.env || undefined,
+        source,
+        category: categorizeAccount(account),
+        ...(profileName ? { profileName } : {}),
+    };
+}
+function candidateFromAccountId(accountId, source, profileName) {
+    const account = getConfigAccountIfExists(accountId);
+    if (account) {
+        return candidateFromAccount(account, source, profileName);
+    }
+    return {
+        accountId,
+        source,
+        category: ACCOUNT_TARGET_CATEGORIES.UNKNOWN,
+        ...(profileName ? { profileName } : {}),
+    };
+}
+function dedupeByAccountId(candidates) {
+    const seen = new Set();
+    return candidates.filter(candidate => {
+        if (seen.has(candidate.accountId)) {
+            return false;
+        }
+        seen.add(candidate.accountId);
+        return true;
+    });
+}
+async function gatherProfileCandidates(projectDir, projectConfig) {
+    const projectSourceDir = path.join(projectDir, projectConfig.srcDir);
+    const profileNames = await getAllHsProfiles(projectSourceDir);
+    const candidates = [];
+    for (const name of profileNames) {
+        let profile;
+        try {
+            profile = loadHsProfileFile(projectSourceDir, name);
+        }
+        catch {
+            continue;
+        }
+        if (profile && profile.accountId) {
+            candidates.push(candidateFromAccountId(profile.accountId, ACCOUNT_TARGET_SELECTION_SOURCES.PROFILE, name));
+        }
+    }
+    return candidates;
+}
+function resolveProfileRecommendation(profileCandidates, explicitProfileName) {
+    if (explicitProfileName) {
+        return profileCandidates.find(candidate => candidate.profileName === explicitProfileName);
+    }
+    if (profileCandidates.length === 1) {
+        return profileCandidates[0];
+    }
+    return undefined;
+}
+function resolveNonProfileRecommendation({ explicitCandidate, envCandidate, linkedCandidates, linkedDefaultAccountId, defaultCandidate, }) {
+    if (explicitCandidate) {
+        return explicitCandidate;
+    }
+    if (envCandidate) {
+        return envCandidate;
+    }
+    if (linkedCandidates.length > 0) {
+        if (linkedDefaultAccountId !== undefined) {
+            const linkedDefault = linkedCandidates.find(candidate => candidate.accountId === linkedDefaultAccountId);
+            if (linkedDefault) {
+                return linkedDefault;
+            }
+        }
+        if (linkedCandidates.length === 1) {
+            return linkedCandidates[0];
+        }
+        return undefined;
+    }
+    return defaultCandidate;
+}
+/**
+ * Discovers the candidate target accounts for a command, plus the recommended
+ * one to use when a single account is the obvious choice.
+ *
+ * Profiles take precedence: when the project defines profiles, the candidates
+ * are the profile accounts only. Otherwise they are ranked explicit account,
+ * then env config, then linked directory, then global default.
+ *
+ * Takes plain options (not yargs argv) and never prompts or exits, so both the
+ * CLI and MCP can call it. `recommended` is omitted when no account is the
+ * obvious choice (for example, several profiles). Throws when an explicit
+ * account is provided but not found in the config.
+ */
+export async function discoverAccountTargets(options = {}) {
+    const { explicitAccount, useEnv, profileName, projectDir, projectConfig } = options;
+    if (projectDir && projectConfig) {
+        const profileCandidates = await gatherProfileCandidates(projectDir, projectConfig);
+        if (profileCandidates.length > 0) {
+            return {
+                candidates: dedupeByAccountId(profileCandidates),
+                recommended: resolveProfileRecommendation(profileCandidates, profileName),
+            };
+        }
+    }
+    const envConfigActive = Boolean(useEnv) ||
+        process.env[ENVIRONMENT_VARIABLES.USE_ENVIRONMENT_HUBSPOT_CONFIG] ===
+            'true';
+    const ordered = [];
+    let explicitCandidate;
+    if (explicitAccount !== undefined && explicitAccount !== '') {
+        const account = getConfigAccountIfExists(explicitAccount);
+        if (!account) {
+            throw new Error(lib.accountTargetDiscovery.errors.explicitAccountNotFound(explicitAccount));
+        }
+        explicitCandidate = candidateFromAccount(account, ACCOUNT_TARGET_SELECTION_SOURCES.EXPLICIT_ACCOUNT);
+        ordered.push(explicitCandidate);
+    }
+    let envCandidate;
+    if (envConfigActive) {
+        const envAccount = getConfigDefaultAccountIfExists();
+        if (envAccount) {
+            envCandidate = candidateFromAccount(envAccount, ACCOUNT_TARGET_SELECTION_SOURCES.ENV_CONFIG);
+            ordered.push(envCandidate);
+        }
+    }
+    const settings = getHsSettingsFileIfExists();
+    const directoryIsLinked = isDirectoryLinked(settings);
+    const linkedCandidates = [];
+    if (directoryIsLinked) {
+        for (const accountId of settings.accounts) {
+            const candidate = candidateFromAccountId(accountId, ACCOUNT_TARGET_SELECTION_SOURCES.LINKED_DIRECTORY);
+            linkedCandidates.push(candidate);
+            ordered.push(candidate);
+        }
+    }
+    let defaultCandidate;
+    if (!envConfigActive) {
+        const defaultAccount = getConfigDefaultAccountIfExists();
+        if (defaultAccount) {
+            defaultCandidate = candidateFromAccount(defaultAccount, ACCOUNT_TARGET_SELECTION_SOURCES.GLOBAL_DEFAULT);
+            ordered.push(defaultCandidate);
+        }
+    }
+    return {
+        candidates: dedupeByAccountId(ordered),
+        recommended: resolveNonProfileRecommendation({
+            explicitCandidate,
+            envCandidate,
+            linkedCandidates,
+            linkedDefaultAccountId: directoryIsLinked
+                ? settings.localDefaultAccount
+                : undefined,
+            defaultCandidate,
+        }),
+    };
+}

package/lib/app/install.d.ts

@@ -0,0 +1,22 @@
+import type { HubSpotConfigAccount } from '@hubspot/local-dev-lib/types/Accounts';
+import type { IntermediateRepresentationNodeLocalDev } from '@hubspot/project-parsing-lib/translate';
+import type { AppInstallationState, AppIRNode } from '../../types/ProjectComponents.js';
+export type ScopeGroup = {
+    id: number;
+    name: string;
+};
+type CanUseStaticAuthTestAccountInstallOptions = {
+    accountConfig?: HubSpotConfigAccount;
+    appNode?: AppIRNode | null;
+    parentAccountId?: number;
+};
+export declare function getAppNodeFromProjectNodes(projectNodes: {
+    [key: string]: IntermediateRepresentationNodeLocalDev;
+}): AppIRNode | null;
+export declare function isStaticAuthApp(appNode?: AppIRNode | null): boolean;
+export declare function isOAuthApp(appNode?: AppIRNode | null): boolean;
+export declare function isPrivateApp(appNode?: AppIRNode | null): boolean;
+export declare function isMarketplaceApp(appNode?: AppIRNode | null): boolean;
+export declare function getAppInstallationState(isInstalledWithScopeGroups: boolean, previouslyAuthorizedScopeGroups: ScopeGroup[]): AppInstallationState;
+export declare function canUseStaticAuthTestAccountInstall({ accountConfig, appNode, parentAccountId, }: CanUseStaticAuthTestAccountInstallOptions): boolean;
+export {};

package/lib/app/install.js

@@ -0,0 +1,42 @@
+import { APP_AUTH_TYPES, APP_DISTRIBUTION_TYPES, APP_INSTALLATION_STATES, } from '../constants.js';
+import { isDeveloperTestAccount, isSandbox } from '../accountTypes.js';
+import { isAppIRNode } from '../projects/structure.js';
+export function getAppNodeFromProjectNodes(projectNodes) {
+    return Object.values(projectNodes).find(isAppIRNode) || null;
+}
+export function isStaticAuthApp(appNode) {
+    return appNode?.config.auth.type.toLowerCase() === APP_AUTH_TYPES.STATIC;
+}
+export function isOAuthApp(appNode) {
+    return appNode?.config.auth.type.toLowerCase() === APP_AUTH_TYPES.OAUTH;
+}
+export function isPrivateApp(appNode) {
+    return (appNode?.config.distribution?.toLowerCase() ===
+        APP_DISTRIBUTION_TYPES.PRIVATE);
+}
+export function isMarketplaceApp(appNode) {
+    return (appNode?.config.distribution?.toLowerCase() ===
+        APP_DISTRIBUTION_TYPES.MARKETPLACE);
+}
+export function getAppInstallationState(isInstalledWithScopeGroups, previouslyAuthorizedScopeGroups) {
+    if (isInstalledWithScopeGroups) {
+        return APP_INSTALLATION_STATES.INSTALLED;
+    }
+    if (previouslyAuthorizedScopeGroups.length > 0) {
+        return APP_INSTALLATION_STATES.INSTALLED_WITH_OUTDATED_SCOPES;
+    }
+    return APP_INSTALLATION_STATES.NOT_INSTALLED;
+}
+export function canUseStaticAuthTestAccountInstall({ accountConfig, appNode, parentAccountId, }) {
+    if (!accountConfig || !isStaticAuthApp(appNode)) {
+        return false;
+    }
+    const accountCanUseTestInstall = isDeveloperTestAccount(accountConfig) || isSandbox(accountConfig);
+    if (!accountCanUseTestInstall) {
+        return false;
+    }
+    if (parentAccountId === undefined) {
+        return true;
+    }
+    return accountConfig.parentAccountId === parentAccountId;
+}

package/lib/app/logs.js

@@ -46,7 +46,7 @@ export function parseSinceTime(sinceInput) {
             endTime: now.valueOf(),
         };
     }
-    const isoTime = moment(sinceInput);
+    const isoTime = moment(sinceInput, moment.ISO_8601, true);
     if (isoTime.isValid()) {
         return {
             startTime: isoTime.valueOf(),

package/lib/auth/awaitPersonalAccessKeyOverWebsocket.js

@@ -3,7 +3,7 @@ import { randomUUID } from 'crypto';
 import open from 'open';
 import { getHubSpotWebsiteOrigin } from '@hubspot/local-dev-lib/urls';
 import CLIWebSocketServer from '../CLIWebSocketServer.js';
-import { ACCOUNT_AUTH_UI_MESSAGE_SEND_TYPES, ACCOUNT_AUTH_UI_MESSAGE_RECEIVE_TYPES, ACCOUNT_AUTH_WEBSOCKET_SERVER_VERSION, } from '../constants.js';
+import { ACCOUNT_AUTH_UI_MESSAGE_RECEIVE_TYPES, ACCOUNT_AUTH_UI_MESSAGE_SEND_TYPES, ACCOUNT_AUTH_WEBSOCKET_SERVER_VERSION, } from '../constants.js';
 import { personalAccessKeyPrompt } from '../prompts/personalAccessKeyPrompt.js';
 import SpinniesManager from '../ui/SpinniesManager.js';
 import { uiLogger } from '../ui/logger.js';
@@ -55,7 +55,8 @@ function createMessageHandler(server, cliCallbackToken, resolveWebsocketPak) {
 }
 async function awaitKeypressOrWebsocketPak(websocketPakPromise) {
     if (!process.stdin.isTTY) {
-        return { type: 'keypress' };
+        const pak = await websocketPakPromise;
+        return { type: 'pak', pak };
     }
     SpinniesManager.init();
     SpinniesManager.add(SPINNER_ID, {

package/lib/doctor/Doctor.d.ts

@@ -17,6 +17,7 @@ export declare class Doctor {
     private checkIfNodeIsInstalled;
     private checkIfNpmIsInstalled;
     private checkCLIVersion;
+    private checkMcpReadiness;
     private checkIfNpmInstallRequired;
     private isValidJsonFile;
     private checkProjectConfigJsonFiles;

package/lib/doctor/Doctor.js

@@ -23,6 +23,8 @@ import { pkg } from '../jsonLoader.js';
 import { lib } from '../../lang/en.js';
 import { uiLink } from '../ui/index.js';
 import { isServerRunningAtUrl } from '../http.js';
+import { detectConfiguredMcpClients } from '../mcp/promotion.js';
+import { MCP_CLIENTS } from '../mcp/clients.js';
 import { WEBHOOKS_KEY, APP_KEY } from '@hubspot/project-parsing-lib/constants';
 import { validateProjectConfig } from '../projects/config.js';
 import { validateSourceDirectory, handleTranslate, } from '../projects/upload.js';
@@ -73,6 +75,7 @@ export class Doctor {
             this.checkIfNodeIsInstalled(),
             this.checkIfNpmIsInstalled(),
             this.checkCLIVersion(),
+            this.checkMcpReadiness(),
         ];
     }
     performNetworkingChecks() {
@@ -252,6 +255,29 @@ export class Doctor {
             });
         }
     }
+    async checkMcpReadiness() {
+        try {
+            const configuredClients = detectConfiguredMcpClients();
+            const allClientIds = MCP_CLIENTS.map(c => c.id);
+            const unconfiguredClients = allClientIds.filter(id => !configuredClients.includes(id));
+            if (configuredClients.length > 0) {
+                this.diagnosis?.addCliSection({
+                    type: 'success',
+                    message: lib.doctor.mcpChecks.configured(configuredClients),
+                });
+            }
+            if (unconfiguredClients.length > 0) {
+                this.diagnosis?.addCliSection({
+                    type: 'warning',
+                    message: lib.doctor.mcpChecks.notConfigured(unconfiguredClients),
+                    secondaryMessaging: lib.doctor.mcpChecks.notConfiguredSecondary,
+                });
+            }
+        }
+        catch (e) {
+            uiLogger.debug(getErrorMessage(e));
+        }
+    }
     async checkIfNpmInstallRequired() {
         let foundError = false;
         for (const packageFile of this.diagnosticInfo?.packageFiles || []) {

package/lib/mcp/clients.d.ts

@@ -0,0 +1,13 @@
+export declare const MCP_SERVER_NAME = "HubSpotDev";
+export type McpClientId = 'codex' | 'claude' | 'cursor' | 'gemini' | 'vscode' | 'windsurf';
+type McpClientDetection = {
+    type: 'json' | 'text';
+    pathSegments: string[];
+};
+export type McpClient = {
+    id: McpClientId;
+    detection: McpClientDetection;
+};
+export declare const MCP_CLIENTS: McpClient[];
+export declare function getMcpClientPathSegments(id: McpClientId): string[];
+export {};

package/lib/mcp/clients.js

@@ -0,0 +1,55 @@
+export const MCP_SERVER_NAME = 'HubSpotDev';
+function getVsCodeMcpConfigPathSegments() {
+    if (process.platform === 'darwin') {
+        return ['Library', 'Application Support', 'Code', 'User', 'mcp.json'];
+    }
+    if (process.platform === 'win32') {
+        return ['AppData', 'Roaming', 'Code', 'User', 'mcp.json'];
+    }
+    return ['.config', 'Code', 'User', 'mcp.json'];
+}
+export const MCP_CLIENTS = [
+    {
+        id: 'codex',
+        detection: {
+            type: 'text',
+            pathSegments: ['.codex', 'config.toml'],
+        },
+    },
+    {
+        id: 'claude',
+        detection: { type: 'json', pathSegments: ['.claude.json'] },
+    },
+    {
+        id: 'cursor',
+        detection: { type: 'json', pathSegments: ['.cursor', 'mcp.json'] },
+    },
+    {
+        id: 'gemini',
+        detection: {
+            type: 'json',
+            pathSegments: ['.gemini', 'settings.json'],
+        },
+    },
+    {
+        id: 'vscode',
+        detection: {
+            type: 'json',
+            pathSegments: getVsCodeMcpConfigPathSegments(),
+        },
+    },
+    {
+        id: 'windsurf',
+        detection: {
+            type: 'json',
+            pathSegments: ['.codeium', 'windsurf', 'mcp_config.json'],
+        },
+    },
+];
+export function getMcpClientPathSegments(id) {
+    const client = MCP_CLIENTS.find(c => c.id === id);
+    if (!client) {
+        return [];
+    }
+    return client.detection.pathSegments;
+}

package/lib/mcp/promotion.d.ts

@@ -0,0 +1,3 @@
+export declare function detectConfiguredMcpClients(): string[];
+export declare function shouldShowMcpPromotion(): Promise<boolean>;
+export declare function showMcpPromotionNudge(commandName: string): Promise<void>;

package/lib/mcp/promotion.js

@@ -0,0 +1,109 @@
+import fs from 'fs-extra';
+import os from 'os';
+import path from 'path';
+import { getStateValue, setStateValue, } from '@hubspot/local-dev-lib/config/state';
+import { STATE_FLAGS } from '@hubspot/local-dev-lib/constants/config';
+import { commands } from '../../lang/en.js';
+import { debugError } from '../errorHandlers/index.js';
+import { uiLogger } from '../ui/logger.js';
+import { trackMcpPromotionShown } from '../usageTracking.js';
+import { MCP_CLIENTS, MCP_SERVER_NAME } from './clients.js';
+const ONE_WEEK_IN_MS = 7 * 24 * 60 * 60 * 1000;
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function configContainsMcpServer(value) {
+    if (typeof value === 'string') {
+        return value === MCP_SERVER_NAME;
+    }
+    if (Array.isArray(value)) {
+        return value.some(configContainsMcpServer);
+    }
+    if (!isRecord(value)) {
+        return false;
+    }
+    return Object.entries(value).some(([key, childValue]) => {
+        return key === MCP_SERVER_NAME || configContainsMcpServer(childValue);
+    });
+}
+function textConfigContainsMcpServer(configContent) {
+    return configContent.includes(MCP_SERVER_NAME);
+}
+function jsonConfigContainsMcpServer(configContent) {
+    const parsedConfig = JSON.parse(configContent);
+    return configContainsMcpServer(parsedConfig);
+}
+export function detectConfiguredMcpClients() {
+    const homeDirectory = os.homedir();
+    return MCP_CLIENTS.reduce((clients, client) => {
+        try {
+            const configPath = path.join(homeDirectory, ...client.detection.pathSegments);
+            if (!fs.existsSync(configPath)) {
+                return clients;
+            }
+            const configContent = fs.readFileSync(configPath, 'utf8');
+            const hasMcpServer = client.detection.type === 'json'
+                ? jsonConfigContainsMcpServer(configContent)
+                : textConfigContainsMcpServer(configContent);
+            if (hasMcpServer) {
+                clients.push(client.id);
+            }
+        }
+        catch (e) {
+            debugError(e);
+            return clients;
+        }
+        return clients;
+    }, []);
+}
+function isScriptSafeSuppressed() {
+    return Boolean(process.env.CI || process.env.HUBSPOT_MCP_AI_AGENT || !process.stdout.isTTY);
+}
+function hasRecentPromotion(lastShownAt, now, cooldownMs) {
+    if (!lastShownAt) {
+        return false;
+    }
+    const lastShownTime = new Date(lastShownAt).getTime();
+    if (Number.isNaN(lastShownTime)) {
+        return false;
+    }
+    return now.getTime() - lastShownTime < cooldownMs;
+}
+function getMcpPromotionLastShownAt() {
+    return getStateValue(STATE_FLAGS.MCP_PROMOTION_LAST_SHOWN_AT);
+}
+export async function shouldShowMcpPromotion() {
+    if (isScriptSafeSuppressed()) {
+        return false;
+    }
+    try {
+        const mcpTotalToolCalls = getStateValue(STATE_FLAGS.MCP_TOTAL_TOOL_CALLS);
+        if (typeof mcpTotalToolCalls === 'number' && mcpTotalToolCalls > 0) {
+            return false;
+        }
+        if (detectConfiguredMcpClients().length > 0) {
+            return false;
+        }
+        return !hasRecentPromotion(getMcpPromotionLastShownAt(), new Date(), ONE_WEEK_IN_MS);
+    }
+    catch (e) {
+        debugError(e);
+        return false;
+    }
+}
+function setMcpPromotionShownAt() {
+    setStateValue(STATE_FLAGS.MCP_PROMOTION_LAST_SHOWN_AT, new Date().toISOString());
+}
+export async function showMcpPromotionNudge(commandName) {
+    try {
+        if (!(await shouldShowMcpPromotion())) {
+            return;
+        }
+        setMcpPromotionShownAt();
+        uiLogger.info(commands.mcp.promotion.activeNudge);
+        await trackMcpPromotionShown(commandName || undefined);
+    }
+    catch (e) {
+        debugError(e);
+    }
+}

package/lib/mcp/setup.d.ts

@@ -1,13 +1,14 @@
+import { McpClientId } from './clients.js';
 export declare const supportedTools: {
     name: string;
-    value: string;
+    value: McpClientId;
 }[];
 interface McpCommand {
     command: string;
     args: string[];
     env?: Record<string, string>;
 }
-export declare function addMcpServerToConfig(targets: string[] | undefined): Promise<string[]>;
+export declare function configureMcpServer(targets: string[] | undefined): Promise<string[]>;
 export declare function setupVsCode(mcpCommand?: McpCommand): Promise<boolean>;
 export declare function setupClaudeCode(mcpCommand?: McpCommand): Promise<boolean>;
 export declare function setupCursor(mcpCommand?: McpCommand): boolean;

package/lib/mcp/setup.js

@@ -4,30 +4,35 @@ import { promptUser } from '../prompts/promptUtils.js';
 import SpinniesManager from '../ui/SpinniesManager.js';
 import { logError, getErrorMessage } from '../errorHandlers/index.js';
 import { execAsync } from '../../mcp-server/utils/command.js';
+import { MCP_CLIENTS, MCP_SERVER_NAME, getMcpClientPathSegments, } from './clients.js';
 import path from 'path';
 import os from 'os';
 import fs from 'fs-extra';
 import { existsSync } from 'fs';
-const mcpServerName = 'HubSpotDev';
+const mcpServerName = MCP_SERVER_NAME;
 const claudeCode = 'claude';
 const windsurf = 'windsurf';
 const cursor = 'cursor';
 const vscode = 'vscode';
 const codex = 'codex';
 const gemini = 'gemini';
-export const supportedTools = [
-    { name: commands.mcp.setup.codex, value: codex },
-    { name: commands.mcp.setup.claudeCode, value: claudeCode },
-    { name: commands.mcp.setup.cursor, value: cursor },
-    { name: commands.mcp.setup.gemini, value: gemini },
-    { name: commands.mcp.setup.vsCode, value: vscode },
-    { name: commands.mcp.setup.windsurf, value: windsurf },
-];
+const clientLabels = {
+    codex: commands.mcp.setup.codex,
+    claude: commands.mcp.setup.claudeCode,
+    cursor: commands.mcp.setup.cursor,
+    gemini: commands.mcp.setup.gemini,
+    vscode: commands.mcp.setup.vsCode,
+    windsurf: commands.mcp.setup.windsurf,
+};
+export const supportedTools = MCP_CLIENTS.map(client => ({
+    name: clientLabels[client.id],
+    value: client.id,
+}));
 const defaultMcpCommand = {
     command: 'hs',
     args: ['mcp', 'start'],
 };
-export async function addMcpServerToConfig(targets) {
+export async function configureMcpServer(targets) {
     try {
         let derivedTargets = [];
         if (!targets || targets.length === 0) {
@@ -247,7 +252,7 @@ export async function setupClaudeCode(mcpCommand = defaultMcpCommand) {
     }
 }
 export function setupCursor(mcpCommand = defaultMcpCommand) {
-    const cursorConfigPath = path.join(os.homedir(), '.cursor', 'mcp.json');
+    const cursorConfigPath = path.join(os.homedir(), ...getMcpClientPathSegments(cursor));
     return setupMcpConfigFile({
         configPath: cursorConfigPath,
         configuringMessage: commands.mcp.setup.spinners.configuringCursor,
@@ -257,7 +262,7 @@ export function setupCursor(mcpCommand = defaultMcpCommand) {
     });
 }
 export function setupWindsurf(mcpCommand = defaultMcpCommand) {
-    const windsurfConfigPath = path.join(os.homedir(), '.codeium', 'windsurf', 'mcp_config.json');
+    const windsurfConfigPath = path.join(os.homedir(), ...getMcpClientPathSegments(windsurf));
     return setupMcpConfigFile({
         configPath: windsurfConfigPath,
         configuringMessage: commands.mcp.setup.spinners.configuringWindsurf,

package/lib/projects/installApp.d.ts

@@ -0,0 +1,58 @@
+import type { HubSpotConfigAccount } from '@hubspot/local-dev-lib/types/Accounts';
+import type { AppInstallationState, AppIRNode } from '../../types/ProjectComponents.js';
+import type { ProjectConfig } from '../../types/Projects.js';
+import { type ScopeGroup } from '../app/install.js';
+export type AppInstallationData = {
+    appId?: number;
+    isInstalledWithScopeGroups: boolean;
+    previouslyAuthorizedScopeGroups: ScopeGroup[];
+};
+export type AppMetadata = {
+    appId: number;
+    scopeGroupIds: number[];
+    ownerPortalId: number;
+};
+type ConfirmInstallAppOptions = {
+    appName: string;
+    targetAccountId: number;
+    force: boolean;
+    needsReinstall: boolean;
+};
+type InstallStaticAuthAppOptions = {
+    appId: number;
+    appNode: AppIRNode;
+    appName: string;
+    targetAccountId: number;
+    targetAccountConfig?: HubSpotConfigAccount;
+    projectId: number;
+    projectName: string;
+    scopeGroupIds: number[];
+    ownerPortalId: number;
+    installationState: AppInstallationState;
+    formatOutputAsJson: boolean;
+};
+type UploadAndDeployOptions = {
+    accountId: number;
+    projectConfig: ProjectConfig;
+    projectDir: string;
+    profile: string | undefined;
+    force: boolean;
+    formatOutputAsJson: boolean;
+};
+export declare function resolveProjectAccountId(derivedAccountId: number, projectConfig: ProjectConfig, projectDir: string, profileOption: string | undefined, useEnvOption: boolean): Promise<{
+    accountId: number;
+    profileName?: string;
+} | null>;
+export declare function loadInstallableAppNode(projectConfig: ProjectConfig, projectDir: string, accountId: number): Promise<AppIRNode | null>;
+export declare function resolveValidInstallAccount(targetAccountId: number, force: boolean, formatOutputAsJson: boolean): Promise<number | null>;
+export declare function resolveProjectId(options: UploadAndDeployOptions): Promise<number | null>;
+export declare function resolveAppMetadata(options: UploadAndDeployOptions & {
+    appId: number | undefined;
+    projectId: number;
+    appUid: string;
+    appName: string;
+}): Promise<AppMetadata | null>;
+export declare function fetchProjectAppInstallationData(targetAccountId: number, projectId: number, appNode: AppIRNode, projectConfig: ProjectConfig): Promise<AppInstallationData | null>;
+export declare function confirmInstallAppAction({ appName, targetAccountId, force, needsReinstall, }: ConfirmInstallAppOptions): Promise<boolean>;
+export declare function installStaticAuthAppForAccount({ appId, appNode, appName, targetAccountId, targetAccountConfig, projectId, projectName, scopeGroupIds, ownerPortalId, installationState, formatOutputAsJson, }: InstallStaticAuthAppOptions): Promise<boolean>;
+export {};