@hubspot/cli 8.8.0 → 8.9.0-beta.0

package/lang/en.js

@@ -2,12 +2,11 @@ import chalk from 'chalk';
 import { mapToUserFriendlyName } from '@hubspot/project-parsing-lib/transform';
 import { PLATFORM_VERSIONS } from '@hubspot/project-parsing-lib/constants';
 import { PERSONAL_ACCESS_KEY_AUTH_METHOD } from '@hubspot/local-dev-lib/constants/auth';
-import { LOCAL_DEV_DEFAULT_PORT } from '../lib/constants.js';
+import { APP_AUTH_TYPES, APP_DISTRIBUTION_TYPES, LEGACY_PUBLIC_APP_FILE, LOCAL_DEV_DEFAULT_PORT, PROJECT_CONFIG_FILE, PROJECT_WITH_APP, } from '../lib/constants.js';
 import { ARCHIVED_HUBSPOT_CONFIG_YAML_FILE_NAME, DEFAULT_HUBSPOT_CONFIG_YAML_FILE_NAME, GLOBAL_CONFIG_PATH, } from '@hubspot/local-dev-lib/constants/config';
 import { indent, UI_COLORS, uiAccountDescription, uiAuthCommandReference, uiBetaTag, uiCommandReference, uiLink, } from '../lib/ui/index.js';
 import { getLocalDevUiUrl, getProjectDetailUrl, getProjectSettingsUrl, } from '../lib/projects/urls.js';
 import { getProductUpdatesUrl } from '../lib/links.js';
-import { APP_AUTH_TYPES, APP_DISTRIBUTION_TYPES, LEGACY_PUBLIC_APP_FILE, PROJECT_CONFIG_FILE, PROJECT_WITH_APP, } from '../lib/constants.js';
 export const commands = {
     generalErrors: {
         srcIsProject: (src, command) => `"${src}" is in a project folder. Did you mean "hs project ${command}"?`,
@@ -124,6 +123,9 @@ export const commands = {
                 options: {
                     account: 'HubSpot account to authenticate',
                     personalAccessKey: 'Enter existing personal access key',
+                    default: 'Set the authenticated account as the default account',
+                    name: 'Set a name for the account in the CLI config',
+                    useDefaultName: 'Use the account name derived from the HubSpot portal name',
                 },
                 errors: {
                     invalidAccountIdProvided: `--account must be a number.`,
@@ -2040,6 +2042,7 @@ export const commands = {
                 return `The dependencies required for linting are missing or outdated.\n\nDependencies:\n${uniquePackages.map(p => `  - ${p}`).join('\n')}\n\n${directories.length === 1 ? 'Directory' : 'Directories'}:\n${directories.map(d => `  - ${d}`).join('\n')}\n\nWould you like to install the required dependencies?`;
             },
             skippingDirectoriesWarning: (directories) => `Skipping linting for the following ${directories.length === 1 ? 'directory' : 'directories'}:\n${directories.map(d => `  - ${d}`).join('\n')}`,
+            skippedDirectoriesError: (directoryCount) => `Linting could not run for ${directoryCount === 1 ? 'the directory' : 'the directories'} above because the required dependencies are missing. Run ${uiCommandReference('hs project lint --install-missing-deps')} to install them.`,
             deprecatedEslintConfigWarning: (details) => {
                 const dirCount = details.length;
                 const header = `Deprecated ESLint configuration file${dirCount === 1 ? '' : 's'} detected in the following ${dirCount === 1 ? 'directory' : 'directories'}:`;
@@ -2402,6 +2405,111 @@ export const commands = {
                     },
                 },
             },
+            logs: {
+                describe: 'View recent application logs.',
+                verboseDescribe: `View recent application logs for a specific log type.\n\nFilter by time range with ${uiCommandReference('--since')} (e.g. 1h, 30m, 2d, or an ISO timestamp). Use ${uiCommandReference('--tail')} to follow logs in real-time, ${uiCommandReference('--compact')} for one-line-per-log output, or ${uiCommandReference('--json')} for machine-readable output.\n\nRun ${uiCommandReference('hs app log-details <logId>')} to inspect a specific log entry.`,
+                options: {
+                    appId: 'App ID',
+                    type: 'Log type',
+                    json: 'Output logs as JSON',
+                    limit: 'Maximum number of logs to return',
+                    since: 'Filter logs by time ago (1h, 30m, 2d, or ISO timestamp)',
+                    tail: 'Follow logs in real-time',
+                    errorsOnly: 'Only show error logs',
+                    compact: 'Display logs in compact format (one line per log)',
+                },
+                errors: {
+                    noLogs: 'No logs found. Try a wider time range (--since) or remove --errors-only to see all logs.',
+                    noApps: `No apps found. Create an app with ${uiCommandReference('hs project create')}.`,
+                },
+                prompts: {
+                    selectType: '[--type] Select the type of logs to view:',
+                },
+                examples: {
+                    basic: 'Fetch webhook logs for app 123456',
+                    since: 'Fetch logs from the last hour',
+                    tail: 'Follow logs in real-time',
+                    json: 'Output logs as JSON',
+                    compact: 'Display logs in compact format',
+                },
+                outputMessages: {
+                    viewInHubSpot: (url) => uiLink('View in HubSpot', url),
+                    tableHeaders: {
+                        appId: 'App ID',
+                        type: 'Type',
+                        logsFound: 'Logs Found',
+                    },
+                    logDetails: {
+                        id: 'ID',
+                        duration: 'Duration',
+                        portal: 'Portal',
+                        trace: 'Trace',
+                        error: 'Error',
+                        viewDetails: (logId, appId, systemType) => `To view more details, run: ${uiCommandReference(`hs app log-details ${logId} --app=${appId} --type=${systemType}`)}`,
+                        viewInUI: (url) => uiLink('View details in UI', url),
+                    },
+                    tailMessages: {
+                        following: (appId) => `Following logs for app ${appId}`,
+                        stop: `> Press ${chalk.bold('q')} to stop following`,
+                    },
+                },
+            },
+            logDetails: {
+                describe: 'View details for a specific log entry.',
+                verboseDescribe: `View full details for a specific app log entry, including request/response bodies, context information, and error details.\n\nUse ${uiCommandReference('--json')} for machine-readable output.`,
+                positionals: {
+                    logId: 'The log ID to fetch details for',
+                },
+                options: {
+                    appId: 'App ID',
+                    type: 'Log type',
+                    json: 'Output details as JSON',
+                },
+                errors: {
+                    noApps: `No apps found. Create an app with ${uiCommandReference('hs project create')}.`,
+                },
+                prompts: {
+                    selectType: '[--type] Select the log type:',
+                },
+                examples: {
+                    basic: 'Fetch details for log abc-123',
+                    json: 'Output log details as JSON',
+                },
+                outputMessages: {
+                    viewInHubSpot: (url) => uiLink('View in HubSpot', url),
+                    logDetailsHeader: 'Log Details',
+                    basicInfo: {
+                        id: 'Log ID',
+                        timestamp: 'Timestamp',
+                        status: 'Status',
+                        duration: 'Duration',
+                        systemType: 'Type',
+                    },
+                    contextInfo: {
+                        header: 'Context',
+                        portalId: 'Portal ID',
+                        traceId: 'Trace ID',
+                        function: 'Function',
+                        location: 'Location',
+                        card: 'Card',
+                        userId: 'User ID',
+                    },
+                    requestResponse: {
+                        header: 'Request/Response',
+                        requestBody: 'Request Body',
+                        responseBody: 'Response Body',
+                    },
+                    errorInfo: {
+                        header: 'Error Details',
+                        errorType: 'Type',
+                        errorMessage: 'Message',
+                        stackTrace: 'Stack Trace',
+                    },
+                    additionalInfo: {
+                        header: 'Additional Information',
+                    },
+                },
+            },
         },
     },
     secret: {
@@ -3273,6 +3381,13 @@ export const lib = {
         appDataNotFound: 'An error occurred while fetching data for your app.',
         oauthAppRedirectUrlError: (redirectUrl) => `${chalk.bold('No reponse from your OAuth service:')} ${redirectUrl}\nYour app needs a valid OAuth2 service to be installed for local dev. ${uiLink('Learn more', 'https://developers.hubspot.com/docs/apps/developer-platform/build-apps/authentication/oauth/working-with-oauth')}`,
     },
+    accountAuthWebsocket: {
+        logs: {
+            openingWebBrowser: (url) => `Opening ${uiLink('HubSpot', url)} in your web browser\n`,
+            spinner: 'Waiting for HubSpot to send your personal access key... (press any key to enter it manually)',
+            received: 'Personal access key received',
+        },
+    },
     CLIWebsocketServer: {
         errors: {
             portManagerNotRunning: (prefix) => `${prefix ? `${prefix} ` : ''}PortManagerServing must be running before starting WebsocketServer.`,
@@ -3280,6 +3395,7 @@ export const lib = {
             missingTypeField: (data) => `Unsupported message received. Missing type field: ${data}`,
             invalidJSON: (data) => `Unsupported message received. Invalid JSON: ${data}`,
             unknownMessageType: (type) => `Unsupported message received. Unknown message type: ${type}`,
+            failedToBindEphemeralPort: (prefix) => `${prefix ? `${prefix} ` : ''}Failed to determine the assigned port for the WebsocketServer.`,
         },
         logs: {
             startup: (port) => `WebsocketServer running on port ${port}`,
@@ -3748,7 +3864,7 @@ export const lib = {
             functionName: (projectName) => `[--function] Select function in ${chalk.bold(projectName)} project`,
         },
         setAsDefaultAccountPrompt: {
-            setAsDefaultAccountMessage: 'Set this account as the default?',
+            setAsDefaultAccountMessage: (accountName) => `Set ${accountName} as your default account? [--default]`,
             setAsDefaultAccount: (accountName) => `Account "${accountName}" set as the default account`,
             keepingCurrentDefault: (accountName) => `Account "${accountName}" will continue to be the default account`,
         },

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,29 +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 { isPromptExitError } from './errors/PromptExitError.js';
-import { personalAccessKeyPrompt } from './prompts/personalAccessKeyPrompt.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;
@@ -77,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;
@@ -86,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;
@@ -97,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

@@ -22,6 +22,7 @@ export type UsageTrackingMeta = {
 export type UsageTrackingRequest = {
     portalId?: number;
     accountId?: number;
+    userId?: number;
     eventName: string;
     eventClass: string;
     meta: UsageTrackingMeta;

package/lib/api/usageTracking.js

@@ -1,23 +1,6 @@
-import { http } from '@hubspot/local-dev-lib/http';
 import { http as unauthedHttp } from '@hubspot/local-dev-lib/http/unauthed';
-import { getConfigAccountById } from '@hubspot/local-dev-lib/config';
 const USAGE_PATH = 'local/dev/tools/proxy/v1/usage';
-const USAGE_AUTHENTICATED_PATH = `${USAGE_PATH}/authenticated`;
 export async function sendUsageEvent(request) {
-    const { accountId } = request;
-    if (accountId) {
-        try {
-            const account = getConfigAccountById(accountId);
-            if (account?.authType === 'personalaccesskey') {
-                await http.post(accountId, {
-                    url: USAGE_AUTHENTICATED_PATH,
-                    data: request,
-                });
-                return;
-            }
-        }
-        catch (_e) { }
-    }
     try {
         await unauthedHttp.post({
             url: USAGE_PATH,

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,
+        });
+    }
+};