@hubspot/cli 7.7.0-experimental.2 → 7.7.0

package/commands/function/server.js

@@ -1,17 +1,15 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const usageTracking_1 = require("../../lib/usageTracking");
-const logger_1 = require("@hubspot/local-dev-lib/logger");
+import { trackCommandUsage } from '../../lib/usageTracking.js';
+import { logger } from '@hubspot/local-dev-lib/logger';
 // This package is not typed, so we need to use require
-const { start: startTestServer } = require('@hubspot/serverless-dev-runtime');
-const lang_1 = require("../../lib/lang");
-const yargsUtils_1 = require("../../lib/yargsUtils");
+import { start as startTestServer } from '@hubspot/serverless-dev-runtime';
+import { i18n } from '../../lib/lang.js';
+import { makeYargsBuilder } from '../../lib/yargsUtils.js';
 const command = 'server <path>';
 const describe = undefined;
 async function handler(args) {
     const { path: functionPath, derivedAccountId } = args;
-    (0, usageTracking_1.trackCommandUsage)('functions-server', undefined, derivedAccountId);
-    logger_1.logger.debug((0, lang_1.i18n)('commands.function.subcommands.server.debug.startingServer', {
+    trackCommandUsage('functions-server', undefined, derivedAccountId);
+    logger.debug(i18n('commands.function.subcommands.server.debug.startingServer', {
         functionPath,
     }));
     startTestServer({
@@ -21,27 +19,27 @@ async function handler(args) {
 }
 function functionServerBuilder(yargs) {
     yargs.positional('path', {
-        describe: (0, lang_1.i18n)('commands.function.subcommands.server.positionals.path.describe'),
+        describe: i18n('commands.function.subcommands.server.positionals.path.describe'),
         type: 'string',
     });
     yargs.options({
         port: {
-            describe: (0, lang_1.i18n)('commands.function.subcommands.server.options.port.describe'),
+            describe: i18n('commands.function.subcommands.server.options.port.describe'),
             type: 'string',
             default: 5432,
         },
         contact: {
-            describe: (0, lang_1.i18n)('commands.function.subcommands.server.options.contact.describe'),
+            describe: i18n('commands.function.subcommands.server.options.contact.describe'),
             type: 'boolean',
             default: true,
         },
         watch: {
-            describe: (0, lang_1.i18n)('commands.function.subcommands.server.options.watch.describe'),
+            describe: i18n('commands.function.subcommands.server.options.watch.describe'),
             type: 'boolean',
             default: true,
         },
         'log-output': {
-            describe: (0, lang_1.i18n)('commands.function.subcommands.server.options.logOutput.describe'),
+            describe: i18n('commands.function.subcommands.server.options.logOutput.describe'),
             type: 'boolean',
             default: false,
         },
@@ -49,12 +47,12 @@ function functionServerBuilder(yargs) {
     yargs.example([
         [
             '$0 functions server ./tmp/myFunctionFolder.functions',
-            (0, lang_1.i18n)('commands.function.subcommands.server.examples.default'),
+            i18n('commands.function.subcommands.server.examples.default'),
         ],
     ]);
     return yargs;
 }
-const builder = (0, yargsUtils_1.makeYargsBuilder)(functionServerBuilder, command, describe, {
+const builder = makeYargsBuilder(functionServerBuilder, command, describe, {
     useConfigOptions: true,
     useAccountOptions: true,
     useEnvironmentOptions: true,
@@ -65,4 +63,4 @@ const functionServerCommand = {
     handler,
     builder,
 };
-exports.default = functionServerCommand;
+export default functionServerCommand;

package/commands/function.d.ts

@@ -1,4 +1,4 @@
-import { YargsCommandModuleBucket } from '../types/Yargs';
+import { YargsCommandModuleBucket } from '../types/Yargs.js';
 export declare const command: string[];
 export declare const describe: string;
 declare const functionCommand: YargsCommandModuleBucket;

package/commands/function.js

@@ -1,29 +1,21 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.describe = exports.command = void 0;
-const list_1 = __importDefault(require("./function/list"));
-const deploy_1 = __importDefault(require("./function/deploy"));
-const server_1 = __importDefault(require("./function/server"));
-const lang_1 = require("../lib/lang");
-const yargsUtils_1 = require("../lib/yargsUtils");
-exports.command = ['function', 'functions'];
-exports.describe = (0, lang_1.i18n)(`commands.function.describe`);
+import list from './function/list.js';
+import deploy from './function/deploy.js';
+import server from './function/server.js';
+import { i18n } from '../lib/lang.js';
+import { makeYargsBuilder } from '../lib/yargsUtils.js';
+export const command = ['function', 'functions'];
+export const describe = i18n(`commands.function.describe`);
 function functionBuilder(yargs) {
-    yargs.command(list_1.default).command(deploy_1.default).command(server_1.default).demandCommand(1, '');
+    yargs.command(list).command(deploy).command(server).demandCommand(1, '');
     return yargs;
 }
-const builder = (0, yargsUtils_1.makeYargsBuilder)(functionBuilder, exports.command, exports.describe, {
+const builder = makeYargsBuilder(functionBuilder, command, describe, {
     useGlobalOptions: true,
 });
 const functionCommand = {
-    command: exports.command,
-    describe: exports.describe,
+    command,
+    describe,
     builder,
     handler: () => { },
 };
-exports.default = functionCommand;
-// TODO Remove this legacy export once we've migrated all commands to TS
-module.exports = functionCommand;
+export default functionCommand;

package/commands/getStarted.d.ts

@@ -0,0 +1,7 @@
+import { AccountArgs, YargsCommandModule, CommonArgs, ConfigArgs, EnvironmentArgs } from '../types/Yargs.js';
+type GetStartedArgs = CommonArgs & ConfigArgs & AccountArgs & EnvironmentArgs & {
+    name?: string;
+    dest?: string;
+};
+declare const getStartedCommand: YargsCommandModule<unknown, GetStartedArgs>;
+export default getStartedCommand;

package/commands/getStarted.js

@@ -0,0 +1,296 @@
+import fs from 'fs-extra';
+import path from 'path';
+import open from 'open';
+import { getCwd } from '@hubspot/local-dev-lib/path';
+import { cloneGithubRepo } from '@hubspot/local-dev-lib/github';
+import { commands } from '../lang/en.js';
+import { trackCommandMetadataUsage, trackCommandUsage, } from '../lib/usageTracking.js';
+import { EXIT_CODES } from '../lib/enums/exitCodes.js';
+import { makeYargsBuilder } from '../lib/yargsUtils.js';
+import { promptUser } from '../lib/prompts/promptUtils.js';
+import { projectNameAndDestPrompt } from '../lib/prompts/projectNameAndDestPrompt.js';
+import { uiAccountDescription, uiFeatureHighlight, uiInfoSection, } from '../lib/ui/index.js';
+import { uiLogger } from '../lib/ui/logger.js';
+import { debugError, logError } from '../lib/errorHandlers/index.js';
+import { handleProjectUpload } from '../lib/projects/upload.js';
+import { PROJECT_CONFIG_FILE, GET_STARTED_OPTIONS, HUBSPOT_PROJECT_COMPONENTS_GITHUB_PATH, } from '../lib/constants.js';
+import { writeProjectConfig, getProjectConfig, validateProjectConfig, } from '../lib/projects/config.js';
+import { getProjectPackageJsonLocations, installPackages, } from '../lib/dependencyManagement.js';
+import { pollProjectBuildAndDeploy } from '../lib/projects/pollProjectBuildAndDeploy.js';
+import { useV3Api } from '../lib/projects/platformVersion.js';
+import { openLink } from '../lib/links.js';
+import { getStaticAuthAppInstallUrl } from '../lib/app/urls.js';
+import { getEnv } from '@hubspot/local-dev-lib/config';
+import { ENVIRONMENTS } from '@hubspot/local-dev-lib/constants/environments';
+import { fetchPublicAppsForPortal } from '@hubspot/local-dev-lib/api/appsDev';
+const command = 'get-started';
+const describe = commands.getStarted.describe;
+async function handler(args) {
+    const { derivedAccountId } = args;
+    const env = getEnv(derivedAccountId) === 'qa' ? ENVIRONMENTS.QA : ENVIRONMENTS.PROD;
+    await trackCommandUsage('get-started', {}, derivedAccountId);
+    const accountName = uiAccountDescription(derivedAccountId);
+    uiInfoSection(commands.getStarted.startTitle, () => {
+        uiLogger.log(commands.getStarted.startDescription);
+        uiLogger.log(commands.getStarted.guideOverview(accountName));
+    });
+    const { default: selectedOption } = await promptUser([
+        {
+            type: 'list',
+            name: 'default',
+            message: commands.getStarted.prompts.selectOption,
+            choices: [
+                {
+                    name: commands.getStarted.prompts.options.app,
+                    value: GET_STARTED_OPTIONS.APP,
+                },
+                {
+                    name: commands.getStarted.prompts.options.cms,
+                    value: GET_STARTED_OPTIONS.CMS,
+                },
+            ],
+            default: GET_STARTED_OPTIONS.APP,
+        },
+    ]);
+    // Track user's initial choice
+    await trackCommandMetadataUsage('get-started', { step: 'select-option', type: selectedOption }, derivedAccountId);
+    if (selectedOption === GET_STARTED_OPTIONS.CMS) {
+        uiLogger.log(' ');
+        uiLogger.log(commands.getStarted.designManager);
+        if (process.env.BROWSER !== 'none') {
+            uiLogger.log(' ');
+            const { shouldOpen } = await promptUser([
+                {
+                    name: 'shouldOpen',
+                    type: 'confirm',
+                    message: commands.getStarted.openDesignManagerPrompt,
+                },
+            ]);
+            // Track Design Manager browser action
+            await trackCommandMetadataUsage('get-started', {
+                step: 'open-design-manager',
+                type: shouldOpen ? 'opened' : 'declined',
+            }, derivedAccountId);
+            if (shouldOpen) {
+                uiLogger.log('');
+                openLink(derivedAccountId, 'design-manager');
+            }
+        }
+        process.exit(EXIT_CODES.SUCCESS);
+    }
+    else {
+        uiLogger.log(' ');
+        uiLogger.log(commands.getStarted.logs.appSelected);
+        const { dest, name } = await projectNameAndDestPrompt(args);
+        const projectDest = path.resolve(getCwd(), dest);
+        const { projectConfig: existingProjectConfig, projectDir: existingProjectDir, } = await getProjectConfig(projectDest);
+        if (existingProjectConfig &&
+            existingProjectDir &&
+            projectDest.startsWith(existingProjectDir)) {
+            // Track nested project error
+            await trackCommandMetadataUsage('get-started', {
+                successful: false,
+                step: 'project-creation',
+            }, derivedAccountId);
+            uiLogger.log(' ');
+            uiLogger.error(commands.project.create.errors.cannotNestProjects(existingProjectDir));
+            process.exit(EXIT_CODES.ERROR);
+        }
+        // 4. Clone the project template from GitHub
+        try {
+            await cloneGithubRepo(HUBSPOT_PROJECT_COMPONENTS_GITHUB_PATH, projectDest, {
+                sourceDir: '2025.2/private-app-get-started-template',
+                hideLogs: true,
+            });
+            await trackCommandMetadataUsage('get-started', {
+                successful: true,
+                step: 'github-clone',
+            }, derivedAccountId);
+        }
+        catch (err) {
+            await trackCommandMetadataUsage('get-started', {
+                successful: false,
+                step: 'github-clone',
+            }, derivedAccountId);
+            debugError(err);
+            uiLogger.log(' ');
+            uiLogger.error(commands.project.create.errors.failedToDownloadProject);
+            process.exit(EXIT_CODES.ERROR);
+        }
+        const projectConfigPath = path.join(projectDest, PROJECT_CONFIG_FILE);
+        const parsedConfigFile = JSON.parse(fs.readFileSync(projectConfigPath).toString());
+        writeProjectConfig(projectConfigPath, {
+            ...parsedConfigFile,
+            name,
+        });
+        uiLogger.log(' ');
+        uiLogger.success(commands.project.create.logs.success(name, projectDest));
+        uiLogger.log(' ');
+        uiLogger.log(commands.getStarted.prompts.projectCreated.title);
+        uiLogger.log(' ');
+        uiLogger.log(commands.getStarted.prompts.projectCreated.description);
+        uiLogger.log(' ');
+        // Track successful project creation
+        await trackCommandMetadataUsage('get-started', {
+            successful: true,
+            step: 'project-creation',
+        }, derivedAccountId);
+        // 5. Install dependencies
+        const installLocations = await getProjectPackageJsonLocations(projectDest);
+        try {
+            await installPackages({
+                installLocations: installLocations,
+            });
+            uiLogger.log(' ');
+            uiLogger.success(commands.getStarted.logs.dependenciesInstalled);
+            uiLogger.log(' ');
+        }
+        catch (err) {
+            uiLogger.log(' ');
+            uiLogger.error(commands.getStarted.errors.installDepsFailed);
+            logError(err);
+            uiLogger.log(' ');
+        }
+        // 6. Ask user if they want to upload the project
+        const { shouldUpload } = await promptUser([
+            {
+                type: 'confirm',
+                name: 'shouldUpload',
+                message: commands.getStarted.prompts.uploadProject(accountName),
+                default: true,
+            },
+        ]);
+        // Track upload decision
+        await trackCommandMetadataUsage('get-started', {
+            step: 'upload-decision',
+            type: shouldUpload ? 'upload' : 'skip',
+        }, derivedAccountId);
+        if (shouldUpload) {
+            try {
+                // Get the project config for the newly created project
+                const { projectConfig: newProjectConfig, projectDir: newProjectDir } = await getProjectConfig(projectDest);
+                if (!newProjectConfig || !newProjectDir) {
+                    // Track config file not found error
+                    await trackCommandMetadataUsage('get-started', {
+                        successful: false,
+                        step: 'config-file-not-found',
+                    }, derivedAccountId);
+                    uiLogger.log(' ');
+                    uiLogger.error(commands.getStarted.errors.configFileNotFound);
+                    process.exit(EXIT_CODES.ERROR);
+                }
+                validateProjectConfig(newProjectConfig, newProjectDir);
+                uiLogger.log(' ');
+                uiLogger.log(commands.getStarted.logs.uploadingProject);
+                uiLogger.log(' ');
+                const { result, uploadError } = await handleProjectUpload({
+                    accountId: derivedAccountId,
+                    projectConfig: newProjectConfig,
+                    projectDir: newProjectDir,
+                    callbackFunc: pollProjectBuildAndDeploy,
+                    uploadMessage: 'Initial upload from get-started command',
+                    forceCreate: true, // Auto-create project on HubSpot
+                    isUploadCommand: false,
+                    sendIR: useV3Api(newProjectConfig.platformVersion),
+                    skipValidation: false,
+                });
+                if (uploadError) {
+                    // Track upload failure
+                    await trackCommandMetadataUsage('get-started', {
+                        successful: false,
+                        step: 'upload',
+                    }, derivedAccountId);
+                    uiLogger.log(' ');
+                    uiLogger.error(commands.getStarted.errors.uploadFailed);
+                    debugError(uploadError);
+                }
+                else if (result) {
+                    // Track successful upload completion
+                    await trackCommandMetadataUsage('get-started', {
+                        successful: true,
+                        step: 'upload',
+                    }, derivedAccountId);
+                    uiLogger.log(' ');
+                    uiLogger.success(commands.getStarted.logs.uploadSuccess);
+                    const { data: { results }, } = await fetchPublicAppsForPortal(derivedAccountId);
+                    const lastCreatedApp = results.sort((a, b) => b.createdAt - a.createdAt)[0];
+                    if (process.env.BROWSER !== 'none') {
+                        uiLogger.log(' ');
+                        uiLogger.log(commands.getStarted.developerOverviewBrowserOpenPrep);
+                        uiLogger.log(' ');
+                        const { shouldOpenOverview } = await promptUser([
+                            {
+                                name: 'shouldOpenOverview',
+                                type: 'confirm',
+                                message: commands.getStarted.openInstallUrl,
+                            },
+                        ]);
+                        // Track Developer Overview browser action
+                        await trackCommandMetadataUsage('get-started', {
+                            step: 'open-distribution-page',
+                            type: shouldOpenOverview ? 'opened' : 'declined',
+                        }, derivedAccountId);
+                        if (shouldOpenOverview) {
+                            open(getStaticAuthAppInstallUrl({
+                                targetAccountId: derivedAccountId,
+                                env: env,
+                                appId: lastCreatedApp.id,
+                            }) + '&tourId=get-started', { url: true });
+                            uiLogger.log(' ');
+                            uiLogger.success(commands.getStarted.openedDeveloperOverview);
+                        }
+                    }
+                    uiLogger.log(' ');
+                    uiFeatureHighlight(['projectDevCommand']);
+                }
+            }
+            catch (err) {
+                // Track upload exception
+                await trackCommandMetadataUsage('get-started', {
+                    successful: false,
+                    step: 'upload',
+                }, derivedAccountId);
+                uiLogger.log(' ');
+                uiLogger.error(commands.getStarted.errors.uploadFailed);
+                debugError(err);
+                process.exit(EXIT_CODES.ERROR);
+            }
+        }
+    }
+    // Track successful completion of get-started command
+    await trackCommandMetadataUsage('get-started', {
+        successful: true,
+        step: 'command-completed',
+    }, derivedAccountId);
+    process.exit(EXIT_CODES.SUCCESS);
+}
+function getStartedBuilder(yargs) {
+    yargs.options({
+        name: {
+            describe: commands.getStarted.options.name.describe,
+            type: 'string',
+        },
+        dest: {
+            describe: commands.getStarted.options.dest.describe,
+            type: 'string',
+        },
+        'template-source': {
+            describe: commands.getStarted.options.templateSource.describe,
+            type: 'string',
+        },
+    });
+    return yargs;
+}
+const builder = makeYargsBuilder(getStartedBuilder, command, commands.getStarted.verboseDescribe, {
+    useGlobalOptions: true,
+    useAccountOptions: true,
+    useConfigOptions: true,
+    useEnvironmentOptions: true,
+});
+const getStartedCommand = {
+    command,
+    describe,
+    handler,
+    builder,
+};
+export default getStartedCommand;

package/commands/hubdb/__tests__/clear.test.d.ts

@@ -0,0 +1 @@
+export {};

package/commands/hubdb/__tests__/clear.test.js

@@ -0,0 +1,28 @@
+import yargs from 'yargs';
+import { addAccountOptions, addConfigOptions, addUseEnvironmentOptions, } from '../../../lib/commonOpts.js';
+import hubdbClearCommand from '../clear.js';
+vi.mock('../../../lib/commonOpts');
+describe('commands/hubdb/clear', () => {
+    const yargsMock = yargs;
+    describe('command', () => {
+        it('should have the correct command structure', () => {
+            expect(hubdbClearCommand.command).toEqual('clear [table-id]');
+        });
+    });
+    describe('describe', () => {
+        it('should provide a description', () => {
+            expect(hubdbClearCommand.describe).toBeDefined();
+        });
+    });
+    describe('builder', () => {
+        it('should support the correct options', () => {
+            hubdbClearCommand.builder(yargsMock);
+            expect(addAccountOptions).toHaveBeenCalledTimes(1);
+            expect(addAccountOptions).toHaveBeenCalledWith(yargsMock);
+            expect(addConfigOptions).toHaveBeenCalledTimes(1);
+            expect(addConfigOptions).toHaveBeenCalledWith(yargsMock);
+            expect(addUseEnvironmentOptions).toHaveBeenCalledTimes(1);
+            expect(addUseEnvironmentOptions).toHaveBeenCalledWith(yargsMock);
+        });
+    });
+});

package/commands/hubdb/__tests__/create.test.d.ts

@@ -0,0 +1 @@
+export {};

package/commands/hubdb/__tests__/create.test.js

@@ -0,0 +1,28 @@
+import yargs from 'yargs';
+import { addAccountOptions, addConfigOptions, addUseEnvironmentOptions, } from '../../../lib/commonOpts.js';
+import hubdbCreateCommand from '../create.js';
+vi.mock('../../../lib/commonOpts');
+describe('commands/hubdb/create', () => {
+    const yargsMock = yargs;
+    describe('command', () => {
+        it('should have the correct command structure', () => {
+            expect(hubdbCreateCommand.command).toEqual('create');
+        });
+    });
+    describe('describe', () => {
+        it('should provide a description', () => {
+            expect(hubdbCreateCommand.describe).toBeDefined();
+        });
+    });
+    describe('builder', () => {
+        it('should support the correct options', () => {
+            hubdbCreateCommand.builder(yargsMock);
+            expect(addAccountOptions).toHaveBeenCalledTimes(1);
+            expect(addAccountOptions).toHaveBeenCalledWith(yargsMock);
+            expect(addConfigOptions).toHaveBeenCalledTimes(1);
+            expect(addConfigOptions).toHaveBeenCalledWith(yargsMock);
+            expect(addUseEnvironmentOptions).toHaveBeenCalledTimes(1);
+            expect(addUseEnvironmentOptions).toHaveBeenCalledWith(yargsMock);
+        });
+    });
+});

package/commands/hubdb/__tests__/delete.test.d.ts

@@ -0,0 +1 @@
+export {};

package/commands/hubdb/__tests__/delete.test.js

@@ -0,0 +1,28 @@
+import yargs from 'yargs';
+import { addAccountOptions, addConfigOptions, addUseEnvironmentOptions, } from '../../../lib/commonOpts.js';
+import hubdbDeleteCommand from '../delete.js';
+vi.mock('../../../lib/commonOpts');
+describe('commands/hubdb/delete', () => {
+    const yargsMock = yargs;
+    describe('command', () => {
+        it('should have the correct command structure', () => {
+            expect(hubdbDeleteCommand.command).toEqual('delete [table-id]');
+        });
+    });
+    describe('describe', () => {
+        it('should provide a description', () => {
+            expect(hubdbDeleteCommand.describe).toBeDefined();
+        });
+    });
+    describe('builder', () => {
+        it('should support the correct options', () => {
+            hubdbDeleteCommand.builder(yargsMock);
+            expect(addAccountOptions).toHaveBeenCalledTimes(1);
+            expect(addAccountOptions).toHaveBeenCalledWith(yargsMock);
+            expect(addConfigOptions).toHaveBeenCalledTimes(1);
+            expect(addConfigOptions).toHaveBeenCalledWith(yargsMock);
+            expect(addUseEnvironmentOptions).toHaveBeenCalledTimes(1);
+            expect(addUseEnvironmentOptions).toHaveBeenCalledWith(yargsMock);
+        });
+    });
+});

package/commands/hubdb/__tests__/fetch.test.d.ts

@@ -0,0 +1 @@
+export {};

package/commands/hubdb/__tests__/fetch.test.js

@@ -0,0 +1,28 @@
+import yargs from 'yargs';
+import { addAccountOptions, addConfigOptions, addUseEnvironmentOptions, } from '../../../lib/commonOpts.js';
+import hubdbFetchCommand from '../fetch.js';
+vi.mock('../../../lib/commonOpts');
+describe('commands/hubdb/fetch', () => {
+    const yargsMock = yargs;
+    describe('command', () => {
+        it('should have the correct command structure', () => {
+            expect(hubdbFetchCommand.command).toEqual('fetch [table-id] [dest]');
+        });
+    });
+    describe('describe', () => {
+        it('should provide a description', () => {
+            expect(hubdbFetchCommand.describe).toBeDefined();
+        });
+    });
+    describe('builder', () => {
+        it('should support the correct options', () => {
+            hubdbFetchCommand.builder(yargsMock);
+            expect(addAccountOptions).toHaveBeenCalledTimes(1);
+            expect(addAccountOptions).toHaveBeenCalledWith(yargsMock);
+            expect(addConfigOptions).toHaveBeenCalledTimes(1);
+            expect(addConfigOptions).toHaveBeenCalledWith(yargsMock);
+            expect(addUseEnvironmentOptions).toHaveBeenCalledTimes(1);
+            expect(addUseEnvironmentOptions).toHaveBeenCalledWith(yargsMock);
+        });
+    });
+});

package/commands/hubdb/__tests__/list.test.d.ts

@@ -0,0 +1 @@
+export {};

package/commands/hubdb/__tests__/list.test.js

@@ -0,0 +1,96 @@
+import yargs from 'yargs';
+import { fetchTables } from '@hubspot/local-dev-lib/api/hubdb';
+import { addAccountOptions, addConfigOptions, addUseEnvironmentOptions, } from '../../../lib/commonOpts.js';
+import { uiLogger } from '../../../lib/ui/logger.js';
+import { mockHubSpotHttpResponse } from '../../../lib/testUtils.js';
+import { trackCommandUsage } from '../../../lib/usageTracking.js';
+import hubdbListCommand from '../list.js';
+vi.mock('../../../lib/commonOpts');
+vi.mock('@hubspot/local-dev-lib/api/hubdb');
+vi.mock('../../../lib/ui/logger', () => ({
+    uiLogger: {
+        success: vi.fn(),
+        log: vi.fn(),
+        error: vi.fn(),
+        exit: vi.fn(),
+    },
+}));
+vi.mock('../../../lib/errorHandlers');
+vi.mock('../../../lib/usageTracking');
+const mockExit = vi
+    .spyOn(process, 'exit')
+    .mockImplementation(() => undefined);
+describe('commands/hubdb/list', () => {
+    const yargsMock = yargs;
+    const mockedFetchTables = fetchTables;
+    const mockedLogger = uiLogger;
+    const mockedTrackCommandUsage = trackCommandUsage;
+    beforeEach(() => {
+        mockedFetchTables.mockReset();
+        mockedTrackCommandUsage.mockReset();
+        vi.mocked(mockedLogger.success).mockReset();
+        vi.mocked(mockedLogger.log).mockReset();
+        vi.mocked(mockedLogger.error).mockReset();
+    });
+    describe('command', () => {
+        it('should have the correct command structure', () => {
+            expect(hubdbListCommand.command).toEqual(['list', 'ls']);
+        });
+    });
+    describe('describe', () => {
+        it('should provide a description', () => {
+            expect(hubdbListCommand.describe).toBeDefined();
+        });
+    });
+    describe('builder', () => {
+        it('should support the correct options', () => {
+            hubdbListCommand.builder(yargsMock);
+            expect(addAccountOptions).toHaveBeenCalledTimes(1);
+            expect(addAccountOptions).toHaveBeenCalledWith(yargsMock);
+            expect(addConfigOptions).toHaveBeenCalledTimes(1);
+            expect(addConfigOptions).toHaveBeenCalledWith(yargsMock);
+            expect(addUseEnvironmentOptions).toHaveBeenCalledTimes(1);
+            expect(addUseEnvironmentOptions).toHaveBeenCalledWith(yargsMock);
+        });
+    });
+    describe('handler', () => {
+        const mockArgs = {
+            derivedAccountId: 123456789,
+            d: false,
+            debug: false,
+            _: [],
+            $0: 'hs',
+        };
+        const mockTables = {
+            results: [
+                {
+                    id: 1,
+                    label: 'Test Table',
+                    name: 'test_table',
+                    columnCount: 5,
+                    rowCount: 10,
+                },
+            ],
+            total: 1,
+        };
+        it('should fetch and display tables', async () => {
+            mockedFetchTables.mockReturnValue(mockHubSpotHttpResponse(mockTables));
+            await hubdbListCommand.handler(mockArgs);
+            expect(mockedFetchTables).toHaveBeenCalledTimes(1);
+            expect(mockedFetchTables).toHaveBeenCalledWith(mockArgs.derivedAccountId);
+            expect(mockedLogger.success).toHaveBeenCalled();
+            expect(mockedLogger.log).toHaveBeenCalled();
+            expect(mockExit).toHaveBeenCalledWith(0);
+        });
+        it('should handle errors appropriately', async () => {
+            const error = new Error('Test error');
+            mockedFetchTables.mockRejectedValue(error);
+            // this is a hack because the system exit is being mocked, so the return value from fetchTables is weird and can't be unpacked by the handler
+            try {
+                await hubdbListCommand.handler(mockArgs);
+            }
+            catch (e) { }
+            expect(mockExit).toHaveBeenCalledWith(1);
+        });
+    });
+});