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

package/lib/errorHandlers/__tests__/index.test.js

@@ -0,0 +1,278 @@
+import { logError, debugError, ApiErrorContext, isErrorWithMessageOrReason, getErrorMessage, } from '../index.js';
+import { uiLogger } from '../../ui/logger.js';
+import { isHubSpotHttpError, isValidationError, } from '@hubspot/local-dev-lib/errors/index';
+import { getConfig } from '@hubspot/local-dev-lib/config';
+import { shouldSuppressError } from '../suppressError.js';
+import { isProjectValidationError } from '../../errors/ProjectValidationError.js';
+import { lib } from '../../../lang/en.js';
+vi.mock('../../ui/logger.js');
+vi.mock('@hubspot/local-dev-lib/errors/index');
+vi.mock('@hubspot/local-dev-lib/config');
+vi.mock('../suppressError.js');
+vi.mock('../../errors/ProjectValidationError.js');
+describe('lib/errorHandlers/index', () => {
+    const uiLoggerErrorMock = uiLogger.error;
+    const uiLoggerDebugMock = uiLogger.debug;
+    const isHubSpotHttpErrorMock = isHubSpotHttpError;
+    const isValidationErrorMock = isValidationError;
+    const getConfigMock = getConfig;
+    const shouldSuppressErrorMock = shouldSuppressError;
+    const isProjectValidationErrorMock = isProjectValidationError;
+    beforeEach(() => {
+        vi.clearAllMocks();
+        isHubSpotHttpErrorMock.mockReturnValue(false);
+        isValidationErrorMock.mockReturnValue(false);
+        shouldSuppressErrorMock.mockReturnValue(false);
+        isProjectValidationErrorMock.mockReturnValue(false);
+        getConfigMock.mockReturnValue({});
+    });
+    describe('logError', () => {
+        it('logs ProjectValidationError message and returns early', () => {
+            const error = {
+                message: 'Project validation failed',
+                name: 'ProjectValidationError',
+            };
+            isProjectValidationErrorMock.mockReturnValue(true);
+            logError(error);
+            expect(uiLoggerErrorMock).toHaveBeenCalledWith('Project validation failed');
+            expect(uiLoggerErrorMock).toHaveBeenCalledTimes(1);
+        });
+        it('returns early when error should be suppressed', () => {
+            const error = new Error('Suppressed error');
+            shouldSuppressErrorMock.mockReturnValue(true);
+            logError(error);
+            expect(shouldSuppressErrorMock).toHaveBeenCalled();
+            expect(uiLoggerErrorMock).not.toHaveBeenCalled();
+        });
+        it('logs validation errors for HubSpotHttpError with validation errors', () => {
+            const mockError = {
+                formattedValidationErrors: vi
+                    .fn()
+                    .mockReturnValue('Formatted validation errors'),
+                updateContext: vi.fn(),
+                context: {},
+            };
+            isHubSpotHttpErrorMock.mockReturnValue(true);
+            isValidationErrorMock.mockReturnValue(true);
+            logError(mockError);
+            expect(mockError.formattedValidationErrors).toHaveBeenCalled();
+            expect(uiLoggerErrorMock).toHaveBeenCalledWith('Formatted validation errors');
+        });
+        it('logs error message for errors with message property', () => {
+            const error = new Error('Something went wrong');
+            logError(error);
+            expect(uiLoggerErrorMock).toHaveBeenCalledWith('Something went wrong');
+        });
+        it('logs error with both message and reason', () => {
+            const error = { message: 'Error message', reason: 'Error reason' };
+            logError(error);
+            expect(uiLoggerErrorMock).toHaveBeenCalledWith('Error message Error reason');
+        });
+        it('logs unknown error message for errors without message or reason', () => {
+            const error = { foo: 'bar' };
+            logError(error);
+            expect(uiLoggerErrorMock).toHaveBeenCalledWith(lib.errorHandlers.index.unknownErrorOccurred);
+        });
+        it('calls updateContext on HubSpotHttpError', () => {
+            const mockError = {
+                updateContext: vi.fn(),
+                context: {},
+                message: 'test',
+            };
+            isHubSpotHttpErrorMock.mockReturnValue(true);
+            logError(mockError);
+            expect(mockError.updateContext).toHaveBeenCalled();
+        });
+        describe('timeout error handling', () => {
+            it('shows config timeout message for direct ETIMEDOUT error matching default timeout', () => {
+                const mockError = {
+                    code: 'ETIMEDOUT',
+                    timeout: 15000,
+                    updateContext: vi.fn(),
+                    context: {},
+                    message: 'Timeout',
+                };
+                isHubSpotHttpErrorMock.mockReturnValue(true);
+                getConfigMock.mockReturnValue({ httpTimeout: 15000 });
+                logError(mockError);
+                expect(uiLoggerErrorMock).toHaveBeenCalledTimes(2);
+                expect(uiLoggerErrorMock).toHaveBeenNthCalledWith(1, 'Timeout');
+                expect(uiLoggerErrorMock).toHaveBeenNthCalledWith(2, lib.errorHandlers.index.configTimeoutErrorOccurred(15000, 'hs config set'));
+            });
+            it('shows generic timeout message for direct ETIMEDOUT error with custom timeout', () => {
+                const mockError = {
+                    code: 'ETIMEDOUT',
+                    timeout: 30000,
+                    updateContext: vi.fn(),
+                    context: {},
+                    message: 'Timeout',
+                };
+                isHubSpotHttpErrorMock.mockReturnValue(true);
+                getConfigMock.mockReturnValue({ httpTimeout: 15000 });
+                logError(mockError);
+                expect(uiLoggerErrorMock).toHaveBeenCalledTimes(2);
+                expect(uiLoggerErrorMock).toHaveBeenNthCalledWith(2, lib.errorHandlers.index.genericTimeoutErrorOccurred);
+            });
+            it('detects timeout error wrapped in error.cause', () => {
+                const causeError = {
+                    code: 'ETIMEDOUT',
+                    timeout: 15000,
+                    name: 'HubSpotHttpError',
+                };
+                const wrapperError = new Error('Assets unavailable');
+                Object.defineProperty(wrapperError, 'cause', {
+                    value: causeError,
+                    writable: true,
+                });
+                isHubSpotHttpErrorMock.mockImplementation(err => {
+                    return err === causeError;
+                });
+                getConfigMock.mockReturnValue({ httpTimeout: 15000 });
+                logError(wrapperError);
+                expect(uiLoggerErrorMock).toHaveBeenCalledWith('Assets unavailable');
+                expect(uiLoggerErrorMock).toHaveBeenCalledWith(lib.errorHandlers.index.configTimeoutErrorOccurred(15000, 'hs config set'));
+            });
+            it('shows generic timeout message for wrapped timeout with different timeout value', () => {
+                const causeError = {
+                    code: 'ETIMEDOUT',
+                    timeout: 60000,
+                    name: 'HubSpotHttpError',
+                };
+                const wrapperError = new Error('Assets unavailable');
+                Object.defineProperty(wrapperError, 'cause', {
+                    value: causeError,
+                    writable: true,
+                });
+                isHubSpotHttpErrorMock.mockImplementation(err => {
+                    return err === causeError;
+                });
+                getConfigMock.mockReturnValue({ httpTimeout: 15000 });
+                logError(wrapperError);
+                expect(uiLoggerErrorMock).toHaveBeenCalledTimes(2);
+                expect(uiLoggerErrorMock).toHaveBeenNthCalledWith(2, lib.errorHandlers.index.genericTimeoutErrorOccurred);
+            });
+            it('does not show timeout message for non-timeout errors', () => {
+                const error = new Error('Regular error');
+                logError(error);
+                expect(uiLoggerErrorMock).toHaveBeenCalledTimes(1);
+                expect(uiLoggerErrorMock).toHaveBeenCalledWith('Regular error');
+            });
+        });
+    });
+    describe('debugError', () => {
+        it('logs HubSpotHttpError using toString', () => {
+            const mockError = {
+                toString: vi.fn().mockReturnValue('HubSpotHttpError details'),
+            };
+            isHubSpotHttpErrorMock.mockReturnValue(true);
+            debugError(mockError);
+            expect(uiLoggerDebugMock).toHaveBeenCalledWith('HubSpotHttpError details');
+        });
+        it('logs regular error using lib.errorHandlers.index.errorOccurred', () => {
+            const error = new Error('Regular error');
+            debugError(error);
+            expect(uiLoggerDebugMock).toHaveBeenCalledWith(lib.errorHandlers.index.errorOccurred('Error: Regular error'));
+        });
+        it('logs error.cause when it is a HubSpotHttpError', () => {
+            const causeError = {
+                toString: vi.fn().mockReturnValue('Cause error details'),
+            };
+            const error = new Error('Wrapper error');
+            Object.defineProperty(error, 'cause', {
+                value: causeError,
+                writable: true,
+            });
+            isHubSpotHttpErrorMock.mockImplementation(err => {
+                return err === causeError;
+            });
+            debugError(error);
+            expect(causeError.toString).toHaveBeenCalled();
+            expect(uiLoggerDebugMock).toHaveBeenCalledWith('Cause error details');
+        });
+        it('logs error.cause using lib.errorHandlers.index.errorCause when not a HubSpotHttpError', () => {
+            const causeError = { customField: 'value' };
+            const error = new Error('Wrapper error');
+            Object.defineProperty(error, 'cause', {
+                value: causeError,
+                writable: true,
+            });
+            debugError(error);
+            expect(uiLoggerDebugMock).toHaveBeenCalledWith(expect.stringMatching(/^Cause:/));
+        });
+        it('logs context using lib.errorHandlers.index.errorContext when provided', () => {
+            const error = new Error('Error');
+            const context = new ApiErrorContext({
+                accountId: 123,
+                request: '/api/test',
+            });
+            debugError(error, context);
+            expect(uiLoggerDebugMock).toHaveBeenCalledWith(expect.stringMatching(/^Context:/));
+        });
+    });
+    describe('ApiErrorContext', () => {
+        it('creates context with all properties', () => {
+            const context = new ApiErrorContext({
+                accountId: 123,
+                request: '/api/test',
+                payload: '{"data": "value"}',
+                projectName: 'my-project',
+            });
+            expect(context.accountId).toBe(123);
+            expect(context.request).toBe('/api/test');
+            expect(context.payload).toBe('{"data": "value"}');
+            expect(context.projectName).toBe('my-project');
+        });
+        it('creates context with default values', () => {
+            const context = new ApiErrorContext();
+            expect(context.accountId).toBeUndefined();
+            expect(context.request).toBe('');
+            expect(context.payload).toBe('');
+            expect(context.projectName).toBe('');
+        });
+        it('creates context with partial properties', () => {
+            const context = new ApiErrorContext({
+                accountId: 456,
+            });
+            expect(context.accountId).toBe(456);
+            expect(context.request).toBe('');
+            expect(context.payload).toBe('');
+            expect(context.projectName).toBe('');
+        });
+    });
+    describe('isErrorWithMessageOrReason', () => {
+        it('returns true for object with message property', () => {
+            expect(isErrorWithMessageOrReason({ message: 'test' })).toBe(true);
+        });
+        it('returns true for object with reason property', () => {
+            expect(isErrorWithMessageOrReason({ reason: 'test' })).toBe(true);
+        });
+        it('returns true for object with both message and reason', () => {
+            expect(isErrorWithMessageOrReason({ message: 'msg', reason: 'rsn' })).toBe(true);
+        });
+        it('returns true for Error instances', () => {
+            expect(isErrorWithMessageOrReason(new Error('test'))).toBe(true);
+        });
+        it('returns false for null', () => {
+            expect(isErrorWithMessageOrReason(null)).toBe(false);
+        });
+        it('returns false for undefined', () => {
+            expect(isErrorWithMessageOrReason(undefined)).toBe(false);
+        });
+        it('returns false for primitive values', () => {
+            expect(isErrorWithMessageOrReason('string')).toBe(false);
+            expect(isErrorWithMessageOrReason(123)).toBe(false);
+            expect(isErrorWithMessageOrReason(true)).toBe(false);
+        });
+        it('returns false for object without message or reason', () => {
+            expect(isErrorWithMessageOrReason({ foo: 'bar' })).toBe(false);
+        });
+        it('returns false for empty object', () => {
+            expect(isErrorWithMessageOrReason({})).toBe(false);
+        });
+    });
+    describe('getErrorMessage', () => {
+        it('returns message from Error instance', () => {
+            expect(getErrorMessage(new Error('Error message'))).toBe('Error message');
+        });
+    });
+});

package/lib/errorHandlers/index.js

@@ -36,12 +36,21 @@ export function logError(error, context) {
         // Unknown errors
         uiLogger.error(lib.errorHandlers.index.unknownErrorOccurred);
     }
+    let timeoutError = null;
     if (isHubSpotHttpError(error) && error.code === 'ETIMEDOUT') {
+        timeoutError = error;
+    }
+    else if (error instanceof Error &&
+        isHubSpotHttpError(error.cause) &&
+        error.cause.code === 'ETIMEDOUT') {
+        timeoutError = error.cause;
+    }
+    if (timeoutError) {
         const config = getConfig();
         const defaultTimeout = config?.httpTimeout;
         // Timeout was caused by the default timeout
-        if (error.timeout && defaultTimeout === error.timeout) {
-            uiLogger.error(lib.errorHandlers.index.configTimeoutErrorOccurred(error.timeout, 'hs config set'));
+        if (timeoutError.timeout && defaultTimeout === timeoutError.timeout) {
+            uiLogger.error(lib.errorHandlers.index.configTimeoutErrorOccurred(timeoutError.timeout, 'hs config set'));
         }
         // Timeout was caused by a custom timeout set by the CLI or LDL
         else {

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

@@ -285,7 +285,7 @@ describe('lib/projects/components', () => {
                 type: 'app',
                 uid: 'app_test_app',
                 config: {
-                    name: 'test-app-Application',
+                    name: 'test-app-App',
                     other: 'property',
                 },
             }, null, 2));

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

@@ -13,6 +13,7 @@ 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
@@ -22,6 +23,11 @@ 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');
@@ -122,6 +128,10 @@ 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/__tests__/workspaceArchive.test.d.ts

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

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

@@ -0,0 +1,237 @@
+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/components.js

@@ -190,7 +190,7 @@ export async function updateHsMetaFilesWithAutoGeneratedFields(projectName, hsMe
             }
             component.uid = uid;
             if (component.type === AppKey && component.config) {
-                component.config.name = `${projectName}-Application`;
+                component.config.name = `${projectName}-App`;
             }
             fs.writeFileSync(hsMetaFile, JSON.stringify(component, null, 2));
         }

package/lib/projects/upload.js

@@ -6,6 +6,7 @@ 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';
@@ -18,6 +19,7 @@ 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', {
@@ -62,6 +64,11 @@ 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 () {
@@ -114,6 +121,8 @@ 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;
 }