@hubspot/cli 8.1.0-beta.0 → 8.2.0-beta.0

package/commands/cms/__tests__/watch.test.js

@@ -64,7 +64,6 @@ describe('commands/cms/watch', () => {
             expect(positionalSpy).toHaveBeenCalledWith('dest', expect.objectContaining({ type: 'string' }));
             expect(optionSpy).toHaveBeenCalledWith('remove', expect.objectContaining({ type: 'boolean', alias: 'r' }));
             expect(optionSpy).toHaveBeenCalledWith('initial-upload', expect.objectContaining({ type: 'boolean', alias: 'i' }));
-            expect(optionSpy).toHaveBeenCalledWith('disable-initial', expect.objectContaining({ type: 'boolean' }));
             expect(optionSpy).toHaveBeenCalledWith('notify', expect.objectContaining({ type: 'string', alias: 'n' }));
             expect(optionSpy).toHaveBeenCalledWith('convert-fields', expect.objectContaining({ type: 'boolean' }));
         });
@@ -78,7 +77,6 @@ describe('commands/cms/watch', () => {
                 derivedAccountId: 123456,
                 remove: false,
                 initialUpload: false,
-                disableInitial: false,
             };
             statSyncSpy.mockReturnValue({
                 isFile: () => false,
@@ -134,7 +132,6 @@ describe('commands/cms/watch', () => {
             });
             it('should start watching without initial upload by default', async () => {
                 await watchCommand.handler(args);
-                expect(uiLogger.info).toHaveBeenCalledWith(expect.stringContaining('not'));
                 expect(getUploadableFileListSpy).not.toHaveBeenCalled();
                 expect(watchSpy).toHaveBeenCalledWith(123456, path.resolve('/test/cwd', 'src'), '/dest', expect.objectContaining({
                     cmsPublishMode: 'publish',
@@ -152,11 +149,6 @@ describe('commands/cms/watch', () => {
                     filePaths: ['file1.js', 'file2.js'],
                 }), null, expect.any(Function), undefined, expect.any(Function));
             });
-            it('should show disable initial message when disableInitial is true', async () => {
-                args.disableInitial = true;
-                await watchCommand.handler(args);
-                expect(uiLogger.info).toHaveBeenCalledWith(expect.stringContaining('disable'));
-            });
             it('should pass remove option to watch', async () => {
                 args.remove = true;
                 await watchCommand.handler(args);

package/commands/cms/function/logs.js

@@ -35,6 +35,7 @@ const endpointLog = async (accountId, functionPath, options) => {
             }
         };
         await tailLogs(accountId, functionPath, fetchLatest, tailCall, compact);
+        process.exit(EXIT_CODES.SUCCESS);
     }
     else if (latest) {
         try {

package/commands/cms/theme/preview.js

@@ -1,16 +1,12 @@
 import fs from 'fs';
 import path from 'path';
-import cliProgress from 'cli-progress';
 import { commands } from '../../../lang/en.js';
 import { getCwd } from '@hubspot/local-dev-lib/path';
-import { FILE_UPLOAD_RESULT_TYPES } from '@hubspot/local-dev-lib/constants/files';
 import { getThemeJSONPath } from '@hubspot/local-dev-lib/cms/themes';
-import { createDevServer } from '@hubspot/cms-dev-server';
-import { getUploadableFileList } from '../../../lib/upload.js';
+import { spawnDevServer } from '../../../lib/theme/cmsDevServerProcess.js';
 import { trackCommandUsage } from '../../../lib/usageTracking.js';
 import { previewPrompt, previewProjectPrompt, } from '../../../lib/prompts/previewPrompt.js';
 import { EXIT_CODES } from '../../../lib/enums/exitCodes.js';
-import { ApiErrorContext, logError } from '../../../lib/errorHandlers/index.js';
 import { getProjectConfig } from '../../../lib/projects/config.js';
 import { findProjectComponents } from '../../../lib/projects/structure.js';
 import { ComponentTypes } from '../../../types/Projects.js';
@@ -73,67 +69,16 @@ async function determineSrcAndDest(args) {
 async function handler(args) {
     const { derivedAccountId, noSsl, resetSession, port, generateFieldsTypes } = args;
     const { absoluteSrc, dest } = await determineSrcAndDest(args);
-    const filePaths = await getUploadableFileList(absoluteSrc, false);
-    function startProgressBar(numFiles) {
-        const initialUploadProgressBar = new cliProgress.SingleBar({
-            gracefulExit: true,
-            format: '[{bar}] {percentage}% | {value}/{total} | {label}',
-            hideCursor: true,
-        }, cliProgress.Presets.rect);
-        initialUploadProgressBar.start(numFiles, 0, {
-            label: commands.cms.subcommands.theme.subcommands.preview
-                .initialUploadProgressBar.start,
-        });
-        let uploadsHaveStarted = false;
-        const uploadOptions = {
-            onAttemptCallback: () => {
-                /* Intentionally blank */
-            },
-            onSuccessCallback: () => {
-                initialUploadProgressBar.increment();
-                if (!uploadsHaveStarted) {
-                    uploadsHaveStarted = true;
-                    initialUploadProgressBar.update(0, {
-                        label: commands.cms.subcommands.theme.subcommands.preview
-                            .initialUploadProgressBar.uploading,
-                    });
-                }
-            },
-            onFirstErrorCallback: () => {
-                /* Intentionally blank */
-            },
-            onRetryCallback: () => {
-                /* Intentionally blank */
-            },
-            onFinalErrorCallback: () => initialUploadProgressBar.increment(),
-            onFinishCallback: (results) => {
-                initialUploadProgressBar.update(numFiles, {
-                    label: commands.cms.subcommands.theme.subcommands.preview
-                        .initialUploadProgressBar.finish,
-                });
-                initialUploadProgressBar.stop();
-                results.forEach(result => {
-                    if (result.resultType == FILE_UPLOAD_RESULT_TYPES.FAILURE) {
-                        uiLogger.error(commands.cms.subcommands.theme.subcommands.preview.errors.uploadFailed(result.file, dest));
-                        logError(result.error, new ApiErrorContext({
-                            accountId: derivedAccountId,
-                            request: dest,
-                            payload: result.file,
-                        }));
-                    }
-                });
-            },
-        };
-        return uploadOptions;
-    }
     trackCommandUsage('preview', {}, derivedAccountId);
-    if (port) {
-        process.env['PORT'] = port.toString();
-    }
-    createDevServer(absoluteSrc, false, '', '', !noSsl, generateFieldsTypes, {
-        filePaths,
+    // Spawn dev server in isolated subprocess to avoid React version conflicts
+    // File listing and progress bars are handled within the subprocess
+    await spawnDevServer({
+        absoluteSrc,
+        accountName: derivedAccountId?.toString(),
+        noSsl,
+        port,
+        generateFieldsTypes,
         resetSession: resetSession || false,
-        startProgressBar,
         dest,
     });
 }

package/commands/cms/watch.d.ts

@@ -5,7 +5,6 @@ export type WatchCommandArgs = ConfigArgs & AccountArgs & EnvironmentArgs & Comm
     fieldOptions?: string[];
     remove?: boolean;
     initialUpload?: boolean;
-    disableInitial?: boolean;
     notify?: string;
     convertFields?: boolean;
     saveOutput?: boolean;

package/commands/cms/watch.js

@@ -15,7 +15,7 @@ import { uiLogger } from '../../lib/ui/logger.js';
 const command = 'watch [src] [dest]';
 const describe = commands.cms.subcommands.watch.describe;
 const handler = async (args) => {
-    const { remove, initialUpload, disableInitial, notify, derivedAccountId } = args;
+    const { remove, initialUpload, notify, derivedAccountId } = args;
     if (!validateCmsPublishMode(args)) {
         process.exit(EXIT_CODES.ERROR);
     }
@@ -40,13 +40,6 @@ const handler = async (args) => {
         return;
     }
     let filesToUpload = [];
-    if (disableInitial) {
-        uiLogger.info(commands.cms.subcommands.watch.warnings.disableInitial);
-    }
-    else if (!initialUpload) {
-        uiLogger.info(commands.cms.subcommands.watch.warnings.notUploaded(src));
-        uiLogger.info(commands.cms.subcommands.watch.warnings.initialUpload);
-    }
     if (initialUpload) {
         filesToUpload = await getUploadableFileList(absoluteSrcPath, args.convertFields);
     }
@@ -99,6 +92,7 @@ function watchBuilder(yargs) {
         describe: commands.cms.subcommands.watch.options.initialUpload,
         type: 'boolean',
     });
+    // TODO: remove this before the next major release
     yargs.option('disable-initial', {
         describe: commands.cms.subcommands.watch.options.disableInitial,
         type: 'boolean',

package/commands/feedback.js

@@ -4,7 +4,7 @@ import { makeYargsBuilder } from '../lib/yargsUtils.js';
 import { EXIT_CODES } from '../lib/enums/exitCodes.js';
 import { commands } from '../lang/en.js';
 import { uiLogger } from '../lib/ui/logger.js';
-const FEEDBACK_URL = 'https://developers.hubspot.com/feedback';
+import { FEEDBACK_URL } from '../lib/constants.js';
 const command = 'feedback';
 const describe = commands.project.feedback.describe;
 async function handler() {

package/commands/mcp/__tests__/start.test.js

@@ -7,14 +7,20 @@ import * as errorHandlers from '../../../lib/errorHandlers/index.js';
 import * as usageTrackingLib from '../../../lib/usageTracking.js';
 import * as processLib from '../../../lib/process.js';
 import { EXIT_CODES } from '../../../lib/enums/exitCodes.js';
-import startCommand from '../start.js';
+// Create a mock execAsync function before importing the module
+const execAsyncMock = vi.fn();
 vi.mock('yargs');
 vi.mock('../../../lib/commonOpts');
 vi.mock('node:child_process');
+vi.mock('node:util', () => ({
+    promisify: vi.fn(() => execAsyncMock),
+}));
 vi.mock('fs');
 vi.mock('@hubspot/local-dev-lib/config');
 vi.mock('../../../lib/errorHandlers/index.js');
 vi.mock('../../../lib/process.js');
+// Import after mocks are set up
+const startCommand = await import('../start.js').then(m => m.default);
 const spawnSpy = vi.mocked(spawn);
 const existsSyncSpy = vi.spyOn(fs, 'existsSync');
 const trackCommandUsageSpy = vi.spyOn(usageTrackingLib, 'trackCommandUsage');
@@ -36,6 +42,7 @@ describe('commands/mcp/start', () => {
         processExitSpy.mockImplementation(() => { });
         // Mock config to prevent reading actual config file in CI
         getConfigAccountIfExistsSpy.mockReturnValue(undefined);
+        execAsyncMock.mockClear();
     });
     describe('command', () => {
         it('should have the correct command structure', () => {

package/commands/mcp/setup.js

@@ -1,21 +1,13 @@
 import { EXIT_CODES } from '../../lib/enums/exitCodes.js';
 import { makeYargsBuilder } from '../../lib/yargsUtils.js';
 import { commands } from '../../lang/en.js';
-import { uiLogger } from '../../lib/ui/logger.js';
 import { addMcpServerToConfig, supportedTools } from '../../lib/mcp/setup.js';
 import { trackCommandUsage } from '../../lib/usageTracking.js';
-import { hasFeature } from '../../lib/hasFeature.js';
-import { FEATURES } from '../../lib/constants.js';
 const command = ['setup'];
 const describe = commands.mcp.setup.describe;
 async function handler(args) {
     const { derivedAccountId } = args;
-    const hasMcpAccess = await hasFeature(derivedAccountId, FEATURES.MCP_ACCESS);
-    if (!hasMcpAccess) {
-        uiLogger.error(commands.mcp.setup.errors.needsMcpAccess(derivedAccountId));
-        process.exit(EXIT_CODES.ERROR);
-    }
-    trackCommandUsage('mcp-setup', {}, args.derivedAccountId);
+    await trackCommandUsage('mcp-setup', {}, derivedAccountId);
     try {
         await addMcpServerToConfig(args.client);
     }

package/commands/mcp/start.js

@@ -28,7 +28,6 @@ async function startMcpServer(aiAgent) {
         uiLogger.debug(commands.mcp.start.startingServer);
         uiLogger.debug(commands.mcp.start.stopInstructions);
         const args = [serverPath];
-        // Start the server using ts-node
         const child = spawn(`node`, args, {
             stdio: 'inherit',
             env: {

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

@@ -50,7 +50,7 @@ describe('commands/project/create', () => {
             expect(optionsCall['platform-version']).toEqual(expect.objectContaining({
                 describe: 'The target platform version for the new project.',
                 type: 'string',
-                choices: ['2025.1', '2025.2'],
+                choices: ['2025.1', '2025.2', '2026.03-beta'],
                 default: '2025.2',
             }));
         });

package/commands/project/create.js

@@ -20,7 +20,7 @@ import { updateHsMetaFilesWithAutoGeneratedFields } from '../../lib/projects/com
 import SpinniesManager from '../../lib/ui/SpinniesManager.js';
 const command = ['create', 'init'];
 const describe = commands.project.create.describe;
-const { v2025_1, v2025_2 } = PLATFORM_VERSIONS;
+const { v2025_1, v2025_2, v2026_03_beta } = PLATFORM_VERSIONS;
 async function handler(args) {
     const { derivedAccountId, platformVersion, templateSource } = args;
     if (templateSource && !templateSource.includes('/')) {
@@ -125,7 +125,7 @@ function projectCreateBuilder(yargs) {
         'platform-version': {
             describe: commands.project.create.options.platformVersion.describe,
             type: 'string',
-            choices: [v2025_1, v2025_2],
+            choices: [v2025_1, v2025_2, v2026_03_beta],
             default: v2025_2,
         },
         'project-base': {

package/commands/project/watch.js

@@ -76,18 +76,30 @@ async function handler(args) {
     try {
         const { data: { results: builds }, } = await fetchProjectBuilds(derivedAccountId, projectConfig.name);
         const hasNoBuilds = !builds || !builds.length;
+        const handleWatchTermination = (error) => {
+            if (error) {
+                logError(error, new ApiErrorContext({ accountId: derivedAccountId }));
+                process.exit(EXIT_CODES.ERROR);
+            }
+            else {
+                process.exit(EXIT_CODES.SUCCESS);
+            }
+        };
         const startWatching = async () => {
-            await createWatcher(derivedAccountId, projectConfig, projectDir, handleBuildStatus, handleUserInput);
+            await createWatcher(derivedAccountId, projectConfig, projectDir, handleBuildStatus, handleUserInput, handleWatchTermination);
         };
         // Upload all files if no build exists for this project yet
         if (initialUpload || hasNoBuilds) {
-            const { uploadError } = await handleProjectUpload({
+            const { uploadError, projectNotFound } = await handleProjectUpload({
                 accountId: derivedAccountId,
                 projectConfig,
                 projectDir,
                 callbackFunc: startWatching,
                 isUploadCommand: false,
             });
+            if (projectNotFound) {
+                process.exit(EXIT_CODES.ERROR);
+            }
             if (uploadError) {
                 if (isSpecifiedError(uploadError, {
                     subCategory: PROJECT_ERROR_TYPES.PROJECT_LOCKED,
@@ -111,6 +123,7 @@ async function handler(args) {
     }
     catch (e) {
         logError(e, new ApiErrorContext({ accountId: derivedAccountId }));
+        process.exit(EXIT_CODES.ERROR);
     }
 }
 function projectWatchBuilder(yargs) {

package/lang/en.d.ts

@@ -43,6 +43,11 @@ export declare const commands: {
             checkOutConfig: (configPath: string) => string;
             pressEnterToInstall: (accountName: string) => string;
             pressKeyToExit: string;
+            installingApp: (appName: string, accountName: string) => string;
+            installInstructions: string;
+            browserFailedToOpen: (url: string) => string;
+            pollingTimeout: (minutes: number) => string;
+            pressEnterToContinueSetup: string;
             prompts: {
                 selectOptionV2: string;
                 options: {
@@ -596,11 +601,6 @@ export declare const commands: {
                     src: string;
                     dest: string;
                 };
-                warnings: {
-                    disableInitial: string;
-                    initialUpload: string;
-                    notUploaded: (path: string) => string;
-                };
             };
             fetch: {
                 describe: string;
@@ -1256,7 +1256,6 @@ export declare const commands: {
             };
             success: (derivedTargets: string[]) => string;
             errors: {
-                needsMcpAccess: (accountId?: number) => string;
                 errorParsingJsonFIle: (filename: string, errorMessage: string) => string;
             };
             spinners: {
@@ -1290,6 +1289,8 @@ export declare const commands: {
             prompts: {
                 targets: string;
                 targetsRequired: string;
+                standaloneMode: string;
+                cliVersion: string;
             };
         };
         start: {
@@ -3976,4 +3977,14 @@ export declare const lib: {
             copyingProjectFilesFailed: string;
         };
     };
+    theme: {
+        cmsDevServerProcess: {
+            installStarted: (targetVersion: string) => string;
+            installSucceeded: string;
+            installFailed: string;
+            serverStartError: (error: Error) => string;
+            serverExit: (code: number) => string;
+            serverKill: (signal: NodeJS.Signals) => string;
+        };
+    };
 };

package/lang/en.js

@@ -51,6 +51,11 @@ export const commands = {
             checkOutConfig: (configPath) => `Check out ${chalk.cyan(configPath)} for the full configuration.`,
             pressEnterToInstall: (accountName) => `? Press ${chalk.bold('<enter>')} to continue installing and previewing this app in ${chalk.bold(accountName)}`,
             pressKeyToExit: `Press any key to exit...`,
+            installingApp: (appName, accountName) => `Installing ${chalk.bold(appName)} in ${chalk.bold(accountName)}...`,
+            installInstructions: `We'll take you to your HubSpot account and walk you through installing your app.`,
+            browserFailedToOpen: (url) => `⚠️  Failed to open browser automatically. Please open this URL manually:\n${chalk.cyan(url)}`,
+            pollingTimeout: (minutes) => `⚠️  Installation polling timed out after ${minutes} minutes. The app may still be installing in the background.`,
+            pressEnterToContinueSetup: `Press ${chalk.bold('<enter>')} to continue with card setup...`,
             prompts: {
                 selectOptionV2: 'Choose a component type to get started',
                 options: {
@@ -604,11 +609,6 @@ export const commands = {
                     src: 'Path to the local directory your files are in, relative to your current working directory',
                     dest: 'Path in HubSpot Design Tools. Can be a net new path',
                 },
-                warnings: {
-                    disableInitial: `Passing the "${chalk.bold('--disable-initial')}" option is no longer necessary. Running "${uiCommandReference('hs watch')}" no longer uploads the watched directory by default.`,
-                    initialUpload: `To upload the directory run "${uiCommandReference('hs upload')}" beforehand or add the "${chalk.bold('--initial-upload')}" option when running "${uiCommandReference('hs watch')}".`,
-                    notUploaded: (path) => `The "${uiCommandReference('hs watch')}" command no longer uploads the watched directory when started. The directory "${path}" was not uploaded.`,
-                },
             },
             fetch: {
                 describe: 'Fetch a file, directory or module from HubSpot and write to a path on your computer.',
@@ -1266,7 +1266,6 @@ export const commands = {
             },
             success: (derivedTargets) => `You can now use the HubSpot CLI MCP Server in ${derivedTargets.join(', ')}.  ${chalk.bold('You may need to restart these tools to apply the changes')}.`,
             errors: {
-                needsMcpAccess: (accountId) => `You must opt in to the developer MCP beta to use this feature on ${uiAccountDescription(accountId)}. Try again with a different account or ${uiLink('join the beta now', getProductUpdatesUrl('239890', accountId))}`,
                 errorParsingJsonFIle: (filename, errorMessage) => `Unable to update ${chalk.bold(filename)} due to invalid JSON: ${errorMessage}`,
             },
             spinners: {
@@ -1306,6 +1305,8 @@ export const commands = {
             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.',
+                standaloneMode: 'Do you want to run in standalone mode? (This will use npx @hubspot/cli instead of the installed hs command)',
+                cliVersion: 'Specify a CLI version to pin (leave blank for latest):',
             },
         },
         start: {
@@ -3076,7 +3077,7 @@ export const lib = {
             updateSucceeded: (latestVersion) => `Successfully updated HubSpot CLI to version ${chalk.bold(latestVersion)}`,
             notInstalledGlobally: 'Cannot auto-update the HubSpot CLI because NPM is not installed globally',
             updateFailed: (latestVersion) => `Failed to update HubSpot CLI to version ${chalk.bold(latestVersion)}`,
-            enableAutoUpdatesMessage: `The HubSpot CLI can automatically keep itself up to date.\n\nThis helps ensure compatibility with the HubSpot platform. You can change this later at any time.\n\nRun${uiCommandReference('hs config set --allow-auto-updates=true')}`,
+            enableAutoUpdatesMessage: `The HubSpot CLI can automatically keep itself up to date.\n\nThis helps ensure compatibility with the HubSpot platform. You can change this later at any time.\n\nRun ${uiCommandReference('hs config set --allow-auto-updates=true')}`,
         },
     },
     projectProfiles: {
@@ -3999,4 +4000,14 @@ export const lib = {
             copyingProjectFilesFailed: 'Unable to copy migrated project files',
         },
     },
+    theme: {
+        cmsDevServerProcess: {
+            installStarted: (targetVersion) => `Installing cms-dev-server ${targetVersion}...`,
+            installSucceeded: 'cms-dev-server setup complete',
+            installFailed: 'Failed to install cms-dev-server',
+            serverStartError: (error) => `Failed to start dev server: ${error}`,
+            serverExit: (code) => `Dev server exited with code ${code}`,
+            serverKill: (signal) => `Dev server killed with signal ${signal}`,
+        },
+    },
 };

package/lib/__tests__/commandSuggestion.test.js

@@ -71,6 +71,8 @@ describe('lib/commandSuggestion', () => {
             // Create a mock yargs builder with strict method
             const mockYargsBuilder = {
                 strict: vi.fn().mockReturnThis(),
+                help: vi.fn().mockReturnThis(),
+                version: vi.fn().mockReturnThis(),
             };
             await commandModule.builder(mockYargsBuilder);
             expect(mockYargsBuilder.strict).toHaveBeenCalledWith(false);

package/lib/__tests__/serverlessLogs.test.js

@@ -1,6 +1,6 @@
-import mockStdIn from 'mock-stdin';
 import { outputLogs } from '../ui/serverlessFunctionLogs.js';
 import { tailLogs } from '../serverlessLogs.js';
+import { handleKeypress } from '../process.js';
 vi.mock('../ui/serverlessFunctionLogs');
 vi.mock('../ui/SpinniesManager', () => ({
     default: {
@@ -12,82 +12,87 @@ vi.mock('../ui/SpinniesManager', () => ({
         stopAll: vi.fn(),
     },
 }));
+vi.mock('../process');
 vi.useFakeTimers();
 const ACCOUNT_ID = 123;
+function terminateTailLogs() {
+    const keypressCallback = vi.mocked(handleKeypress).mock.calls[0][0];
+    keypressCallback({ name: 'q' });
+}
 describe('lib/serverlessLogs', () => {
     describe('tailLogs()', () => {
-        let stdinMock;
-        beforeEach(() => {
-            // @ts-ignore - we don't need to mock the entire process object
-            vi.spyOn(process, 'exit').mockImplementation(() => { });
-            stdinMock = mockStdIn.stdin();
-        });
         afterEach(() => {
             vi.clearAllTimers();
-            stdinMock.restore();
+            vi.clearAllMocks();
         });
         it('calls tailCall() to get the next results', async () => {
             const compact = false;
-            const fetchLatest = vi.fn(() => {
-                return Promise.resolve({
-                    data: {
-                        id: '1234',
-                        executionTime: 510,
-                        log: 'Log message',
-                        error: { message: '', type: '', stackTrace: [] },
-                        status: 'SUCCESS',
-                        createdAt: 1620232011451,
-                        memory: '70/128 MB',
-                        duration: '53.40 ms',
-                    },
-                    status: 200,
-                    statusText: 'OK',
-                    headers: {},
-                    config: {},
-                });
-            });
-            const tailCall = vi.fn(() => {
-                return Promise.resolve({
-                    data: {
-                        results: [],
-                        paging: {
-                            next: {
-                                after: 'somehash',
-                            },
+            const fetchLatest = vi.fn(() => Promise.resolve({
+                data: {
+                    id: '1234',
+                    executionTime: 510,
+                    log: 'Log message',
+                    error: { message: '', type: '', stackTrace: [] },
+                    status: 'SUCCESS',
+                    createdAt: 1620232011451,
+                    memory: '70/128 MB',
+                    duration: '53.40 ms',
+                },
+                status: 200,
+                statusText: 'OK',
+                headers: {},
+                // eslint-disable-next-line
+                config: { headers: {} },
+            }));
+            const tailCall = vi.fn(() => Promise.resolve({
+                data: {
+                    results: [],
+                    paging: {
+                        next: {
+                            after: 'somehash',
                         },
                     },
-                    status: 200,
-                    statusText: 'OK',
-                    headers: {},
-                    config: {},
-                });
-            });
+                },
+                status: 200,
+                statusText: 'OK',
+                headers: {},
+                // eslint-disable-next-line
+                config: { headers: {} },
+            }));
             // @ts-ignore - headers is not used in the actual function and does not need to be mocked
-            await tailLogs(ACCOUNT_ID, 'name', fetchLatest, tailCall, compact);
-            vi.runOnlyPendingTimers();
+            const tailPromise = tailLogs(ACCOUNT_ID, 'name', fetchLatest, tailCall, compact);
+            await vi.advanceTimersByTimeAsync(0);
             expect(fetchLatest).toHaveBeenCalled();
+            expect(tailCall).toHaveBeenCalledTimes(1);
+            await vi.advanceTimersByTimeAsync(5000);
             expect(tailCall).toHaveBeenCalledTimes(2);
+            terminateTailLogs();
+            await tailPromise;
         });
         it('outputs results', async () => {
             const compact = false;
-            const fetchLatest = vi.fn(() => {
-                return Promise.resolve({
-                    data: {
-                        id: '1234',
-                        executionTime: 510,
-                        log: 'Log message',
-                        error: { message: '', type: '', stackTrace: [], statusCode: null },
-                        status: 'SUCCESS',
-                        createdAt: 1620232011451,
-                        memory: '70/128 MB',
-                        duration: '53.40 ms',
+            const fetchLatest = vi.fn(() => Promise.resolve({
+                data: {
+                    id: '1234',
+                    executionTime: 510,
+                    log: 'Log message',
+                    error: {
+                        message: '',
+                        type: '',
+                        stackTrace: [],
+                        statusCode: null,
                     },
-                    status: 200,
-                    statusText: 'OK',
-                    headers: {},
-                    config: {},
-                });
-            });
+                    status: 'SUCCESS',
+                    createdAt: 1620232011451,
+                    memory: '70/128 MB',
+                    duration: '53.40 ms',
+                },
+                status: 200,
+                statusText: 'OK',
+                headers: {},
+                // eslint-disable-next-line
+                config: { headers: {} },
+            }));
             const latestLogResponse = {
                 results: [
                     {
@@ -117,12 +122,23 @@ describe('lib/serverlessLogs', () => {
                     },
                 },
             };
-            const tailCall = vi.fn(() => Promise.resolve({ data: latestLogResponse }));
+            const tailCall = vi.fn(() => Promise.resolve({
+                data: latestLogResponse,
+                status: 200,
+                statusText: 'OK',
+                headers: {},
+                // eslint-disable-next-line
+                config: { headers: {} },
+            }));
             // @ts-ignore - headers is not used in the actual function and does not need to be mocked
-            await tailLogs(ACCOUNT_ID, 'name', fetchLatest, tailCall, compact);
-            vi.runOnlyPendingTimers();
+            const tailPromise = tailLogs(ACCOUNT_ID, 'name', fetchLatest, tailCall, compact);
+            await vi.advanceTimersByTimeAsync(0);
             expect(outputLogs).toHaveBeenCalledWith(latestLogResponse, expect.objectContaining({ compact }));
+            expect(tailCall).toHaveBeenCalledTimes(1);
+            await vi.advanceTimersByTimeAsync(5000);
             expect(tailCall).toHaveBeenCalledTimes(2);
+            terminateTailLogs();
+            await tailPromise;
         });
         it('handles no logs', async () => {
             const compact = false;
@@ -141,8 +157,7 @@ describe('lib/serverlessLogs', () => {
                 statusCode: 404,
             }));
             await tailLogs(ACCOUNT_ID, 'name', fetchLatest, tailCall, compact);
-            vi.runOnlyPendingTimers();
-            expect(tailCall).toHaveBeenCalledTimes(2);
+            expect(tailCall).toHaveBeenCalledTimes(1);
         });
     });
 });