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

package/lib/CLIWebSocketServer.d.ts

@@ -5,11 +5,11 @@ export type CLIWebSocketMessage = {
 };
 declare class CLIWebSocketServer {
     private server?;
-    private instanceId;
+    private instanceId?;
     private logPrefix?;
     private debug?;
     constructor({ instanceId, logPrefix, debug, }: {
-        instanceId: string;
+        instanceId?: string;
         logPrefix?: string;
         debug?: boolean;
     });
@@ -17,12 +17,14 @@ declare class CLIWebSocketServer {
     private logError;
     sendMessage(websocket: WebSocket, message: CLIWebSocketMessage): void;
     private sendCliMetadata;
+    private bindPortManagerPort;
+    private bindEphemeralPort;
     start({ onConnection, onMessage, onClose, metadata, }: {
         onConnection?: (websocket: WebSocket) => void;
         onMessage?: (websocket: WebSocket, message: CLIWebSocketMessage) => boolean;
         onClose?: () => void;
         metadata?: Record<string, unknown>;
-    }): Promise<void>;
+    }): Promise<number>;
     shutdown(): void;
 }
 export default CLIWebSocketServer;

package/lib/CLIWebSocketServer.js

@@ -39,14 +39,40 @@ class CLIWebSocketServer {
             },
         });
     }
-    async start({ onConnection, onMessage, onClose, metadata, }) {
+    async bindPortManagerPort(instanceId) {
         const portManagerIsRunning = await isPortManagerServerRunning();
         if (!portManagerIsRunning) {
             throw new Error(lib.CLIWebsocketServer.errors.portManagerNotRunning(this.logPrefix));
         }
-        const portData = await requestPorts([{ instanceId: this.instanceId }]);
-        const port = portData[this.instanceId];
-        this.server = new WebSocketServer({ port });
+        const portData = await requestPorts([{ instanceId }]);
+        const port = portData[instanceId];
+        return { server: new WebSocketServer({ port }), port };
+    }
+    async bindEphemeralPort() {
+        const server = new WebSocketServer({ port: 0 });
+        await new Promise((resolve, reject) => {
+            const onListening = () => {
+                server.off('error', onError);
+                resolve();
+            };
+            const onError = (err) => {
+                server.off('listening', onListening);
+                reject(err);
+            };
+            server.once('listening', onListening);
+            server.once('error', onError);
+        });
+        const address = server.address();
+        if (!address || typeof address !== 'object') {
+            throw new Error(lib.CLIWebsocketServer.errors.failedToBindEphemeralPort(this.logPrefix));
+        }
+        return { server, port: address.port };
+    }
+    async start({ onConnection, onMessage, onClose, metadata, }) {
+        const { server, port } = this.instanceId
+            ? await this.bindPortManagerPort(this.instanceId)
+            : await this.bindEphemeralPort();
+        this.server = server;
         this.log(lib.CLIWebsocketServer.logs.startup(port));
         this.server.on('connection', (ws, req) => {
             const origin = req.headers.origin;
@@ -82,6 +108,7 @@ class CLIWebSocketServer {
                 onClose();
             }
         });
+        return port;
     }
     shutdown() {
         this.server?.close();

package/lib/accountAuth.d.ts

@@ -5,6 +5,8 @@ type AuthenticateNewAccountOptions = {
     providedPersonalAccessKey?: string;
     accountId?: number;
     setAsDefaultAccount?: boolean;
+    accountName?: string;
+    useDefaultAccountName?: boolean;
 };
-export declare function authenticateNewAccount({ env, providedPersonalAccessKey, accountId, setAsDefaultAccount, }: AuthenticateNewAccountOptions): Promise<HubSpotConfigAccount | null>;
+export declare function authenticateNewAccount({ env, providedPersonalAccessKey, accountId, setAsDefaultAccount, accountName: providedAccountName, useDefaultAccountName, }: AuthenticateNewAccountOptions): Promise<HubSpotConfigAccount | null>;
 export {};

package/lib/accountAuth.js

@@ -1,28 +1,52 @@
-import { updateConfigAccount, createEmptyConfigFile, getConfigFilePath, localConfigFileExists, globalConfigFileExists, setConfigAccountAsDefault, } from '@hubspot/local-dev-lib/config';
+import { updateConfigAccount, createEmptyConfigFile, getConfigFilePath, localConfigFileExists, globalConfigFileExists, setConfigAccountAsDefault, getConfigDefaultAccountIfExists, } from '@hubspot/local-dev-lib/config';
 import { getAccessToken, updateConfigWithAccessToken, } from '@hubspot/local-dev-lib/personalAccessKey';
 import { toKebabCase } from '@hubspot/local-dev-lib/text';
 import { handleMerge, handleMigration } from './configMigrate.js';
 import { debugError, logError } from './errorHandlers/index.js';
-import { personalAccessKeyPrompt } from './prompts/personalAccessKeyPrompt.js';
+import { isPromptExitError } from './errors/PromptExitError.js';
+import { legacyPersonalAccessKeyPrompt } from './prompts/personalAccessKeyPrompt.js';
 import { cliAccountNamePrompt } from './prompts/accountNamePrompt.js';
 import { setAsDefaultAccountPrompt } from './prompts/setAsDefaultAccountPrompt.js';
+import { awaitPersonalAccessKeyOverWebsocket } from './auth/awaitPersonalAccessKeyOverWebsocket.js';
 import { commands } from '../lang/en.js';
 import { uiLogger } from './ui/logger.js';
-async function updateConfigWithNewAccount(env, configAlreadyExists, providedPersonalAccessKey, accountId) {
-    try {
-        const { personalAccessKey } = providedPersonalAccessKey
-            ? { personalAccessKey: providedPersonalAccessKey }
-            : await personalAccessKeyPrompt({
+async function getPersonalAccessKey(env, accountId) {
+    if (process.env.BROWSER !== 'none') {
+        try {
+            return await awaitPersonalAccessKeyOverWebsocket({
                 env,
                 account: accountId,
             });
+        }
+        catch (e) {
+            if (isPromptExitError(e))
+                throw e;
+            debugError(e);
+        }
+    }
+    const { personalAccessKey } = await legacyPersonalAccessKeyPrompt({
+        env,
+        account: accountId,
+    });
+    return personalAccessKey;
+}
+async function updateConfigWithNewAccount(env, configAlreadyExists, providedPersonalAccessKey, accountId, providedAccountName, useDefaultAccountName) {
+    try {
+        const personalAccessKey = providedPersonalAccessKey ?? (await getPersonalAccessKey(env, accountId));
         const token = await getAccessToken(personalAccessKey, env);
         const defaultAccountName = token.hubName
             ? toKebabCase(token.hubName)
             : undefined;
-        const accountName = configAlreadyExists
-            ? undefined
-            : (await cliAccountNamePrompt(defaultAccountName)).name;
+        let accountName;
+        if (providedAccountName) {
+            accountName = providedAccountName;
+        }
+        else if (useDefaultAccountName && defaultAccountName) {
+            accountName = defaultAccountName;
+        }
+        else if (!configAlreadyExists) {
+            accountName = (await cliAccountNamePrompt(defaultAccountName)).name;
+        }
         const updatedConfig = await updateConfigWithAccessToken(token, personalAccessKey, env, accountName, !configAlreadyExists);
         if (!updatedConfig)
             return null;
@@ -36,6 +60,9 @@ async function updateConfigWithNewAccount(env, configAlreadyExists, providedPers
         return updatedConfig;
     }
     catch (e) {
+        if (isPromptExitError(e)) {
+            throw e;
+        }
         debugError(e);
         return null;
     }
@@ -73,7 +100,7 @@ async function handleConfigMigration() {
         return false;
     }
 }
-export async function authenticateNewAccount({ env, providedPersonalAccessKey, accountId, setAsDefaultAccount, }) {
+export async function authenticateNewAccount({ env, providedPersonalAccessKey, accountId, setAsDefaultAccount, accountName: providedAccountName, useDefaultAccountName, }) {
     const configMigrationSuccess = await handleConfigMigration();
     if (!configMigrationSuccess) {
         return null;
@@ -82,7 +109,7 @@ export async function authenticateNewAccount({ env, providedPersonalAccessKey, a
     if (!configAlreadyExists) {
         createEmptyConfigFile(true);
     }
-    const updatedConfig = await updateConfigWithNewAccount(env, configAlreadyExists, providedPersonalAccessKey, accountId);
+    const updatedConfig = await updateConfigWithNewAccount(env, configAlreadyExists, providedPersonalAccessKey, accountId, providedAccountName, useDefaultAccountName);
     if (!updatedConfig) {
         uiLogger.error(commands.account.subcommands.auth.errors.failedToUpdateConfig);
         return null;
@@ -93,12 +120,15 @@ export async function authenticateNewAccount({ env, providedPersonalAccessKey, a
         uiLogger.success(commands.account.subcommands.auth.success.configFileCreated(getConfigFilePath()));
         uiLogger.success(commands.account.subcommands.auth.success.configFileUpdated(newAccountId));
     }
-    else if (setAsDefaultAccount) {
-        setConfigAccountAsDefault(name);
-        uiLogger.log('');
-        uiLogger.success(commands.account.subcommands.auth.success.configFileUpdated(newAccountId));
+    else if (setAsDefaultAccount === true) {
+        const currentDefault = getConfigDefaultAccountIfExists();
+        if (currentDefault?.name !== name) {
+            setConfigAccountAsDefault(name);
+            uiLogger.log('');
+            uiLogger.success(commands.account.subcommands.auth.success.configFileUpdated(newAccountId));
+        }
     }
-    else {
+    else if (setAsDefaultAccount !== false) {
         await setAsDefaultAccountPrompt(name);
     }
     return updatedConfig;

package/lib/api/usageTracking.d.ts

@@ -0,0 +1,30 @@
+export type ConfigType = 'local' | 'global';
+export type ExecutionSource = 'ci' | 'mcp' | 'user';
+export type UsageTrackingMeta = {
+    action?: string;
+    os?: string;
+    nodeVersion?: string;
+    nodeMajorVersion?: string;
+    version?: string;
+    command?: string;
+    authType?: string;
+    step?: string;
+    assetType?: string;
+    mode?: string;
+    type?: string | number;
+    file?: boolean;
+    successful?: boolean;
+    configType?: ConfigType;
+    executionSource?: ExecutionSource;
+    platformVersion?: string;
+    executionTime?: number;
+};
+export type UsageTrackingRequest = {
+    portalId?: number;
+    accountId?: number;
+    userId?: number;
+    eventName: string;
+    eventClass: string;
+    meta: UsageTrackingMeta;
+};
+export declare function sendUsageEvent(request: UsageTrackingRequest): Promise<void>;

package/lib/api/usageTracking.js

@@ -0,0 +1,11 @@
+import { http as unauthedHttp } from '@hubspot/local-dev-lib/http/unauthed';
+const USAGE_PATH = 'local/dev/tools/proxy/v1/usage';
+export async function sendUsageEvent(request) {
+    try {
+        await unauthedHttp.post({
+            url: USAGE_PATH,
+            data: request,
+        });
+    }
+    catch (_e) { }
+}

package/lib/app/logs.d.ts

@@ -0,0 +1,38 @@
+import { AppLogEntry as ApiAppLogEntry, SystemType } from '@hubspot/local-dev-lib/types/AppLogs';
+export declare const SYSTEM_TYPE_DISPLAY_NAMES: {
+    [key: string]: string;
+};
+export declare const SYSTEM_TYPE_CHOICES: string[];
+export declare function parseSinceTime(sinceInput: string): {
+    startTime: number;
+    endTime: number;
+};
+export declare function transformApiLogEntry(apiLog: ApiAppLogEntry): {
+    id: string;
+    createdAt: number;
+    executionTimeMillis?: number;
+    portalId?: number;
+    traceId?: string;
+    status: 'SUCCESS' | 'ERROR';
+    errorType?: string;
+    errorMessage?: string;
+};
+export type AppLogsOptions = {
+    since?: string;
+    compact?: boolean;
+    json?: boolean;
+    limit?: number;
+    errorsOnly?: boolean;
+};
+export declare function toTypeChoice(systemType: string): string;
+export declare function toSystemType(choice: string): string;
+export declare function getTypeChoices(): {
+    name: string;
+    value: string;
+}[];
+export declare const handleLogsRequest: (accountId: number, appId: number, systemType: string, options: AppLogsOptions) => Promise<void>;
+export declare const tailAppLogs: (accountId: number, appId: number, systemType: string, options: AppLogsOptions) => Promise<void>;
+export type LogDetailsOptions = {
+    json?: boolean;
+};
+export declare const handleLogDetailsRequest: (accountId: number, appId: number, logId: string, systemType: SystemType, options: LogDetailsOptions) => Promise<void>;

package/lib/app/logs.js

@@ -0,0 +1,225 @@
+import moment from 'moment';
+import { getAppLogDetails, searchAppLogs, } from '@hubspot/local-dev-lib/api/appLogs';
+import { outputAppLogDetails, outputAppLogs } from '../ui/appLogs.js';
+import { uiLogger } from '../ui/logger.js';
+import SpinniesManager from '../ui/SpinniesManager.js';
+import { handleExit, handleKeypress } from '../process.js';
+import { commands } from '../../lang/en.js';
+export const SYSTEM_TYPE_DISPLAY_NAMES = {
+    WEBHOOKS: 'Webhooks',
+    API_CALL: 'API Call',
+    SERVERLESS_EXECUTION: 'Serverless Function',
+    CRM_EXTENSIBILITY_CARD: 'CRM Card',
+    CRM_LEGACY_CARD: 'CRM Legacy Card',
+    EXTENSION_LOG: 'Extension Log',
+    EXTENSION_RENDER: 'Extension Render',
+    APP_SETTINGS: 'App Settings',
+    PROXY_EXECUTION: 'Proxy Execution',
+    SERVERLESS_GATEWAY_EXECUTION: 'Serverless Gateway Execution',
+    ACCEPTANCE_TEST: 'Acceptance Test',
+    OAUTH_AUTHORIZATION: 'OAuth Authorization',
+};
+export const SYSTEM_TYPE_CHOICES = Object.keys(SYSTEM_TYPE_DISPLAY_NAMES).map(toTypeChoice);
+export function parseSinceTime(sinceInput) {
+    const now = moment();
+    const relativeTimePattern = /^(\d+)([mhd])$/;
+    const match = sinceInput.match(relativeTimePattern);
+    if (match) {
+        const value = parseInt(match[1], 10);
+        const unit = match[2];
+        let startTime;
+        switch (unit) {
+            case 'm':
+                startTime = now.clone().subtract(value, 'minutes');
+                break;
+            case 'h':
+                startTime = now.clone().subtract(value, 'hours');
+                break;
+            case 'd':
+                startTime = now.clone().subtract(value, 'days');
+                break;
+            default:
+                throw new Error(`Invalid time unit: ${unit}`);
+        }
+        return {
+            startTime: startTime.valueOf(),
+            endTime: now.valueOf(),
+        };
+    }
+    const isoTime = moment(sinceInput);
+    if (isoTime.isValid()) {
+        return {
+            startTime: isoTime.valueOf(),
+            endTime: now.valueOf(),
+        };
+    }
+    throw new Error(`Invalid time format: ${sinceInput}`);
+}
+export function transformApiLogEntry(apiLog) {
+    return {
+        id: apiLog.id,
+        createdAt: apiLog.requestExecutionTimestamp,
+        executionTimeMillis: apiLog.duration,
+        portalId: apiLog.portalId,
+        traceId: apiLog.traceId,
+        status: apiLog.errorType ? 'ERROR' : 'SUCCESS',
+        errorType: apiLog.errorType,
+        errorMessage: apiLog.errorMessage,
+    };
+}
+const TAIL_DELAY = 5000;
+export function toTypeChoice(systemType) {
+    return systemType.toLowerCase().replaceAll('_', '-');
+}
+export function toSystemType(choice) {
+    return choice.toUpperCase().replaceAll('-', '_');
+}
+export function getTypeChoices() {
+    return Object.entries(SYSTEM_TYPE_DISPLAY_NAMES).map(([key, name]) => ({
+        name,
+        value: key,
+    }));
+}
+function buildTransformedResponse(data) {
+    return {
+        results: data.results.map(transformApiLogEntry),
+        hasMore: !!data.paging?.next,
+        offset: 0,
+        total: data.results.length,
+    };
+}
+export const handleLogsRequest = async (accountId, appId, systemType, options) => {
+    const { since, compact, json, limit, errorsOnly } = options;
+    const resolvedLimit = limit ?? 50;
+    let timeRange;
+    if (since) {
+        timeRange = parseSinceTime(since);
+    }
+    const query = {
+        loggingSystemType: systemType,
+        limit: resolvedLimit,
+        offset: 0,
+        errorTypes: errorsOnly ? ['*'] : [],
+        resultsOrder: 'DESC',
+        ...timeRange,
+    };
+    const requestBody = {
+        query,
+        limit: resolvedLimit,
+    };
+    const { data } = await searchAppLogs(accountId, appId, requestBody);
+    if (json) {
+        uiLogger.json(data);
+    }
+    else {
+        await outputAppLogs(buildTransformedResponse(data), {
+            compact: !!compact,
+            accountId,
+            appId,
+            systemType,
+            typeName: SYSTEM_TYPE_DISPLAY_NAMES[systemType],
+        });
+    }
+};
+export const tailAppLogs = async (accountId, appId, systemType, options) => {
+    const { compact, since, errorsOnly } = options;
+    let currentAfter;
+    let currentStartTime;
+    if (since) {
+        currentStartTime = parseSinceTime(since).startTime;
+    }
+    return new Promise(resolve => {
+        function cleanup() {
+            SpinniesManager.remove('tailLogs');
+            SpinniesManager.remove('stopMessage');
+        }
+        let resolved = false;
+        // eslint-disable-next-line prefer-const -- assigned after onTerminate is defined due to circular reference
+        let removeExitListeners;
+        let timeoutHandle;
+        const onTerminate = async () => {
+            if (resolved)
+                return;
+            resolved = true;
+            removeExitListeners?.();
+            if (timeoutHandle) {
+                clearTimeout(timeoutHandle);
+            }
+            cleanup();
+            resolve();
+        };
+        removeExitListeners = handleExit(onTerminate);
+        handleKeypress(key => {
+            if ((key.ctrl && key.name === 'c') || key.name === 'q') {
+                onTerminate();
+            }
+        });
+        async function tail() {
+            try {
+                const query = {
+                    loggingSystemType: systemType,
+                    limit: 50,
+                    offset: 0,
+                    errorTypes: errorsOnly ? ['*'] : [],
+                    resultsOrder: 'ASC',
+                    ...(currentStartTime !== undefined && {
+                        startTime: currentStartTime,
+                    }),
+                };
+                const requestBody = {
+                    query,
+                    limit: 50,
+                    ...(currentAfter && { after: currentAfter }),
+                };
+                const { data } = await searchAppLogs(accountId, appId, requestBody);
+                if (data.results && data.results.length > 0) {
+                    await outputAppLogs(buildTransformedResponse(data), {
+                        compact: !!compact,
+                        tail: true,
+                        accountId,
+                        appId,
+                        systemType,
+                        typeName: SYSTEM_TYPE_DISPLAY_NAMES[systemType],
+                    });
+                    if (data.paging?.next?.after) {
+                        currentAfter = data.paging.next.after;
+                    }
+                    else {
+                        const lastResult = data.results[data.results.length - 1];
+                        currentStartTime = lastResult.requestExecutionTimestamp + 1;
+                        currentAfter = undefined;
+                    }
+                }
+                timeoutHandle = setTimeout(() => {
+                    tail();
+                }, TAIL_DELAY);
+            }
+            catch (e) {
+                await onTerminate();
+                throw e;
+            }
+        }
+        const tailCopy = commands.app.subcommands.logs.outputMessages.tailMessages;
+        SpinniesManager.add('tailLogs', {
+            text: tailCopy.following(appId),
+        });
+        SpinniesManager.add('stopMessage', {
+            text: tailCopy.stop,
+            status: 'non-spinnable',
+        });
+        void tail();
+    });
+};
+export const handleLogDetailsRequest = async (accountId, appId, logId, systemType, options) => {
+    const { json } = options;
+    const { data } = await getAppLogDetails(accountId, appId, systemType, logId);
+    if (json) {
+        uiLogger.json(data);
+    }
+    else {
+        outputAppLogDetails(data.log, {
+            accountId,
+            appId,
+        });
+    }
+};

package/lib/app/migrate.js

@@ -5,6 +5,7 @@ import chalk from 'chalk';
 import { validateUid } from '@hubspot/project-parsing-lib/uid';
 import { UNMIGRATABLE_REASONS } from '@hubspot/local-dev-lib/constants/projects';
 import { mapToUserFacingType } from '@hubspot/project-parsing-lib/transform';
+import { AUTO_GENERATED_COMPONENT_TYPES } from '@hubspot/project-parsing-lib/constants';
 import { MIGRATION_STATUS } from '@hubspot/local-dev-lib/types/Migration';
 import { downloadProject, fetchProjectComponentsMetadata, } from '@hubspot/local-dev-lib/api/projects';
 import { Separator } from '@inquirer/prompts';
@@ -123,12 +124,21 @@ export async function selectAppToMigrate(allApps, derivedAccountId, appId) {
     const selectedApp = allApps.find(app => app.appId === appIdToMigrate);
     const migratableComponents = new Set();
     const unmigratableComponents = new Set();
+    let hasLegacyCrmCards = false;
     selectedApp?.migrationComponents.forEach(component => {
-        if (component.isSupported) {
-            migratableComponents.add(mapToUserFacingType(component.componentType));
+        const userFacingComponentType = mapToUserFacingType(component.componentType);
+        if (component.componentType === 'LEGACY_CRM_CARD' &&
+            !component.isSupported) {
+            hasLegacyCrmCards = true;
         }
-        else {
-            unmigratableComponents.add(mapToUserFacingType(component.componentType));
+        const shouldDisplayComponent = !AUTO_GENERATED_COMPONENT_TYPES.includes(userFacingComponentType);
+        if (shouldDisplayComponent) {
+            if (component.isSupported) {
+                migratableComponents.add(userFacingComponentType);
+            }
+            else {
+                unmigratableComponents.add(userFacingComponentType);
+            }
         }
     });
     if (migratableComponents.size !== 0) {
@@ -137,6 +147,9 @@ export async function selectAppToMigrate(allApps, derivedAccountId, appId) {
     if (unmigratableComponents.size !== 0) {
         uiLogger.log(lib.migrate.componentsThatWillNotBeMigrated(`\n - ${[...unmigratableComponents].join('\n - ')}`));
     }
+    if (hasLegacyCrmCards) {
+        uiLogger.info(lib.migrate.legacyCrmCardMigrationDocs());
+    }
     uiLogger.log('');
     const proceed = await confirmPrompt(lib.migrate.prompt.proceed, {
         defaultAnswer: false,
@@ -255,7 +268,7 @@ export async function pollMigrationStatus(derivedAccountId, migrationId, success
     return poll(() => checkMigrationStatusV2(derivedAccountId, migrationId), {
         successStates: [...successStates],
         errorStates: [...DEFAULT_POLLING_STATUS_LOOKUP.errorStates],
-    });
+    }, 300_000);
 }
 export async function finalizeAppMigration(derivedAccountId, migrationId, uidMap, projectName) {
     let pollResponse;

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