@hubspot/cli 8.12.0 → 8.13.0

package/commands/config/set.js

@@ -2,6 +2,7 @@ import { promptUser } from '../../lib/prompts/promptUtils.js';
 import { EXIT_CODES } from '../../lib/enums/exitCodes.js';
 import { setDefaultCmsPublishMode, setHttpTimeout, setAllowUsageTracking, setAllowAutoUpdates, setAutoOpenBrowser, } from '../../lib/configOptions.js';
 import { makeWrappedYargsHandler } from '../../lib/yargs/makeWrappedYargsHandler.js';
+import { trackCommandMetadataUsage } from '../../lib/usageTracking.js';
 import { commands } from '../../lang/en.js';
 import { makeYargsBuilder, strictEnforceBoolean, } from '../../lib/yargsUtils.js';
 import { logError } from '../../lib/errorHandlers/index.js';
@@ -30,21 +31,39 @@ async function selectOptions() {
 }
 async function handleConfigUpdate(accountId, args) {
     const { allowAutoUpdates, allowUsageTracking, defaultCmsPublishMode, httpTimeout, autoOpenBrowser, } = args;
+    // Emit one metadata event per setting so each field:value pair surfaces as its
+    // own entry in Amplitude instead of a combined string that fragments the charts.
+    const trackingRequests = [];
+    const trackAction = (action) => {
+        trackingRequests.push(trackCommandMetadataUsage('config-set', { action }, accountId));
+    };
     if (allowAutoUpdates !== undefined) {
-        await setAllowAutoUpdates({ allowAutoUpdates, accountId });
+        const value = await setAllowAutoUpdates({ allowAutoUpdates, accountId });
+        trackAction(`allowAutoUpdates:${value}`);
     }
     if (allowUsageTracking !== undefined) {
-        await setAllowUsageTracking({ allowUsageTracking, accountId });
+        const value = await setAllowUsageTracking({
+            allowUsageTracking,
+            accountId,
+        });
+        trackAction(`allowUsageTracking:${value}`);
     }
     if (autoOpenBrowser !== undefined) {
-        await setAutoOpenBrowser({ autoOpenBrowser, accountId });
+        const value = await setAutoOpenBrowser({ autoOpenBrowser, accountId });
+        trackAction(`autoOpenBrowser:${value}`);
     }
     if (defaultCmsPublishMode !== undefined) {
-        await setDefaultCmsPublishMode({ defaultCmsPublishMode, accountId });
+        const value = await setDefaultCmsPublishMode({
+            defaultCmsPublishMode,
+            accountId,
+        });
+        trackAction(`defaultCmsPublishMode:${value}`);
     }
     if (httpTimeout !== undefined) {
-        await setHttpTimeout({ httpTimeout, accountId });
+        const value = await setHttpTimeout({ httpTimeout, accountId });
+        trackAction(`httpTimeout:${value}`);
     }
+    await Promise.all(trackingRequests);
 }
 async function handler(args) {
     const { derivedAccountId, allowAutoUpdates, allowUsageTracking, defaultCmsPublishMode, httpTimeout, autoOpenBrowser, exit, } = args;

package/commands/customObject/createSchema.js

@@ -1,8 +1,7 @@
 import { uiLogger } from '../../lib/ui/logger.js';
-import { getConfigAccountEnvironment } from '@hubspot/local-dev-lib/config';
 import { getAbsoluteFilePath } from '@hubspot/local-dev-lib/path';
 import { createObjectSchema } from '@hubspot/local-dev-lib/api/customObjects';
-import { getHubSpotWebsiteOrigin } from '@hubspot/local-dev-lib/urls';
+import { getHubSpotWebsiteOriginByAccountId } from '@hubspot/local-dev-lib/urls';
 import { logError } from '../../lib/errorHandlers/index.js';
 import { checkAndConvertToJson } from '../../lib/validation.js';
 import { commands } from '../../lang/en.js';
@@ -22,7 +21,7 @@ async function handler(args) {
     }
     try {
         const { data } = await createObjectSchema(derivedAccountId, schemaJson);
-        uiLogger.success(commands.customObject.subcommands.createSchema.success.schemaViewable(`${getHubSpotWebsiteOrigin(getConfigAccountEnvironment(derivedAccountId))}/contacts/${derivedAccountId}/objects/${data.objectTypeId}`));
+        uiLogger.success(commands.customObject.subcommands.createSchema.success.schemaViewable(`${getHubSpotWebsiteOriginByAccountId(derivedAccountId)}/contacts/${derivedAccountId}/objects/${data.objectTypeId}`));
     }
     catch (e) {
         logError(e, { accountId: derivedAccountId });

package/commands/customObject/updateSchema.js

@@ -1,8 +1,7 @@
 import { fetchObjectSchemas, updateObjectSchema, } from '@hubspot/local-dev-lib/api/customObjects';
 import { uiLogger } from '../../lib/ui/logger.js';
 import { getAbsoluteFilePath } from '@hubspot/local-dev-lib/path';
-import { getConfigAccountEnvironment } from '@hubspot/local-dev-lib/config';
-import { getHubSpotWebsiteOrigin } from '@hubspot/local-dev-lib/urls';
+import { getHubSpotWebsiteOriginByAccountId } from '@hubspot/local-dev-lib/urls';
 import { listPrompt } from '../../lib/prompts/promptUtils.js';
 import { logError } from '../../lib/errorHandlers/index.js';
 import { checkAndConvertToJson } from '../../lib/validation.js';
@@ -32,7 +31,7 @@ async function handler(args) {
                     choices: schemaNames,
                 });
         const { data } = await updateObjectSchema(derivedAccountId, name, schemaJson);
-        uiLogger.success(commands.customObject.subcommands.updateSchema.success.viewAtUrl(`${getHubSpotWebsiteOrigin(getConfigAccountEnvironment(derivedAccountId))}/contacts/${derivedAccountId}/objects/${data.objectTypeId}`));
+        uiLogger.success(commands.customObject.subcommands.updateSchema.success.viewAtUrl(`${getHubSpotWebsiteOriginByAccountId(derivedAccountId)}/contacts/${derivedAccountId}/objects/${data.objectTypeId}`));
     }
     catch (e) {
         logError(e, { accountId: derivedAccountId });

package/commands/hubdb/list.js

@@ -2,11 +2,12 @@ import { fetchTables } from '@hubspot/local-dev-lib/api/hubdb';
 import { makeWrappedYargsHandler } from '../../lib/yargs/makeWrappedYargsHandler.js';
 import { EXIT_CODES } from '../../lib/enums/exitCodes.js';
 import { uiLogger } from '../../lib/ui/logger.js';
+import { uiLine } from '../../lib/ui/index.js';
 import { logError } from '../../lib/errorHandlers/index.js';
 import { commands } from '../../lang/en.js';
 import { makeYargsBuilder } from '../../lib/yargsUtils.js';
 import { renderTable } from '../../ui/render.js';
-import { getBaseHubSpotUrlForAccount } from '../../lib/projects/urls.js';
+import { getHubSpotWebsiteOriginByAccountId } from '@hubspot/local-dev-lib/urls';
 const command = ['list', 'ls'];
 const describe = commands.hubdb.subcommands.list.describe;
 async function getTableData(accountId) {
@@ -44,22 +45,20 @@ async function handler(args) {
         commands.hubdb.subcommands.list.labels.rows,
     ];
     uiLogger.success(commands.hubdb.subcommands.list.success(derivedAccountId));
-    uiLogger.log(' ');
-    // link devs to the hubdb page in hubspot for easy access
-    const baseUrl = getBaseHubSpotUrlForAccount(derivedAccountId);
-    uiLogger.log(commands.hubdb.subcommands.list.viewTablesLink(baseUrl, derivedAccountId));
     // don't bother showing an empty list of tables
     if (tables.length > 0) {
+        uiLogger.log(commands.hubdb.subcommands.list.tables);
+        renderTable(tableHeader, tableUIData);
         // if truncated is 0, it will be interpreted as falsy
         const truncated = total - tables.length;
+        uiLine();
         uiLogger.log(commands.hubdb.subcommands.list.tablesDisplayed(tables.length, total, truncated));
-        uiLogger.log('--------------------------------');
-        uiLogger.log(commands.hubdb.subcommands.list.tables);
-        renderTable(tableHeader, tableUIData);
     }
     else {
         uiLogger.log(commands.hubdb.subcommands.list.noTables(derivedAccountId));
     }
+    // link devs to the hubdb page in hubspot for easy access
+    uiLogger.log(commands.hubdb.subcommands.list.viewTablesLink(getHubSpotWebsiteOriginByAccountId(derivedAccountId), derivedAccountId));
     return exit(EXIT_CODES.SUCCESS);
 }
 function hubdbListBuilder(yargs) {

package/commands/project/listBuilds.d.ts

@@ -1,5 +1,5 @@
 import { CommonArgs, ConfigArgs, AccountArgs, EnvironmentArgs, YargsCommandModule } from '../../types/Yargs.js';
-type ProjectListBuildsArgs = CommonArgs & ConfigArgs & AccountArgs & EnvironmentArgs & {
+export type ProjectListBuildsArgs = CommonArgs & ConfigArgs & AccountArgs & EnvironmentArgs & {
     project?: string;
     limit?: number;
 };

package/commands/project/listBuilds.js

@@ -17,12 +17,6 @@ const describe = commands.project.listBuilds.describe;
 async function fetchAndDisplayBuilds(accountId, project, options) {
     const { data: { results, paging }, } = await fetchProjectBuilds(accountId, project.name, options);
     const currentDeploy = project.deployedBuildId;
-    if (options && options.after) {
-        uiLogger.log(commands.project.listBuilds.showingNextBuilds(results.length, project.name));
-    }
-    else {
-        uiLogger.log(commands.project.listBuilds.showingRecentBuilds(results.length, project.name, uiLink(commands.project.listBuilds.viewAllBuildsLink, getProjectDetailUrl(project.name, accountId))));
-    }
     if (results.length === 0) {
         uiLogger.log(commands.project.listBuilds.errors.noBuilds);
     }
@@ -46,6 +40,14 @@ async function fetchAndDisplayBuilds(accountId, project, options) {
         });
         renderTable(['Build ID', 'Status', 'Completed', 'Duration', 'Details'], builds);
     }
+    if (options && options.after) {
+        if (results.length > 0) {
+            uiLogger.log(commands.project.listBuilds.showingNextBuilds(results.length, project.name));
+        }
+    }
+    else {
+        uiLogger.log(commands.project.listBuilds.showingRecentBuilds(results.length, project.name, uiLink(commands.project.listBuilds.viewAllBuildsLink, getProjectDetailUrl(project.name, accountId))));
+    }
     if (paging && paging.next) {
         await promptUser({
             name: 'more',

package/commands/project/logs.js

@@ -1,5 +1,4 @@
-import { getConfigAccountEnvironment } from '@hubspot/local-dev-lib/config';
-import { getHubSpotWebsiteOrigin } from '@hubspot/local-dev-lib/urls';
+import { getHubSpotWebsiteOriginByAccountId } from '@hubspot/local-dev-lib/urls';
 import { logError } from '../../lib/errorHandlers/index.js';
 import { uiLine } from '../../lib/ui/index.js';
 import { projectLogsPrompt } from '../../lib/prompts/projectsLogsPrompt.js';
@@ -11,8 +10,7 @@ import { makeWrappedYargsHandler } from '../../lib/yargs/makeWrappedYargsHandler
 import { makeYargsBuilder } from '../../lib/yargsUtils.js';
 import { renderTable } from '../../ui/render.js';
 function getPrivateAppsUrl(accountId) {
-    const baseUrl = getHubSpotWebsiteOrigin(getConfigAccountEnvironment(accountId));
-    return `${baseUrl}/private-apps/${accountId}`;
+    return `${getHubSpotWebsiteOriginByAccountId(accountId)}/private-apps/${accountId}`;
 }
 function logPreamble() {
     if (ProjectLogsManager.isPublicFunction) {

package/commands/project/release/list.js

@@ -18,7 +18,6 @@ const describe = undefined;
 const verboseDescribe = undefined;
 async function fetchAndDisplayReleases(accountId, projectName, options) {
     const { data: { results, paging }, } = await listReleases(accountId, projectName, options);
-    uiLogger.log(commands.project.release.list.showingReleases(results.length, projectName));
     if (results.length === 0) {
         uiLogger.log(commands.project.release.list.noReleases);
     }
@@ -29,6 +28,7 @@ async function fetchAndDisplayReleases(accountId, projectName, options) {
             new Date(release.createdAt).toLocaleString(),
         ]);
         renderTable(['Release', 'Build', 'Created'], rows);
+        uiLogger.log(commands.project.release.list.showingReleases(results.length, projectName));
     }
     if (paging?.next?.after) {
         await promptUser({

package/commands/sandbox/delete.js

@@ -2,8 +2,7 @@ import { uiLogger } from '../../lib/ui/logger.js';
 import { isSpecifiedError } from '@hubspot/local-dev-lib/errors/index';
 import { deleteSandbox } from '@hubspot/local-dev-lib/api/sandboxHubs';
 import { getConfigAccountEnvironment, removeAccountFromConfig, setConfigAccountAsDefault, getAllConfigAccounts, getConfigAccountIfExists, getConfigDefaultAccountIfExists, } from '@hubspot/local-dev-lib/config';
-import { getHubSpotWebsiteOrigin } from '@hubspot/local-dev-lib/urls';
-import { getValidEnv } from '@hubspot/local-dev-lib/environment';
+import { getHubSpotWebsiteOriginByAccountId } from '@hubspot/local-dev-lib/urls';
 import { logError, debugError } from '../../lib/errorHandlers/index.js';
 import { commands } from '../../lang/en.js';
 import { deleteSandboxPrompt } from '../../lib/prompts/sandboxesPrompt.js';
@@ -43,7 +42,7 @@ async function handler(args) {
     const sandboxAccountId = sandboxAccount.accountId;
     const defaultAccount = getConfigDefaultAccountIfExists();
     const isDefaultAccount = sandboxAccountId === defaultAccount?.accountId;
-    const baseUrl = getHubSpotWebsiteOrigin(getValidEnv(getConfigAccountEnvironment(sandboxAccountId)));
+    const baseUrl = getHubSpotWebsiteOriginByAccountId(sandboxAccountId);
     let parentAccountId;
     const accountsList = getAllConfigAccounts() || [];
     for (const portal of accountsList) {

package/lang/en.d.ts

@@ -1325,9 +1325,11 @@ export declare const commands: {
             codex: string;
             claudeCode: string;
             cursor: string;
+            devin: string;
             gemini: string;
-            windsurf: string;
+            opencode: string;
             vsCode: string;
+            other: string;
             args: {
                 client: string;
                 standalone: string;
@@ -1362,15 +1364,25 @@ export declare const commands: {
                 geminiNotFound: string;
                 geminiInstallFailed: string;
                 alreadyInstalled: string;
-                configuringWindsurf: string;
-                windsurfNotFound: string;
-                failedToConfigureWindsurf: string;
-                configuredWindsurf: string;
+                configuringDevin: string;
+                devinNotFound: string;
+                failedToConfigureDevin: string;
+                configuredDevin: string;
+                configuringOpenCode: string;
+                openCodeNotFound: string;
+                openCodeInstallFailed: string;
+                configuredOpenCode: string;
                 configuringVsCode: string;
                 failedToConfigureVsCode: string;
                 configuredVsCode: string;
                 vsCodeNotFound: string;
             };
+            otherInstructions: {
+                header: string;
+                docsNote: string;
+                commandLabel: string;
+                jsonLabel: string;
+            };
             prompts: {
                 targets: string;
                 targetsRequired: string;

package/lang/en.js

@@ -1334,9 +1334,11 @@ export const commands = {
             codex: 'Codex CLI',
             claudeCode: 'Claude Code',
             cursor: 'Cursor',
+            devin: 'Devin',
             gemini: 'Gemini CLI',
-            windsurf: 'Windsurf',
+            opencode: 'OpenCode',
             vsCode: 'VSCode',
+            other: 'Other (manual setup)',
             args: {
                 client: 'Target apps to configure',
                 standalone: 'Use npx for all of the hs commands run by the MCP server. This allows you to use the MCP server without having the CLI globally installed.',
@@ -1375,17 +1377,28 @@ export const commands = {
                 geminiNotFound: "Gemini CLI is not installed (missing 'gemini' command). Install it and re-run hs mcp setup.",
                 geminiInstallFailed: 'Failed to configure Gemini CLI',
                 alreadyInstalled: 'HubSpot CLI mcp server already installed, reinstalling',
-                // Windsurf
-                configuringWindsurf: 'Configuring Windsurf...',
-                windsurfNotFound: 'Windsurf is not installed. Install it and re-run hs mcp setup.',
-                failedToConfigureWindsurf: 'Failed to configure Windsurf',
-                configuredWindsurf: 'Configured Windsurf',
+                // Devin
+                configuringDevin: 'Configuring Devin...',
+                devinNotFound: 'Devin is not installed. Install it and re-run hs mcp setup.',
+                failedToConfigureDevin: 'Failed to configure Devin',
+                configuredDevin: 'Configured Devin',
+                // OpenCode
+                configuringOpenCode: 'Configuring OpenCode...',
+                openCodeNotFound: "OpenCode is not installed (missing 'opencode' command). Install it and re-run hs mcp setup.",
+                openCodeInstallFailed: 'Failed to configure OpenCode',
+                configuredOpenCode: 'Configured OpenCode',
                 // VS Code
                 configuringVsCode: 'Configuring VSCode...',
                 failedToConfigureVsCode: 'Failed to configure VSCode',
                 configuredVsCode: 'Configured VSCode',
                 vsCodeNotFound: "VSCode CLI is not installed (missing 'code' command). Install it and re-run hs mcp setup.",
             },
+            otherInstructions: {
+                header: 'To connect the HubSpot MCP server to another tool, add the following MCP server configuration.',
+                docsNote: "Each tool handles MCP setup differently. Check your tool's documentation for how to add an MCP server using a command or JSON config.",
+                commandLabel: 'Command:',
+                jsonLabel: 'JSON configuration (for tools that use a config file):',
+            },
             prompts: {
                 targets: '[--client] Which tools would you like to add the HubSpot CLI MCP server to?',
                 targetsRequired: 'Must choose at least one app to configure.',

package/lib/app/urls.js

@@ -1,5 +1,4 @@
-import { getHubSpotWebsiteOrigin } from '@hubspot/local-dev-lib/urls';
-import { getBaseHubSpotUrlForAccount } from '../projects/urls.js';
+import { getHubSpotWebsiteOrigin, getHubSpotWebsiteOriginByAccountId, } from '@hubspot/local-dev-lib/urls';
 export function getOauthAppInstallUrl({ targetAccountId, env, clientId, scopes, redirectUrls, }) {
     const websiteOrigin = getHubSpotWebsiteOrigin(env);
     return (`${websiteOrigin}/oauth/${targetAccountId}/authorize` +
@@ -16,7 +15,7 @@ export function getAppCardSetupUrl({ targetAccountId, env, appId, }) {
     return `${websiteOrigin}/integrations-settings/${targetAccountId}/installed/framework/${appId}/app-cards?tourId=get-started`;
 }
 export function getAppLogsUrl(accountId, appId, systemType) {
-    return `${getBaseHubSpotUrlForAccount(accountId)}/developer-monitoring/${accountId}/?logType=${systemType}&appId=${appId}`;
+    return `${getHubSpotWebsiteOriginByAccountId(accountId)}/developer-monitoring/${accountId}/?logType=${systemType}&appId=${appId}`;
 }
 export function getAppLogDetailsUrl(accountId, appId, systemType, logId) {
     return `${getAppLogsUrl(accountId, appId, systemType)}&logId=${logId}`;

package/lib/configOptions.d.ts

@@ -1,21 +1,21 @@
 import { CmsPublishMode } from '@hubspot/local-dev-lib/types/Files';
-export declare function setAllowUsageTracking({ accountId, allowUsageTracking, }: {
+export declare function setAllowUsageTracking({ allowUsageTracking, }: {
     accountId: number;
     allowUsageTracking?: boolean;
-}): Promise<void>;
-export declare function setAllowAutoUpdates({ accountId, allowAutoUpdates, }: {
+}): Promise<boolean>;
+export declare function setAllowAutoUpdates({ allowAutoUpdates, }: {
     accountId: number;
     allowAutoUpdates?: boolean;
-}): Promise<void>;
-export declare function setDefaultCmsPublishMode({ accountId, defaultCmsPublishMode, }: {
+}): Promise<boolean>;
+export declare function setDefaultCmsPublishMode({ defaultCmsPublishMode, }: {
     accountId: number;
     defaultCmsPublishMode?: CmsPublishMode;
-}): Promise<void>;
-export declare function setHttpTimeout({ accountId, httpTimeout, }: {
+}): Promise<CmsPublishMode>;
+export declare function setHttpTimeout({ httpTimeout, }: {
     accountId: number;
     httpTimeout?: string;
-}): Promise<void>;
-export declare function setAutoOpenBrowser({ accountId, autoOpenBrowser, }: {
+}): Promise<string>;
+export declare function setAutoOpenBrowser({ autoOpenBrowser, }: {
     accountId: number;
     autoOpenBrowser: boolean;
-}): Promise<void>;
+}): Promise<boolean>;

package/lib/configOptions.js

@@ -1,7 +1,6 @@
 import { updateAllowUsageTracking, updateAllowAutoUpdates, updateDefaultCmsPublishMode, updateHttpTimeout, updateAutoOpenBrowser, } from '@hubspot/local-dev-lib/config';
 import { CMS_PUBLISH_MODE } from '@hubspot/local-dev-lib/constants/files';
 import { commaSeparatedValues } from '@hubspot/local-dev-lib/text';
-import { trackCommandUsage } from './usageTracking.js';
 import { promptUser, listPrompt } from './prompts/promptUtils.js';
 import { lib } from '../lang/en.js';
 import { uiLogger } from './ui/logger.js';
@@ -23,8 +22,7 @@ async function enableOrDisableBooleanFieldPrompt(fieldName) {
     });
     return isEnabled;
 }
-export async function setAllowUsageTracking({ accountId, allowUsageTracking, }) {
-    trackCommandUsage('config-set-allow-usage-tracking', undefined, accountId);
+export async function setAllowUsageTracking({ allowUsageTracking, }) {
     let isEnabled;
     if (typeof allowUsageTracking === 'boolean') {
         isEnabled = allowUsageTracking;
@@ -34,9 +32,9 @@ export async function setAllowUsageTracking({ accountId, allowUsageTracking, })
     }
     updateAllowUsageTracking(isEnabled);
     uiLogger.success(lib.configOptions.setAllowUsageTracking.success(isEnabled.toString()));
+    return isEnabled;
 }
-export async function setAllowAutoUpdates({ accountId, allowAutoUpdates, }) {
-    trackCommandUsage('config-set-allow-auto-updates', undefined, accountId);
+export async function setAllowAutoUpdates({ allowAutoUpdates, }) {
     let isEnabled;
     if (typeof allowAutoUpdates === 'boolean') {
         isEnabled = allowAutoUpdates;
@@ -46,6 +44,7 @@ export async function setAllowAutoUpdates({ accountId, allowAutoUpdates, }) {
     }
     updateAllowAutoUpdates(isEnabled);
     uiLogger.success(lib.configOptions.setAllowAutoUpdates.success(isEnabled.toString()));
+    return isEnabled;
 }
 const ALL_CMS_PUBLISH_MODES = Object.values(CMS_PUBLISH_MODE);
 async function selectCmsPublishMode() {
@@ -55,8 +54,7 @@ async function selectCmsPublishMode() {
     });
     return cmsPublishMode;
 }
-export async function setDefaultCmsPublishMode({ accountId, defaultCmsPublishMode, }) {
-    trackCommandUsage('config-set-default-mode', undefined, accountId);
+export async function setDefaultCmsPublishMode({ defaultCmsPublishMode, }) {
     let newDefault;
     if (!defaultCmsPublishMode) {
         newDefault = await selectCmsPublishMode();
@@ -71,6 +69,7 @@ export async function setDefaultCmsPublishMode({ accountId, defaultCmsPublishMod
     }
     updateDefaultCmsPublishMode(newDefault);
     uiLogger.success(lib.configOptions.setDefaultCmsPublishMode.success(newDefault));
+    return newDefault;
 }
 async function enterTimeout() {
     const { timeout } = await promptUser([
@@ -90,8 +89,7 @@ async function enterTimeout() {
     ]);
     return timeout;
 }
-export async function setHttpTimeout({ accountId, httpTimeout, }) {
-    trackCommandUsage('config-set-http-timeout', undefined, accountId);
+export async function setHttpTimeout({ httpTimeout, }) {
     let newHttpTimeout;
     if (!httpTimeout) {
         newHttpTimeout = await enterTimeout();
@@ -101,11 +99,12 @@ export async function setHttpTimeout({ accountId, httpTimeout, }) {
     }
     updateHttpTimeout(newHttpTimeout);
     uiLogger.success(lib.configOptions.setHttpTimeout.success(newHttpTimeout));
+    return newHttpTimeout;
 }
-export async function setAutoOpenBrowser({ accountId, autoOpenBrowser, }) {
-    trackCommandUsage('config-set-auto-open-browser', undefined, accountId);
+export async function setAutoOpenBrowser({ autoOpenBrowser, }) {
     updateAutoOpenBrowser(autoOpenBrowser);
     uiLogger.success(autoOpenBrowser
         ? lib.configOptions.setAutoOpenBrowser.enabled
         : lib.configOptions.setAutoOpenBrowser.disabled);
+    return autoOpenBrowser;
 }

package/lib/dependencyManagement.js

@@ -5,7 +5,7 @@ import { exec as execAsync } from 'node:child_process';
 import { getProjectConfig } from './projects/config.js';
 import { commands } from '../lang/en.js';
 import SpinniesManager from './ui/SpinniesManager.js';
-import { isGloballyInstalled, executeInstall, executeUpdate, DEFAULT_PACKAGE_MANAGER, } from './npm/npmCli.js';
+import { isGloballyInstalled, executeInstall, executeUpdate, getNpmExecErrorOutput, DEFAULT_PACKAGE_MANAGER, } from './npm/npmCli.js';
 import { findAllPackageJsonFilesInProjectCached, safeGetPackageJsonCached, } from './npm/packageJson.js';
 import { getNpmWorkspaceDirectoryForPackageAtLocationCached } from './npm/workspaces.js';
 class NoPackageJsonFilesError extends Error {
@@ -106,9 +106,9 @@ async function installPackagesInDirectory({ directory, packages, dev = false, np
         SpinniesManager.fail(spinner, {
             text: commands.project.installDeps.installingDependenciesFailed(relativeDir),
         });
-        throw new Error(commands.project.installDeps.installingDependenciesFailed(relativeDir), {
-            cause: e,
-        });
+        const npmErrorOutput = getNpmExecErrorOutput(e);
+        throw new Error(npmErrorOutput ||
+            commands.project.installDeps.installingDependenciesFailed(relativeDir), npmErrorOutput ? undefined : { cause: e });
     }
 }
 export async function updatePackages({ packages, installLocations, }) {
@@ -176,9 +176,9 @@ async function updatePackagesInDirectory({ directory, packages, npmWorkspaceDire
         SpinniesManager.fail(spinner, {
             text: commands.project.updateDeps.updatingDependenciesFailed(relativeDir),
         });
-        throw new Error(commands.project.updateDeps.updatingDependenciesFailed(relativeDir), {
-            cause: e,
-        });
+        const npmErrorOutput = getNpmExecErrorOutput(e);
+        throw new Error(npmErrorOutput ||
+            commands.project.updateDeps.updatingDependenciesFailed(relativeDir), npmErrorOutput ? undefined : { cause: e });
     }
 }
 export async function getProjectPackageJsonLocations(dir, isUpdate = false) {

package/lib/importData.js

@@ -1,16 +1,15 @@
-import { getConfigAccountById, getConfigAccountEnvironment, getConfigAccountIfExists, } from '@hubspot/local-dev-lib/config';
+import { getConfigAccountById, getConfigAccountIfExists, } from '@hubspot/local-dev-lib/config';
 import { createImport } from '@hubspot/local-dev-lib/api/crm';
-import { getHubSpotWebsiteOrigin } from '@hubspot/local-dev-lib/urls';
+import { getHubSpotWebsiteOriginByAccountId } from '@hubspot/local-dev-lib/urls';
 import { importDataTestAccountSelectPrompt } from './prompts/importDataTestAccountSelectPrompt.js';
 import { lib } from '../lang/en.js';
 import { isAppDeveloperAccount, isDeveloperTestAccount, isStandardAccount, } from './accountTypes.js';
 import { uiLogger } from './ui/logger.js';
 export async function handleImportData(targetAccountId, dataFileNames, importRequest) {
     try {
-        const baseUrl = getHubSpotWebsiteOrigin(getConfigAccountEnvironment(targetAccountId));
         const response = await createImport(targetAccountId, importRequest, dataFileNames);
         const importId = response.data.id;
-        uiLogger.info(lib.importData.viewImportLink(baseUrl, targetAccountId, importId));
+        uiLogger.info(lib.importData.viewImportLink(getHubSpotWebsiteOriginByAccountId(targetAccountId), targetAccountId, importId));
     }
     catch (error) {
         uiLogger.error(lib.importData.errors.failedToImportData);

package/lib/links.js

@@ -1,6 +1,5 @@
 import open from 'open';
-import { getConfigAccountEnvironment } from '@hubspot/local-dev-lib/config';
-import { getHubSpotWebsiteOrigin } from '@hubspot/local-dev-lib/urls';
+import { getHubSpotWebsiteOrigin, getHubSpotWebsiteOriginByAccountId, } from '@hubspot/local-dev-lib/urls';
 import { ENVIRONMENTS } from '@hubspot/local-dev-lib/constants/environments';
 import { uiLogger } from './ui/logger.js';
 import { renderTable } from '../ui/render.js';
@@ -75,7 +74,7 @@ const COMMON_SITE_LINKS = {
     },
 };
 export function getSiteLinksAsArray(accountId) {
-    const baseUrl = getHubSpotWebsiteOrigin(getConfigAccountEnvironment(accountId));
+    const baseUrl = getHubSpotWebsiteOriginByAccountId(accountId);
     return Object.values(COMMON_SITE_LINKS)
         .sort((a, b) => (a.shortcut < b.shortcut ? -1 : 1))
         .map(l => ({ ...l, url: l.getUrl(accountId, baseUrl) }));
@@ -94,12 +93,14 @@ export function openLink(accountId, shortcut) {
         uiLogger.error(`We couldn't find a shortcut matching ${shortcut}.  Type 'hs open list' to see a list of available shortcuts`);
         return;
     }
-    const baseUrl = getHubSpotWebsiteOrigin(getConfigAccountEnvironment(accountId));
+    const baseUrl = getHubSpotWebsiteOriginByAccountId(accountId);
     open(match.getUrl(accountId, baseUrl), { url: true });
     uiLogger.success(`We opened ${match.getUrl(accountId, baseUrl)} in your browser`);
 }
 export function getProductUpdatesUrl(rolloutId, accountId) {
-    const baseUrl = getHubSpotWebsiteOrigin(accountId ? getConfigAccountEnvironment(accountId) : ENVIRONMENTS.PROD);
+    const baseUrl = accountId
+        ? getHubSpotWebsiteOriginByAccountId(accountId)
+        : getHubSpotWebsiteOrigin(ENVIRONMENTS.PROD);
     if (accountId) {
         return `${baseUrl}/product-updates/${accountId}/in-beta?rollout=${rolloutId}`;
     }

package/lib/mcp/clients.d.ts

@@ -1,5 +1,5 @@
 export declare const MCP_SERVER_NAME = "HubSpotDev";
-export type McpClientId = 'codex' | 'claude' | 'cursor' | 'gemini' | 'vscode' | 'windsurf';
+export type McpClientId = 'codex' | 'claude' | 'cursor' | 'devin' | 'gemini' | 'opencode' | 'vscode';
 type McpClientDetection = {
     type: 'json' | 'text';
     pathSegments: string[];

package/lib/mcp/clients.js

@@ -39,12 +39,19 @@ export const MCP_CLIENTS = [
         },
     },
     {
-        id: 'windsurf',
+        id: 'devin',
         detection: {
             type: 'json',
             pathSegments: ['.codeium', 'windsurf', 'mcp_config.json'],
         },
     },
+    {
+        id: 'opencode',
+        detection: {
+            type: 'json',
+            pathSegments: ['.config', 'opencode', 'config.json'],
+        },
+    },
 ];
 export function getMcpClientPathSegments(id) {
     const client = MCP_CLIENTS.find(c => c.id === id);

package/lib/mcp/setup.d.ts

@@ -1,7 +1,6 @@
-import { McpClientId } from './clients.js';
 export declare const supportedTools: {
     name: string;
-    value: McpClientId;
+    value: string;
 }[];
 interface McpCommand {
     command: string;
@@ -17,7 +16,8 @@ export declare function configureMcpServer(options: ConfigureMcpServerOptions):
 export declare function setupVsCode(mcpCommand?: McpCommand): Promise<boolean>;
 export declare function setupClaudeCode(mcpCommand?: McpCommand): Promise<boolean>;
 export declare function setupCursor(mcpCommand?: McpCommand): boolean;
-export declare function setupWindsurf(mcpCommand?: McpCommand): boolean;
+export declare function setupDevin(mcpCommand?: McpCommand): boolean;
 export declare function setupCodex(mcpCommand?: McpCommand): Promise<boolean>;
 export declare function setupGemini(mcpCommand?: McpCommand): Promise<boolean>;
+export declare function setupOpenCode(mcpCommand?: McpCommand): Promise<boolean>;
 export {};

package/lib/mcp/setup.js

@@ -11,23 +11,29 @@ import fs from 'fs-extra';
 import { existsSync } from 'fs';
 const mcpServerName = MCP_SERVER_NAME;
 const claudeCode = 'claude';
-const windsurf = 'windsurf';
 const cursor = 'cursor';
+const devin = 'devin';
 const vscode = 'vscode';
 const codex = 'codex';
 const gemini = 'gemini';
+const opencode = 'opencode';
+const OTHER_TOOL = 'other';
 const clientLabels = {
     codex: commands.mcp.setup.codex,
     claude: commands.mcp.setup.claudeCode,
     cursor: commands.mcp.setup.cursor,
+    devin: commands.mcp.setup.devin,
     gemini: commands.mcp.setup.gemini,
+    opencode: commands.mcp.setup.opencode,
     vscode: commands.mcp.setup.vsCode,
-    windsurf: commands.mcp.setup.windsurf,
 };
-export const supportedTools = MCP_CLIENTS.map(client => ({
-    name: clientLabels[client.id],
-    value: client.id,
-}));
+export const supportedTools = [
+    ...MCP_CLIENTS.map(client => ({
+        name: clientLabels[client.id],
+        value: client.id,
+    })),
+    { name: commands.mcp.setup.other, value: OTHER_TOOL },
+];
 const defaultMcpCommand = {
     command: 'hs',
     args: ['mcp', 'start'],
@@ -42,6 +48,7 @@ export async function configureMcpServer(options) {
                 type: 'checkbox',
                 message: commands.mcp.setup.prompts.targets,
                 choices: supportedTools,
+                pageSize: supportedTools.length,
                 validate: (choices) => {
                     return choices.length === 0
                         ? commands.mcp.setup.prompts.targetsRequired
@@ -53,7 +60,8 @@ export async function configureMcpServer(options) {
         else {
             derivedTargets = targets;
         }
-        let useStandaloneMode = standalone;
+        const onlyOther = derivedTargets.length === 1 && derivedTargets[0] === OTHER_TOOL;
+        let useStandaloneMode = onlyOther ? false : standalone;
         if (useStandaloneMode === undefined) {
             const response = await promptUser({
                 name: 'useStandaloneMode',
@@ -102,8 +110,8 @@ export async function configureMcpServer(options) {
         if (derivedTargets.includes(cursor)) {
             await runSetupFunction(() => setupCursor(mcpCommand));
         }
-        if (derivedTargets.includes(windsurf)) {
-            await runSetupFunction(() => setupWindsurf(mcpCommand));
+        if (derivedTargets.includes(devin)) {
+            await runSetupFunction(() => setupDevin(mcpCommand));
         }
         if (derivedTargets.includes(vscode)) {
             await runSetupFunction(() => setupVsCode(mcpCommand));
@@ -114,8 +122,17 @@ export async function configureMcpServer(options) {
         if (derivedTargets.includes(gemini)) {
             await runSetupFunction(() => setupGemini(mcpCommand));
         }
-        uiLogger.info(commands.mcp.setup.success(derivedTargets));
-        return derivedTargets;
+        if (derivedTargets.includes(opencode)) {
+            await runSetupFunction(() => setupOpenCode(mcpCommand));
+        }
+        if (derivedTargets.includes(OTHER_TOOL)) {
+            logOtherToolInstructions(mcpCommand);
+        }
+        const configuredTargets = derivedTargets.filter(t => t !== OTHER_TOOL);
+        if (configuredTargets.length > 0) {
+            uiLogger.info(commands.mcp.setup.success(configuredTargets));
+        }
+        return configuredTargets;
     }
     catch (error) {
         SpinniesManager.fail('mcpSetup', {
@@ -272,14 +289,14 @@ export function setupCursor(mcpCommand = defaultMcpCommand) {
         mcpCommand: buildCommandWithAgentString(mcpCommand, cursor),
     });
 }
-export function setupWindsurf(mcpCommand = defaultMcpCommand) {
-    const windsurfConfigPath = path.join(os.homedir(), ...getMcpClientPathSegments(windsurf));
+export function setupDevin(mcpCommand = defaultMcpCommand) {
+    const devinConfigPath = path.join(os.homedir(), ...getMcpClientPathSegments(devin));
     return setupMcpConfigFile({
-        configPath: windsurfConfigPath,
-        configuringMessage: commands.mcp.setup.spinners.configuringWindsurf,
-        configuredMessage: commands.mcp.setup.spinners.configuredWindsurf,
-        failedMessage: commands.mcp.setup.spinners.failedToConfigureWindsurf,
-        mcpCommand: buildCommandWithAgentString(mcpCommand, windsurf),
+        configPath: devinConfigPath,
+        configuringMessage: commands.mcp.setup.spinners.configuringDevin,
+        configuredMessage: commands.mcp.setup.spinners.configuredDevin,
+        failedMessage: commands.mcp.setup.spinners.failedToConfigureDevin,
+        mcpCommand: buildCommandWithAgentString(mcpCommand, devin),
     });
 }
 export async function setupCodex(mcpCommand = defaultMcpCommand) {
@@ -341,6 +358,58 @@ export async function setupGemini(mcpCommand = defaultMcpCommand) {
         return false;
     }
 }
+export async function setupOpenCode(mcpCommand = defaultMcpCommand) {
+    try {
+        SpinniesManager.add('openCodeSpinner', {
+            text: commands.mcp.setup.spinners.configuringOpenCode,
+        });
+        try {
+            await execAsync('opencode --version');
+        }
+        catch (error) {
+            SpinniesManager.fail('openCodeSpinner', {
+                text: commands.mcp.setup.spinners.openCodeNotFound,
+            });
+            return false;
+        }
+        const mcpCommandWithAgent = buildCommandWithAgentString(mcpCommand, opencode);
+        await execAsync(`opencode mcp add "${mcpServerName}"${buildEnvFlagString(mcpCommand)} -- ${mcpCommandWithAgent.command} ${mcpCommandWithAgent.args.join(' ')}`);
+        SpinniesManager.succeed('openCodeSpinner', {
+            text: commands.mcp.setup.spinners.configuredOpenCode,
+        });
+        return true;
+    }
+    catch (error) {
+        SpinniesManager.fail('openCodeSpinner', {
+            text: commands.mcp.setup.spinners.openCodeInstallFailed,
+        });
+        logError(error);
+        return false;
+    }
+}
+function logOtherToolInstructions(mcpCommand) {
+    const { otherInstructions } = commands.mcp.setup;
+    uiLogger.log('');
+    uiLogger.log(otherInstructions.header);
+    uiLogger.log(otherInstructions.docsNote);
+    uiLogger.log('');
+    uiLogger.log(`  ${otherInstructions.commandLabel}`);
+    uiLogger.log(`    ${mcpCommand.command} ${mcpCommand.args.join(' ')}`);
+    uiLogger.log('');
+    uiLogger.log(`  ${otherInstructions.jsonLabel}`);
+    uiLogger.log('');
+    const jsonConfig = {
+        mcpServers: {
+            [mcpServerName]: mcpCommand,
+        },
+    };
+    const indented = JSON.stringify(jsonConfig, null, 2)
+        .split('\n')
+        .map(line => `    ${line}`)
+        .join('\n');
+    uiLogger.log(indented);
+    uiLogger.log('');
+}
 function buildCommandWithAgentString(mcpCommand, agent) {
     const mcpCommandCopy = structuredClone(mcpCommand);
     mcpCommandCopy.args.push('--ai-agent', agent);

package/lib/npm/npmCli.d.ts

@@ -4,6 +4,7 @@ export declare function getLatestPackageVersion(packageName: string): Promise<{
     latest: string | null;
     next: string | null;
 }>;
+export declare function getNpmExecErrorOutput(error: unknown): string | null;
 export declare function executeInstall(packages?: string[], flags?: string | null, options?: {
     cwd?: string;
 }): Promise<void>;

package/lib/npm/npmCli.js

@@ -23,6 +23,19 @@ export async function getLatestPackageVersion(packageName) {
         return { latest: null, next: null };
     }
 }
+function isNpmExecError(error) {
+    return (typeof error === 'object' &&
+        error !== null &&
+        ('stderr' in error || 'stdout' in error));
+}
+export function getNpmExecErrorOutput(error) {
+    if (!isNpmExecError(error)) {
+        return null;
+    }
+    const stderr = error.stderr?.trim();
+    const stdout = error.stdout?.trim();
+    return stderr || stdout || null;
+}
 export async function executeInstall(packages = [], flags, options) {
     const installCommand = `${DEFAULT_PACKAGE_MANAGER} install${flags ? ` ${flags}` : ''} ${packages.join(' ')}`;
     uiLogger.debug('Running', installCommand);

package/lib/projects/urls.d.ts

@@ -1,4 +1,3 @@
-export declare function getBaseHubSpotUrlForAccount(accountId: number): string;
 export declare function getProjectComponentDistributionUrl(projectName: string, componentName: string, accountId: number): string;
 export declare function getDeveloperOverviewUrl(accountId: number): string;
 export declare function getProjectDetailUrl(projectName: string, accountId: number): string | undefined;

package/lib/projects/urls.js

@@ -1,18 +1,12 @@
-import { getHubSpotWebsiteOrigin } from '@hubspot/local-dev-lib/urls';
-import { getConfigAccountEnvironment } from '@hubspot/local-dev-lib/config';
-export function getBaseHubSpotUrlForAccount(accountId) {
-    return getHubSpotWebsiteOrigin(getConfigAccountEnvironment(accountId));
-}
+import { getHubSpotWebsiteOriginByAccountId } from '@hubspot/local-dev-lib/urls';
 function getProjectHomeUrl(accountId) {
-    return `${getBaseHubSpotUrlForAccount(accountId)}/developer-projects/${accountId}`;
+    return `${getHubSpotWebsiteOriginByAccountId(accountId)}/developer-projects/${accountId}`;
 }
 export function getProjectComponentDistributionUrl(projectName, componentName, accountId) {
-    const baseUrl = getHubSpotWebsiteOrigin(getConfigAccountEnvironment(accountId));
-    return `${baseUrl}/developer-projects/${accountId}/project/${projectName}/component/${componentName}/distribution`;
+    return `${getHubSpotWebsiteOriginByAccountId(accountId)}/developer-projects/${accountId}/project/${projectName}/component/${componentName}/distribution`;
 }
 export function getDeveloperOverviewUrl(accountId) {
-    const baseUrl = getHubSpotWebsiteOrigin(getConfigAccountEnvironment(accountId));
-    return `${baseUrl}/developer-overview/${accountId}`;
+    return `${getHubSpotWebsiteOriginByAccountId(accountId)}/developer-overview/${accountId}`;
 }
 export function getProjectDetailUrl(projectName, accountId) {
     if (!projectName)
@@ -34,9 +28,8 @@ export function getProjectDeployDetailUrl(projectName, deployId, accountId) {
     return `${getProjectActivityUrl(projectName, accountId)}/deploy/${deployId}`;
 }
 export function getLocalDevUiUrl(accountId, showWelcomeScreen) {
-    return `${getBaseHubSpotUrlForAccount(accountId)}/developer-projects-local-dev/${accountId}${showWelcomeScreen ? '?welcome' : ''}`;
+    return `${getHubSpotWebsiteOriginByAccountId(accountId)}/developer-projects-local-dev/${accountId}${showWelcomeScreen ? '?welcome' : ''}`;
 }
 export function getAccountHomeUrl(accountId) {
-    const baseUrl = getHubSpotWebsiteOrigin(getConfigAccountEnvironment(accountId));
-    return `${baseUrl}/home?portalId=${accountId}`;
+    return `${getHubSpotWebsiteOriginByAccountId(accountId)}/home?portalId=${accountId}`;
 }

package/mcp-server/tools/project/DocsSearchTool.js

@@ -4,8 +4,8 @@ import { Tool } from '../../Tool.js';
 import { formatTextContents } from '../../utils/content.js';
 import { absoluteCurrentWorkingDirectory, docsSearchQuery, } from './constants.js';
 import { isHubSpotHttpError } from '@hubspot/local-dev-lib/errors/index';
-import { getConfigDefaultAccountIfExists } from '@hubspot/local-dev-lib/config';
 import { setupHubSpotConfig } from '../../utils/config.js';
+import { discoverAccountTargets } from '../../../lib/accountTargetDiscovery.js';
 import { getErrorMessage } from '../../../lib/errorHandlers/index.js';
 const docsSearchLimit = z
     .number()
@@ -33,18 +33,13 @@ export class DocsSearchTool extends Tool {
     }
     async handler({ docsSearchQuery, docsSearchLimit, absoluteCurrentWorkingDirectory, }) {
         setupHubSpotConfig(absoluteCurrentWorkingDirectory);
-        let accountId;
-        try {
-            accountId = getConfigDefaultAccountIfExists()?.accountId;
-        }
-        catch {
-            // Config file does not exist
-        }
-        if (!accountId) {
-            const authErrorMessage = `No account ID found. Call the auth-account tool to authenticate a HubSpot account.`;
-            return formatTextContents(authErrorMessage);
-        }
         try {
+            const { recommended } = await discoverAccountTargets();
+            const accountId = recommended?.accountId;
+            if (!accountId) {
+                const authErrorMessage = `No account ID found. Call the auth-account tool to authenticate a HubSpot account.`;
+                return formatTextContents(authErrorMessage);
+            }
             const response = await http.post(accountId, {
                 url: 'dev/docs/llms/v1/docs-search',
                 data: {

package/mcp-server/tools/project/GetApiUsagePatternsByAppIdTool.d.ts

@@ -5,6 +5,7 @@ import { McpLogger } from '../../utils/logger.js';
 import { z } from 'zod';
 declare const inputSchemaZodObject: z.ZodObject<{
     absoluteCurrentWorkingDirectory: z.ZodString;
+    absoluteProjectPath: z.ZodOptional<z.ZodString>;
     appId: z.ZodString;
     startDate: z.ZodOptional<z.ZodString>;
     endDate: z.ZodOptional<z.ZodString>;
@@ -12,7 +13,7 @@ declare const inputSchemaZodObject: z.ZodObject<{
 export type GetApiUsagePatternsByAppIdInputSchema = z.infer<typeof inputSchemaZodObject>;
 export declare class GetApiUsagePatternsByAppIdTool extends Tool<GetApiUsagePatternsByAppIdInputSchema> {
     constructor(mcpServer: McpServer, logger: McpLogger);
-    handler({ appId, startDate, endDate, absoluteCurrentWorkingDirectory, }: GetApiUsagePatternsByAppIdInputSchema): Promise<TextContentResponse>;
+    handler({ appId, startDate, endDate, absoluteCurrentWorkingDirectory, absoluteProjectPath, }: GetApiUsagePatternsByAppIdInputSchema): Promise<TextContentResponse>;
     register(): RegisteredTool;
 }
 export {};

package/mcp-server/tools/project/GetApiUsagePatternsByAppIdTool.js

@@ -3,12 +3,13 @@ import { z } from 'zod';
 import { http } from '@hubspot/local-dev-lib/http';
 import { formatTextContents } from '../../utils/content.js';
 import { isHubSpotHttpError } from '@hubspot/local-dev-lib/errors/index';
-import { getConfigDefaultAccountIfExists } from '@hubspot/local-dev-lib/config';
-import { absoluteCurrentWorkingDirectory } from './constants.js';
+import { absoluteCurrentWorkingDirectory, absoluteProjectPath, } from './constants.js';
 import { setupHubSpotConfig } from '../../utils/config.js';
+import { discoverAccountTargets } from '../../../lib/accountTargetDiscovery.js';
 import { getErrorMessage } from '../../../lib/errorHandlers/index.js';
 const inputSchema = {
     absoluteCurrentWorkingDirectory,
+    absoluteProjectPath: absoluteProjectPath.optional(),
     appId: z
         .string()
         .describe('The numeric app ID as a string (e.g., "3003909"). Must contain only digits. Use get-apps-info to find available app IDs.'),
@@ -28,16 +29,11 @@ export class GetApiUsagePatternsByAppIdTool extends Tool {
     constructor(mcpServer, logger) {
         super(mcpServer, logger, toolName);
     }
-    async handler({ appId, startDate, endDate, absoluteCurrentWorkingDirectory, }) {
-        setupHubSpotConfig(absoluteCurrentWorkingDirectory);
+    async handler({ appId, startDate, endDate, absoluteCurrentWorkingDirectory, absoluteProjectPath, }) {
+        setupHubSpotConfig(absoluteProjectPath ?? absoluteCurrentWorkingDirectory);
         try {
-            let accountId;
-            try {
-                accountId = getConfigDefaultAccountIfExists()?.accountId;
-            }
-            catch {
-                // Config file does not exist
-            }
+            const { recommended } = await discoverAccountTargets();
+            const accountId = recommended?.accountId;
             if (!accountId) {
                 const authErrorMessage = `No account ID found. Call the auth-account tool to authenticate a HubSpot account.`;
                 return formatTextContents(authErrorMessage);

package/mcp-server/tools/project/GetApplicationInfoTool.d.ts

@@ -5,11 +5,12 @@ import { McpLogger } from '../../utils/logger.js';
 import { z } from 'zod';
 declare const inputSchemaZodObject: z.ZodObject<{
     absoluteCurrentWorkingDirectory: z.ZodString;
+    absoluteProjectPath: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
 export type GetApplicationInfoInputSchema = z.infer<typeof inputSchemaZodObject>;
 export declare class GetApplicationInfoTool extends Tool<GetApplicationInfoInputSchema> {
     constructor(mcpServer: McpServer, logger: McpLogger);
-    handler({ absoluteCurrentWorkingDirectory, }: GetApplicationInfoInputSchema): Promise<TextContentResponse>;
+    handler({ absoluteCurrentWorkingDirectory, absoluteProjectPath, }: GetApplicationInfoInputSchema): Promise<TextContentResponse>;
     register(): RegisteredTool;
 }
 export {};

package/mcp-server/tools/project/GetApplicationInfoTool.js

@@ -3,11 +3,14 @@ import { z } from 'zod';
 import { http } from '@hubspot/local-dev-lib/http';
 import { formatTextContents } from '../../utils/content.js';
 import { isHubSpotHttpError } from '@hubspot/local-dev-lib/errors/index';
-import { getConfigDefaultAccountIfExists } from '@hubspot/local-dev-lib/config';
-import { absoluteCurrentWorkingDirectory } from './constants.js';
+import { absoluteCurrentWorkingDirectory, absoluteProjectPath, } from './constants.js';
 import { setupHubSpotConfig } from '../../utils/config.js';
+import { discoverAccountTargets } from '../../../lib/accountTargetDiscovery.js';
 import { getErrorMessage } from '../../../lib/errorHandlers/index.js';
-const inputSchema = { absoluteCurrentWorkingDirectory };
+const inputSchema = {
+    absoluteCurrentWorkingDirectory,
+    absoluteProjectPath: absoluteProjectPath.optional(),
+};
 // eslint-disable-next-line @typescript-eslint/no-unused-vars
 const inputSchemaZodObject = z.object({ ...inputSchema });
 const toolName = 'get-apps-info';
@@ -15,16 +18,11 @@ export class GetApplicationInfoTool extends Tool {
     constructor(mcpServer, logger) {
         super(mcpServer, logger, toolName);
     }
-    async handler({ absoluteCurrentWorkingDirectory, }) {
-        setupHubSpotConfig(absoluteCurrentWorkingDirectory);
+    async handler({ absoluteCurrentWorkingDirectory, absoluteProjectPath, }) {
+        setupHubSpotConfig(absoluteProjectPath ?? absoluteCurrentWorkingDirectory);
         try {
-            let accountId;
-            try {
-                accountId = getConfigDefaultAccountIfExists()?.accountId;
-            }
-            catch {
-                // Config file does not exist
-            }
+            const { recommended } = await discoverAccountTargets();
+            const accountId = recommended?.accountId;
             if (!accountId) {
                 const authErrorMessage = `No account ID found. Call the auth-account tool to authenticate a HubSpot account.`;
                 return formatTextContents(authErrorMessage);

package/mcp-server/tools/project/GetBuildLogsTool.js

@@ -5,8 +5,8 @@ import { isHubSpotHttpError } from '@hubspot/local-dev-lib/errors/index';
 import { http } from '@hubspot/local-dev-lib/http';
 import { getProjectConfig, validateProjectConfig, } from '../../../lib/projects/config.js';
 import { absoluteCurrentWorkingDirectory, absoluteProjectPath, } from './constants.js';
-import { getConfigDefaultAccountIfExists } from '@hubspot/local-dev-lib/config';
 import { setupHubSpotConfig } from '../../utils/config.js';
+import { discoverAccountTargets } from '../../../lib/accountTargetDiscovery.js';
 const TOOL_NAME = 'get-build-logs';
 const PROJECTS_LOGS_API_PATH = 'dfs/logging/v1';
 const inputSchema = {
@@ -62,20 +62,18 @@ export class GetBuildLogsTool extends Tool {
         super(mcpServer, logger, TOOL_NAME);
     }
     async handler({ absoluteProjectPath, absoluteCurrentWorkingDirectory, buildId, logLevel, }) {
-        setupHubSpotConfig(absoluteCurrentWorkingDirectory);
+        setupHubSpotConfig(absoluteProjectPath);
         try {
-            let accountId;
-            try {
-                accountId = getConfigDefaultAccountIfExists()?.accountId;
-            }
-            catch {
-                // Config file does not exist
-            }
+            const { projectConfig, projectDir } = await getProjectConfig(absoluteProjectPath);
+            validateProjectConfig(projectConfig, projectDir);
+            const { recommended } = await discoverAccountTargets({
+                projectDir,
+                projectConfig,
+            });
+            const accountId = recommended?.accountId;
             if (!accountId) {
                 return formatTextContents(absoluteCurrentWorkingDirectory, 'No account ID found. Call the auth-account tool to authenticate a HubSpot account.');
             }
-            const { projectConfig, projectDir } = await getProjectConfig(absoluteProjectPath);
-            validateProjectConfig(projectConfig, projectDir);
             const projectName = projectConfig.name;
             const response = await http.get(accountId, {
                 url: `${PROJECTS_LOGS_API_PATH}/logs/projects/${encodeURIComponent(projectName)}/builds/${buildId}`,

package/mcp-server/tools/project/GetBuildStatusTool.js

@@ -6,8 +6,8 @@ import { fetchProjectBuilds, getBuildStatus, } from '@hubspot/local-dev-lib/api/
 import { getProjectConfig, validateProjectConfig, } from '../../../lib/projects/config.js';
 import moment from 'moment';
 import { absoluteCurrentWorkingDirectory, absoluteProjectPath, } from './constants.js';
-import { getConfigDefaultAccountIfExists } from '@hubspot/local-dev-lib/config';
 import { setupHubSpotConfig } from '../../utils/config.js';
+import { discoverAccountTargets } from '../../../lib/accountTargetDiscovery.js';
 const TOOL_NAME = 'get-build-status';
 const inputSchema = {
     absoluteProjectPath,
@@ -107,20 +107,18 @@ export class GetBuildStatusTool extends Tool {
         super(mcpServer, logger, TOOL_NAME);
     }
     async handler({ absoluteProjectPath, absoluteCurrentWorkingDirectory, buildId, limit, }) {
-        setupHubSpotConfig(absoluteCurrentWorkingDirectory);
+        setupHubSpotConfig(absoluteProjectPath);
         try {
-            let accountId;
-            try {
-                accountId = getConfigDefaultAccountIfExists()?.accountId;
-            }
-            catch {
-                // Config file does not exist
-            }
+            const { projectConfig, projectDir } = await getProjectConfig(absoluteProjectPath);
+            validateProjectConfig(projectConfig, projectDir);
+            const { recommended } = await discoverAccountTargets({
+                projectDir,
+                projectConfig,
+            });
+            const accountId = recommended?.accountId;
             if (!accountId) {
                 return formatTextContents(absoluteCurrentWorkingDirectory, 'No account ID found. Call the auth-account tool to authenticate a HubSpot account.');
             }
-            const { projectConfig, projectDir } = await getProjectConfig(absoluteProjectPath);
-            validateProjectConfig(projectConfig, projectDir);
             const projectName = projectConfig.name;
             let output;
             if (buildId) {

package/mcp-server/tools/project/GetConfigValuesTool.d.ts

@@ -5,13 +5,14 @@ import { McpLogger } from '../../utils/logger.js';
 import { z } from 'zod';
 declare const inputSchemaZodObject: z.ZodObject<{
     absoluteCurrentWorkingDirectory: z.ZodString;
+    absoluteProjectPath: z.ZodOptional<z.ZodString>;
     platformVersion: z.ZodString;
     featureType: z.ZodString;
 }, z.core.$strip>;
 type InputSchemaType = z.infer<typeof inputSchemaZodObject>;
 export declare class GetConfigValuesTool extends Tool<InputSchemaType> {
     constructor(mcpServer: McpServer, logger: McpLogger);
-    handler({ platformVersion, featureType, absoluteCurrentWorkingDirectory, }: InputSchemaType): Promise<TextContentResponse>;
+    handler({ platformVersion, featureType, absoluteCurrentWorkingDirectory, absoluteProjectPath, }: InputSchemaType): Promise<TextContentResponse>;
     register(): RegisteredTool;
 }
 export {};

package/mcp-server/tools/project/GetConfigValuesTool.js

@@ -1,14 +1,15 @@
 import { Tool } from '../../Tool.js';
 import { z } from 'zod';
 import { formatTextContents } from '../../utils/content.js';
-import { absoluteCurrentWorkingDirectory } from './constants.js';
+import { absoluteCurrentWorkingDirectory, absoluteProjectPath, } from './constants.js';
 import { getIntermediateRepresentationSchema } from '@hubspot/project-parsing-lib/schema';
 import { mapToInternalType } from '@hubspot/project-parsing-lib/transform';
 import { isLegacyProject } from '@hubspot/project-parsing-lib/projects';
-import { getConfigDefaultAccountIfExists } from '@hubspot/local-dev-lib/config';
 import { setupHubSpotConfig } from '../../utils/config.js';
+import { discoverAccountTargets } from '../../../lib/accountTargetDiscovery.js';
 const inputSchema = {
     absoluteCurrentWorkingDirectory,
+    absoluteProjectPath: absoluteProjectPath.optional(),
     platformVersion: z
         .string()
         .describe('The platform version for the project. Located in the hsproject.json file.'),
@@ -25,19 +26,14 @@ export class GetConfigValuesTool extends Tool {
     constructor(mcpServer, logger) {
         super(mcpServer, logger, toolName);
     }
-    async handler({ platformVersion, featureType, absoluteCurrentWorkingDirectory, }) {
-        setupHubSpotConfig(absoluteCurrentWorkingDirectory);
+    async handler({ platformVersion, featureType, absoluteCurrentWorkingDirectory, absoluteProjectPath, }) {
+        setupHubSpotConfig(absoluteProjectPath ?? absoluteCurrentWorkingDirectory);
         try {
             if (isLegacyProject(platformVersion)) {
                 return formatTextContents(`Can only be used on projects with a minimum platformVersion of 2025.2`);
             }
-            let accountId;
-            try {
-                accountId = getConfigDefaultAccountIfExists()?.accountId;
-            }
-            catch {
-                // Config file does not exist
-            }
+            const { recommended } = await discoverAccountTargets();
+            const accountId = recommended?.accountId;
             if (!accountId) {
                 const authErrorMessage = `No account ID found. Call the auth-account tool to authenticate a HubSpot account.`;
                 return formatTextContents(authErrorMessage);

package/mcp-server/utils/config.js

@@ -8,4 +8,9 @@ export function setupHubSpotConfig(absoluteCurrentWorkingDirectory) {
     if (configPath) {
         process.env.HUBSPOT_CONFIG_PATH = configPath;
     }
+    else {
+        // Clear any value set by a previous tool call so this call doesn't
+        // inherit a stale config path from a different project.
+        delete process.env.HUBSPOT_CONFIG_PATH;
+    }
 }

package/mcp-server/utils/toolUsageTracking.js

@@ -1,5 +1,6 @@
 import { EventClass, getExecutionEnvironmentMeta, } from '../../lib/usageTracking.js';
-import { getConfig, getConfigDefaultAccountIfExists, } from '@hubspot/local-dev-lib/config';
+import { getConfig } from '@hubspot/local-dev-lib/config';
+import { discoverAccountTargets } from '../../lib/accountTargetDiscovery.js';
 import { sendUsageEvent } from '../../lib/api/usageTracking.js';
 export async function trackToolUsage(toolName, meta) {
     let config;
@@ -20,7 +21,14 @@ export async function trackToolUsage(toolName, meta) {
         ...getExecutionEnvironmentMeta(),
         ...meta,
     };
-    const accountId = getConfigDefaultAccountIfExists()?.accountId || undefined;
+    let accountId;
+    try {
+        const { recommended } = await discoverAccountTargets();
+        accountId = recommended?.accountId;
+    }
+    catch {
+        // Account discovery failed; continue without account ID
+    }
     try {
         await sendUsageEvent({
             eventName: 'cli-interaction',

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@hubspot/cli",
-    "version": "8.12.0",
+    "version": "8.13.0",
     "description": "The official CLI for developing on HubSpot",
     "license": "Apache-2.0",
     "repository": "https://github.com/HubSpot/hubspot-cli",
@@ -10,10 +10,10 @@
         "!**/__tests__/**"
     ],
     "dependencies": {
-        "@hubspot/local-dev-lib": "5.10.1",
+        "@hubspot/local-dev-lib": "5.10.2",
         "@hubspot/project-parsing-lib": "0.21.0",
         "@hubspot/serverless-dev-runtime": "7.0.7",
-        "@hubspot/ui-extensions-dev-server": "2.0.13",
+        "@hubspot/ui-extensions-dev-server": "2.1.0",
         "@inquirer/prompts": "7.1.0",
         "@modelcontextprotocol/sdk": "1.29.0",
         "archiver": "7.0.1",
@@ -44,7 +44,7 @@
         "zod": "^4.4.3"
     },
     "devDependencies": {
-        "@hubspot/npm-scripts": "0.3.1",
+        "@hubspot/npm-scripts": "^0.3.3",
         "@types/archiver": "^6.0.3",
         "@types/cli-progress": "^3.11.6",
         "@types/express": "^5.0.0",