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

package/lib/projects/workspaces.js

@@ -0,0 +1,365 @@
+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);
+}
+/**
+ * Converts native path separators to POSIX forward slashes.
+ *
+ * Zip entry names and npm workspace globs are POSIX-only. On Windows,
+ * `path.relative` returns backslash-separated paths; archiver normalizes
+ * its appended entry names to forward slashes but its filter callback
+ * receives forward-slashed names too. Without this normalization, lookups
+ * in our exclusion Sets miss on Windows and a file gets archived twice.
+ */
+export function toPosixPath(p) {
+    if (path.sep === path.posix.sep) {
+        return p;
+    }
+    return p.replaceAll(path.sep, path.posix.sep);
+}
+/**
+ * Determines the archive path for an external workspace or file: dependency.
+ * Produces `_workspaces/<basename>-<hash>` with no subdirectory.
+ * The hash prevents collisions between different directories with the same basename.
+ */
+export function computeExternalArchivePath(absolutePath) {
+    const resolved = path.resolve(absolutePath);
+    const name = path.basename(resolved);
+    return path.posix.join('_workspaces', `${name}-${shortHash(resolved)}`);
+}
+/**
+ * Returns true if dir is inside srcDir (i.e. it will already be included
+ * in the archive from the srcDir walk and must not be copied again).
+ */
+function isInsideSrcDir(dir, srcDir) {
+    const rel = path.relative(path.resolve(srcDir), path.resolve(dir));
+    return !rel.startsWith('..') && !path.isAbsolute(rel);
+}
+/**
+ * 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.
+ *
+ * Internal workspaces (inside srcDir) are not archived — they are already
+ * included via the srcDir walk. Their relative paths (from the package.json
+ * directory to the workspace directory) are stored directly in the entries.
+ *
+ * External workspaces (outside srcDir) are copied to `_workspaces/<name>-<hash>`
+ * and their relative archive paths (e.g. `../_workspaces/<name>-<hash>`) are stored.
+ */
+async function archiveWorkspaceDirectories(archive, srcDir, workspaceMappings) {
+    const externalArchivePaths = new Map(); // resolvedDir -> archivePath
+    const archivePathToDir = new Map(); // archivePath -> resolvedDir (collision detection)
+    const packageWorkspaceEntries = new Map();
+    const externalsToArchive = [];
+    for (const mapping of workspaceMappings) {
+        const { workspaceDir, sourcePackageJsonPath } = mapping;
+        if (!packageWorkspaceEntries.has(sourcePackageJsonPath)) {
+            packageWorkspaceEntries.set(sourcePackageJsonPath, []);
+        }
+        if (isInsideSrcDir(workspaceDir, srcDir)) {
+            // Internal: already in archive from srcDir walk.
+            // Store the relative path from the package.json directory so npm can resolve it.
+            const relPath = toPosixPath(path.relative(path.dirname(sourcePackageJsonPath), path.resolve(workspaceDir)));
+            packageWorkspaceEntries.get(sourcePackageJsonPath).push(relPath);
+        }
+        else {
+            // External: archive to _workspaces/<name>-<hash>.
+            const archivePath = computeExternalArchivePath(workspaceDir);
+            const resolvedDir = path.resolve(workspaceDir);
+            // Detect hash collisions (different dirs mapping to the same archive path)
+            const existing = archivePathToDir.get(archivePath);
+            if (existing && existing !== resolvedDir) {
+                throw new Error(lib.projectUpload.handleProjectUpload.workspaceCollision(archivePath, workspaceDir, existing));
+            }
+            if (!externalArchivePaths.has(resolvedDir)) {
+                externalArchivePaths.set(resolvedDir, archivePath);
+                archivePathToDir.set(archivePath, resolvedDir);
+                externalsToArchive.push({ dir: workspaceDir, archivePath });
+            }
+            const relPkgJsonDir = path.relative(srcDir, path.dirname(sourcePackageJsonPath));
+            const relativeEntry = toPosixPath(path.relative(relPkgJsonDir, archivePath));
+            packageWorkspaceEntries.get(sourcePackageJsonPath).push(relativeEntry);
+        }
+    }
+    // Fetch packable files in parallel (I/O optimization)
+    const withPackableFiles = await Promise.all(externalsToArchive.map(async (item) => ({
+        ...item,
+        packableFiles: await getPackableFiles(item.dir),
+    })));
+    // Archive directories sequentially (archiver requires sequential operations)
+    for (const { dir, archivePath, packableFiles } of withPackableFiles) {
+        uiLogger.log(lib.projectUpload.handleProjectUpload.workspaceIncluded(dir, archivePath));
+        archive.directory(dir, archivePath, createWorkspaceFileFilter(packableFiles));
+    }
+    return { externalArchivePaths, packageWorkspaceEntries };
+}
+/**
+ * Archives file: dependencies and returns mapping information.
+ *
+ * Internal file: dependencies (inside srcDir) are skipped — their original
+ * `file:` references in package.json remain valid after upload.
+ *
+ * External file: dependencies are archived to `_workspaces/<name>-<hash>`
+ * and tracked in the returned map so package.json can be rewritten.
+ */
+async function archiveFileDependencies(archive, srcDir, fileDependencyMappings, externalArchivePaths) {
+    const packageFileDeps = new Map();
+    const toArchive = [];
+    for (const mapping of fileDependencyMappings) {
+        const { packageName, localPath, sourcePackageJsonPath } = mapping;
+        if (isInsideSrcDir(localPath, srcDir)) {
+            // Internal: original file: reference stays unchanged, nothing to do
+            continue;
+        }
+        // External: archive to _workspaces/<name>-<hash>
+        const archivePath = computeExternalArchivePath(localPath);
+        const resolvedPath = path.resolve(localPath);
+        if (!packageFileDeps.has(sourcePackageJsonPath)) {
+            packageFileDeps.set(sourcePackageJsonPath, new Map());
+        }
+        const relPkgJsonDir = path.relative(srcDir, path.dirname(sourcePackageJsonPath));
+        const relativeArchivePath = toPosixPath(path.relative(relPkgJsonDir, archivePath));
+        packageFileDeps
+            .get(sourcePackageJsonPath)
+            .set(packageName, relativeArchivePath);
+        // Only archive each unique path once
+        if (!externalArchivePaths.has(resolvedPath)) {
+            externalArchivePaths.set(resolvedPath, archivePath);
+            toArchive.push({ localPath, archivePath, packageName });
+        }
+    }
+    // Fetch packable files in parallel (I/O optimization)
+    const withPackableFiles = await Promise.all(toArchive.map(async (item) => ({
+        ...item,
+        packableFiles: await getPackableFiles(item.localPath),
+    })));
+    // Archive directories sequentially (archiver requires sequential operations)
+    for (const { localPath, archivePath, packageName, packableFiles, } of withPackableFiles) {
+        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.
+ *
+ * Workspace entries in packageWorkspaces are already in final form:
+ * - Internal workspaces: relative paths (e.g. "../packages/utils")
+ * - External workspaces: relative paths (e.g. "../_workspaces/logger-abc")
+ *
+ * Only external file: dependencies appear in packageFileDeps; internal ones
+ * keep their original file: references and are left untouched.
+ */
+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;
+        }
+        const relativePackageJsonPath = toPosixPath(path.relative(srcDir, packageJsonPath));
+        let rawContent;
+        try {
+            rawContent = fs.readFileSync(packageJsonPath, 'utf8');
+        }
+        catch {
+            continue;
+        }
+        let packageJson;
+        try {
+            packageJson = JSON.parse(rawContent);
+        }
+        catch (e) {
+            uiLogger.warn(lib.projectUpload.handleProjectUpload.malformedPackageJson(packageJsonPath, e instanceof Error ? e.message : String(e)));
+            archive.append(rawContent, { name: relativePackageJsonPath });
+            continue;
+        }
+        let modified = false;
+        // Update workspaces field — entries are already in their final form
+        const workspaceEntries = packageWorkspaces.get(packageJsonPath);
+        if (workspaceEntries && packageJson.workspaces) {
+            packageJson.workspaces = workspaceEntries;
+            modified = true;
+            uiLogger.debug(lib.projectUpload.handleProjectUpload.updatingPackageJsonWorkspaces(relativePackageJsonPath));
+            uiLogger.debug(lib.projectUpload.handleProjectUpload.updatedWorkspaces(workspaceEntries.join(', ')));
+        }
+        // Update external file: dependencies; internal ones are left untouched
+        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:')) {
+                    packageJson.dependencies[packageName] = `file:${archivePath}`;
+                    modified = true;
+                    uiLogger.debug(lib.projectUpload.handleProjectUpload.updatedFileDependency(packageName, archivePath));
+                }
+            }
+        }
+        archive.append(modified ? JSON.stringify(packageJson, null, 2) : rawContent, { 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));
+}
+export function rewriteLockfileForExternalDeps(lockfileContent, pathMappings) {
+    if (pathMappings.length === 0) {
+        return lockfileContent;
+    }
+    const packages = lockfileContent.packages;
+    if (!packages) {
+        return lockfileContent;
+    }
+    const newPackages = {};
+    for (const [key, value] of Object.entries(packages)) {
+        const mapping = pathMappings.find(m => m.oldPath === key);
+        newPackages[mapping ? mapping.newPath : key] = value;
+    }
+    for (const [key, value] of Object.entries(newPackages)) {
+        if (key.startsWith('node_modules/') &&
+            typeof value === 'object' &&
+            value !== null) {
+            const entry = value;
+            if (entry.link === true && typeof entry.resolved === 'string') {
+                const mapping = pathMappings.find(m => m.oldPath === entry.resolved);
+                if (mapping) {
+                    newPackages[key] = { ...entry, resolved: mapping.newPath };
+                }
+            }
+        }
+    }
+    const rootEntry = newPackages[''];
+    if (rootEntry && typeof rootEntry === 'object' && rootEntry !== null) {
+        const root = rootEntry;
+        if (Array.isArray(root.workspaces)) {
+            newPackages[''] = {
+                ...root,
+                workspaces: root.workspaces.map((ws) => {
+                    if (typeof ws !== 'string')
+                        return ws;
+                    const mapping = pathMappings.find(m => m.oldPath === ws);
+                    return mapping ? mapping.newPath : ws;
+                }),
+            };
+        }
+    }
+    return { ...lockfileContent, packages: newPackages };
+}
+export function getPackageJsonPathsToUpdate(srcDir, workspaceMappings, fileDependencyMappings) {
+    const paths = new Set();
+    for (const { sourcePackageJsonPath } of workspaceMappings) {
+        paths.add(toPosixPath(path.relative(srcDir, sourcePackageJsonPath)));
+    }
+    for (const { localPath, sourcePackageJsonPath } of fileDependencyMappings) {
+        if (!isInsideSrcDir(localPath, srcDir)) {
+            paths.add(toPosixPath(path.relative(srcDir, sourcePackageJsonPath)));
+        }
+    }
+    return paths;
+}
+function getDirsWithExternalDeps(srcDir, workspaceMappings, fileDependencyMappings) {
+    const dirs = new Set();
+    for (const { workspaceDir, sourcePackageJsonPath } of workspaceMappings) {
+        if (!isInsideSrcDir(workspaceDir, srcDir)) {
+            dirs.add(path.dirname(sourcePackageJsonPath));
+        }
+    }
+    for (const { localPath, sourcePackageJsonPath } of fileDependencyMappings) {
+        if (!isInsideSrcDir(localPath, srcDir)) {
+            dirs.add(path.dirname(sourcePackageJsonPath));
+        }
+    }
+    return dirs;
+}
+export function getLockfilePathsToUpdate(srcDir, workspaceMappings, fileDependencyMappings) {
+    const dirsWithExternalDeps = getDirsWithExternalDeps(srcDir, workspaceMappings, fileDependencyMappings);
+    const paths = new Set();
+    for (const dir of dirsWithExternalDeps) {
+        const lockfilePath = path.join(dir, 'package-lock.json');
+        if (fs.existsSync(lockfilePath)) {
+            paths.add(toPosixPath(path.relative(srcDir, lockfilePath)));
+        }
+    }
+    return paths;
+}
+async function rewriteLockfilesInArchive(archive, srcDir, externalArchivePaths, dirsWithExternalDeps) {
+    if (externalArchivePaths.size === 0)
+        return;
+    for (const dir of dirsWithExternalDeps) {
+        const lockfilePath = path.join(dir, 'package-lock.json');
+        if (!fs.existsSync(lockfilePath))
+            continue;
+        let rawContent;
+        try {
+            rawContent = fs.readFileSync(lockfilePath, 'utf8');
+        }
+        catch {
+            continue;
+        }
+        let lockfileContent;
+        try {
+            lockfileContent = JSON.parse(rawContent);
+        }
+        catch {
+            continue;
+        }
+        const pathMappings = [];
+        for (const [absoluteExternalPath, archivePath] of externalArchivePaths) {
+            pathMappings.push({
+                oldPath: toPosixPath(path.relative(dir, absoluteExternalPath)),
+                newPath: toPosixPath(path.relative(dir, path.join(srcDir, archivePath))),
+            });
+        }
+        const rewritten = rewriteLockfileForExternalDeps(lockfileContent, pathMappings);
+        const relativeLockfilePath = toPosixPath(path.relative(srcDir, lockfilePath));
+        uiLogger.debug(lib.projectUpload.handleProjectUpload.updatingLockfile(relativeLockfilePath));
+        archive.append(JSON.stringify(rewritten, null, 2), {
+            name: relativeLockfilePath,
+        });
+    }
+    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, workspaceMappings, fileDependencyMappings) {
+    // Archive workspace directories (internal ones are skipped, externals are copied)
+    const { externalArchivePaths, packageWorkspaceEntries } = await archiveWorkspaceDirectories(archive, srcDir, workspaceMappings);
+    // Archive external file: dependencies (internals are skipped)
+    const packageFileDeps = await archiveFileDependencies(archive, srcDir, fileDependencyMappings, externalArchivePaths);
+    // Update package.json files with new paths
+    await updatePackageJsonInArchive(archive, srcDir, packageWorkspaceEntries, packageFileDeps);
+    // Rewrite lock files to point to archive paths for external deps
+    const dirsWithExternalDeps = getDirsWithExternalDeps(srcDir, workspaceMappings, fileDependencyMappings);
+    await rewriteLockfilesInArchive(archive, srcDir, externalArchivePaths, dirsWithExternalDeps);
+    return { packageWorkspaces: packageWorkspaceEntries, packageFileDeps };
+}

package/lib/prompts/createApiSamplePrompt.js

@@ -1,5 +1,6 @@
 import { promptUser } from './promptUtils.js';
 import { lib } from '../../lang/en.js';
+import { isPromptExitError } from '../errors/PromptExitError.js';
 function getSampleTypesPrompt(choices) {
     return {
         type: 'rawlist',
@@ -53,6 +54,9 @@ export async function createApiSamplePrompt(samplesConfig) {
         };
     }
     catch (e) {
+        if (isPromptExitError(e)) {
+            throw e;
+        }
         return {};
     }
 }

package/lib/prompts/downloadProjectPrompt.js

@@ -2,21 +2,22 @@ import { promptUser } from './promptUtils.js';
 import { getConfigAccountIfExists } from '@hubspot/local-dev-lib/config';
 import { fetchProjects } from '@hubspot/local-dev-lib/api/projects';
 import { logError, ApiErrorContext } from '../errorHandlers/index.js';
-import { uiLogger } from '../ui/logger.js';
-import { EXIT_CODES } from '../enums/exitCodes.js';
 import { lib } from '../../lang/en.js';
+import { PromptExitError } from '../errors/PromptExitError.js';
+import { EXIT_CODES } from '../enums/exitCodes.js';
+import { uiLogger } from '../ui/logger.js';
 async function createProjectsList(accountId) {
-    try {
-        if (accountId) {
-            const { data: projects } = await fetchProjects(accountId);
-            return projects.results;
-        }
+    if (!accountId) {
         uiLogger.error(lib.prompts.downloadProjectPrompt.errors.accountIdRequired);
-        process.exit(EXIT_CODES.ERROR);
+        throw new PromptExitError(lib.prompts.downloadProjectPrompt.errors.accountIdRequired, EXIT_CODES.ERROR);
+    }
+    try {
+        const { data: projects } = await fetchProjects(accountId);
+        return projects.results;
     }
     catch (e) {
-        logError(e, accountId ? new ApiErrorContext({ accountId }) : undefined);
-        process.exit(EXIT_CODES.ERROR);
+        logError(e, new ApiErrorContext({ accountId }));
+        throw new PromptExitError('Failed to fetch projects', EXIT_CODES.ERROR);
     }
 }
 export async function downloadProjectPrompt(promptOptions) {

package/lib/prompts/installAppPrompt.js

@@ -1,8 +1,9 @@
 import open from 'open';
 import { promptUser } from './promptUtils.js';
-import { EXIT_CODES } from '../enums/exitCodes.js';
 import { lib } from '../../lang/en.js';
 import { uiLogger } from '../ui/logger.js';
+import { PromptExitError } from '../errors/PromptExitError.js';
+import { EXIT_CODES } from '../enums/exitCodes.js';
 export async function installAppBrowserPrompt(installUrl, isReinstall = false) {
     uiLogger.log('');
     if (isReinstall) {
@@ -20,7 +21,7 @@ export async function installAppBrowserPrompt(installUrl, isReinstall = false) {
     });
     if (!isReinstall && !shouldOpenBrowser) {
         uiLogger.log(lib.prompts.installAppPrompt.decline);
-        process.exit(EXIT_CODES.SUCCESS);
+        throw new PromptExitError(lib.prompts.installAppPrompt.decline, EXIT_CODES.SUCCESS);
     }
     else if (!shouldOpenBrowser) {
         return;

package/lib/prompts/personalAccessKeyPrompt.js

@@ -6,8 +6,9 @@ import { uiLogger } from '../ui/logger.js';
 import { promptUser } from './promptUtils.js';
 import { getCliAccountNamePromptConfig, } from './accountNamePrompt.js';
 import { uiInfoSection } from '../ui/index.js';
-import { EXIT_CODES } from '../enums/exitCodes.js';
 import { lib } from '../../lang/en.js';
+import { PromptExitError } from '../errors/PromptExitError.js';
+import { EXIT_CODES } from '../enums/exitCodes.js';
 /**
  * Displays notification to user that we are about to open the browser,
  * then opens their browser to the personal-access-key shortlink
@@ -27,7 +28,7 @@ export async function personalAccessKeyPrompt({ env, account, }) {
         ]);
         if (!choice) {
             deleteConfigFileIfEmpty();
-            process.exit(EXIT_CODES.SUCCESS);
+            throw new PromptExitError(lib.prompts.personalAccessKeyPrompt.errors.authCancelled, EXIT_CODES.SUCCESS);
         }
         if (choice ===
             lib.prompts.personalAccessKeyPrompt.personalAccessKeyPromptChoices

package/lib/prompts/projectDevTargetAccountPrompt.d.ts

@@ -10,3 +10,4 @@ export declare function selectSandboxTargetAccountPrompt(accounts: HubSpotConfig
 export declare function selectDeveloperTestTargetAccountPrompt(accounts: HubSpotConfigAccount[], defaultAccountConfig: HubSpotConfigAccount): Promise<ProjectDevTargetAccountPromptResponse>;
 export declare function confirmDefaultAccountPrompt(accountName: string, accountType: string): Promise<boolean>;
 export declare function confirmUseExistingDeveloperTestAccountPrompt(account: DeveloperTestAccount): Promise<boolean>;
+export declare function confirmLinkExistingDeveloperTestAccountPrompt(accountName: string): Promise<boolean>;

package/lib/prompts/projectDevTargetAccountPrompt.js

@@ -6,6 +6,7 @@ import { lib } from '../../lang/en.js';
 import { uiLogger } from '../ui/logger.js';
 import { uiAccountDescription } from '../ui/index.js';
 import { isSandbox } from '../accountTypes.js';
+import { PromptExitError } from '../errors/PromptExitError.js';
 import { EXIT_CODES } from '../enums/exitCodes.js';
 function mapNestedAccount(accountConfig) {
     const parentAccountId = accountConfig.parentAccountId ?? null;
@@ -23,20 +24,18 @@ function getNonConfigDeveloperTestAccountName(account) {
 }
 export async function selectSandboxTargetAccountPrompt(accounts, defaultAccountConfig) {
     const defaultAccountId = defaultAccountConfig.accountId;
+    if (!defaultAccountId) {
+        uiLogger.error(lib.prompts.projectDevTargetAccountPrompt.noAccountId);
+        throw new PromptExitError(lib.prompts.projectDevTargetAccountPrompt.noAccountId, EXIT_CODES.ERROR);
+    }
     let choices = [];
     let sandboxUsage = {
         STANDARD: { used: 0, available: 0, limit: 0 },
         DEVELOPER: { used: 0, available: 0, limit: 0 },
     };
     try {
-        if (defaultAccountId) {
-            const { data } = await getSandboxUsageLimits(defaultAccountId);
-            sandboxUsage = data.usage;
-        }
-        else {
-            uiLogger.error(lib.prompts.projectDevTargetAccountPrompt.noAccountId);
-            process.exit(EXIT_CODES.ERROR);
-        }
+        const { data } = await getSandboxUsageLimits(defaultAccountId);
+        sandboxUsage = data.usage;
     }
     catch (err) {
         uiLogger.debug('Unable to fetch sandbox usage limits: ', err);
@@ -83,16 +82,14 @@ export async function selectSandboxTargetAccountPrompt(accounts, defaultAccountC
 }
 export async function selectDeveloperTestTargetAccountPrompt(accounts, defaultAccountConfig) {
     const defaultAccountId = defaultAccountConfig.accountId;
+    if (!defaultAccountId) {
+        uiLogger.error(lib.prompts.projectDevTargetAccountPrompt.noAccountId);
+        throw new PromptExitError(lib.prompts.projectDevTargetAccountPrompt.noAccountId, EXIT_CODES.ERROR);
+    }
     let devTestAccountsResponse;
     try {
-        if (defaultAccountId) {
-            const { data } = await fetchDeveloperTestAccounts(defaultAccountId);
-            devTestAccountsResponse = data;
-        }
-        else {
-            uiLogger.error(lib.prompts.projectDevTargetAccountPrompt.noAccountId);
-            process.exit(EXIT_CODES.ERROR);
-        }
+        const { data } = await fetchDeveloperTestAccounts(defaultAccountId);
+        devTestAccountsResponse = data;
     }
     catch (err) {
         uiLogger.debug('Unable to fetch developer test account usage limits: ', err);
@@ -167,3 +164,13 @@ export async function confirmUseExistingDeveloperTestAccountPrompt(account) {
     ]);
     return confirmUseExistingDeveloperTestAccount;
 }
+export async function confirmLinkExistingDeveloperTestAccountPrompt(accountName) {
+    const { confirmLinkExistingDeveloperTestAccount } = await promptUser([
+        {
+            name: 'confirmLinkExistingDeveloperTestAccount',
+            type: 'confirm',
+            message: lib.prompts.projectDevTargetAccountPrompt.confirmLinkExistingDeveloperTestAccount(accountName),
+        },
+    ]);
+    return confirmLinkExistingDeveloperTestAccount;
+}

package/lib/prompts/projectProfilePrompt.d.ts

@@ -0,0 +1,2 @@
+import { ProjectConfig } from '../../types/Projects.js';
+export declare function projectProfilePrompt(projectDir: string, projectConfig: ProjectConfig, profileName?: string, exitIfMissing?: boolean): Promise<string | null>;

package/lib/prompts/projectProfilePrompt.js

@@ -0,0 +1,46 @@
+import path from 'path';
+import { getAllHsProfiles } from '@hubspot/project-parsing-lib/profiles';
+import { listPrompt } from './promptUtils.js';
+import { loadProfile } from '../projects/projectProfiles.js';
+import { lib } from '../../lang/en.js';
+function generateProfilePromptOption(projectDir, projectConfig, profileName) {
+    const choice = {
+        name: profileName,
+        value: profileName,
+    };
+    try {
+        const profile = loadProfile(projectConfig, projectDir, profileName);
+        choice.name = `${profileName} [${profile.accountId}]`;
+    }
+    catch (e) {
+        choice.name = `${profileName} [Invalid profile]`;
+        choice.disabled = true;
+    }
+    return choice;
+}
+export async function projectProfilePrompt(projectDir, projectConfig, profileName, exitIfMissing) {
+    if (profileName) {
+        return profileName;
+    }
+    const existingProfiles = await getAllHsProfiles(path.join(projectDir, projectConfig.srcDir));
+    if (existingProfiles.length !== 0) {
+        if (existingProfiles.length === 1) {
+            return existingProfiles[0];
+        }
+        // In automated workflows exit instead of prompting
+        if (exitIfMissing) {
+            throw new Error(lib.prompts.projectProfilePrompt.exitMessage);
+        }
+        const listOptions = existingProfiles.map(p => generateProfilePromptOption(projectDir, projectConfig, p));
+        const hasAnyValidProfiles = listOptions.some(option => typeof option === 'object' && 'name' in option && !option.disabled);
+        // Exit early if the user has no valid profiles for us to show in the prompt
+        if (!hasAnyValidProfiles) {
+            throw new Error(lib.prompts.projectProfilePrompt.noValidProfilesMessage);
+        }
+        const profileNameFromPrompt = await listPrompt(lib.prompts.projectProfilePrompt.message, {
+            choices: listOptions,
+        });
+        return profileNameFromPrompt;
+    }
+    return null;
+}

package/lib/prompts/projectsLogsPrompt.js

@@ -4,6 +4,9 @@ export async function projectLogsPrompt({ functionChoices, promptOptions, projec
     if (!functionChoices) {
         return {};
     }
+    if (promptOptions?.function) {
+        return { functionName: promptOptions.function };
+    }
     if (functionChoices.length === 1) {
         return { functionName: functionChoices[0] };
     }

package/lib/prompts/promptUtils.js

@@ -3,6 +3,7 @@ import { EXIT_CODES } from '../enums/exitCodes.js';
 import chalk from 'chalk';
 import { lib } from '../../lang/en.js';
 import { uiLogger } from '../ui/logger.js';
+import { PromptExitError } from '../errors/PromptExitError.js';
 export const Separator = new _Separator();
 export const PROMPT_THEME = { prefix: { idle: chalk.green('?') } };
 export const CHECKBOX_PROMPT_THEME = {
@@ -19,14 +20,14 @@ function isNoSelectableChoicesError(error) {
 }
 function handlePromptError(config, error) {
     if (isUserCancellationError(error)) {
-        process.exit(EXIT_CODES.SUCCESS);
+        throw new PromptExitError(lib.prompts.promptUtils.errors.userCancelled, EXIT_CODES.SUCCESS);
     }
     if (isNoSelectableChoicesError(error)) {
         if (!Array.isArray(config)) {
             uiLogger.log(config.message);
         }
         uiLogger.error(lib.prompts.promptUtils.errors.noSelectableChoices);
-        process.exit(EXIT_CODES.ERROR);
+        throw new PromptExitError(lib.prompts.promptUtils.errors.noSelectableChoices, EXIT_CODES.ERROR);
     }
     throw error;
 }
@@ -41,6 +42,7 @@ function mapPromptChoicesToChoices(choices) {
         return {
             value: choice.value,
             name: choice.name,
+            short: choice.short,
             disabled: choice.disabled,
             checked: choice.checked,
         };

package/lib/prompts/selectHubDBTablePrompt.js

@@ -4,25 +4,29 @@ import { lib } from '../../lang/en.js';
 import { debugError } from '../errorHandlers/index.js';
 import { uiLogger } from '../ui/logger.js';
 import { fetchTables } from '@hubspot/local-dev-lib/api/hubdb';
-import { EXIT_CODES } from '../enums/exitCodes.js';
 import { isValidPath, untildify } from '@hubspot/local-dev-lib/path';
+import { isPromptExitError, PromptExitError, } from '../errors/PromptExitError.js';
+import { EXIT_CODES } from '../enums/exitCodes.js';
 async function fetchHubDBOptions(accountId) {
     try {
         const { data: { results: tables }, } = await fetchTables(accountId);
         if (tables.length === 0) {
             uiLogger.log(lib.prompts.selectHubDBTablePrompt.errors.noTables(accountId.toString()));
-            process.exit(EXIT_CODES.SUCCESS);
+            throw new PromptExitError(lib.prompts.selectHubDBTablePrompt.errors.noTables(accountId.toString()), EXIT_CODES.SUCCESS);
         }
         return tables;
     }
     catch (error) {
+        if (isPromptExitError(error)) {
+            throw error;
+        }
         debugError(error, { accountId });
         uiLogger.error(lib.prompts.selectHubDBTablePrompt.errors.errorFetchingTables(accountId.toString()));
-        process.exit(EXIT_CODES.ERROR);
+        throw new PromptExitError(lib.prompts.selectHubDBTablePrompt.errors.errorFetchingTables(accountId.toString()), EXIT_CODES.ERROR);
     }
 }
 export async function selectHubDBTablePrompt({ accountId, options, skipDestPrompt = true, }) {
-    const hubdbTables = (await fetchHubDBOptions(accountId)) || [];
+    const hubdbTables = await fetchHubDBOptions(accountId);
     const id = options.tableId?.toString();
     const isValidTable = options.tableId && hubdbTables.find(table => table.id === id);
     return promptUser([