@sinch/cli 0.1.27-beta.0 → 0.1.28-beta.0

package/dist/commands/logs.js

@@ -0,0 +1,1001 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const chalk_1 = __importDefault(require("chalk"));
+const commander_1 = require("commander");
+const api_1 = require("../lib/api");
+const config_1 = require("../lib/config");
+const logger_1 = require("../utils/logger");
+const spinner_1 = require("../utils/spinner");
+const child_process_1 = require("child_process");
+const fs_1 = __importDefault(require("fs"));
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+const logs = new commander_1.Command('logs');
+logs
+    .description('View function logs')
+    .argument('[function-id]', 'Function ID to get logs for (optional if sinch.json exists)')
+    .option('-f, --follow', 'Follow log output in real-time')
+    .option('-n, --lines <number>', 'Number of historical lines to show', '50')
+    .option('--level <level>', 'Filter by log level (debug, info, warning, error)')
+    .option('--search <text>', 'Search for text in log messages')
+    .option('--since <duration>', 'Show logs since duration (e.g., 1h, 30m, 5s)')
+    .action(async (functionIdArg, options) => {
+    try {
+        await config_1.config.load();
+        const api = new api_1.SinchAPI(config_1.config.getApiConfig());
+        let functionId = functionIdArg;
+        if (!functionId) {
+            if (!config_1.config.isInProject()) {
+                throw new Error('Function ID required. Provide as argument or run from function directory with sinch.json');
+            }
+            const projectConfig = config_1.config.getProjectConfig();
+            if (!projectConfig) {
+                throw new Error('No project configuration found');
+            }
+            functionId = projectConfig.functionId;
+            if (!functionId) {
+                throw new Error('No function ID found in sinch.json. Deploy the function first or provide function ID as argument.');
+            }
+        }
+        spinner_1.spinner.start('Loading function details...');
+        const func = await api.getFunction(functionId);
+        spinner_1.spinner.stop();
+        logger_1.logger.info(`📋 Logs for function: ${chalk_1.default.cyan(func.name)} (${getStatusDisplay(func.status)})`);
+        logger_1.logger.newline();
+        if (options.follow) {
+            await streamFunctionLogs(api, functionId, func.name, options);
+        }
+        else {
+            await showHistoricalLogs(api, functionId, options);
+        }
+    }
+    catch (error) {
+        spinner_1.spinner.stop();
+        logger_1.logger.error(`Failed to get logs: ${error.message}`);
+        process.exit(1);
+    }
+});
+logs
+    .command('stream')
+    .description('Stream function logs in real-time')
+    .argument('[function-id]', 'Function ID to stream logs for (optional if sinch.json exists)')
+    .option('--level <level>', 'Filter by log level (debug, info, warning, error)')
+    .option('--search <text>', 'Search for text in log messages')
+    .action(async (functionIdArg, options) => {
+    try {
+        await config_1.config.load();
+        const api = new api_1.SinchAPI(config_1.config.getApiConfig());
+        let functionId = functionIdArg;
+        if (!functionId) {
+            if (!config_1.config.isInProject()) {
+                throw new Error('Function ID required. Provide as argument or run from function directory with sinch.json');
+            }
+            const projectConfig = config_1.config.getProjectConfig();
+            if (!projectConfig) {
+                throw new Error('No project configuration found');
+            }
+            functionId = projectConfig.functionId;
+            if (!functionId) {
+                throw new Error('No function ID found in sinch.json. Deploy the function first or provide function ID as argument.');
+            }
+        }
+        spinner_1.spinner.start('Connecting to log stream...');
+        const func = await setupStreamConnection(api, functionId);
+        spinner_1.spinner.stop();
+        await streamFunctionLogs(api, functionId, func.name, { ...options, follow: true });
+    }
+    catch (error) {
+        spinner_1.spinner.stop();
+        logger_1.logger.error(`Failed to stream logs: ${error.message}`);
+        process.exit(1);
+    }
+});
+async function setupStreamConnection(api, functionId) {
+    const func = await api.getFunction(functionId);
+    return func;
+}
+async function streamFunctionLogs(api, functionId, functionName, _options) {
+    const baseUrl = api.baseUrl.replace(/\/+$/, '');
+    const projectId = api.projectId;
+    const streamUrl = `${baseUrl}/v1/projects/${projectId}/functions/${functionId}/logs/stream`;
+    const credentials = api.credentials;
+    const requests = [];
+    const screen = createBlessedLogViewer(requests, 'STREAMING', functionName);
+    let headers = {
+        'Accept': 'text/event-stream',
+        'Cache-Control': 'no-cache'
+    };
+    if (credentials) {
+        try {
+            const creds = await credentials.retrieve();
+            if (creds && creds.keyId && creds.keySecret) {
+                const authString = Buffer.from(`${creds.keyId}:${creds.keySecret}`).toString('base64');
+                headers['Authorization'] = `Basic ${authString}`;
+            }
+        }
+        catch (error) {
+            logger_1.logger.debug('Failed to add authentication:', error);
+        }
+    }
+    const abortController = new AbortController();
+    try {
+        const response = await fetch(streamUrl, {
+            method: 'GET',
+            headers,
+            signal: abortController.signal
+        });
+        if (!response.ok) {
+            throw new Error(`SSE connection failed: ${response.status} ${response.statusText}`);
+        }
+        if (!response.body) {
+            throw new Error('Response body is null');
+        }
+        updateStatusBar(screen.statusBar, 'CONNECTED', functionName);
+        screen.screen.render();
+        const reader = response.body.getReader();
+        const decoder = new TextDecoder();
+        let buffer = '';
+        const processStream = async () => {
+            try {
+                while (true) {
+                    const { done, value } = await reader.read();
+                    if (done)
+                        break;
+                    buffer += decoder.decode(value, { stream: true });
+                    const lines = buffer.split('\n');
+                    buffer = lines.pop() || '';
+                    for (const line of lines) {
+                        if (line.startsWith('event:')) {
+                            continue;
+                        }
+                        if (line.startsWith('data:')) {
+                            const dataStr = line.substring(5).trim();
+                            if (dataStr) {
+                                try {
+                                    const logEvent = JSON.parse(dataStr);
+                                    if (logEvent.type === 'request' && logEvent.request) {
+                                        requests.push(logEvent.request);
+                                        updateTableWithRequest(screen.table, logEvent.request, requests);
+                                        screen.table.focus();
+                                        screen.screen.render();
+                                    }
+                                }
+                                catch (e) {
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+            catch (error) {
+                if (error.name !== 'AbortError') {
+                    updateStatusBar(screen.statusBar, 'RECONNECTING', functionName);
+                    screen.screen.render();
+                }
+            }
+        };
+        processStream();
+        screen.screen.key(['q', 'C-c'], () => {
+            abortController.abort();
+            process.exit(0);
+        });
+        await new Promise(() => { });
+    }
+    catch (error) {
+        abortController.abort();
+        logger_1.logger.error(`❌ Streaming failed: ${error.message}`);
+        process.exit(1);
+    }
+}
+function getStatusDisplay(status) {
+    const statusColors = {
+        'Running': chalk_1.default.green('✅ Running'),
+        'Failed': chalk_1.default.red('❌ Failed'),
+        'Pending': chalk_1.default.yellow('⏳ Pending'),
+        'Building': chalk_1.default.blue('🔨 Building')
+    };
+    return statusColors[status] || chalk_1.default.gray(status);
+}
+let globalTableData = [];
+function updateTableWithRequest(table, request, requestsArray) {
+    const date = new Date(request.startTime);
+    const timestamp = date.getFullYear() + '-' +
+        String(date.getMonth() + 1).padStart(2, '0') + '-' +
+        String(date.getDate()).padStart(2, '0') + ' ' +
+        String(date.getHours()).padStart(2, '0') + ':' +
+        String(date.getMinutes()).padStart(2, '0') + ':' +
+        String(date.getSeconds()).padStart(2, '0');
+    const callback = extractCallback(request);
+    const duration = `${request.executionTimeMs}ms`;
+    const status = request.statusCode.toString();
+    const terminalWidth = process.stdout.columns || 120;
+    const fixedColumnsWidth = 35;
+    const availablePathWidth = Math.max(30, terminalWidth - fixedColumnsWidth);
+    const pathDisplay = request.url.length > availablePathWidth ?
+        request.url.substring(0, availablePathWidth - 2) + '..' :
+        request.url;
+    globalTableData.push([
+        timestamp,
+        callback,
+        duration,
+        status,
+        pathDisplay
+    ]);
+    if (globalTableData.length > 100) {
+        globalTableData = globalTableData.slice(-100);
+        if (requestsArray && requestsArray.length > 100) {
+            requestsArray.splice(0, requestsArray.length - 100);
+        }
+    }
+    const tableData = [['Time', 'Callback', 'Duration', 'Status', 'Path'], ...globalTableData];
+    table.setData(tableData);
+}
+function showBlessedZoomedRequest(request, screen, table, _statusBar, _functionName) {
+    try {
+        const blessed = require('blessed');
+        logger_1.logger.debug(`Showing request details for ${request.httpMethod} ${request.url}`);
+        const modal = blessed.box({
+            parent: screen,
+            top: 0,
+            left: 0,
+            width: '100%',
+            height: '100%',
+            border: { type: 'line' },
+            style: {
+                border: { fg: 'cyan' },
+                bg: 'black',
+                fg: 'white'
+            },
+            scrollable: true,
+            alwaysScroll: true,
+            keys: true,
+            vi: true,
+            tags: true,
+            label: ' Request Details '
+        });
+        const modalStatus = blessed.box({
+            parent: modal,
+            top: 1,
+            left: 2,
+            width: '100%-4',
+            height: 1,
+            content: '{gray-fg}[Esc/Q] Close  [↑↓] Scroll  [J/1] JSON  [C/2] cURL{/}',
+            tags: true,
+            style: { bg: 'blue', fg: 'white' }
+        });
+        blessed.box({
+            parent: modal,
+            top: 2,
+            left: 2,
+            width: '100%-4',
+            height: 1,
+            content: `{bold}{cyan-fg}${request.httpMethod}{/} {blue-fg}${request.url}{/} - {${getStatusCodeColorName(request.statusCode)}}${request.statusCode}{/} - {yellow-fg}${request.executionTimeMs}ms{/} - {magenta-fg}${request.memoryUsedMB || 0}MB{/}`,
+            tags: true,
+            style: { bg: 'black' }
+        });
+        const contentArea = blessed.box({
+            parent: modal,
+            top: 4,
+            left: 2,
+            width: '100%-4',
+            height: '100%-5',
+            scrollable: true,
+            alwaysScroll: true,
+            keys: true,
+            vi: true,
+            tags: true,
+            content: buildFullRequestResponseContent(request)
+        });
+        contentArea.focus();
+        screen.render();
+        let isModalOpen = true;
+        const closeModal = () => {
+            if (!isModalOpen)
+                return;
+            isModalOpen = false;
+            modal.destroy();
+            table.focus();
+            screen.render();
+        };
+        screen.key(['escape', 'q'], () => {
+            if (isModalOpen)
+                closeModal();
+        });
+        screen.key(['up', 'k'], () => {
+            if (isModalOpen) {
+                contentArea.scroll(-1);
+                screen.render();
+            }
+        });
+        screen.key(['down', 'j'], () => {
+            if (isModalOpen) {
+                contentArea.scroll(1);
+                screen.render();
+            }
+        });
+        screen.on('keypress', (ch, key) => {
+            if (isModalOpen) {
+                logger_1.logger.debug(`Key pressed: ch="${ch}" key=${JSON.stringify(key)}`);
+            }
+        });
+        screen.key(['J', 'j'], () => {
+            if (!isModalOpen)
+                return;
+            logger_1.logger.debug('J/j key pressed - attempting JSON copy');
+            modalStatus.setContent('{black-bg}{yellow-fg} J KEY PRESSED - COPYING JSON... {/}');
+            screen.render();
+            setTimeout(() => {
+                try {
+                    const jsonContent = JSON.stringify(request, null, 2);
+                    logger_1.logger.debug(`JSON content length: ${jsonContent.length}`);
+                    logger_1.logger.debug('Attempting native clipboard copy');
+                    copyToClipboard(jsonContent)
+                        .then(() => {
+                        modalStatus.setContent('{green-fg}✓ Request JSON copied to clipboard!{/}');
+                        logger_1.logger.debug('Native clipboard copy succeeded');
+                        screen.render();
+                        setTimeout(() => {
+                            if (isModalOpen) {
+                                modalStatus.setContent('{gray-fg}[Esc/Q] Close  [↑↓] Scroll  [J] JSON  [C] cURL{/}');
+                                screen.render();
+                            }
+                        }, 3000);
+                    })
+                        .catch((_clipError) => {
+                        logger_1.logger.debug(`Native clipboard failed: ${_clipError.message}`);
+                        const tempFile = path_1.default.join(os_1.default.tmpdir(), `sinch-request-${Date.now()}.json`);
+                        fs_1.default.writeFileSync(tempFile, jsonContent);
+                        modalStatus.setContent(`{yellow-fg}✓ JSON saved to: ${tempFile}{/}`);
+                        logger_1.logger.debug(`Saved to temp file: ${tempFile}`);
+                        screen.render();
+                        setTimeout(() => {
+                            if (isModalOpen) {
+                                modalStatus.setContent('{gray-fg}[Esc/Q] Close  [↑↓] Scroll  [J] JSON  [C] cURL{/}');
+                                screen.render();
+                            }
+                        }, 3000);
+                    });
+                }
+                catch (error) {
+                    logger_1.logger.debug(`JSON copy error: ${error.message}`);
+                    modalStatus.setContent(`{red-fg}✗ Copy failed: ${error.message}{/}`);
+                    screen.render();
+                    setTimeout(() => {
+                        if (isModalOpen) {
+                            modalStatus.setContent('{gray-fg}[Esc/Q] Close  [↑↓] Scroll  [J] JSON  [C] cURL{/}');
+                            screen.render();
+                        }
+                    }, 3000);
+                }
+            }, 100);
+        });
+        screen.key(['C', 'c'], () => {
+            if (!isModalOpen)
+                return;
+            logger_1.logger.debug('C/c key pressed - attempting cURL copy');
+            modalStatus.setContent('{black-bg}{yellow-fg} C KEY PRESSED - COPYING CURL... {/}');
+            screen.render();
+            setTimeout(() => {
+                try {
+                    const curlCommand = generateCurlCommand(request);
+                    logger_1.logger.debug('Attempting native clipboard copy for cURL');
+                    copyToClipboard(curlCommand)
+                        .then(() => {
+                        modalStatus.setContent('{green-fg}✓ cURL command copied to clipboard!{/}');
+                        logger_1.logger.debug('Native clipboard copy succeeded for cURL');
+                        screen.render();
+                        setTimeout(() => {
+                            if (isModalOpen) {
+                                modalStatus.setContent('{gray-fg}[Esc/Q] Close  [↑↓] Scroll  [J] JSON  [C] cURL{/}');
+                                screen.render();
+                            }
+                        }, 3000);
+                    })
+                        .catch((_clipError) => {
+                        logger_1.logger.debug(`Native clipboard failed for cURL: ${_clipError.message}`);
+                        const tempFile = path_1.default.join(os_1.default.tmpdir(), `sinch-curl-${Date.now()}.sh`);
+                        fs_1.default.writeFileSync(tempFile, curlCommand);
+                        modalStatus.setContent(`{yellow-fg}✓ cURL saved to: ${tempFile}{/}`);
+                        screen.render();
+                        setTimeout(() => {
+                            if (isModalOpen) {
+                                modalStatus.setContent('{gray-fg}[Esc/Q] Close  [↑↓] Scroll  [J] JSON  [C] cURL{/}');
+                                screen.render();
+                            }
+                        }, 3000);
+                    });
+                }
+                catch (error) {
+                    logger_1.logger.debug(`cURL copy error: ${error.message}`);
+                    modalStatus.setContent(`{red-fg}✗ Copy failed: ${error.message}{/}`);
+                    screen.render();
+                    setTimeout(() => {
+                        if (isModalOpen) {
+                            modalStatus.setContent('{gray-fg}[Esc/Q] Close  [↑↓] Scroll  [J] JSON  [C] cURL{/}');
+                            screen.render();
+                        }
+                    }, 3000);
+                }
+            }, 100);
+        });
+        screen.key(['1'], () => {
+            if (!isModalOpen)
+                return;
+            logger_1.logger.debug('1 key pressed - copying JSON (alternative binding)');
+            modalStatus.setContent('{black-bg}{yellow-fg} 1 KEY - COPYING JSON... {/}');
+            screen.render();
+            setTimeout(() => {
+                try {
+                    const jsonContent = JSON.stringify(request, null, 2);
+                    copyToClipboard(jsonContent)
+                        .then(() => {
+                        modalStatus.setContent('{green-fg}✓ Request JSON copied to clipboard!{/}');
+                        screen.render();
+                        setTimeout(() => {
+                            if (isModalOpen) {
+                                modalStatus.setContent('{gray-fg}[Esc/Q] Close  [↑↓] Scroll  [J] JSON  [C] cURL{/}');
+                                screen.render();
+                            }
+                        }, 3000);
+                    })
+                        .catch((_clipError) => {
+                        const tempFile = path_1.default.join(os_1.default.tmpdir(), `sinch-request-${Date.now()}.json`);
+                        fs_1.default.writeFileSync(tempFile, jsonContent);
+                        modalStatus.setContent(`{yellow-fg}✓ JSON saved to: ${tempFile}{/}`);
+                        screen.render();
+                        setTimeout(() => {
+                            if (isModalOpen) {
+                                modalStatus.setContent('{gray-fg}[Esc/Q] Close  [↑↓] Scroll  [J] JSON  [C] cURL{/}');
+                                screen.render();
+                            }
+                        }, 3000);
+                    });
+                }
+                catch (error) {
+                    modalStatus.setContent(`{red-fg}✗ Copy failed: ${error.message}{/}`);
+                    screen.render();
+                    setTimeout(() => {
+                        if (isModalOpen) {
+                            modalStatus.setContent('{gray-fg}[Esc/Q] Close  [↑↓] Scroll  [J] JSON  [C] cURL{/}');
+                            screen.render();
+                        }
+                    }, 3000);
+                }
+            }, 100);
+        });
+        screen.key(['2'], () => {
+            if (!isModalOpen)
+                return;
+            logger_1.logger.debug('2 key pressed - copying cURL (alternative binding)');
+            modalStatus.setContent('{black-bg}{yellow-fg} 2 KEY - COPYING CURL... {/}');
+            screen.render();
+            setTimeout(() => {
+                try {
+                    const curlCommand = generateCurlCommand(request);
+                    copyToClipboard(curlCommand)
+                        .then(() => {
+                        modalStatus.setContent('{green-fg}✓ cURL command copied to clipboard!{/}');
+                        screen.render();
+                        setTimeout(() => {
+                            if (isModalOpen) {
+                                modalStatus.setContent('{gray-fg}[Esc/Q] Close  [↑↓] Scroll  [J] JSON  [C] cURL{/}');
+                                screen.render();
+                            }
+                        }, 3000);
+                    })
+                        .catch((_clipError) => {
+                        const tempFile = path_1.default.join(os_1.default.tmpdir(), `sinch-curl-${Date.now()}.sh`);
+                        fs_1.default.writeFileSync(tempFile, curlCommand);
+                        modalStatus.setContent(`{yellow-fg}✓ cURL saved to: ${tempFile}{/}`);
+                        screen.render();
+                        setTimeout(() => {
+                            if (isModalOpen) {
+                                modalStatus.setContent('{gray-fg}[Esc/Q] Close  [↑↓] Scroll  [J] JSON  [C] cURL{/}');
+                                screen.render();
+                            }
+                        }, 3000);
+                    });
+                }
+                catch (error) {
+                    modalStatus.setContent(`{red-fg}✗ Copy failed: ${error.message}{/}`);
+                    screen.render();
+                    setTimeout(() => {
+                        if (isModalOpen) {
+                            modalStatus.setContent('{gray-fg}[Esc/Q] Close  [↑↓] Scroll  [J] JSON  [C] cURL{/}');
+                            screen.render();
+                        }
+                    }, 3000);
+                }
+            }, 100);
+        });
+    }
+    catch (error) {
+        logger_1.logger.debug(`Error in showBlessedZoomedRequest: ${error.message}`);
+    }
+}
+function buildFullRequestResponseContent(request) {
+    let content = '';
+    content += '\n';
+    content += buildRequestSection(request);
+    content += '\n';
+    content += buildResponseSection(request);
+    content += '\n';
+    content += buildLogsSection(request);
+    return content;
+}
+function buildRequestSection(request) {
+    let content = '';
+    const WIDTH = process.stdout.columns - 6;
+    content += '{bold}{green-fg}┌─ REQUEST ' + '─'.repeat(Math.max(0, WIDTH - 10)) + '┐{/}\n';
+    const callId = extractCallId(request);
+    if (callId) {
+        content += `{green-fg}│{/} {bold}Call ID:{/} {cyan-fg}${callId}{/}\n`;
+    }
+    if (request.headers) {
+        content += `{green-fg}│{/} {bold}Headers:{/}\n`;
+        try {
+            const headers = typeof request.headers === 'string' ?
+                JSON.parse(request.headers) : request.headers;
+            Object.entries(headers).forEach(([key, value]) => {
+                const headerLine = `  ${key}: ${value}`;
+                content += wrapText(headerLine, WIDTH - 2, '{green-fg}│{/} ');
+            });
+        }
+        catch (e) {
+            content += wrapText(`  ${request.headers}`, WIDTH - 2, '{green-fg}│{/} ');
+        }
+    }
+    if (request.requestBody) {
+        content += `{green-fg}│{/} {bold}Body:{/}\n`;
+        try {
+            const parsed = JSON.parse(request.requestBody);
+            const formatted = JSON.stringify(parsed, null, 2);
+            formatted.split('\n').forEach(line => {
+                content += wrapText(line, WIDTH - 2, '{green-fg}│{/} ');
+            });
+        }
+        catch (e) {
+            content += wrapText(request.requestBody, WIDTH - 2, '{green-fg}│{/} ');
+        }
+    }
+    content += '{green-fg}└' + '─'.repeat(Math.max(0, WIDTH)) + '┘{/}\n';
+    return content;
+}
+function buildResponseSection(request) {
+    let content = '';
+    const WIDTH = process.stdout.columns - 6;
+    content += '{bold}{blue-fg}┌─ RESPONSE ' + '─'.repeat(Math.max(0, WIDTH - 11)) + '┐{/}\n';
+    if (request.responseHeaders) {
+        content += `{blue-fg}│{/} {bold}Headers:{/}\n`;
+        try {
+            const headers = typeof request.responseHeaders === 'string' ?
+                JSON.parse(request.responseHeaders) : request.responseHeaders;
+            Object.entries(headers).forEach(([key, value]) => {
+                const headerLine = `  ${key}: ${value}`;
+                content += wrapText(headerLine, WIDTH - 2, '{blue-fg}│{/} ');
+            });
+        }
+        catch (e) {
+            content += wrapText(`  ${request.responseHeaders}`, WIDTH - 2, '{blue-fg}│{/} ');
+        }
+    }
+    if (request.responseBody) {
+        content += `{blue-fg}│{/} {bold}Body:{/}\n`;
+        try {
+            const parsed = JSON.parse(request.responseBody);
+            const formatted = JSON.stringify(parsed, null, 2);
+            formatted.split('\n').forEach(line => {
+                content += wrapText(line, WIDTH - 2, '{blue-fg}│{/} ');
+            });
+        }
+        catch (e) {
+            content += wrapText(request.responseBody, WIDTH - 2, '{blue-fg}│{/} ');
+        }
+    }
+    if (request.errorMessage) {
+        content += `{blue-fg}│{/} {bold}{red-fg}Error:{/}\n`;
+        content += wrapText(request.errorMessage, WIDTH - 2, '{blue-fg}│{/} ');
+    }
+    content += '{blue-fg}└' + '─'.repeat(Math.max(0, WIDTH)) + '┘{/}\n';
+    return content;
+}
+function buildLogsSection(request) {
+    let content = '';
+    const WIDTH = process.stdout.columns - 6;
+    content += '{bold}{magenta-fg}┌─ CONSOLE LOGS ' + '─'.repeat(Math.max(0, WIDTH - 15)) + '┐{/}\n';
+    if (request.logs && request.logs.length > 0) {
+        request.logs.forEach((log, _index) => {
+            const time = new Date(log.timestamp).toLocaleTimeString();
+            const level = log.level.toUpperCase().padEnd(5);
+            const color = getLogLevelColor(log.level);
+            const logLine = `${time} [${level}] ${log.message}`;
+            content += wrapText(logLine, WIDTH - 2, '{magenta-fg}│{/} ', color);
+        });
+    }
+    else {
+        content += `{magenta-fg}│{/} {gray-fg}No console logs for this request{/}\n`;
+    }
+    content += '{magenta-fg}└' + '─'.repeat(Math.max(0, WIDTH)) + '┘{/}\n';
+    return content;
+}
+function wrapText(text, maxWidth, prefix, color = '') {
+    if (!text)
+        return '';
+    let result = '';
+    const lines = text.split('\n');
+    lines.forEach(line => {
+        if (line.length <= maxWidth) {
+            result += `${prefix}${color}${line}{/}\n`;
+        }
+        else {
+            let currentLine = line;
+            let isFirst = true;
+            while (currentLine.length > maxWidth) {
+                const wrapPoint = maxWidth - (isFirst ? 0 : 4);
+                const part = currentLine.substring(0, wrapPoint);
+                const indent = isFirst ? '' : '    ';
+                result += `${prefix}${indent}${color}${part}{/}\n`;
+                currentLine = currentLine.substring(wrapPoint);
+                isFirst = false;
+            }
+            if (currentLine.length > 0) {
+                const indent = isFirst ? '' : '    ';
+                result += `${prefix}${indent}${color}${currentLine}{/}\n`;
+            }
+        }
+    });
+    return result;
+}
+function getLogLevelColor(level) {
+    switch (level.toLowerCase()) {
+        case 'debug': return 'gray-fg';
+        case 'info': return 'blue-fg';
+        case 'warning': return 'yellow-fg';
+        case 'error': return 'red-fg';
+        default: return 'white-fg';
+    }
+}
+function getStatusCodeColorName(statusCode) {
+    if (statusCode >= 200 && statusCode < 300)
+        return 'green-fg';
+    if (statusCode >= 300 && statusCode < 400)
+        return 'yellow-fg';
+    if (statusCode >= 400 && statusCode < 500)
+        return 'red-fg';
+    if (statusCode >= 500)
+        return 'red-fg}{bold';
+    return 'white-fg';
+}
+function extractCallId(request) {
+    try {
+        if (request.requestBody) {
+            const parsed = JSON.parse(request.requestBody);
+            return parsed.callId || parsed.callid || parsed.call_id || null;
+        }
+    }
+    catch (e) {
+    }
+    return null;
+}
+function extractCallback(request) {
+    try {
+        let action = '';
+        if (request.requestBody) {
+            const parsed = JSON.parse(request.requestBody);
+            if (parsed.event) {
+                action = parsed.event.toLowerCase();
+            }
+            else {
+                const pathSegments = request.url.split('/').filter(s => s);
+                action = pathSegments[pathSegments.length - 1] || '';
+            }
+            return action || '';
+        }
+    }
+    catch (e) {
+    }
+    return '';
+}
+async function showHistoricalLogs(api, functionId, options) {
+    try {
+        spinner_1.spinner.start(`Loading ${options.lines} recent log entries...`);
+        const logOptions = {
+            limit: parseInt(options.lines || '50'),
+            level: options.level,
+            search: options.search
+        };
+        if (options.since) {
+            const sinceTime = parseSinceDuration(options.since);
+            if (sinceTime) {
+                logOptions.startTime = sinceTime.toISOString();
+            }
+        }
+        const response = await api.getFunctionLogs(functionId, logOptions);
+        spinner_1.spinner.stop();
+        logger_1.logger.debug('Historical API response:', {
+            totalRequests: response.requests?.length || 0,
+            firstRequest: response.requests?.[0] || 'No requests',
+            responseKeys: Object.keys(response)
+        });
+        if (!response.requests || response.requests.length === 0) {
+            logger_1.logger.info('📝 No logs found');
+            logger_1.logger.info('💡 Logs will appear here after function receives requests');
+            return;
+        }
+        const requests = response.requests;
+        logger_1.logger.debug('Historical requests:', {
+            totalRequests: requests.length,
+            firstRequest: requests[0] || 'No requests',
+            requestTimestamps: requests.slice(0, 3).map(r => r.startTime)
+        });
+        await showBlessedLogViewer(requests, 'HISTORICAL', 'Function');
+    }
+    catch (error) {
+        spinner_1.spinner.stop();
+        throw error;
+    }
+}
+function parseSinceDuration(duration) {
+    if (!duration)
+        return null;
+    const match = duration.match(/^(\d+)([smhd])$/);
+    if (!match)
+        return null;
+    const value = parseInt(match[1]);
+    const unit = match[2];
+    const now = new Date();
+    switch (unit) {
+        case 's': return new Date(now.getTime() - value * 1000);
+        case 'm': return new Date(now.getTime() - value * 60 * 1000);
+        case 'h': return new Date(now.getTime() - value * 60 * 60 * 1000);
+        case 'd': return new Date(now.getTime() - value * 24 * 60 * 60 * 1000);
+        default: return null;
+    }
+}
+async function showBlessedLogViewer(requests, mode, functionName) {
+    const screen = createBlessedLogViewer(requests, mode, functionName);
+    requests.forEach((request) => {
+        updateTableWithRequest(screen.table, request, requests);
+    });
+    screen.screen.render();
+    await new Promise(() => { });
+}
+function createBlessedLogViewer(requests, mode, functionName) {
+    const blessed = require('blessed');
+    process.stdout.write('\x1Bc');
+    globalTableData = [];
+    const screen = blessed.screen({
+        smartCSR: true,
+        title: `Sinch Functions - ${functionName} Logs`,
+        fullUnicode: true
+    });
+    const statusBar = blessed.box({
+        parent: screen,
+        top: 0,
+        left: 0,
+        width: '100%',
+        height: 1,
+        content: getStatusBarContent(mode, functionName),
+        tags: true,
+        style: { bg: 'black' }
+    });
+    const table = blessed.listtable({
+        parent: screen,
+        top: 1,
+        left: 0,
+        width: '100%',
+        height: '100%-1',
+        border: { type: 'line', fg: 'blue' },
+        style: {
+            header: { fg: 'white', bg: 'blue', bold: true },
+            cell: { fg: 'white' },
+            selected: { bg: 'blue', fg: 'white', bold: true }
+        },
+        keys: true,
+        vi: true,
+        mouse: true,
+        interactive: true,
+        label: `${functionName} Logs (q to quit)`,
+        align: 'left',
+        pad: 1
+    });
+    const headers = ['Time', 'Callback', 'Duration', 'Status', 'Path'];
+    table.setData([headers]);
+    table.focus();
+    screen.key(['q', 'C-c'], () => {
+        process.exit(0);
+    });
+    const openSelectedRequest = () => {
+        try {
+            let selectedIndex = table.selected || 0;
+            const dataIndex = selectedIndex - 1;
+            if (dataIndex >= 0 && dataIndex < requests.length && requests[dataIndex]) {
+                logger_1.logger.debug(`Opening request details for index ${dataIndex}`);
+                showBlessedZoomedRequest(requests[dataIndex], screen, table, statusBar, functionName);
+            }
+            else {
+                const debugInfo = `Selected: ${selectedIndex}, DataIndex: ${dataIndex}, Requests: ${requests.length}, TableData: ${globalTableData.length}`;
+                logger_1.logger.debug(`Selection out of bounds: ${debugInfo}`);
+            }
+        }
+        catch (error) {
+            logger_1.logger.debug(`Error in request selection: ${error.message}`);
+        }
+    };
+    screen.key(['enter'], openSelectedRequest);
+    table.on('select', (_item, _index) => {
+        openSelectedRequest();
+    });
+    screen.on('wheelup', () => {
+        if (table.focused) {
+            table.scroll(-1);
+            screen.render();
+        }
+    });
+    screen.on('wheeldown', () => {
+        if (table.focused) {
+            table.scroll(1);
+            screen.render();
+        }
+    });
+    return { screen, table, statusBar };
+}
+function getStatusBarContent(mode, functionName) {
+    switch (mode) {
+        case 'STREAMING':
+            return '{blue-fg}🔴 STREAMING: ' + functionName + '{/} {gray-fg}| ↑↓/Wheel=scroll | Enter/Click=details | Q=quit{/}';
+        case 'CONNECTED':
+            return '{green-fg}✅ CONNECTED: ' + functionName + '{/} {gray-fg}| ↑↓/Wheel=scroll | Enter/Click=details | Q=quit{/}';
+        case 'RECONNECTING':
+            return '{yellow-fg}⚠️  RECONNECTING: ' + functionName + '{/} {gray-fg}| ↑↓/Wheel=scroll | Enter/Click=details | Q=quit{/}';
+        case 'HISTORICAL':
+            return '{cyan-fg}📜 HISTORICAL: ' + functionName + '{/} {gray-fg}| ↑↓/Wheel=scroll | Enter/Click=details | Q=quit{/}';
+        default:
+            return '{gray-fg}' + functionName + ' | ↑↓/Wheel=scroll | Enter/Click=details | Q=quit{/}';
+    }
+}
+function updateStatusBar(statusBar, mode, functionName) {
+    statusBar.setContent(getStatusBarContent(mode, functionName));
+}
+function copyToClipboard(text) {
+    return new Promise((resolve, reject) => {
+        let clipboardCmd;
+        let clipboardArgs;
+        if (process.platform === 'win32') {
+            clipboardCmd = 'clip';
+            clipboardArgs = [];
+        }
+        else if (process.platform === 'darwin') {
+            clipboardCmd = 'pbcopy';
+            clipboardArgs = [];
+        }
+        else {
+            clipboardCmd = 'xclip';
+            clipboardArgs = ['-selection', 'clipboard'];
+        }
+        logger_1.logger.debug(`Using clipboard command: ${clipboardCmd} with args:`, clipboardArgs);
+        const clipProcess = (0, child_process_1.spawn)(clipboardCmd, clipboardArgs, {
+            stdio: ['pipe', 'ignore', 'pipe']
+        });
+        let errorOutput = '';
+        clipProcess.stderr.on('data', (data) => {
+            errorOutput += data.toString();
+        });
+        clipProcess.on('error', (error) => {
+            logger_1.logger.debug(`Clipboard process error: ${error.message}`);
+            if (process.platform === 'linux' && clipboardCmd === 'xclip') {
+                logger_1.logger.debug('Trying xsel as fallback');
+                const xselProcess = (0, child_process_1.spawn)('xsel', ['--clipboard', '--input'], {
+                    stdio: ['pipe', 'ignore', 'pipe']
+                });
+                xselProcess.on('error', (xselError) => {
+                    reject(new Error(`No clipboard utility found: ${error.message} / ${xselError.message}`));
+                });
+                xselProcess.on('close', (code) => {
+                    if (code === 0) {
+                        resolve();
+                    }
+                    else {
+                        reject(new Error(`xsel failed with code ${code}`));
+                    }
+                });
+                if (xselProcess.stdin) {
+                    xselProcess.stdin.write(text);
+                    xselProcess.stdin.end();
+                }
+                return;
+            }
+            reject(error);
+        });
+        clipProcess.on('close', (code) => {
+            if (code === 0) {
+                logger_1.logger.debug('Clipboard copy successful');
+                resolve();
+            }
+            else {
+                logger_1.logger.debug(`Clipboard process failed with code ${code}, error: ${errorOutput}`);
+                reject(new Error(`Clipboard command failed with code ${code}: ${errorOutput}`));
+            }
+        });
+        if (clipProcess.stdin) {
+            clipProcess.stdin.write(text);
+            clipProcess.stdin.end();
+        }
+    });
+}
+function generateCurlCommand(request) {
+    const isWindows = process.platform === 'win32';
+    let curl = `curl -X ${request.httpMethod}`;
+    let headers = {};
+    if (request.headers) {
+        try {
+            headers = typeof request.headers === 'string' ?
+                JSON.parse(request.headers) : request.headers;
+        }
+        catch (e) {
+        }
+    }
+    let url = request.url;
+    if (url && !url.startsWith('http')) {
+        const host = headers.host || headers.Host;
+        if (host) {
+            const protocol = host.includes('localhost') || host.includes('127.0.0.1') ? 'http' : 'https';
+            url = `${protocol}://${host}${url.startsWith('/') ? url : '/' + url}`;
+        }
+    }
+    curl += ` "${url}"`;
+    Object.entries(headers).forEach(([key, value]) => {
+        const skipHeaders = ['content-length', 'connection', 'user-agent'];
+        if (!request.url.startsWith('http')) {
+            skipHeaders.push('host');
+        }
+        if (!skipHeaders.includes(key.toLowerCase())) {
+            if (isWindows) {
+                curl += ` -H "${key}: ${value}"`;
+            }
+            else {
+                curl += ` \\\n  -H "${key}: ${value}"`;
+            }
+        }
+    });
+    if (request.requestBody && ['POST', 'PUT', 'PATCH'].includes(request.httpMethod)) {
+        try {
+            const parsed = JSON.parse(request.requestBody);
+            const formatted = JSON.stringify(parsed);
+            if (isWindows) {
+                curl += ` -d '${formatted.replace(/'/g, "\\'")}'`;
+            }
+            else {
+                curl += ` \\\n  -d '${JSON.stringify(parsed, null, 2)}'`;
+            }
+        }
+        catch (e) {
+            if (isWindows) {
+                curl += ` -d '${request.requestBody.replace(/'/g, "\\'")}'`;
+            }
+            else {
+                curl += ` \\\n  -d '${request.requestBody}'`;
+            }
+        }
+        if (!curl.toLowerCase().includes('content-type')) {
+            if (isWindows) {
+                curl += ` -H "Content-Type: application/json"`;
+            }
+            else {
+                curl += ` \\\n  -H "Content-Type: application/json"`;
+            }
+        }
+    }
+    if (isWindows) {
+        curl += ` -v`;
+    }
+    else {
+        curl += ` \\\n  -v`;
+    }
+    return curl;
+}
+module.exports = logs;
+//# sourceMappingURL=logs.js.map