@hubspot/cli 8.0.10-experimental.6 → 8.0.11-experimental.0

package/commands/getStarted.js

@@ -0,0 +1,322 @@
+import { cloneGithubRepo } from '@hubspot/local-dev-lib/github';
+import { getCwd } from '@hubspot/local-dev-lib/path';
+import fs from 'fs-extra';
+import open from 'open';
+import path from 'path';
+import { commands } from '../lang/en.js';
+import { GET_STARTED_OPTIONS, HUBSPOT_PROJECT_COMPONENTS_GITHUB_PATH, PROJECT_CONFIG_FILE, } from '../lib/constants.js';
+import { EXIT_CODES } from '../lib/enums/exitCodes.js';
+import { debugError, logError } from '../lib/errorHandlers/index.js';
+import { getProjectConfig, validateProjectConfig, writeProjectConfig, } from '../lib/projects/config.js';
+import { handleProjectUpload } from '../lib/projects/upload.js';
+import { projectNameAndDestPrompt } from '../lib/prompts/projectNameAndDestPrompt.js';
+import { promptUser } from '../lib/prompts/promptUtils.js';
+import { uiAccountDescription, uiFeatureHighlight, uiInfoSection, } from '../lib/ui/index.js';
+import { uiLogger } from '../lib/ui/logger.js';
+import { trackCommandMetadataUsage, trackCommandUsage, } from '../lib/usageTracking.js';
+import { makeYargsBuilder } from '../lib/yargsUtils.js';
+import { isV2Project } from '../lib/projects/platformVersion.js';
+import { pollProjectBuildAndDeploy } from '../lib/projects/pollProjectBuildAndDeploy.js';
+import { fetchPublicAppsForPortal } from '@hubspot/local-dev-lib/api/appsDev';
+import { getConfigAccountEnvironment } from '@hubspot/local-dev-lib/config';
+import { getStaticAuthAppInstallUrl } from '../lib/app/urls.js';
+import ProjectValidationError from '../lib/errors/ProjectValidationError.js';
+import { openLink } from '../lib/links.js';
+import { runGetStartedV2 } from '../lib/getStarted/getStartedV2.js';
+const command = 'get-started';
+const describe = commands.getStarted.describe;
+async function handler(args) {
+    const { derivedAccountId } = args;
+    const env = getConfigAccountEnvironment(derivedAccountId);
+    await trackCommandUsage('get-started', {}, derivedAccountId);
+    const accountName = uiAccountDescription(derivedAccountId);
+    if (args.v2) {
+        try {
+            await runGetStartedV2({
+                ...args,
+                name: args.name,
+                dest: args.dest,
+            });
+            process.exit(EXIT_CODES.SUCCESS);
+            return;
+        }
+        catch (error) {
+            logError(error);
+            process.exit(EXIT_CODES.ERROR);
+            return;
+        }
+    }
+    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: '2026.03/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. 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);
+                }
+                try {
+                    validateProjectConfig(newProjectConfig, newProjectDir);
+                }
+                catch (error) {
+                    if (error instanceof ProjectValidationError) {
+                        // Track validation error
+                        await trackCommandMetadataUsage('get-started', {
+                            successful: false,
+                            step: 'project-validation-failed',
+                        }, derivedAccountId);
+                        uiLogger.log(' ');
+                        uiLogger.error(error.message);
+                        process.exit(EXIT_CODES.ERROR);
+                    }
+                    throw error;
+                }
+                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: isV2Project(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);
+            }
+        }
+        else {
+            uiLogger.log(' ');
+            uiFeatureHighlight(['projectUploadCommand', 'projectDevCommand']);
+            process.exit(EXIT_CODES.SUCCESS);
+        }
+    }
+    // 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',
+        },
+        v2: {
+            describe: commands.getStarted.options.v2.describe,
+            type: 'boolean',
+            default: false,
+            hidden: true,
+        },
+        '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,88 @@
+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('@hubspot/local-dev-lib/config');
+vi.mock('../../../lib/errorHandlers');
+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);
+        });
+    });
+});

package/commands/hubdb/clear.d.ts

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

package/commands/hubdb/clear.js

@@ -0,0 +1,58 @@
+import { uiLogger } from '../../lib/ui/logger.js';
+import { logError } from '../../lib/errorHandlers/index.js';
+import { PromptExitError } from '../../lib/errors/PromptExitError.js';
+import { clearHubDbTableRows } from '@hubspot/local-dev-lib/hubdb';
+import { publishTable } from '@hubspot/local-dev-lib/api/hubdb';
+import { selectHubDBTablePrompt } from '../../lib/prompts/selectHubDBTablePrompt.js';
+import { trackCommandUsage } from '../../lib/usageTracking.js';
+import { commands } from '../../lang/en.js';
+import { makeYargsBuilder } from '../../lib/yargsUtils.js';
+const command = 'clear [table-id]';
+const describe = commands.hubdb.subcommands.clear.describe;
+async function handler(args) {
+    const { derivedAccountId } = args;
+    trackCommandUsage('hubdb-clear', {}, derivedAccountId);
+    try {
+        const { tableId } = 'tableId' in args
+            ? args
+            : await selectHubDBTablePrompt({
+                accountId: derivedAccountId,
+                options: args,
+            });
+        const { deletedRowCount } = await clearHubDbTableRows(derivedAccountId, tableId);
+        if (deletedRowCount > 0) {
+            uiLogger.log(commands.hubdb.subcommands.clear.logs.removedRows(deletedRowCount, tableId));
+            const { data: { rowCount }, } = await publishTable(derivedAccountId, tableId);
+            uiLogger.log(commands.hubdb.subcommands.clear.logs.rowCount(tableId, rowCount));
+        }
+        else {
+            uiLogger.log(commands.hubdb.subcommands.clear.logs.tableEmpty(tableId));
+        }
+    }
+    catch (e) {
+        if (e instanceof PromptExitError) {
+            process.exit(e.exitCode);
+        }
+        logError(e);
+    }
+}
+function hubdbClearBuilder(yargs) {
+    yargs.positional('table-id', {
+        describe: commands.hubdb.subcommands.clear.positionals.tableId.describe,
+        type: 'string',
+    });
+    return yargs;
+}
+const builder = makeYargsBuilder(hubdbClearBuilder, command, describe, {
+    useGlobalOptions: true,
+    useConfigOptions: true,
+    useAccountOptions: true,
+    useEnvironmentOptions: true,
+});
+const hubdbClearCommand = {
+    command,
+    describe,
+    handler,
+    builder,
+};
+export default hubdbClearCommand;

package/commands/hubdb/create.d.ts

@@ -0,0 +1,6 @@
+import { CommonArgs, ConfigArgs, AccountArgs, EnvironmentArgs, YargsCommandModule } from '../../types/Yargs.js';
+type HubdbCreateArgs = CommonArgs & ConfigArgs & AccountArgs & EnvironmentArgs & {
+    path?: string;
+};
+declare const hubdbCreateCommand: YargsCommandModule<unknown, HubdbCreateArgs>;
+export default hubdbCreateCommand;