@hubspot/cli 8.0.0-experimental.0 → 8.0.1-experimental.0

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', () => {
@@ -133,5 +140,64 @@ describe('commands/mcp/start', () => {
             expect(uiLogger.error).toHaveBeenCalledWith(expect.stringContaining('Failed to start'));
             expect(logErrorSpy).toHaveBeenCalledWith(error);
         });
+        it('should fetch CLI version in standalone mode', async () => {
+            const originalEnv = process.env.HUBSPOT_MCP_STANDALONE;
+            process.env.HUBSPOT_MCP_STANDALONE = 'true';
+            execAsyncMock.mockResolvedValue({
+                stdout: '8.0.0',
+                stderr: '',
+            });
+            await startCommand.handler(args);
+            expect(execAsyncMock).toHaveBeenCalledWith('npm view @hubspot/cli version');
+            expect(spawnSpy).toHaveBeenCalledWith('node', expect.any(Array), expect.objectContaining({
+                env: expect.objectContaining({
+                    HUBSPOT_CLI_VERSION: '8.0.0',
+                }),
+            }));
+            // Restore original env
+            if (originalEnv === undefined) {
+                delete process.env.HUBSPOT_MCP_STANDALONE;
+            }
+            else {
+                process.env.HUBSPOT_MCP_STANDALONE = originalEnv;
+            }
+        });
+        it('should not fetch CLI version when not in standalone mode', async () => {
+            const originalEnv = process.env.HUBSPOT_MCP_STANDALONE;
+            delete process.env.HUBSPOT_MCP_STANDALONE;
+            await startCommand.handler(args);
+            expect(execAsyncMock).not.toHaveBeenCalled();
+            expect(spawnSpy).toHaveBeenCalledWith('node', expect.any(Array), expect.objectContaining({
+                env: expect.not.objectContaining({
+                    HUBSPOT_CLI_VERSION: expect.anything(),
+                }),
+            }));
+            // Restore original env
+            if (originalEnv !== undefined) {
+                process.env.HUBSPOT_MCP_STANDALONE = originalEnv;
+            }
+        });
+        it('should handle version fetch errors gracefully', async () => {
+            const originalEnv = process.env.HUBSPOT_MCP_STANDALONE;
+            process.env.HUBSPOT_MCP_STANDALONE = 'true';
+            const error = new Error('Version fetch failed');
+            execAsyncMock.mockRejectedValue(error);
+            await startCommand.handler(args);
+            expect(execAsyncMock).toHaveBeenCalledWith('npm view @hubspot/cli version');
+            expect(uiLogger.warn).toHaveBeenCalledWith(expect.stringContaining('Failed to get CLI version'));
+            expect(logErrorSpy).toHaveBeenCalledWith(error);
+            expect(spawnSpy).toHaveBeenCalledWith('node', expect.any(Array), expect.objectContaining({
+                env: expect.not.objectContaining({
+                    HUBSPOT_CLI_VERSION: expect.anything(),
+                }),
+            }));
+            // Restore original env
+            if (originalEnv === undefined) {
+                delete process.env.HUBSPOT_MCP_STANDALONE;
+            }
+            else {
+                process.env.HUBSPOT_MCP_STANDALONE = originalEnv;
+            }
+        });
     });
 });

package/commands/mcp/start.js

@@ -1,4 +1,5 @@
-import { spawn } from 'node:child_process';
+import { spawn, exec } from 'node:child_process';
+import { promisify } from 'node:util';
 import path from 'path';
 import fs from 'fs';
 import { EXIT_CODES } from '../../lib/enums/exitCodes.js';
@@ -9,6 +10,7 @@ import { commands } from '../../lang/en.js';
 import { handleExit } from '../../lib/process.js';
 import { trackCommandUsage } from '../../lib/usageTracking.js';
 import { fileURLToPath } from 'url';
+const execAsync = promisify(exec);
 const command = 'start';
 const describe = undefined; // Leave hidden for now
 const __filename = fileURLToPath(import.meta.url);
@@ -28,12 +30,28 @@ async function startMcpServer(aiAgent) {
         uiLogger.debug(commands.mcp.start.startingServer);
         uiLogger.debug(commands.mcp.start.stopInstructions);
         const args = [serverPath];
+        // Get CLI version if running in standalone mode
+        let cliVersion;
+        if (process.env.HUBSPOT_MCP_STANDALONE === 'true') {
+            try {
+                // const { stdout } = await execAsync('npm view @hubspot/cli version');
+                // // Extract version number from output (e.g., "8.0.0")
+                // cliVersion = stdout.trim();
+                cliVersion = '8.0.1-experimental.0';
+                uiLogger.debug(`Using @hubspot/cli version: ${cliVersion}`);
+            }
+            catch (error) {
+                uiLogger.warn('Failed to get CLI version, will use latest');
+                logError(error);
+            }
+        }
         // Start the server using ts-node
         const child = spawn(`node`, args, {
             stdio: 'inherit',
             env: {
                 ...process.env,
                 HUBSPOT_MCP_AI_AGENT: aiAgent || 'unknown',
+                ...(cliVersion && { HUBSPOT_CLI_VERSION: cliVersion }),
             },
         });
         // Handle server process events

package/lang/en.d.ts

@@ -1246,6 +1246,7 @@ export declare const commands: {
             prompts: {
                 targets: string;
                 targetsRequired: string;
+                standaloneMode: string;
             };
         };
         start: {
@@ -3132,14 +3133,6 @@ export declare const lib: {
             fileFiltered: (filename: string) => string;
             legacyFileDetected: (filename: string, platformVersion: string) => string;
             projectDoesNotExist: (accountId: number) => string;
-            workspaceIncluded: (workspaceDir: string, archivePath: string) => string;
-            fileDependencyIncluded: (packageName: string, localPath: string, archivePath: string) => string;
-            malformedPackageJson: (packageJsonPath: string, error: string) => string;
-            workspaceCollision: (archivePath: string, workspaceDir: string, existingWorkspace: string) => string;
-            fileDependencyAlreadyIncluded: (packageName: string, archivePath: string) => string;
-            updatingPackageJsonWorkspaces: (packageJsonPath: string) => string;
-            updatedWorkspaces: (workspaces: string) => string;
-            updatedFileDependency: (packageName: string, relativePath: string) => string;
         };
     };
     importData: {

package/lang/en.js

@@ -1262,6 +1262,7 @@ 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 local hs command)',
             },
         },
         start: {
@@ -3155,14 +3156,6 @@ export const lib = {
             fileFiltered: (filename) => `Ignore rule triggered for "${filename}"`,
             legacyFileDetected: (filename, platformVersion) => `The ${chalk.bold(filename)} file is not supported on platform version ${chalk.bold(platformVersion)} and will be ignored.`,
             projectDoesNotExist: (accountId) => `Upload cancelled. Run ${uiCommandReference('hs project upload')} again to create the project in ${uiAccountDescription(accountId)}.`,
-            workspaceIncluded: (workspaceDir, archivePath) => `Including workspace: ${workspaceDir} → ${archivePath}`,
-            fileDependencyIncluded: (packageName, localPath, archivePath) => `Including file: dependency ${packageName}: ${localPath} → ${archivePath}`,
-            malformedPackageJson: (packageJsonPath, error) => `Skipping malformed package.json at ${packageJsonPath}: ${error}`,
-            workspaceCollision: (archivePath, workspaceDir, existingWorkspace) => `Workspace collision: ${archivePath} from ${workspaceDir} and ${existingWorkspace}`,
-            fileDependencyAlreadyIncluded: (packageName, archivePath) => `file: dependency ${packageName} already included as workspace: ${archivePath}`,
-            updatingPackageJsonWorkspaces: (packageJsonPath) => `Updating package.json workspaces in archive: ${packageJsonPath}`,
-            updatedWorkspaces: (workspaces) => `  Updated workspaces: ${workspaces}`,
-            updatedFileDependency: (packageName, relativePath) => `  Updated dependencies.${packageName}: file:${relativePath}`,
         },
     },
     importData: {

package/lib/mcp/__tests__/setup.test.js

@@ -132,6 +132,23 @@ describe('lib/mcp/setup', () => {
             });
             expect(mockedLogError).toHaveBeenCalledWith(error);
         });
+        it('should pass through environment variables in command', async () => {
+            const mockMcpCommandWithEnv = {
+                command: 'test-command',
+                args: ['--arg1'],
+                env: { HUBSPOT_MCP_STANDALONE: 'true' },
+            };
+            mockedExecAsync.mockResolvedValueOnce({
+                stdout: 'codex version 1.0.0',
+                stderr: '',
+            });
+            mockedExecAsync.mockResolvedValueOnce({ stdout: '', stderr: '' });
+            const result = await setupCodex(mockMcpCommandWithEnv);
+            expect(result).toBe(true);
+            // The env is passed through buildCommandWithAgentString, but not used in the command string
+            // This is expected as env vars are set by the client when starting the MCP server
+            expect(mockedExecAsync).toHaveBeenCalledWith('codex mcp add "HubSpotDev" -- test-command --arg1 --ai-agent codex');
+        });
     });
     describe('setupGemini', () => {
         const mockMcpCommand = {

package/lib/mcp/setup.d.ts

@@ -5,6 +5,7 @@ export declare const supportedTools: {
 interface McpCommand {
     command: string;
     args: string[];
+    env?: Record<string, string>;
 }
 export declare function addMcpServerToConfig(targets: string[] | undefined): Promise<string[]>;
 export declare function setupVsCode(mcpCommand?: McpCommand): Promise<boolean>;

package/lib/mcp/setup.js

@@ -47,23 +47,44 @@ export async function addMcpServerToConfig(targets) {
         else {
             derivedTargets = targets;
         }
+        // Prompt for standalone mode
+        const { useStandaloneMode } = await promptUser({
+            name: 'useStandaloneMode',
+            type: 'confirm',
+            message: commands.mcp.setup.prompts.standaloneMode,
+            default: false,
+        });
+        const mcpCommand = useStandaloneMode
+            ? {
+                command: 'npx',
+                args: [
+                    '-y',
+                    '-p',
+                    '@hubspot/cli@8.0.1-experimental.0',
+                    'hs',
+                    'mcp',
+                    'start',
+                ],
+                env: { HUBSPOT_MCP_STANDALONE: 'true' },
+            }
+            : defaultMcpCommand;
         if (derivedTargets.includes(claudeCode)) {
-            await runSetupFunction(setupClaudeCode);
+            await runSetupFunction(() => setupClaudeCode(mcpCommand));
         }
         if (derivedTargets.includes(cursor)) {
-            await runSetupFunction(setupCursor);
+            await runSetupFunction(() => setupCursor(mcpCommand));
         }
         if (derivedTargets.includes(windsurf)) {
-            await runSetupFunction(setupWindsurf);
+            await runSetupFunction(() => setupWindsurf(mcpCommand));
         }
         if (derivedTargets.includes(vscode)) {
-            await runSetupFunction(setupVsCode);
+            await runSetupFunction(() => setupVsCode(mcpCommand));
         }
         if (derivedTargets.includes(codex)) {
-            await runSetupFunction(setupCodex);
+            await runSetupFunction(() => setupCodex(mcpCommand));
         }
         if (derivedTargets.includes(gemini)) {
-            await runSetupFunction(setupGemini);
+            await runSetupFunction(() => setupGemini(mcpCommand));
         }
         uiLogger.info(commands.mcp.setup.success(derivedTargets));
         return derivedTargets;
@@ -122,9 +143,14 @@ function setupMcpConfigFile(config) {
             mcpConfig.mcpServers = {};
         }
         // Add or update HubSpot CLI MCP server
-        mcpConfig.mcpServers[mcpServerName] = {
-            ...config.mcpCommand,
+        const serverConfig = {
+            command: config.mcpCommand.command,
+            args: config.mcpCommand.args,
         };
+        if (config.mcpCommand.env) {
+            serverConfig.env = config.mcpCommand.env;
+        }
+        mcpConfig.mcpServers[mcpServerName] = serverConfig;
         // Write the updated config
         fs.writeFileSync(config.configPath, JSON.stringify(mcpConfig, null, 2));
         SpinniesManager.succeed('spinner', {
@@ -145,10 +171,16 @@ export async function setupVsCode(mcpCommand = defaultMcpCommand) {
         SpinniesManager.add('vsCode', {
             text: commands.mcp.setup.spinners.configuringVsCode,
         });
-        const mcpConfig = JSON.stringify({
+        const commandWithAgent = buildCommandWithAgentString(mcpCommand, vscode);
+        const configObject = {
             name: mcpServerName,
-            ...buildCommandWithAgentString(mcpCommand, vscode),
-        });
+            command: commandWithAgent.command,
+            args: commandWithAgent.args,
+        };
+        if (commandWithAgent.env) {
+            configObject.env = commandWithAgent.env;
+        }
+        const mcpConfig = JSON.stringify(configObject);
         await execAsync(`code --add-mcp ${JSON.stringify(mcpConfig)}`);
         SpinniesManager.succeed('vsCode', {
             text: commands.mcp.setup.spinners.configuredVsCode,
@@ -180,10 +212,16 @@ export async function setupClaudeCode(mcpCommand = defaultMcpCommand) {
             // Check if claude command is available
             await execAsync('claude --version');
             // Run claude mcp add command
-            const mcpConfig = JSON.stringify({
+            const commandWithAgent = buildCommandWithAgentString(mcpCommand, claudeCode);
+            const configObject = {
                 type: 'stdio',
-                ...buildCommandWithAgentString(mcpCommand, claudeCode),
-            });
+                command: commandWithAgent.command,
+                args: commandWithAgent.args,
+            };
+            if (commandWithAgent.env) {
+                configObject.env = commandWithAgent.env;
+            }
+            const mcpConfig = JSON.stringify(configObject);
             const { stdout } = await execAsync('claude mcp list');
             if (stdout.includes(mcpServerName)) {
                 SpinniesManager.update('claudeCode', {

package/lib/projects/__tests__/upload.test.js

@@ -13,7 +13,6 @@ import { walk } from '@hubspot/local-dev-lib/fs';
 import { uploadProject } from '@hubspot/local-dev-lib/api/projects';
 import { ensureProjectExists } from '../ensureProjectExists.js';
 import { projectContainsHsMetaFiles } from '@hubspot/project-parsing-lib/projects';
-import { findAndParsePackageJsonFiles, collectWorkspaceDirectories, collectFileDependencies, } from '@hubspot/project-parsing-lib/workspaces';
 import { shouldIgnoreFile } from '@hubspot/local-dev-lib/ignoreRules';
 import { getConfigAccountIfExists } from '@hubspot/local-dev-lib/config';
 // Mock dependencies
@@ -23,11 +22,6 @@ vi.mock('@hubspot/local-dev-lib/fs');
 vi.mock('@hubspot/local-dev-lib/api/projects');
 vi.mock('../ensureProjectExists.js');
 vi.mock('@hubspot/project-parsing-lib/projects');
-vi.mock('@hubspot/project-parsing-lib/workspaces', () => ({
-    findAndParsePackageJsonFiles: vi.fn(),
-    collectWorkspaceDirectories: vi.fn(),
-    collectFileDependencies: vi.fn(),
-}));
 vi.mock('@hubspot/local-dev-lib/ignoreRules');
 vi.mock('@hubspot/local-dev-lib/config');
 vi.mock('archiver');
@@ -128,10 +122,6 @@ describe('lib/projects/upload', () => {
             vi.mocked(shouldIgnoreFile).mockReturnValue(false);
             vi.mocked(projectContainsHsMetaFiles).mockResolvedValue(false);
             vi.mocked(isV2Project).mockReturnValue(false);
-            // Mock workspace functions to return empty arrays
-            vi.mocked(findAndParsePackageJsonFiles).mockResolvedValue([]);
-            vi.mocked(collectWorkspaceDirectories).mockResolvedValue([]);
-            vi.mocked(collectFileDependencies).mockResolvedValue([]);
             vi.mocked(tmp.fileSync).mockReturnValue({
                 name: path.join(tempDir, 'test.zip'),
                 fd: 1,

package/lib/projects/upload.js

@@ -6,7 +6,6 @@ import { uploadProject } from '@hubspot/local-dev-lib/api/projects';
 import { shouldIgnoreFile } from '@hubspot/local-dev-lib/ignoreRules';
 import { isTranslationError, translate, } from '@hubspot/project-parsing-lib/translate';
 import { projectContainsHsMetaFiles } from '@hubspot/project-parsing-lib/projects';
-import { findAndParsePackageJsonFiles, collectWorkspaceDirectories, collectFileDependencies, } from '@hubspot/project-parsing-lib/workspaces';
 import SpinniesManager from '../ui/SpinniesManager.js';
 import { uiAccountDescription } from '../ui/index.js';
 import { logError } from '../errorHandlers/index.js';
@@ -19,7 +18,6 @@ import { EXIT_CODES } from '../enums/exitCodes.js';
 import ProjectValidationError from '../errors/ProjectValidationError.js';
 import { walk } from '@hubspot/local-dev-lib/fs';
 import { LEGACY_CONFIG_FILES } from '../constants.js';
-import { archiveWorkspacesAndDependencies } from './workspaces.js';
 async function uploadProjectFiles(accountId, projectName, filePath, uploadMessage, platformVersion, intermediateRepresentation) {
     const accountIdentifier = uiAccountDescription(accountId) || `${accountId}`;
     SpinniesManager.add('upload', {
@@ -64,11 +62,6 @@ export async function handleProjectUpload({ accountId, projectConfig, projectDir
     }
     const tempFile = tmp.fileSync({ postfix: '.zip' });
     uiLogger.debug(lib.projectUpload.handleProjectUpload.compressing(tempFile.name));
-    // Find and parse all package.json files once (avoids duplicate filesystem walks)
-    const parsedPackageJsons = await findAndParsePackageJsonFiles(srcDir);
-    // Collect workspace directories and file: dependencies from parsed data
-    const workspaceMappings = await collectWorkspaceDirectories(parsedPackageJsons);
-    const fileDependencyMappings = await collectFileDependencies(parsedPackageJsons);
     const output = fs.createWriteStream(tempFile.name);
     const archive = archiver('zip');
     const result = new Promise(resolve => output.on('close', async function () {
@@ -121,8 +114,6 @@ export async function handleProjectUpload({ accountId, projectConfig, projectDir
         }
         return ignored ? false : file;
     });
-    // Archive workspaces and file: dependencies
-    await archiveWorkspacesAndDependencies(archive, srcDir, projectDir, workspaceMappings, fileDependencyMappings);
     archive.finalize();
     return result;
 }

package/mcp-server/utils/__tests__/project.test.js

@@ -136,5 +136,130 @@ describe('mcp-server/utils/project', () => {
                 env: expect.any(Object),
             }));
         });
+        it('should use npx -p @hubspot/cli when HUBSPOT_MCP_STANDALONE is true', async () => {
+            const originalEnv = process.env.HUBSPOT_MCP_STANDALONE;
+            process.env.HUBSPOT_MCP_STANDALONE = 'true';
+            const hsCommand = 'hs project upload';
+            const expectedResult = {
+                stdout: 'success',
+                stderr: '',
+            };
+            mockExistsSync.mockReturnValue(true);
+            mockExecAsync.mockResolvedValue(expectedResult);
+            await runCommandInDir(mockDirectory, hsCommand);
+            expect(mockExecAsync).toHaveBeenCalledWith('npx -p @hubspot/cli hs project upload --disable-usage-tracking "true"', expect.objectContaining({
+                cwd: mockResolvedPath,
+                env: expect.any(Object),
+            }));
+            // Restore original env
+            if (originalEnv === undefined) {
+                delete process.env.HUBSPOT_MCP_STANDALONE;
+            }
+            else {
+                process.env.HUBSPOT_MCP_STANDALONE = originalEnv;
+            }
+        });
+        it('should use regular hs command when HUBSPOT_MCP_STANDALONE is not set', async () => {
+            const originalEnv = process.env.HUBSPOT_MCP_STANDALONE;
+            delete process.env.HUBSPOT_MCP_STANDALONE;
+            const hsCommand = 'hs project upload';
+            const expectedResult = {
+                stdout: 'success',
+                stderr: '',
+            };
+            mockExistsSync.mockReturnValue(true);
+            mockExecAsync.mockResolvedValue(expectedResult);
+            await runCommandInDir(mockDirectory, hsCommand);
+            expect(mockExecAsync).toHaveBeenCalledWith('hs project upload --disable-usage-tracking "true"', expect.objectContaining({
+                cwd: mockResolvedPath,
+                env: expect.any(Object),
+            }));
+            // Restore original env
+            if (originalEnv !== undefined) {
+                process.env.HUBSPOT_MCP_STANDALONE = originalEnv;
+            }
+        });
+        it('should use npx -p @hubspot/cli for hs commands with flags in standalone mode', async () => {
+            const originalEnv = process.env.HUBSPOT_MCP_STANDALONE;
+            process.env.HUBSPOT_MCP_STANDALONE = 'true';
+            const hsCommand = 'hs project upload --profile prod';
+            const expectedResult = {
+                stdout: 'success',
+                stderr: '',
+            };
+            mockExistsSync.mockReturnValue(true);
+            mockExecAsync.mockResolvedValue(expectedResult);
+            await runCommandInDir(mockDirectory, hsCommand);
+            expect(mockExecAsync).toHaveBeenCalledWith('npx -p @hubspot/cli hs project upload --profile prod --disable-usage-tracking "true"', expect.objectContaining({
+                cwd: mockResolvedPath,
+                env: expect.any(Object),
+            }));
+            // Restore original env
+            if (originalEnv === undefined) {
+                delete process.env.HUBSPOT_MCP_STANDALONE;
+            }
+            else {
+                process.env.HUBSPOT_MCP_STANDALONE = originalEnv;
+            }
+        });
+        it('should use pinned CLI version when HUBSPOT_CLI_VERSION is set in standalone mode', async () => {
+            const originalStandaloneEnv = process.env.HUBSPOT_MCP_STANDALONE;
+            const originalVersionEnv = process.env.HUBSPOT_CLI_VERSION;
+            process.env.HUBSPOT_MCP_STANDALONE = 'true';
+            process.env.HUBSPOT_CLI_VERSION = '8.0.0';
+            const hsCommand = 'hs project upload';
+            const expectedResult = {
+                stdout: 'success',
+                stderr: '',
+            };
+            mockExistsSync.mockReturnValue(true);
+            mockExecAsync.mockResolvedValue(expectedResult);
+            await runCommandInDir(mockDirectory, hsCommand);
+            expect(mockExecAsync).toHaveBeenCalledWith('npx -p @hubspot/cli@8.0.0 hs project upload --disable-usage-tracking "true"', expect.objectContaining({
+                cwd: mockResolvedPath,
+                env: expect.any(Object),
+            }));
+            // Restore original env
+            if (originalStandaloneEnv === undefined) {
+                delete process.env.HUBSPOT_MCP_STANDALONE;
+            }
+            else {
+                process.env.HUBSPOT_MCP_STANDALONE = originalStandaloneEnv;
+            }
+            if (originalVersionEnv === undefined) {
+                delete process.env.HUBSPOT_CLI_VERSION;
+            }
+            else {
+                process.env.HUBSPOT_CLI_VERSION = originalVersionEnv;
+            }
+        });
+        it('should use latest CLI version when HUBSPOT_CLI_VERSION is not set in standalone mode', async () => {
+            const originalStandaloneEnv = process.env.HUBSPOT_MCP_STANDALONE;
+            const originalVersionEnv = process.env.HUBSPOT_CLI_VERSION;
+            process.env.HUBSPOT_MCP_STANDALONE = 'true';
+            delete process.env.HUBSPOT_CLI_VERSION;
+            const hsCommand = 'hs project upload';
+            const expectedResult = {
+                stdout: 'success',
+                stderr: '',
+            };
+            mockExistsSync.mockReturnValue(true);
+            mockExecAsync.mockResolvedValue(expectedResult);
+            await runCommandInDir(mockDirectory, hsCommand);
+            expect(mockExecAsync).toHaveBeenCalledWith('npx -p @hubspot/cli hs project upload --disable-usage-tracking "true"', expect.objectContaining({
+                cwd: mockResolvedPath,
+                env: expect.any(Object),
+            }));
+            // Restore original env
+            if (originalStandaloneEnv === undefined) {
+                delete process.env.HUBSPOT_MCP_STANDALONE;
+            }
+            else {
+                process.env.HUBSPOT_MCP_STANDALONE = originalStandaloneEnv;
+            }
+            if (originalVersionEnv !== undefined) {
+                process.env.HUBSPOT_CLI_VERSION = originalVersionEnv;
+            }
+        });
     });
 });

package/mcp-server/utils/project.js

@@ -7,6 +7,14 @@ export async function runCommandInDir(directory, command) {
     }
     let finalCommand = command;
     if (command.startsWith('hs ')) {
+        // Check if running in standalone mode
+        if (process.env.HUBSPOT_MCP_STANDALONE === 'true') {
+            // Use pinned version if available, otherwise use latest
+            const cliPackage = process.env.HUBSPOT_CLI_VERSION
+                ? `@hubspot/cli@8.0.1-experimental.0`
+                : '@hubspot/cli';
+            finalCommand = command.replace(/^hs /, `npx -y -p ${cliPackage} hs `);
+        }
         finalCommand = addFlag(finalCommand, 'disable-usage-tracking', true);
     }
     return execAsync(finalCommand, {

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@hubspot/cli",
-    "version": "8.0.0-experimental.0",
+    "version": "8.0.1-experimental.0",
     "description": "The official CLI for developing on HubSpot",
     "license": "Apache-2.0",
     "repository": "https://github.com/HubSpot/hubspot-cli",
@@ -8,7 +8,7 @@
     "dependencies": {
         "@hubspot/cms-dev-server": "1.2.1",
         "@hubspot/local-dev-lib": "5.1.1",
-        "@hubspot/project-parsing-lib": "0.1.0-experimental.0",
+        "@hubspot/project-parsing-lib": "0.11.2",
         "@hubspot/serverless-dev-runtime": "7.0.7",
         "@hubspot/ui-extensions-dev-server": "1.1.3",
         "@inquirer/prompts": "7.1.0",

package/lib/projects/__tests__/workspaceArchive.test.d.ts

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

package/lib/projects/__tests__/workspaceArchive.test.js

@@ -1,237 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import path from 'path';
-import { determineWorkspaceArchivePath, determineFileDependencyArchivePath, shortHash, } from '../workspaces.js';
-describe('determineWorkspaceArchivePath', () => {
-    const projectDir = '/Users/test/my-project';
-    describe('internal workspaces', () => {
-        it('handles workspace in src directory', () => {
-            const workspaceDir = path.join(projectDir, 'src/app/workspaces/utils');
-            const result = determineWorkspaceArchivePath(workspaceDir, projectDir);
-            expect(result).toBe(path.join('_workspaces', 'src/app/workspaces/utils'));
-            expect(result).not.toContain('..');
-        });
-        it('handles workspace at project root', () => {
-            const workspaceDir = path.join(projectDir, 'packages/core');
-            const result = determineWorkspaceArchivePath(workspaceDir, projectDir);
-            expect(result).toBe(path.join('_workspaces', 'packages/core'));
-            expect(result).not.toContain('..');
-        });
-        it('handles deeply nested workspace', () => {
-            const workspaceDir = path.join(projectDir, 'src/app/functions/shared/utils/http');
-            const result = determineWorkspaceArchivePath(workspaceDir, projectDir);
-            expect(result).toBe(path.join('_workspaces', 'src/app/functions/shared/utils/http'));
-            expect(result).not.toContain('..');
-        });
-    });
-    describe('external workspaces', () => {
-        it('handles workspace outside project directory', () => {
-            const workspaceDir = '/Users/test/company-libs/utils';
-            const result = determineWorkspaceArchivePath(workspaceDir, projectDir);
-            const expectedHash = shortHash(path.resolve(workspaceDir));
-            expect(result).toBe(path.join('_workspaces', 'external', `utils-${expectedHash}`));
-            expect(result).not.toContain('..');
-        });
-        it('handles workspace in home directory', () => {
-            const workspaceDir = '/Users/test/shared-code/helpers';
-            const result = determineWorkspaceArchivePath(workspaceDir, projectDir);
-            const expectedHash = shortHash(path.resolve(workspaceDir));
-            expect(result).toBe(path.join('_workspaces', 'external', `helpers-${expectedHash}`));
-            expect(result).not.toContain('..');
-        });
-        it('handles workspace with parent directory navigation', () => {
-            const workspaceDir = '/Users/test/other-project/shared';
-            const result = determineWorkspaceArchivePath(workspaceDir, projectDir);
-            const expectedHash = shortHash(path.resolve(workspaceDir));
-            expect(result).toBe(path.join('_workspaces', 'external', `shared-${expectedHash}`));
-            expect(result).not.toContain('..');
-        });
-        it('detects path traversal vulnerability with similar project names', () => {
-            // This tests the vulnerability where /Users/test/my-project-malicious
-            // would incorrectly be treated as internal with startsWith() check
-            const maliciousWorkspace = '/Users/test/my-project-malicious/evil';
-            const result = determineWorkspaceArchivePath(maliciousWorkspace, projectDir);
-            const expectedHash = shortHash(path.resolve(maliciousWorkspace));
-            // Should be treated as external, not internal
-            expect(result).toBe(path.join('_workspaces', 'external', `evil-${expectedHash}`));
-            expect(result).not.toContain('my-project-malicious');
-        });
-        it('includes hash suffix for deterministic collision prevention', () => {
-            const workspaceDir = '/Users/test/libs/utils';
-            const result = determineWorkspaceArchivePath(workspaceDir, projectDir);
-            // Normalize path separators for cross-platform compatibility (Windows uses backslashes)
-            const normalized = result.replace(/\\/g, '/');
-            // Verify the hash suffix format: basename-8hexchars
-            expect(normalized).toMatch(/_workspaces\/external\/utils-[a-f0-9]{8}$/);
-        });
-    });
-    describe('path validity', () => {
-        it('never produces paths with .. segments', () => {
-            const testCases = [
-                path.join(projectDir, 'src/utils'),
-                '/Users/other/libs/utils',
-                '/completely/different/path',
-                path.join(projectDir, '../sibling-project/shared'),
-            ];
-            testCases.forEach(workspaceDir => {
-                const result = determineWorkspaceArchivePath(workspaceDir, projectDir);
-                expect(result).not.toContain('..');
-            });
-        });
-        it('always starts with _workspaces/', () => {
-            const testCases = [
-                path.join(projectDir, 'src/utils'),
-                '/Users/other/libs/utils',
-                path.join(projectDir, 'packages/core'),
-            ];
-            testCases.forEach(workspaceDir => {
-                const result = determineWorkspaceArchivePath(workspaceDir, projectDir);
-                expect(result.startsWith('_workspaces')).toBe(true);
-            });
-        });
-    });
-});
-describe('workspace collision prevention', () => {
-    const projectDir = '/Users/test/my-project';
-    it('prevents collision when two external workspaces have same basename', () => {
-        const workspace1 = '/Users/test/project-a/utils';
-        const workspace2 = '/Users/test/project-b/utils';
-        const path1 = determineWorkspaceArchivePath(workspace1, projectDir);
-        const path2 = determineWorkspaceArchivePath(workspace2, projectDir);
-        // Paths should be DIFFERENT due to hash suffix
-        expect(path1).not.toBe(path2);
-        // Both should contain the basename
-        expect(path1).toContain('utils-');
-        expect(path2).toContain('utils-');
-        // Both should be in external folder
-        expect(path1).toContain('external');
-        expect(path2).toContain('external');
-    });
-    it('produces deterministic paths for the same workspace', () => {
-        const workspaceDir = '/Users/test/libs/utils';
-        const path1 = determineWorkspaceArchivePath(workspaceDir, projectDir);
-        const path2 = determineWorkspaceArchivePath(workspaceDir, projectDir);
-        // Same input should always produce same output
-        expect(path1).toBe(path2);
-    });
-    it('no collision when workspaces have different names', () => {
-        const workspace1 = '/Users/test/libs/utils';
-        const workspace2 = '/Users/test/libs/helpers';
-        const path1 = determineWorkspaceArchivePath(workspace1, projectDir);
-        const path2 = determineWorkspaceArchivePath(workspace2, projectDir);
-        expect(path1).not.toBe(path2);
-    });
-    it('no collision between internal and external with same basename', () => {
-        const internalWorkspace = path.join(projectDir, 'src/utils');
-        const externalWorkspace = '/Users/test/other/utils';
-        const path1 = determineWorkspaceArchivePath(internalWorkspace, projectDir);
-        const path2 = determineWorkspaceArchivePath(externalWorkspace, projectDir);
-        const expectedHash = shortHash(path.resolve(externalWorkspace));
-        expect(path1).not.toBe(path2);
-        expect(path1).toBe(path.join('_workspaces', 'src/utils'));
-        expect(path2).toBe(path.join('_workspaces', 'external', `utils-${expectedHash}`));
-    });
-});
-describe('package.json workspace mapping', () => {
-    const projectDir = '/project';
-    it('maps workspaces to correct package.json files using determineWorkspaceArchivePath', () => {
-        const mappings = [
-            {
-                workspaceDir: '/project/src/app/workspaces/functions-utils',
-                sourcePackageJsonPath: '/project/src/app/functions/package.json',
-            },
-            {
-                workspaceDir: '/project/src/app/workspaces/cards-utils',
-                sourcePackageJsonPath: '/project/src/app/cards/package.json',
-            },
-        ];
-        const packageWorkspaces = new Map();
-        for (const mapping of mappings) {
-            // Use the actual function to determine archive path
-            const archivePath = determineWorkspaceArchivePath(mapping.workspaceDir, projectDir);
-            if (!packageWorkspaces.has(mapping.sourcePackageJsonPath)) {
-                packageWorkspaces.set(mapping.sourcePackageJsonPath, []);
-            }
-            packageWorkspaces.get(mapping.sourcePackageJsonPath).push(archivePath);
-        }
-        // Internal workspaces use relative paths (no hash)
-        expect(packageWorkspaces.get('/project/src/app/functions/package.json')).toEqual([path.join('_workspaces', 'src/app/workspaces/functions-utils')]);
-        expect(packageWorkspaces.get('/project/src/app/cards/package.json')).toEqual([path.join('_workspaces', 'src/app/workspaces/cards-utils')]);
-    });
-    it('handles multiple external workspaces per package.json with hash suffixes', () => {
-        const mappings = [
-            {
-                workspaceDir: '/external/utils-a',
-                sourcePackageJsonPath: '/project/package.json',
-            },
-            {
-                workspaceDir: '/external/utils-b',
-                sourcePackageJsonPath: '/project/package.json',
-            },
-        ];
-        const packageWorkspaces = new Map();
-        for (const mapping of mappings) {
-            const archivePath = determineWorkspaceArchivePath(mapping.workspaceDir, projectDir);
-            if (!packageWorkspaces.has(mapping.sourcePackageJsonPath)) {
-                packageWorkspaces.set(mapping.sourcePackageJsonPath, []);
-            }
-            packageWorkspaces.get(mapping.sourcePackageJsonPath).push(archivePath);
-        }
-        const workspaces = packageWorkspaces.get('/project/package.json');
-        expect(workspaces).toHaveLength(2);
-        // External workspaces should have hash suffixes
-        expect(workspaces[0]).toMatch(/_workspaces\/external\/utils-a-[a-f0-9]{8}/);
-        expect(workspaces[1]).toMatch(/_workspaces\/external\/utils-b-[a-f0-9]{8}/);
-    });
-});
-describe('shortHash', () => {
-    it('produces 8-character hex string', () => {
-        const hash = shortHash('/some/path');
-        expect(hash).toMatch(/^[a-f0-9]{8}$/);
-    });
-    it('is deterministic', () => {
-        const input = '/Users/test/workspace';
-        expect(shortHash(input)).toBe(shortHash(input));
-    });
-    it('produces different hashes for different inputs', () => {
-        const hash1 = shortHash('/path/a');
-        const hash2 = shortHash('/path/b');
-        expect(hash1).not.toBe(hash2);
-    });
-});
-describe('determineFileDependencyArchivePath', () => {
-    it('places file: dependencies in _workspaces/external/', () => {
-        const localPath = '/Users/test/my-local-lib';
-        const result = determineFileDependencyArchivePath(localPath);
-        expect(result).toContain('_workspaces');
-        expect(result).toContain('external');
-        expect(result).toContain('my-local-lib');
-    });
-    it('includes hash suffix for collision prevention', () => {
-        const localPath = '/Users/test/libs/utils';
-        const result = determineFileDependencyArchivePath(localPath);
-        // Should match pattern: _workspaces/external/utils-[8 hex chars]
-        expect(result).toMatch(/_workspaces\/external\/utils-[a-f0-9]{8}$/);
-    });
-    it('produces different paths for different local paths with same basename', () => {
-        const path1 = '/Users/test/project-a/utils';
-        const path2 = '/Users/test/project-b/utils';
-        const result1 = determineFileDependencyArchivePath(path1);
-        const result2 = determineFileDependencyArchivePath(path2);
-        expect(result1).not.toBe(result2);
-        expect(result1).toContain('utils-');
-        expect(result2).toContain('utils-');
-    });
-    it('is deterministic', () => {
-        const localPath = '/Users/test/my-lib';
-        const result1 = determineFileDependencyArchivePath(localPath);
-        const result2 = determineFileDependencyArchivePath(localPath);
-        expect(result1).toBe(result2);
-    });
-    it('handles scoped package directories', () => {
-        const localPath = '/Users/test/libs/@company/shared-utils';
-        const result = determineFileDependencyArchivePath(localPath);
-        // Should use the last path segment (shared-utils) as the basename
-        expect(result).toContain('shared-utils-');
-        expect(result).toMatch(/_workspaces\/external\/shared-utils-[a-f0-9]{8}$/);
-    });
-});

package/lib/projects/workspaces.d.ts

@@ -1,35 +0,0 @@
-import archiver from 'archiver';
-import { WorkspaceMapping, FileDependencyMapping } from '@hubspot/project-parsing-lib/workspaces';
-/**
- * Result of archiving workspaces and file dependencies
- */
-export type WorkspaceArchiveResult = {
-    packageWorkspaces: Map<string, string[]>;
-    packageFileDeps: Map<string, Map<string, string>>;
-};
-/**
- * Generates a short hash of the input string for use in workspace paths.
- * Uses SHA256 truncated to 8 hex characters (4 billion possibilities).
- */
-export declare function shortHash(input: string): string;
-/**
- * Determines the archive path for a workspace directory.
- * Internal workspaces use their relative path from projectDir.
- * External workspaces use 'external' subdirectory + basename + hash.
- */
-export declare function determineWorkspaceArchivePath(workspaceDir: string, projectDir: string): string;
-/**
- * Determines the archive path for a file: dependency.
- * All file: dependencies are treated as external and placed in _workspaces/external/
- * with a hash suffix to prevent collisions.
- */
-export declare function determineFileDependencyArchivePath(localPath: string): string;
-/**
- * Updates package.json files in the archive to reflect new workspace and file: dependency paths.
- */
-export declare function updatePackageJsonInArchive(archive: archiver.Archiver, srcDir: string, packageWorkspaces: Map<string, string[]>, packageFileDeps: Map<string, Map<string, string>>): Promise<void>;
-/**
- * Main orchestration function that handles archiving of workspaces and file dependencies.
- * This is the clean integration point for upload.ts.
- */
-export declare function archiveWorkspacesAndDependencies(archive: archiver.Archiver, srcDir: string, projectDir: string, workspaceMappings: WorkspaceMapping[], fileDependencyMappings: FileDependencyMapping[]): Promise<WorkspaceArchiveResult>;

package/lib/projects/workspaces.js

@@ -1,216 +0,0 @@
-import fs from 'fs-extra';
-import path from 'path';
-import crypto from 'crypto';
-import { shouldIgnoreFile } from '@hubspot/local-dev-lib/ignoreRules';
-import { getPackableFiles, } from '@hubspot/project-parsing-lib/workspaces';
-import { uiLogger } from '../ui/logger.js';
-import { lib } from '../../lang/en.js';
-/**
- * Generates a short hash of the input string for use in workspace paths.
- * Uses SHA256 truncated to 8 hex characters (4 billion possibilities).
- */
-export function shortHash(input) {
-    return crypto.createHash('sha256').update(input).digest('hex').slice(0, 8);
-}
-/**
- * Determines the archive path for a workspace directory.
- * Internal workspaces use their relative path from projectDir.
- * External workspaces use 'external' subdirectory + basename + hash.
- */
-export function determineWorkspaceArchivePath(workspaceDir, projectDir) {
-    const normalizedWorkspace = path.resolve(workspaceDir);
-    const normalizedProject = path.resolve(projectDir);
-    const relPath = path.relative(normalizedProject, normalizedWorkspace);
-    if (!relPath.startsWith('..') && !path.isAbsolute(relPath)) {
-        // Internal workspace - use relative path from projectDir
-        return path.join('_workspaces', relPath);
-    }
-    else {
-        // External workspace - use 'external' subdirectory + basename + hash
-        const workspaceName = path.basename(normalizedWorkspace);
-        const hash = shortHash(normalizedWorkspace);
-        return path.join('_workspaces', 'external', `${workspaceName}-${hash}`);
-    }
-}
-/**
- * Determines the archive path for a file: dependency.
- * All file: dependencies are treated as external and placed in _workspaces/external/
- * with a hash suffix to prevent collisions.
- */
-export function determineFileDependencyArchivePath(localPath) {
-    const normalizedPath = path.resolve(localPath);
-    const depName = path.basename(normalizedPath);
-    const hash = shortHash(normalizedPath);
-    return path.join('_workspaces', 'external', `${depName}-${hash}`);
-}
-/**
- * Creates a file filter function for workspace archiving.
- * Filters files based on packable files list and ignore rules.
- */
-function createWorkspaceFileFilter(packableFiles) {
-    return (file) => {
-        if (packableFiles.size > 0 && !packableFiles.has(file.name)) {
-            uiLogger.debug(lib.projectUpload.handleProjectUpload.fileFiltered(file.name));
-            return false;
-        }
-        const ignored = shouldIgnoreFile(file.name, true);
-        if (ignored) {
-            uiLogger.debug(lib.projectUpload.handleProjectUpload.fileFiltered(file.name));
-            return false;
-        }
-        return file;
-    };
-}
-/**
- * Archives workspace directories and returns mapping information.
- */
-async function archiveWorkspaceDirectories(archive, projectDir, workspaceMappings) {
-    const workspacePaths = new Map();
-    const archivePathToWorkspace = new Map();
-    const packageWorkspaces = new Map();
-    // First pass: determine archive paths and check for collisions (O(n) with reverse map)
-    for (const mapping of workspaceMappings) {
-        const { workspaceDir, sourcePackageJsonPath } = mapping;
-        const archivePath = determineWorkspaceArchivePath(workspaceDir, projectDir);
-        // Check for name collisions using reverse map (O(1) lookup)
-        const existingWorkspace = archivePathToWorkspace.get(archivePath);
-        if (existingWorkspace) {
-            throw new Error(lib.projectUpload.handleProjectUpload.workspaceCollision(archivePath, workspaceDir, existingWorkspace));
-        }
-        archivePathToWorkspace.set(archivePath, workspaceDir);
-        workspacePaths.set(workspaceDir, archivePath);
-        // Track which archive paths belong to which package.json
-        if (!packageWorkspaces.has(sourcePackageJsonPath)) {
-            packageWorkspaces.set(sourcePackageJsonPath, []);
-        }
-        packageWorkspaces.get(sourcePackageJsonPath).push(archivePath);
-    }
-    // Fetch all packable files in parallel (I/O optimization)
-    const workspacePackableFiles = await Promise.all(workspaceMappings.map(async (mapping) => ({
-        mapping,
-        packableFiles: await getPackableFiles(mapping.workspaceDir),
-    })));
-    // Archive directories sequentially (archiver requires sequential operations)
-    for (const { mapping, packableFiles } of workspacePackableFiles) {
-        const { workspaceDir } = mapping;
-        const archivePath = workspacePaths.get(workspaceDir);
-        uiLogger.log(lib.projectUpload.handleProjectUpload.workspaceIncluded(workspaceDir, archivePath));
-        archive.directory(workspaceDir, archivePath, createWorkspaceFileFilter(packableFiles));
-    }
-    return { workspacePaths, archivePathToWorkspace, packageWorkspaces };
-}
-/**
- * Archives file: dependencies and returns mapping information.
- */
-async function archiveFileDependencies(archive, fileDependencyMappings, workspacePaths, archivePathToWorkspace) {
-    const packageFileDeps = new Map();
-    const fileDepPathsToArchive = [];
-    // First pass: determine which file deps need archiving and track mappings
-    for (const mapping of fileDependencyMappings) {
-        const { packageName, localPath, sourcePackageJsonPath } = mapping;
-        const archivePath = determineFileDependencyArchivePath(localPath);
-        // Check for path collisions using reverse map (O(1) lookup)
-        if (archivePathToWorkspace.has(archivePath)) {
-            uiLogger.debug(lib.projectUpload.handleProjectUpload.fileDependencyAlreadyIncluded(packageName, archivePath));
-            // Still track the dependency mapping even if already archived
-            if (!packageFileDeps.has(sourcePackageJsonPath)) {
-                packageFileDeps.set(sourcePackageJsonPath, new Map());
-            }
-            packageFileDeps.get(sourcePackageJsonPath).set(packageName, archivePath);
-            continue;
-        }
-        // Only archive each unique path once
-        if (!workspacePaths.has(localPath)) {
-            workspacePaths.set(localPath, archivePath);
-            archivePathToWorkspace.set(archivePath, localPath);
-            fileDepPathsToArchive.push({ localPath, archivePath, packageName });
-        }
-        // Track which package.json has which file: dependencies
-        if (!packageFileDeps.has(sourcePackageJsonPath)) {
-            packageFileDeps.set(sourcePackageJsonPath, new Map());
-        }
-        packageFileDeps.get(sourcePackageJsonPath).set(packageName, archivePath);
-    }
-    // Fetch all packable files in parallel (I/O optimization)
-    const fileDepPackableFiles = await Promise.all(fileDepPathsToArchive.map(async ({ localPath, archivePath, packageName }) => ({
-        localPath,
-        archivePath,
-        packageName,
-        packableFiles: await getPackableFiles(localPath),
-    })));
-    // Archive directories sequentially (archiver requires sequential operations)
-    for (const { localPath, archivePath, packageName, packableFiles, } of fileDepPackableFiles) {
-        uiLogger.log(lib.projectUpload.handleProjectUpload.fileDependencyIncluded(packageName, localPath, archivePath));
-        archive.directory(localPath, archivePath, createWorkspaceFileFilter(packableFiles));
-    }
-    return packageFileDeps;
-}
-/**
- * Updates package.json files in the archive to reflect new workspace and file: dependency paths.
- */
-export async function updatePackageJsonInArchive(archive, srcDir, packageWorkspaces, packageFileDeps) {
-    // Collect all package.json paths that need updating
-    const allPackageJsonPaths = new Set([
-        ...packageWorkspaces.keys(),
-        ...packageFileDeps.keys(),
-    ]);
-    for (const packageJsonPath of allPackageJsonPaths) {
-        if (!fs.existsSync(packageJsonPath)) {
-            continue;
-        }
-        let packageJson;
-        try {
-            packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
-        }
-        catch (e) {
-            uiLogger.warn(lib.projectUpload.handleProjectUpload.malformedPackageJson(packageJsonPath, e instanceof Error ? e.message : String(e)));
-            continue;
-        }
-        const relativePackageJsonPath = path.relative(srcDir, packageJsonPath);
-        const packageJsonDir = path.dirname(relativePackageJsonPath);
-        let modified = false;
-        // Update workspaces field if this package.json has workspaces
-        const workspaceArchivePaths = packageWorkspaces.get(packageJsonPath);
-        if (workspaceArchivePaths && packageJson.workspaces) {
-            packageJson.workspaces = workspaceArchivePaths;
-            modified = true;
-            uiLogger.debug(lib.projectUpload.handleProjectUpload.updatingPackageJsonWorkspaces(relativePackageJsonPath));
-            uiLogger.debug(lib.projectUpload.handleProjectUpload.updatedWorkspaces(workspaceArchivePaths.join(', ')));
-        }
-        // Update file: dependencies if this package.json has any
-        const fileDeps = packageFileDeps.get(packageJsonPath);
-        if (fileDeps && fileDeps.size > 0 && packageJson.dependencies) {
-            for (const [packageName, archivePath] of fileDeps.entries()) {
-                if (packageJson.dependencies[packageName]?.startsWith('file:')) {
-                    // Calculate relative path from package.json location to archive path
-                    const relativePath = path.relative(packageJsonDir, archivePath);
-                    packageJson.dependencies[packageName] = `file:${relativePath}`;
-                    modified = true;
-                    uiLogger.debug(lib.projectUpload.handleProjectUpload.updatedFileDependency(packageName, relativePath));
-                }
-            }
-        }
-        if (modified) {
-            // Add modified package.json to archive (will replace the original)
-            archive.append(JSON.stringify(packageJson, null, 2), {
-                name: relativePackageJsonPath,
-            });
-        }
-    }
-    // Ensure all append operations are queued before finalize is called
-    // Use setImmediate to yield control and let archiver process the queue
-    await new Promise(resolve => setImmediate(resolve));
-}
-/**
- * Main orchestration function that handles archiving of workspaces and file dependencies.
- * This is the clean integration point for upload.ts.
- */
-export async function archiveWorkspacesAndDependencies(archive, srcDir, projectDir, workspaceMappings, fileDependencyMappings) {
-    // Archive workspace directories
-    const { workspacePaths, archivePathToWorkspace, packageWorkspaces } = await archiveWorkspaceDirectories(archive, projectDir, workspaceMappings);
-    // Archive file: dependencies
-    const packageFileDeps = await archiveFileDependencies(archive, fileDependencyMappings, workspacePaths, archivePathToWorkspace);
-    // Update package.json files with new paths
-    await updatePackageJsonInArchive(archive, srcDir, packageWorkspaces, packageFileDeps);
-    return { packageWorkspaces, packageFileDeps };
-}