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

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/constants.d.ts

@@ -1,4 +1,5 @@
 export declare const HUBSPOT_PROJECT_COMPONENTS_GITHUB_PATH: "HubSpot/hubspot-project-components";
+export declare const MAX_LOG_FILES = 10;
 export declare const DEFAULT_PROJECT_TEMPLATE_BRANCH: "main";
 export declare const FEEDBACK_INTERVAL: 10;
 export declare const HUBSPOT_FOLDER: "@hubspot";
@@ -81,6 +82,7 @@ export declare const FEATURES: {
     readonly APP_EVENTS: "Developers:UnifiedApps:AppEventsAccess";
     readonly THEME_MIGRATION_2025_2: "Developers:ProjectThemeMigrations:2025.2";
     readonly AGENT_TOOLS: "ThirdPartyAgentTools";
+    readonly APP_ACTIONS: "Developers:AppActions";
 };
 export declare const LOCAL_DEV_UI_MESSAGE_SEND_TYPES: {
     UPLOAD_SUCCESS: string;

package/lib/constants.js

@@ -1,4 +1,5 @@
 export const HUBSPOT_PROJECT_COMPONENTS_GITHUB_PATH = 'HubSpot/hubspot-project-components';
+export const MAX_LOG_FILES = 10;
 export const DEFAULT_PROJECT_TEMPLATE_BRANCH = 'main';
 export const FEEDBACK_INTERVAL = 10;
 export const HUBSPOT_FOLDER = '@hubspot';
@@ -73,6 +74,7 @@ export const FEATURES = {
     APP_EVENTS: 'Developers:UnifiedApps:AppEventsAccess',
     THEME_MIGRATION_2025_2: 'Developers:ProjectThemeMigrations:2025.2',
     AGENT_TOOLS: 'ThirdPartyAgentTools',
+    APP_ACTIONS: 'Developers:AppActions',
 };
 export const LOCAL_DEV_UI_MESSAGE_SEND_TYPES = {
     UPLOAD_SUCCESS: 'server:uploadSuccess',

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/getStartedV2Actions.js

@@ -73,7 +73,7 @@ async function fetchAppAfterDeploy(accountId, env) {
 async function buildProjectMetadata(projectDir, projectConfig, accountId) {
     const srcDir = path.join(projectDir, projectConfig.srcDir);
     const projectMetadata = await getProjectMetadata(srcDir);
-    const intermediateRepresentation = await translate({
+    const { intermediateRepresentation } = await translate({
         projectSourceDir: srcDir,
         platformVersion: projectConfig.platformVersion,
         accountId,
@@ -111,6 +111,7 @@ export async function uploadAndDeployAction({ accountId, projectDest, }) {
             isUploadCommand: false,
             sendIR: !isLegacyProject(projectConfig.platformVersion),
             skipValidation: false,
+            force: true,
         });
         if (uploadError) {
             throw new ProjectUploadError(commands.getStarted.errors.uploadActionFailed, uploadError);

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/jsonOutput.d.ts

@@ -0,0 +1,109 @@
+import { z } from 'zod';
+import { Release } from '../api/releases.js';
+declare const ReleaseComponentSchema: z.ZodObject<{
+    buildType: z.ZodString;
+    buildName: z.ZodOptional<z.ZodString>;
+    rootPath: z.ZodOptional<z.ZodString>;
+    id: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const ReleaseSchema: z.ZodObject<{
+    releaseTag: z.ZodString;
+    buildId: z.ZodNumber;
+    createdAt: z.ZodString;
+    components: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        buildType: z.ZodString;
+        buildName: z.ZodOptional<z.ZodString>;
+        rootPath: z.ZodOptional<z.ZodString>;
+        id: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export declare const ReleaseListSchema: z.ZodObject<{
+    results: z.ZodArray<z.ZodObject<{
+        releaseTag: z.ZodString;
+        buildId: z.ZodNumber;
+        createdAt: z.ZodString;
+        components: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            buildType: z.ZodString;
+            buildName: z.ZodOptional<z.ZodString>;
+            rootPath: z.ZodOptional<z.ZodString>;
+            id: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>>;
+    paging: z.ZodOptional<z.ZodObject<{
+        next: z.ZodObject<{
+            after: z.ZodString;
+        }, z.core.$strip>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const ProjectInfoSchema: z.ZodObject<{
+    projectName: z.ZodString;
+    platformVersion: z.ZodString;
+    projectId: z.ZodNumber;
+    deployedBuildId: z.ZodNumber;
+    autoDeployEnabled: z.ZodBoolean;
+    projectUrl: z.ZodOptional<z.ZodString>;
+    app: z.ZodOptional<z.ZodObject<{
+        name: z.ZodString;
+        id: z.ZodNumber;
+        uid: z.ZodString;
+        authType: z.ZodOptional<z.ZodString>;
+        distributionType: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    components: z.ZodArray<z.ZodObject<{
+        uid: z.ZodString;
+        type: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+declare const PreviewSchema: z.ZodObject<{
+    releaseTag: z.ZodOptional<z.ZodString>;
+    succeeded: z.ZodBoolean;
+}, z.core.$strip>;
+export declare const UploadSchema: z.ZodObject<{
+    buildId: z.ZodOptional<z.ZodNumber>;
+    deployId: z.ZodOptional<z.ZodNumber>;
+    preview: z.ZodOptional<z.ZodObject<{
+        releaseTag: z.ZodOptional<z.ZodString>;
+        succeeded: z.ZodBoolean;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const DeploySchema: z.ZodObject<{
+    deployId: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const InstallStatusSchema: z.ZodObject<{
+    appId: z.ZodOptional<z.ZodNumber>;
+    appUid: z.ZodString;
+    accountId: z.ZodNumber;
+    projectId: z.ZodNumber;
+    isInstalled: z.ZodBoolean;
+    isInstalledWithCurrentScopes: z.ZodBoolean;
+    previouslyAuthorizedScopeGroups: z.ZodArray<z.ZodObject<{
+        id: z.ZodNumber;
+        name: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const InstallAppSchema: z.ZodObject<{
+    appId: z.ZodNumber;
+    appUid: z.ZodString;
+    accountId: z.ZodNumber;
+    projectId: z.ZodNumber;
+    installationState: z.ZodString;
+    installed: z.ZodBoolean;
+    reinstalled: z.ZodBoolean;
+}, z.core.$strip>;
+export declare const CreateTestAccountSchema: z.ZodObject<{
+    accountName: z.ZodOptional<z.ZodString>;
+    accountId: z.ZodOptional<z.ZodNumber>;
+    personalAccessKey: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type ReleaseComponentJsonOutput = z.infer<typeof ReleaseComponentSchema>;
+export type ReleaseJsonOutput = z.infer<typeof ReleaseSchema>;
+export type ReleaseListJsonOutput = z.infer<typeof ReleaseListSchema>;
+export type ProjectInfoJsonOutput = z.infer<typeof ProjectInfoSchema>;
+export type PreviewJsonOutput = z.infer<typeof PreviewSchema>;
+export type UploadJsonOutput = z.infer<typeof UploadSchema>;
+export type DeployJsonOutput = z.infer<typeof DeploySchema>;
+export type InstallStatusJsonOutput = z.infer<typeof InstallStatusSchema>;
+export type InstallAppJsonOutput = z.infer<typeof InstallAppSchema>;
+export type CreateTestAccountJsonOutput = z.infer<typeof CreateTestAccountSchema>;
+export declare function mapReleaseToJsonOutput(release: Release): ReleaseJsonOutput;
+export {};

package/lib/jsonOutput.js

@@ -0,0 +1,94 @@
+import { z } from 'zod';
+const ReleaseComponentSchema = z.object({
+    buildType: z.string(),
+    buildName: z.string().optional(),
+    rootPath: z.string().optional(),
+    id: z.string().optional(),
+});
+export const ReleaseSchema = z.object({
+    releaseTag: z.string(),
+    buildId: z.number(),
+    createdAt: z.string(),
+    components: z.array(ReleaseComponentSchema).optional(),
+});
+export const ReleaseListSchema = z.object({
+    results: z.array(ReleaseSchema),
+    paging: z
+        .object({
+        next: z.object({
+            after: z.string(),
+        }),
+    })
+        .optional(),
+});
+export const ProjectInfoSchema = z.object({
+    projectName: z.string(),
+    platformVersion: z.string(),
+    projectId: z.number(),
+    deployedBuildId: z.number(),
+    autoDeployEnabled: z.boolean(),
+    projectUrl: z.string().optional(),
+    app: z
+        .object({
+        name: z.string(),
+        id: z.number(),
+        uid: z.string(),
+        authType: z.string().optional(),
+        distributionType: z.string().optional(),
+    })
+        .optional(),
+    components: z.array(z.object({ uid: z.string(), type: z.string() })),
+});
+const PreviewSchema = z.object({
+    releaseTag: z.string().optional(),
+    succeeded: z.boolean(),
+});
+export const UploadSchema = z.object({
+    buildId: z.number().optional(),
+    deployId: z.number().optional(),
+    preview: PreviewSchema.optional(),
+});
+export const DeploySchema = z.object({
+    deployId: z.number().optional(),
+});
+const ScopeGroupSchema = z.object({
+    id: z.number(),
+    name: z.string(),
+});
+export const InstallStatusSchema = z.object({
+    appId: z.number().optional(),
+    appUid: z.string(),
+    accountId: z.number(),
+    projectId: z.number(),
+    isInstalled: z.boolean(),
+    isInstalledWithCurrentScopes: z.boolean(),
+    previouslyAuthorizedScopeGroups: z.array(ScopeGroupSchema),
+});
+export const InstallAppSchema = z.object({
+    appId: z.number(),
+    appUid: z.string(),
+    accountId: z.number(),
+    projectId: z.number(),
+    installationState: z.string(),
+    installed: z.boolean(),
+    reinstalled: z.boolean(),
+});
+export const CreateTestAccountSchema = z.object({
+    accountName: z.string().optional(),
+    accountId: z.number().optional(),
+    personalAccessKey: z.string().optional(),
+});
+export function mapReleaseToJsonOutput(release) {
+    const { releaseTag, buildId, createdAt, components } = release;
+    return {
+        releaseTag,
+        buildId,
+        createdAt,
+        components: components?.map(({ buildType, buildName, rootPath, id }) => ({
+            buildType,
+            buildName,
+            rootPath,
+            id,
+        })),
+    };
+}

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,18 +1,23 @@
-import { McpClientId } from './clients.js';
 export declare const supportedTools: {
     name: string;
-    value: McpClientId;
+    value: string;
 }[];
 interface McpCommand {
     command: string;
     args: string[];
     env?: Record<string, string>;
 }
-export declare function configureMcpServer(targets: string[] | undefined): Promise<string[]>;
+interface ConfigureMcpServerOptions {
+    targets?: string[];
+    standalone?: boolean;
+    cliVersion?: string;
+}
+export declare function configureMcpServer(options: ConfigureMcpServerOptions): 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;
-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 {};