@hubspot/cli 8.2.0 → 8.2.1-experimental.1

package/lib/projects/workspaces.d.ts

@@ -0,0 +1,60 @@
+import archiver from 'archiver';
+import { WorkspaceMapping, FileDependencyMapping, FileDependencyKind, LocalDependencyProtocol } from '@hubspot/project-parsing-lib/workspaces';
+export type FileDepArchiveEntry = {
+    archivePath: string;
+    protocol: LocalDependencyProtocol;
+};
+/**
+ * Result of archiving workspaces and file dependencies
+ */
+export type WorkspaceArchiveResult = {
+    packageWorkspaces: Map<string, string[]>;
+    packageFileDeps: Map<string, Map<string, FileDepArchiveEntry>>;
+};
+/**
+ * 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;
+/**
+ * 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 declare function toPosixPath(p: string): string;
+/**
+ * Determines the archive path for an external workspace or file: dependency.
+ *
+ * For directories, produces `_workspaces/<basename>-<hash>`.
+ * For tarballs, produces `_workspaces/<basename-no-ext>-<hash>/<original-basename>`,
+ * so the rewritten package.json reference still ends in the original filename.
+ *
+ * The hash prevents collisions between different paths with the same basename.
+ */
+export declare function computeExternalArchivePath(absolutePath: string, kind?: FileDependencyKind): string;
+/**
+ * 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 declare function updatePackageJsonInArchive(archive: archiver.Archiver, srcDir: string, packageWorkspaces: Map<string, string[]>, packageFileDeps: Map<string, Map<string, FileDepArchiveEntry>>): Promise<void>;
+export declare function rewriteLockfileForExternalDeps(lockfileContent: Record<string, unknown>, pathMappings: Array<{
+    oldPath: string;
+    newPath: string;
+}>): Record<string, unknown>;
+export declare function getPackageJsonPathsToUpdate(srcDir: string, workspaceMappings: WorkspaceMapping[], fileDependencyMappings: FileDependencyMapping[]): Set<string>;
+export declare function getLockfilePathsToUpdate(srcDir: string, workspaceMappings: WorkspaceMapping[], fileDependencyMappings: FileDependencyMapping[]): Set<string>;
+/**
+ * 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, workspaceMappings: WorkspaceMapping[], fileDependencyMappings: FileDependencyMapping[]): Promise<WorkspaceArchiveResult>;

package/lib/projects/workspaces.js

@@ -0,0 +1,411 @@
+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';
+const FILE_PROTOCOL_PREFIX = 'file:';
+const LINK_PROTOCOL_PREFIX = 'link:';
+const KIND_DIRECTORY = 'directory';
+const KIND_TARBALL = 'tarball';
+/**
+ * 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);
+}
+/**
+ * Strips the longest matching tarball extension (.tar.gz, .tgz, .tar)
+ * from a file basename. Returns the input unchanged if no extension matches.
+ */
+function stripTarballExtension(basename) {
+    const lower = basename.toLowerCase();
+    for (const ext of ['.tar.gz', '.tgz', '.tar']) {
+        if (lower.endsWith(ext)) {
+            return basename.slice(0, basename.length - ext.length);
+        }
+    }
+    return basename;
+}
+/**
+ * Determines the archive path for an external workspace or file: dependency.
+ *
+ * For directories, produces `_workspaces/<basename>-<hash>`.
+ * For tarballs, produces `_workspaces/<basename-no-ext>-<hash>/<original-basename>`,
+ * so the rewritten package.json reference still ends in the original filename.
+ *
+ * The hash prevents collisions between different paths with the same basename.
+ */
+export function computeExternalArchivePath(absolutePath, kind = KIND_DIRECTORY) {
+    const resolved = path.resolve(absolutePath);
+    const name = path.basename(resolved);
+    if (kind === KIND_TARBALL) {
+        const nameNoExt = stripTarballExtension(name);
+        return path.posix.join('_workspaces', `${nameNoExt}-${shortHash(resolved)}`, name);
+    }
+    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: and link: dependencies and returns mapping information.
+ *
+ * Internal dependencies (inside srcDir) are skipped — their original
+ * references in package.json remain valid after upload.
+ *
+ * External directory dependencies are archived to `_workspaces/<name>-<hash>`.
+ * External tarball dependencies are archived to
+ * `_workspaces/<name-no-ext>-<hash>/<original-basename>` so the rewritten
+ * reference still ends in the original filename.
+ */
+async function archiveFileDependencies(archive, srcDir, fileDependencyMappings, externalArchivePaths) {
+    const packageFileDeps = new Map();
+    const toArchive = [];
+    for (const mapping of fileDependencyMappings) {
+        const { packageName, localPath, sourcePackageJsonPath, kind, protocol } = mapping;
+        if (isInsideSrcDir(localPath, srcDir)) {
+            continue;
+        }
+        const archivePath = computeExternalArchivePath(localPath, kind);
+        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, { archivePath: relativeArchivePath, protocol });
+        if (!externalArchivePaths.has(resolvedPath)) {
+            externalArchivePaths.set(resolvedPath, archivePath);
+            toArchive.push({ localPath, archivePath, packageName, kind });
+        }
+    }
+    const directoryItems = toArchive.filter(item => item.kind === KIND_DIRECTORY);
+    const tarballItems = toArchive.filter(item => item.kind === KIND_TARBALL);
+    // getPackableFiles only applies to directory deps; tarballs are a single file.
+    const directoriesWithPackableFiles = await Promise.all(directoryItems.map(async (item) => ({
+        ...item,
+        packableFiles: await getPackableFiles(item.localPath),
+    })));
+    for (const { localPath, archivePath, packageName, packableFiles, } of directoriesWithPackableFiles) {
+        uiLogger.log(lib.projectUpload.handleProjectUpload.fileDependencyIncluded(packageName, localPath, archivePath));
+        archive.directory(localPath, archivePath, createWorkspaceFileFilter(packableFiles));
+    }
+    for (const { localPath, archivePath, packageName } of tarballItems) {
+        uiLogger.log(lib.projectUpload.handleProjectUpload.fileDependencyIncluded(packageName, localPath, archivePath));
+        archive.file(localPath, { name: archivePath });
+    }
+    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: and link: dependencies; internal ones are left untouched.
+        // The protocol prefix (file: vs link:) is preserved from the original spec.
+        const fileDeps = packageFileDeps.get(packageJsonPath);
+        if (fileDeps && fileDeps.size > 0 && packageJson.dependencies) {
+            for (const [packageName, { archivePath, protocol },] of fileDeps.entries()) {
+                const current = packageJson.dependencies[packageName];
+                if (typeof current === 'string' &&
+                    (current.startsWith(FILE_PROTOCOL_PREFIX) ||
+                        current.startsWith(LINK_PROTOCOL_PREFIX))) {
+                    const newValue = `${protocol}:${archivePath}`;
+                    packageJson.dependencies[packageName] = newValue;
+                    modified = true;
+                    uiLogger.debug(lib.projectUpload.handleProjectUpload.updatedFileDependency(packageName, newValue));
+                }
+            }
+        }
+        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 (typeof entry.resolved !== 'string')
+                continue;
+            // Symlink entries (directory deps with link:true) store resolved as a
+            // bare relative path. Tarball entries store resolved as a "file:" URL.
+            const resolved = entry.resolved;
+            const isFileUrl = resolved.startsWith(FILE_PROTOCOL_PREFIX);
+            const resolvedPath = isFileUrl
+                ? resolved.slice(FILE_PROTOCOL_PREFIX.length)
+                : resolved;
+            const mapping = pathMappings.find(m => m.oldPath === resolvedPath);
+            if (mapping) {
+                newPackages[key] = {
+                    ...entry,
+                    resolved: isFileUrl
+                        ? `${FILE_PROTOCOL_PREFIX}${mapping.newPath}`
+                        : 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.d.ts

@@ -17,13 +17,10 @@ type ScopesPromptResponse = {
     scopes: string[];
 };
 export type OauthPromptResponse = AccountNamePromptResponse & AccountIdPromptResponse & ClientIdPromptResponse & ClientSecretPromptResponse & ScopesPromptResponse;
-/**
- * Displays notification to user that we are about to open the browser,
- * then opens their browser to the personal-access-key shortlink
- */
-export declare function personalAccessKeyPrompt({ env, account, }: {
+export declare function legacyPersonalAccessKeyPrompt({ env, account, }: {
     env: string;
     account?: number;
 }): Promise<PersonalAccessKeyPromptResponse>;
+export declare function personalAccessKeyPrompt(): Promise<string>;
 export declare const OAUTH_FLOW: (PromptConfig<AccountNamePromptResponse> | PromptConfig<AccountIdPromptResponse> | PromptConfig<ClientIdPromptResponse> | PromptConfig<ClientSecretPromptResponse> | PromptConfig<ScopesPromptResponse>)[];
 export {};

package/lib/prompts/personalAccessKeyPrompt.js

@@ -6,13 +6,11 @@ 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';
-/**
- * Displays notification to user that we are about to open the browser,
- * then opens their browser to the personal-access-key shortlink
- */
-export async function personalAccessKeyPrompt({ env, account, }) {
+import { PromptExitError } from '../errors/PromptExitError.js';
+import { EXIT_CODES } from '../enums/exitCodes.js';
+// Full PAK flow: browser-open menu + paste. Used by commands that haven't adopted websocket PAK delivery.
+export async function legacyPersonalAccessKeyPrompt({ env, account, }) {
     const websiteOrigin = getHubSpotWebsiteOrigin(env);
     let url = `${websiteOrigin}/l/personal-access-key`;
     if (process.env.BROWSER !== 'none') {
@@ -27,7 +25,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
@@ -42,6 +40,11 @@ export async function personalAccessKeyPrompt({ env, account, }) {
         env,
     };
 }
+// Paste-only: shows the masked input directly. Used by hs account auth after the browser is already open via websocket.
+export async function personalAccessKeyPrompt() {
+    const { personalAccessKey } = await promptUser(PERSONAL_ACCESS_KEY);
+    return personalAccessKey;
+}
 const ACCOUNT_ID = {
     name: 'accountId',
     message: lib.prompts.personalAccessKeyPrompt.enterAccountId,

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>;