@hubspot/cli 8.8.0 → 8.9.0-beta.1

package/lib/app/urls.d.ts

@@ -14,4 +14,6 @@ type PublicAppInstallUrlArgs = {
 export declare function getOauthAppInstallUrl({ targetAccountId, env, clientId, scopes, redirectUrls, }: PublicAppInstallUrlArgs): string;
 export declare function getStaticAuthAppInstallUrl({ targetAccountId, env, appId, }: PrivateAppInstallUrlArgs): string;
 export declare function getAppCardSetupUrl({ targetAccountId, env, appId, }: PrivateAppInstallUrlArgs): string;
+export declare function getAppLogsUrl(accountId: number, appId: number, systemType: string): string;
+export declare function getAppLogDetailsUrl(accountId: number, appId: number, systemType: string, logId: string): string;
 export {};

package/lib/app/urls.js

@@ -1,4 +1,5 @@
 import { getHubSpotWebsiteOrigin } from '@hubspot/local-dev-lib/urls';
+import { getBaseHubSpotUrlForAccount } from '../projects/urls.js';
 export function getOauthAppInstallUrl({ targetAccountId, env, clientId, scopes, redirectUrls, }) {
     const websiteOrigin = getHubSpotWebsiteOrigin(env);
     return (`${websiteOrigin}/oauth/${targetAccountId}/authorize` +
@@ -14,3 +15,9 @@ export function getAppCardSetupUrl({ targetAccountId, env, appId, }) {
     const websiteOrigin = getHubSpotWebsiteOrigin(env);
     return `${websiteOrigin}/integrations-settings/${targetAccountId}/installed/framework/${appId}/app-cards?tourId=get-started`;
 }
+export function getAppLogsUrl(accountId, appId, systemType) {
+    return `${getBaseHubSpotUrlForAccount(accountId)}/developer-monitoring/${accountId}/?logType=${systemType}&appId=${appId}`;
+}
+export function getAppLogDetailsUrl(accountId, appId, systemType, logId) {
+    return `${getAppLogsUrl(accountId, appId, systemType)}&logId=${logId}`;
+}

package/lib/auth/awaitPersonalAccessKeyOverWebsocket.d.ts

@@ -0,0 +1,4 @@
+export declare function awaitPersonalAccessKeyOverWebsocket({ env, account, }: {
+    env: string;
+    account?: number;
+}): Promise<string>;

package/lib/auth/awaitPersonalAccessKeyOverWebsocket.js

@@ -0,0 +1,145 @@
+import readline from 'readline';
+import { randomUUID } from 'crypto';
+import open from 'open';
+import { getHubSpotWebsiteOrigin } from '@hubspot/local-dev-lib/urls';
+import CLIWebSocketServer from '../CLIWebSocketServer.js';
+import { ACCOUNT_AUTH_UI_MESSAGE_SEND_TYPES, ACCOUNT_AUTH_UI_MESSAGE_RECEIVE_TYPES, ACCOUNT_AUTH_WEBSOCKET_SERVER_VERSION, } from '../constants.js';
+import { personalAccessKeyPrompt } from '../prompts/personalAccessKeyPrompt.js';
+import SpinniesManager from '../ui/SpinniesManager.js';
+import { uiLogger } from '../ui/logger.js';
+import { lib } from '../../lang/en.js';
+import { PromptExitError } from '../errors/PromptExitError.js';
+import { EXIT_CODES } from '../enums/exitCodes.js';
+const LOG_PREFIX = '[AccountAuthWebsocketServer]';
+const SPINNER_ID = 'pak-websocket';
+const CTRL_C = 3;
+function isPersonalAccessKeyMessageData(data) {
+    if (typeof data !== 'object' || data === null)
+        return false;
+    const d = data;
+    return (typeof d.personalAccessKey === 'string' &&
+        typeof d.cliCallbackToken === 'string');
+}
+function buildPakUrl(env, account, cliCallbackPort, cliCallbackToken) {
+    const websiteOrigin = getHubSpotWebsiteOrigin(env);
+    const baseUrl = account
+        ? `${websiteOrigin}/personal-access-key/${account}`
+        : `${websiteOrigin}/l/personal-access-key`;
+    return `${baseUrl}?cliCallbackPort=${cliCallbackPort}&cliCallbackToken=${cliCallbackToken}`;
+}
+function createMessageHandler(server, cliCallbackToken, resolveWebsocketPak) {
+    return (ws, message) => {
+        if (message.type !== ACCOUNT_AUTH_UI_MESSAGE_RECEIVE_TYPES.PERSONAL_ACCESS_KEY) {
+            return false;
+        }
+        if (!isPersonalAccessKeyMessageData(message.data)) {
+            return true;
+        }
+        const { cliCallbackToken: receivedToken, personalAccessKey } = message.data;
+        if (receivedToken !== cliCallbackToken) {
+            server.sendMessage(ws, {
+                type: ACCOUNT_AUTH_UI_MESSAGE_SEND_TYPES.AUTH_FAILED,
+                data: { reason: 'cliCallbackTokenMismatch' },
+            });
+            return true;
+        }
+        if (personalAccessKey.length === 0) {
+            return true;
+        }
+        server.sendMessage(ws, {
+            type: ACCOUNT_AUTH_UI_MESSAGE_SEND_TYPES.AUTH_RECEIVED,
+        });
+        resolveWebsocketPak(personalAccessKey);
+        return true;
+    };
+}
+async function awaitKeypressOrWebsocketPak(websocketPakPromise) {
+    if (!process.stdin.isTTY) {
+        return { type: 'keypress' };
+    }
+    SpinniesManager.init();
+    SpinniesManager.add(SPINNER_ID, {
+        text: lib.accountAuthWebsocket.logs.spinner,
+    });
+    let cleanupStdin;
+    const keypressPromise = new Promise((resolve, reject) => {
+        readline.emitKeypressEvents(process.stdin);
+        process.stdin.setRawMode(true);
+        const onData = (chunk) => {
+            doCleanup();
+            if (chunk[0] === CTRL_C) {
+                return reject(new PromptExitError(lib.prompts.personalAccessKeyPrompt.errors.authCancelled, EXIT_CODES.SUCCESS));
+            }
+            resolve({ type: 'keypress' });
+        };
+        const doCleanup = () => {
+            process.stdin.removeListener('data', onData);
+            try {
+                process.stdin.setRawMode(false);
+            }
+            catch { }
+            process.stdin.pause();
+        };
+        cleanupStdin = doCleanup;
+        process.stdin.on('data', onData);
+    });
+    try {
+        const result = await Promise.race([
+            websocketPakPromise.then(pak => ({ type: 'pak', pak })),
+            keypressPromise,
+        ]);
+        if (result.type === 'pak') {
+            SpinniesManager.succeed(SPINNER_ID, {
+                text: lib.accountAuthWebsocket.logs.received,
+            });
+        }
+        else {
+            SpinniesManager.remove(SPINNER_ID);
+        }
+        return result;
+    }
+    catch (e) {
+        SpinniesManager.remove(SPINNER_ID);
+        throw e;
+    }
+    finally {
+        cleanupStdin?.();
+    }
+}
+export async function awaitPersonalAccessKeyOverWebsocket({ env, account, }) {
+    const cliCallbackToken = randomUUID();
+    const server = new CLIWebSocketServer({ logPrefix: LOG_PREFIX });
+    let resolveWebsocketPak;
+    const websocketPakPromise = new Promise(resolve => {
+        resolveWebsocketPak = resolve;
+    });
+    try {
+        const cliCallbackPort = await server.start({
+            metadata: {
+                accountAuthWebsocketServerVersion: ACCOUNT_AUTH_WEBSOCKET_SERVER_VERSION,
+            },
+            onMessage: createMessageHandler(server, cliCallbackToken, resolveWebsocketPak),
+        });
+        const url = buildPakUrl(env, account, cliCallbackPort, cliCallbackToken);
+        await open(url, { url: true });
+        uiLogger.log(lib.accountAuthWebsocket.logs.openingWebBrowser(url));
+        const waitResult = await awaitKeypressOrWebsocketPak(websocketPakPromise);
+        if (waitResult.type === 'pak') {
+            return waitResult.pak;
+        }
+        let pastePhaseActive = true;
+        websocketPakPromise
+            .then(pak => {
+            if (pastePhaseActive) {
+                process.stdin.push(`${pak}\n`);
+            }
+        })
+            .catch(() => { });
+        const personalAccessKey = await personalAccessKeyPrompt();
+        pastePhaseActive = false;
+        return personalAccessKey;
+    }
+    finally {
+        server.shutdown();
+    }
+}

package/lib/buildAccount.js

@@ -5,7 +5,7 @@ import { createDeveloperTestAccount, fetchDeveloperTestAccountGateSyncStatus, ge
 import { HUBSPOT_ACCOUNT_TYPES } from '@hubspot/local-dev-lib/constants/config';
 import { createV2Sandbox, getSandboxPersonalAccessKey, } from '@hubspot/local-dev-lib/api/sandboxHubs';
 import { isPromptExitError } from './errors/PromptExitError.js';
-import { personalAccessKeyPrompt } from './prompts/personalAccessKeyPrompt.js';
+import { legacyPersonalAccessKeyPrompt as personalAccessKeyPrompt } from './prompts/personalAccessKeyPrompt.js';
 import { createDeveloperTestAccountConfigPrompt } from './prompts/createDeveloperTestAccountConfigPrompt.js';
 import { cliAccountNamePrompt } from './prompts/accountNamePrompt.js';
 import SpinniesManager from './ui/SpinniesManager.js';

package/lib/constants.d.ts

@@ -124,6 +124,14 @@ export declare const LOCAL_DEV_SERVER_MESSAGE_TYPES: {
     readonly OAUTH_APP_INSTALL_INITIATED: "APP_INSTALL_INITIATED";
 };
 export declare const LOCAL_DEV_WEBSOCKET_SERVER_INSTANCE_ID = "local-dev-ui-websocket-server";
+export declare const ACCOUNT_AUTH_UI_MESSAGE_SEND_TYPES: {
+    readonly AUTH_RECEIVED: "server:authReceived";
+    readonly AUTH_FAILED: "server:authFailed";
+};
+export declare const ACCOUNT_AUTH_UI_MESSAGE_RECEIVE_TYPES: {
+    readonly PERSONAL_ACCESS_KEY: "client:personalAccessKey";
+};
+export declare const ACCOUNT_AUTH_WEBSOCKET_SERVER_VERSION = 1;
 export declare const CONFIG_LOCAL_STATE_FLAGS: {
     readonly LOCAL_DEV_UI_WELCOME: "LOCAL_DEV_UI_WELCOME";
 };

package/lib/constants.js

@@ -116,6 +116,14 @@ export const LOCAL_DEV_SERVER_MESSAGE_TYPES = {
     OAUTH_APP_INSTALL_INITIATED: 'APP_INSTALL_INITIATED',
 };
 export const LOCAL_DEV_WEBSOCKET_SERVER_INSTANCE_ID = 'local-dev-ui-websocket-server';
+export const ACCOUNT_AUTH_UI_MESSAGE_SEND_TYPES = {
+    AUTH_RECEIVED: 'server:authReceived',
+    AUTH_FAILED: 'server:authFailed',
+};
+export const ACCOUNT_AUTH_UI_MESSAGE_RECEIVE_TYPES = {
+    PERSONAL_ACCESS_KEY: 'client:personalAccessKey',
+};
+export const ACCOUNT_AUTH_WEBSOCKET_SERVER_VERSION = 1;
 export const CONFIG_LOCAL_STATE_FLAGS = {
     LOCAL_DEV_UI_WELCOME: 'LOCAL_DEV_UI_WELCOME',
 };

package/lib/middleware/commandTargetingUtils.js

@@ -21,6 +21,7 @@ const SKIP_CONFIG_LOADING_COMMANDS = {
     init: true,
     feedback: true,
     mcp: { start: true },
+    project: { lint: true },
 };
 // Returns true if the command requires a config file to be present
 export function shouldLoadConfigForCommand(commandParts) {

package/lib/projects/localDev/LocalDevWebsocketServer.js

@@ -150,7 +150,7 @@ class LocalDevWebsocketServer {
         this.setupDevServersStartedListener(websocket);
     }
     async start() {
-        return this.cliWebSocketServer.start({
+        await this.cliWebSocketServer.start({
             metadata: {
                 localDevWebsocketServerVersion: LOCAL_DEV_WEBSOCKET_SERVER_VERSION,
             },

package/lib/projects/workspaces.d.ts

@@ -1,11 +1,15 @@
 import archiver from 'archiver';
-import { WorkspaceMapping, FileDependencyMapping } from '@hubspot/project-parsing-lib/workspaces';
+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, string>>;
+    packageFileDeps: Map<string, Map<string, FileDepArchiveEntry>>;
 };
 /**
  * Generates a short hash of the input string for use in workspace paths.
@@ -24,10 +28,14 @@ export declare function shortHash(input: string): string;
 export declare function toPosixPath(p: string): string;
 /**
  * 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.
+ *
+ * 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): string;
+export declare function computeExternalArchivePath(absolutePath: string, kind?: FileDependencyKind): string;
 /**
  * Updates package.json files in the archive to reflect new workspace and file: dependency paths.
  *
@@ -38,7 +46,7 @@ export declare function computeExternalArchivePath(absolutePath: string): string
  * 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, string>>): Promise<void>;
+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;

package/lib/projects/workspaces.js

@@ -5,6 +5,10 @@ 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).
@@ -27,14 +31,35 @@ export function toPosixPath(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.
- * Produces `_workspaces/<basename>-<hash>` with no subdirectory.
- * The hash prevents collisions between different directories with the same basename.
+ *
+ * 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) {
+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)}`);
 }
 /**
@@ -121,25 +146,25 @@ async function archiveWorkspaceDirectories(archive, srcDir, workspaceMappings) {
     return { externalArchivePaths, packageWorkspaceEntries };
 }
 /**
- * Archives file: dependencies and returns mapping information.
+ * Archives file: and link: dependencies and returns mapping information.
  *
- * Internal file: dependencies (inside srcDir) are skipped — their original
- * `file:` references in package.json remain valid after upload.
+ * Internal dependencies (inside srcDir) are skipped — their original
+ * 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.
+ * 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 } = mapping;
+        const { packageName, localPath, sourcePackageJsonPath, kind, protocol } = 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 archivePath = computeExternalArchivePath(localPath, kind);
         const resolvedPath = path.resolve(localPath);
         if (!packageFileDeps.has(sourcePackageJsonPath)) {
             packageFileDeps.set(sourcePackageJsonPath, new Map());
@@ -148,23 +173,27 @@ async function archiveFileDependencies(archive, srcDir, fileDependencyMappings,
         const relativeArchivePath = toPosixPath(path.relative(relPkgJsonDir, archivePath));
         packageFileDeps
             .get(sourcePackageJsonPath)
-            .set(packageName, relativeArchivePath);
-        // Only archive each unique path once
+            .set(packageName, { archivePath: relativeArchivePath, protocol });
         if (!externalArchivePaths.has(resolvedPath)) {
             externalArchivePaths.set(resolvedPath, archivePath);
-            toArchive.push({ localPath, archivePath, packageName });
+            toArchive.push({ localPath, archivePath, packageName, kind });
         }
     }
-    // Fetch packable files in parallel (I/O optimization)
-    const withPackableFiles = await Promise.all(toArchive.map(async (item) => ({
+    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),
     })));
-    // Archive directories sequentially (archiver requires sequential operations)
-    for (const { localPath, archivePath, packageName, packableFiles, } of withPackableFiles) {
+    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;
 }
 /**
@@ -213,14 +242,19 @@ export async function updatePackageJsonInArchive(archive, srcDir, packageWorkspa
             uiLogger.debug(lib.projectUpload.handleProjectUpload.updatingPackageJsonWorkspaces(relativePackageJsonPath));
             uiLogger.debug(lib.projectUpload.handleProjectUpload.updatedWorkspaces(workspaceEntries.join(', ')));
         }
-        // Update external file: dependencies; internal ones are left untouched
+        // 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] of fileDeps.entries()) {
-                if (packageJson.dependencies[packageName]?.startsWith('file:')) {
-                    packageJson.dependencies[packageName] = `file:${archivePath}`;
+            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, archivePath));
+                    uiLogger.debug(lib.projectUpload.handleProjectUpload.updatedFileDependency(packageName, newValue));
                 }
             }
         }
@@ -248,11 +282,23 @@ export function rewriteLockfileForExternalDeps(lockfileContent, pathMappings) {
             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 };
-                }
+            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,
+                };
             }
         }
     }

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

@@ -9,11 +9,8 @@ import { uiInfoSection } from '../ui/index.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
- */
-export async function personalAccessKeyPrompt({ env, account, }) {
+// 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') {
@@ -43,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/selectAppPrompt.js

@@ -27,6 +27,7 @@ export async function selectAppPrompt(accountId, appId) {
             uiLogger.error(lib.prompts.selectAppPrompt.errors.invalidAppId);
         }
     }
+    availableApps.sort((a, b) => a.name.localeCompare(b.name));
     const appPromptValue = await listPrompt(lib.prompts.selectAppPrompt.selectAppId, {
         choices: availableApps.map(app => ({
             name: `${app.name} (${app.id})`,

package/lib/prompts/setAsDefaultAccountPrompt.js

@@ -11,7 +11,8 @@ export async function setAsDefaultAccountPrompt(accountName) {
             name: 'setAsDefault',
             type: 'confirm',
             when: accounts.length >= 1 && defaultAccount?.name !== accountName,
-            message: lib.prompts.setAsDefaultAccountPrompt.setAsDefaultAccountMessage,
+            message: lib.prompts.setAsDefaultAccountPrompt.setAsDefaultAccountMessage(accountName),
+            default: false,
         },
     ]);
     uiLogger.log('');

package/lib/serverlessLogs.js

@@ -2,11 +2,11 @@ import https from 'https';
 import chalk from 'chalk';
 import { uiLogger } from './ui/logger.js';
 import { isHubSpotHttpError, isMissingScopeError, } from '@hubspot/local-dev-lib/errors/index';
-import { SCOPE_GROUPS, PERSONAL_ACCESS_KEY_AUTH_METHOD, } from '@hubspot/local-dev-lib/constants/auth';
+import { PERSONAL_ACCESS_KEY_AUTH_METHOD, SCOPE_GROUPS, } from '@hubspot/local-dev-lib/constants/auth';
 import { getConfigAccountById } from '@hubspot/local-dev-lib/config';
 import { fetchScopeData } from '@hubspot/local-dev-lib/api/localDevAuth';
 import { outputLogs } from './ui/serverlessFunctionLogs.js';
-import { logError, ApiErrorContext } from './errorHandlers/index.js';
+import { ApiErrorContext, logError } from './errorHandlers/index.js';
 import SpinniesManager from './ui/SpinniesManager.js';
 import { handleExit, handleKeypress } from './process.js';
 import { lib } from '../lang/en.js';

package/lib/ui/appLogs.d.ts

@@ -0,0 +1,32 @@
+import { AppLogDetails } from '@hubspot/local-dev-lib/types/AppLogs';
+type AppLogEntry = {
+    id: string;
+    createdAt: number;
+    executionTimeMillis?: number;
+    portalId?: number;
+    traceId?: string;
+    status: 'SUCCESS' | 'ERROR';
+    errorType?: string;
+    errorMessage?: string;
+};
+type AppLogsSearchResponse = {
+    results: AppLogEntry[];
+    hasMore: boolean;
+    offset: number;
+    total: number;
+};
+type OutputOptions = {
+    compact?: boolean;
+    tail?: boolean;
+    accountId: number;
+    appId: number;
+    systemType: string;
+    typeName: string;
+};
+export declare function outputAppLogs(response: AppLogsSearchResponse, options: OutputOptions): Promise<void>;
+type LogDetailsOutputOptions = {
+    accountId: number;
+    appId: number;
+};
+export declare function outputAppLogDetails(details: AppLogDetails, options: LogDetailsOutputOptions): void;
+export {};