aparavi-client 1.0.2

package/dist/cli/cli/aparavi.js

@@ -0,0 +1,1401 @@
+#!/usr/bin/env node
+"use strict";
+/**
+ * MIT License
+ *
+ * Copyright (c) 2024 Aparavi Development Team
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AparaviCLI = void 0;
+exports.main = main;
+/**
+ * Aparavi Unified CLI Client.
+ *
+ * This module provides a comprehensive command-line interface for managing Aparavi pipelines,
+ * uploading files, monitoring task status, and controlling pipeline execution using the
+ * Debug Adapter Protocol (DAP).
+ *
+ * Features:
+ * - Start and manage Aparavi data processing pipelines
+ * - Upload files with parallel processing and progress tracking
+ * - Monitor real-time pipeline status and metrics
+ * - Stop running pipelines gracefully
+ * - Environment-based configuration via .env files
+ *
+ * Configuration:
+ * The client supports configuration via .env file with the following variables:
+ * - APARAVI_APIKEY: Your Aparavi API key (required for authentication)
+ * - APARAVI_URI: The Aparavi server URI (defaults to wss://eaas.aparavi.com)
+ * - APARAVI_PIPELINE: Path to your default pipeline configuration file
+ * - APARAVI_TOKEN: Task token for existing pipelines
+ *
+ * Commands:
+ * - start: Start a new pipeline from configuration file
+ * - upload: Upload files to a pipeline (with --pipeline or --token)
+ * - status: Monitor real-time status of a running pipeline
+ * - stop: Terminate a running pipeline gracefully
+ *
+ * @example
+ * ```bash
+ * # Start a pipeline
+ * aparavi start --pipeline ./my-pipeline.json --apikey YOUR_KEY
+ *
+ * # Upload files with progress tracking
+ * aparavi upload files/*.csv --pipeline ./pipeline.json --max-concurrent 10
+ *
+ * # Monitor pipeline status
+ * aparavi status --token TASK_TOKEN
+ *
+ * # Stop a pipeline
+ * aparavi stop --token TASK_TOKEN
+ * ```
+ */
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const glob = __importStar(require("glob"));
+const process = __importStar(require("process"));
+const commander_1 = require("commander");
+const client_1 = require("../src/client");
+// ANSI Color and Control Codes for terminal formatting
+const ANSI_RESET = '\x1b[0m';
+const ANSI_RED = '\x1b[91m';
+const ANSI_GREEN = '\x1b[92m';
+const ANSI_YELLOW = '\x1b[93m';
+const ANSI_BLUE = '\x1b[94m';
+const ANSI_GRAY = '\x1b[90m';
+const ANSI_CLEAR_SCREEN = '\x1b[2J';
+const ANSI_CURSOR_HOME = '\x1b[1;1H';
+// Global character mapping
+let CHR_TL = '┌';
+let CHR_TR = '┐';
+let CHR_BL = '└';
+let CHR_BR = '┘';
+let CHR_HORIZ = '─';
+let CHR_VERT = '│';
+let CHR_BLOCK = '█';
+let CHR_LIGHT_BLOCK = '░';
+let CHR_CHECK = '✓';
+let CHR_CROSS = '✗';
+const ANSI_ESCAPE_PATTERN = /\x1b\[[0-9;]*[mK]/g;
+class Box {
+    constructor(title, lines, width = 75) {
+        this.title = title;
+        this.lines = lines || [];
+        this.width = width;
+    }
+    visualLength(text) {
+        return text.replace(ANSI_ESCAPE_PATTERN, '').length;
+    }
+    boxTop() {
+        const titlePart = ` ${this.title} `;
+        const remainingWidth = (this.width - 3) - titlePart.length;
+        return CHR_TL + CHR_HORIZ + titlePart + CHR_HORIZ.repeat(Math.max(0, remainingWidth)) + CHR_TR;
+    }
+    boxMiddle(content) {
+        const visualWidth = this.visualLength(content);
+        const availableWidth = this.width - 3;
+        let finalContent = content;
+        if (visualWidth > availableWidth) {
+            finalContent = content.substring(0, availableWidth - 3) + '...';
+        }
+        const padding = availableWidth - this.visualLength(finalContent);
+        return CHR_VERT + ' ' + finalContent + ' '.repeat(Math.max(0, padding)) + CHR_VERT;
+    }
+    boxBottom() {
+        return CHR_BL + CHR_HORIZ.repeat(this.width - 2) + CHR_BR;
+    }
+    render() {
+        if (this.lines.length === 0) {
+            return [];
+        }
+        const output = [];
+        output.push(this.boxTop());
+        for (const line of this.lines) {
+            output.push(this.boxMiddle(line));
+        }
+        output.push(this.boxBottom());
+        return output;
+    }
+}
+class BoxMonitor {
+    constructor(cli, commandTitle, width, height) {
+        this.boxes = [];
+        this.lastLineCount = 0;
+        this.screenCleared = false;
+        this.commandStatus = ['Initializing...'];
+        this.cli = cli;
+        this.commandTitle = commandTitle;
+        if (width === undefined || height === undefined) {
+            const [detectedWidth, detectedHeight] = this.detectTerminalSize();
+            this.width = width ?? detectedWidth;
+            this.height = height ?? detectedHeight;
+        }
+        else {
+            this.width = width;
+            this.height = height;
+        }
+        this.isTerminal = this.isTerminalCheck();
+    }
+    detectTerminalSize() {
+        try {
+            const size = process.stdout.getWindowSize();
+            const width = size[0];
+            const height = size[1];
+            if (width >= 20 && width <= 300 && height >= 10 && height <= 100) {
+                return [Math.max(width - 1, 20), Math.max(height - 2, 10)];
+            }
+        }
+        catch {
+            // Ignore errors
+        }
+        return [79, 41];
+    }
+    isTerminalCheck() {
+        return process.stdout.isTTY && process.stderr.isTTY;
+    }
+    updateTerminalSize() {
+        const [width, height] = this.detectTerminalSize();
+        this.width = width;
+        this.height = height;
+    }
+    clear() {
+        this.boxes = [];
+    }
+    clearScreen() {
+        this.screenCleared = false;
+        this.lastLineCount = 0;
+    }
+    setCommandStatus(status) {
+        if (typeof status === 'string') {
+            this.commandStatus = [status];
+        }
+        else {
+            this.commandStatus = status;
+        }
+    }
+    addBox(title, lines) {
+        if (lines.length > 0) {
+            const box = new Box(title, lines, this.width);
+            this.boxes.push(box);
+        }
+    }
+    positionToTop() {
+        process.stdout.write(ANSI_CURSOR_HOME);
+    }
+    draw() {
+        this.updateTerminalSize();
+        if (!this.screenCleared) {
+            process.stdout.write(ANSI_CLEAR_SCREEN);
+            this.screenCleared = true;
+        }
+        this.positionToTop();
+        const allBoxes = [];
+        if (this.commandStatus.length > 0) {
+            const commandBox = new Box(this.commandTitle, this.commandStatus, this.width);
+            allBoxes.push(commandBox);
+        }
+        allBoxes.push(...this.boxes);
+        const allLines = [];
+        for (let i = 0; i < allBoxes.length; i++) {
+            const boxLines = allBoxes[i].render();
+            allLines.push(...boxLines);
+            if (i < allBoxes.length - 1 && boxLines.length > 0) {
+                allLines.push(' '.repeat(this.width));
+            }
+        }
+        for (const line of allLines) {
+            console.log(line + ' ');
+        }
+        const currentLineCount = allLines.length;
+        if (currentLineCount < this.lastLineCount) {
+            for (let i = currentLineCount; i < this.lastLineCount; i++) {
+                console.log(' '.repeat(this.width));
+            }
+        }
+        this.lastLineCount = currentLineCount;
+        process.stdout.write('');
+    }
+    formatSize(sizeBytes) {
+        if (sizeBytes === 0)
+            return '0 B';
+        const units = ['B', 'KB', 'MB', 'GB', 'TB'];
+        let unitIndex = 0;
+        let size = sizeBytes;
+        while (size >= 1024 && unitIndex < units.length - 1) {
+            size /= 1024;
+            unitIndex++;
+        }
+        if (unitIndex === 0) {
+            return `${Math.floor(size)} ${units[unitIndex]}`;
+        }
+        else {
+            return `${size.toFixed(1)} ${units[unitIndex]}`;
+        }
+    }
+    onEvent(message) {
+        // Override in subclasses
+    }
+}
+class GenericMonitor extends BoxMonitor {
+    constructor(cli, commandTitle, width, height) {
+        super(cli, commandTitle, width, height);
+    }
+}
+class StatusMonitor extends BoxMonitor {
+    constructor(cli, token, width, height) {
+        super(cli, 'Aparavi Task Monitor', width, height);
+        this.token = token;
+        this.setCommandStatus(`Token: ${this.token}`);
+    }
+    formatDuration(startTime, endTime) {
+        if (startTime === 0)
+            return 'Not started';
+        const end = endTime || Date.now() / 1000;
+        const totalSeconds = Math.floor(end - startTime);
+        if (totalSeconds < 60) {
+            return `${totalSeconds}secs`;
+        }
+        else if (totalSeconds < 3600) {
+            const minutes = Math.floor(totalSeconds / 60);
+            const seconds = totalSeconds % 60;
+            return `${minutes}min, ${seconds}secs`;
+        }
+        else {
+            const hours = Math.floor(totalSeconds / 3600);
+            const minutes = Math.floor((totalSeconds % 3600) / 60);
+            const seconds = totalSeconds % 60;
+            return `${hours}hr, ${minutes}min, ${seconds}secs`;
+        }
+    }
+    getStateDisplay(state) {
+        const stateMap = {
+            0: ['Offline', ANSI_GRAY],
+            1: ['Offline', ANSI_GRAY],
+            2: ['Initializing', ANSI_BLUE],
+            3: ['Online', ANSI_GREEN],
+            4: ['Stopping', ANSI_YELLOW],
+            5: ['Offline', ANSI_GRAY],
+            6: ['Offline', ANSI_GRAY]
+        };
+        return stateMap[state] || ['Unknown', ANSI_RESET];
+    }
+    hasCountData(status) {
+        return ((status.totalSize || 0) > 0 ||
+            (status.totalCount || 0) > 0 ||
+            (status.completedSize || 0) > 0 ||
+            (status.completedCount || 0) > 0 ||
+            (status.failedSize || 0) > 0 ||
+            (status.failedCount || 0) > 0 ||
+            (status.rateSize || 0) > 0 ||
+            (status.rateCount || 0) > 0);
+    }
+    hasMetricsData(status) {
+        const metrics = status.metrics || {};
+        return Object.values(metrics).some(value => typeof value === 'number' && value > 0);
+    }
+    onEvent(message) {
+        const eventType = message.event || '';
+        if (eventType !== 'apaevt_status_update') {
+            return;
+        }
+        const status = message.body || {};
+        this.displayStatus(status);
+    }
+    displayStatus(status) {
+        this.clear();
+        if (status) {
+            const pipelineLines = this.buildPipelineLines(status);
+            this.addBox('Pipeline Status', pipelineLines);
+            const metricsLines = this.buildMetricsLines(status);
+            this.addBox('Metrics', metricsLines);
+            const errorLines = this.buildErrorLines(status.errors || [], 'Error');
+            this.addBox('Errors', errorLines);
+            const warningLines = this.buildErrorLines(status.warnings || [], 'Warning');
+            this.addBox('Warnings', warningLines);
+            const noteLines = this.buildNoteLines(status.notes || []);
+            this.addBox('Notes', noteLines);
+        }
+        else {
+            this.addBox('Status', ['No status available']);
+        }
+        this.draw();
+    }
+    buildPipelineLines(status) {
+        const lines = [];
+        if (status.name) {
+            lines.push(status.name);
+            lines.push('');
+        }
+        if (status.status) {
+            lines.push(status.status);
+            lines.push('');
+        }
+        const state = status.state || 0;
+        const [stateName, stateColor] = this.getStateDisplay(state);
+        lines.push(`State: ${stateColor}${stateName}${ANSI_RESET}`);
+        const startTime = status.startTime || 0;
+        if (startTime > 0) {
+            const startStr = new Date(startTime * 1000).toLocaleString();
+            lines.push(`Started: ${startStr}`);
+            const endTime = status.completed ? (status.endTime || 0) : undefined;
+            const duration = this.formatDuration(startTime, endTime);
+            lines.push(`Elapsed: ${duration}`);
+        }
+        if (this.hasCountData(status)) {
+            lines.push('');
+            const dataTypes = [
+                ['total', 'Total'],
+                ['completed', 'Completed'],
+                ['failed', 'Failed']
+            ];
+            for (const [keyBase, label] of dataTypes) {
+                const count = status[`${keyBase}Count`] || 0;
+                const size = status[`${keyBase}Size`] || 0;
+                if (count > 0 || size > 0) {
+                    lines.push(`${label}: ${count} items (${this.formatSize(size)})`);
+                }
+            }
+            const rateSize = status.rateSize || 0;
+            const rateCount = status.rateCount || 0;
+            if (rateSize > 0 || rateCount > 0) {
+                lines.push(`Rate: ${this.formatSize(rateSize)}/s (${rateCount}/s items)`);
+            }
+        }
+        return lines.length > 0 ? lines : ['No pipeline data available'];
+    }
+    buildMetricsLines(status) {
+        if (!this.hasMetricsData(status)) {
+            return [];
+        }
+        const lines = [];
+        const metrics = status.metrics || {};
+        for (const [key, value] of Object.entries(metrics)) {
+            if (typeof value === 'number' && value > 0) {
+                const label = key.replace(/_/g, ' ').replace(/\b\w/g, l => l.toUpperCase());
+                lines.push(`${label}: ${value}`);
+            }
+        }
+        return lines;
+    }
+    buildErrorLines(items, errorType) {
+        if (!items || items.length === 0) {
+            return [];
+        }
+        const lines = [];
+        const color = errorType === 'Error' ? ANSI_RED : ANSI_YELLOW;
+        for (const item of items.slice(-5)) {
+            const parts = item.split('*');
+            if (parts.length >= 3) {
+                const errType = parts[0].trim();
+                const message = parts[1].replace(/`/g, '').trim();
+                const fileInfo = parts[2].trim();
+                const filename = fileInfo.includes('\\') || fileInfo.includes('/') ?
+                    path.basename(fileInfo) : fileInfo;
+                lines.push(`${color}${errType}${ANSI_RESET}: ${message}`);
+                if (filename) {
+                    lines.push(`  -> ${filename}`);
+                }
+            }
+            else {
+                lines.push(`${color}• ${ANSI_RESET}${item}`);
+            }
+        }
+        return lines;
+    }
+    buildNoteLines(items) {
+        if (!items || items.length === 0) {
+            return [];
+        }
+        return items.slice(-5).map(item => `• ${item}`);
+    }
+    displayConnecting(url, attempt) {
+        this.clear();
+        const retry = attempt > 0 ? ` (attempt ${attempt})` : '';
+        const connectionLines = [`Connecting to ${url}${retry}...`];
+        this.addBox('Connection Status', connectionLines);
+        this.addBox('Controls', ['Press Ctrl+C to stop monitoring...']);
+        this.draw();
+    }
+}
+class UploadProgressMonitor extends BoxMonitor {
+    constructor(cli, width, height) {
+        super(cli, 'Aparavi File Upload', width, height);
+        this.totalFiles = 0;
+        this.activeUploads = new Map();
+        this.completedUploads = new Map();
+        this.failedUploads = new Map();
+        this.setCommandStatus('Preparing upload...');
+    }
+    createProgressBar(percent, width = 30) {
+        const filledLength = Math.floor(width * percent / 100);
+        const bar = CHR_BLOCK.repeat(filledLength) + CHR_LIGHT_BLOCK.repeat(width - filledLength);
+        return `[${bar}] ${percent.toFixed(1).padStart(5)}%`;
+    }
+    truncateFilename(filename, maxLength) {
+        if (filename.length <= maxLength) {
+            return filename;
+        }
+        const ext = path.extname(filename);
+        const name = path.basename(filename, ext);
+        if (ext.length < maxLength - 3) {
+            const available = maxLength - ext.length - 3;
+            return `${name.substring(0, available)}...${ext}`;
+        }
+        else {
+            return `${filename.substring(0, maxLength - 3)}...`;
+        }
+    }
+    setTotalFiles(totalFiles) {
+        this.totalFiles = totalFiles;
+    }
+    onUploadProgress(result) {
+        // Process UPLOAD_RESULT from sendFiles
+        const filepath = result.filepath || 'unknown';
+        const bytesSent = result.bytes_sent || 0;
+        const fileSize = result.file_size || 0;
+        const action = result.action;
+        const filename = path.basename(filepath);
+        if (action === 'open') {
+            // Don't show pending opens
+        }
+        else if (action === 'write') {
+            this.activeUploads.set(filename, {
+                filepath,
+                action,
+                bytes_sent: bytesSent,
+                file_size: fileSize
+            });
+        }
+        else if (action === 'close') {
+            const existing = this.activeUploads.get(filename);
+            if (existing) {
+                this.activeUploads.set(filename, {
+                    ...existing,
+                    action,
+                    bytes_sent: bytesSent,
+                    file_size: fileSize
+                });
+            }
+        }
+        else if (action === 'complete') {
+            this.activeUploads.delete(filename);
+            this.completedUploads.set(filename, {
+                filepath,
+                action,
+                file_size: fileSize
+            });
+        }
+        else if (action === 'error') {
+            this.activeUploads.delete(filename);
+            const errorMessage = result.error || 'Unknown error';
+            this.failedUploads.set(filename, {
+                filepath,
+                action,
+                file_size: fileSize,
+                error: errorMessage
+            });
+        }
+        this.draw();
+    }
+    onEvent(message) {
+        const eventType = message.event || '';
+        if (eventType !== 'apaevt_status_upload') {
+            return;
+        }
+        const body = message.body || {};
+        const filepath = body.filepath || 'unknown';
+        const bytesSent = body.bytes_sent || 0;
+        const fileSize = body.file_size || 0;
+        const action = body.action;
+        const filename = path.basename(filepath);
+        if (action === 'open') {
+            // Don't show pending opens
+        }
+        else if (action === 'write') {
+            this.activeUploads.set(filename, {
+                filepath,
+                action,
+                bytes_sent: bytesSent,
+                file_size: fileSize
+            });
+        }
+        else if (action === 'close') {
+            const existing = this.activeUploads.get(filename);
+            if (existing) {
+                this.activeUploads.set(filename, {
+                    ...existing,
+                    action,
+                    bytes_sent: bytesSent,
+                    file_size: fileSize
+                });
+            }
+        }
+        else if (action === 'complete') {
+            this.activeUploads.delete(filename);
+            this.completedUploads.set(filename, {
+                filepath,
+                action,
+                file_size: fileSize
+            });
+        }
+        else if (action === 'error') {
+            this.activeUploads.delete(filename);
+            const errorMessage = body.error || 'Unknown error';
+            this.failedUploads.set(filename, {
+                filepath,
+                action,
+                file_size: fileSize,
+                error: errorMessage
+            });
+        }
+        if (this.cli.isCancelled()) {
+            this.setCommandStatus(`${ANSI_RED}Upload cancelling...${ANSI_RESET}`);
+        }
+        else {
+            const totalProcessed = this.completedUploads.size + this.failedUploads.size;
+            this.setCommandStatus(`Processed ${totalProcessed} of ${this.totalFiles} files...`);
+        }
+        this.renderUploadStatus();
+        if (this.cli.isCancelled()) {
+            throw new Error('Upload cancelled');
+        }
+    }
+    renderUploadStatus() {
+        this.clear();
+        // Add active uploads box
+        if (this.activeUploads.size > 0) {
+            const uploadLines = [];
+            const activeEntries = Array.from(this.activeUploads.entries());
+            for (const [filename, data] of activeEntries.slice(0, 10)) {
+                const displayName = this.truncateFilename(filename, 20).padEnd(20);
+                const action = data.action;
+                const phase = action === 'write' ? 'Writing ' : action === 'close' ? 'Finalize' : '        ';
+                const bytesSent = data.bytes_sent || 0;
+                const fileSize = data.file_size || 1;
+                const percent = fileSize > 0 ? (bytesSent / fileSize * 100) : 0;
+                const progressBar = this.createProgressBar(percent, 12);
+                const sizeInfo = `${this.formatSize(bytesSent)}/${this.formatSize(fileSize)}`;
+                uploadLines.push(`${displayName} ${phase} ${progressBar} ${sizeInfo}`);
+            }
+            if (this.activeUploads.size > 10) {
+                const remaining = this.activeUploads.size - 10;
+                uploadLines.push(`... and ${remaining} more uploads in progress`);
+            }
+            this.addBox(`Active Uploads (${this.activeUploads.size})`, uploadLines);
+        }
+        // Add summary box
+        if (this.completedUploads.size > 0 || this.failedUploads.size > 0) {
+            const summaryLines = [];
+            if (this.completedUploads.size > 0) {
+                summaryLines.push(`Completed: ${this.completedUploads.size} files`);
+            }
+            if (this.failedUploads.size > 0) {
+                summaryLines.push(`Failed: ${this.failedUploads.size} files`);
+            }
+            const totalBytes = Array.from(this.completedUploads.values())
+                .reduce((sum, data) => sum + (data.file_size || 0), 0);
+            summaryLines.push(`Total size: ${this.formatSize(totalBytes)}`);
+            this.addBox('Upload Summary', summaryLines);
+        }
+        // Add failed uploads box
+        if (this.failedUploads.size > 0) {
+            const failedLines = [];
+            const failedEntries = Array.from(this.failedUploads.entries());
+            const displayCount = failedEntries.length > 5 ? 4 : 5;
+            for (const [filename, data] of failedEntries.slice(-displayCount)) {
+                const displayName = this.truncateFilename(filename, 25);
+                const errorMsg = (data.error || '').length > 30 ?
+                    `${data.error.substring(0, 30)}...` : data.error;
+                failedLines.push(`${ANSI_RED}${CHR_CROSS}${ANSI_RESET} ${displayName} - ${errorMsg}`);
+            }
+            if (failedEntries.length > 5) {
+                const remaining = failedEntries.length - 4;
+                failedLines.push(`... and ${remaining} more files have failed`);
+            }
+            this.addBox(`Failed Uploads (${this.failedUploads.size})`, failedLines);
+        }
+        // Add recently completed box
+        if (this.completedUploads.size > 0) {
+            const completedLines = [];
+            const completedEntries = Array.from(this.completedUploads.entries());
+            for (const [filename, data] of completedEntries.slice(-3)) {
+                const displayName = this.truncateFilename(filename, 35);
+                const sizeStr = this.formatSize(data.file_size || 0);
+                completedLines.push(`${ANSI_GREEN}${CHR_CHECK}${ANSI_RESET} ${displayName} (${sizeStr})`);
+            }
+            this.addBox('Recently Completed', completedLines);
+        }
+        this.draw();
+    }
+    reset() {
+        this.activeUploads.clear();
+        this.completedUploads.clear();
+        this.failedUploads.clear();
+        this.setCommandStatus('Preparing upload...');
+        this.clearScreen();
+    }
+}
+class AparaviCLI {
+    constructor() {
+        this.uploadStats = {
+            files_processed: 0,
+            total_bytes: 0,
+            successful_uploads: 0,
+            failed_uploads: 0,
+            upload_times: []
+        };
+        this.uri = '';
+        this.connected = false;
+        this.attempt = 0;
+        this.cancelled = false;
+        this.setupSignalHandlers();
+    }
+    cancel() {
+        this.cancelled = true;
+    }
+    isCancelled() {
+        return this.cancelled;
+    }
+    setupSignalHandlers() {
+        // TODO: Enable proper signal handling
+        // const signalHandler = () => {
+        // 	this.cancel();
+        // };
+        // process.on('SIGINT', signalHandler);
+        // process.on('SIGTERM', signalHandler);
+    }
+    createProgram() {
+        const program = new commander_1.Command();
+        program
+            .name('aparavi')
+            .description('Aparavi Unified Pipeline and File Management CLI')
+            .version('1.3.0');
+        // Common options
+        const addCommonOptions = (cmd) => {
+            return cmd
+                .option('--host <hostname>', 'Aparavi DAP server hostname', 'eaas.aparavi.com')
+                .option('--port <port>', 'Aparavi DAP server port', '443')
+                .option('--apikey <key>', 'API key for Aparavi server authentication (can use APARAVI_APIKEY in .env or env var)', process.env.APARAVI_APIKEY);
+        };
+        // Start command
+        const startCmd = program
+            .command('start')
+            .description('Start a new pipeline')
+            .option('--pipeline <file>', 'Path to .pipeline file containing pipeline configuration (can use APARAVI_PIPELINE in .env or env var)', process.env.APARAVI_PIPELINE)
+            .option('--token <token>', 'Optional existing task token for pipeline resume/control (can use APARAVI_TOKEN in .env or env var)', process.env.APARAVI_TOKEN)
+            .option('--threads <num>', 'Number of threads to use for pipeline execution', '4')
+            .option('--args <args...>', 'Additional arguments to pass to pipeline execution')
+            .action(async (options) => {
+            // Validate required arguments - validation will happen in createAndConnectClient
+            if (!options.pipeline) {
+                console.error('Error: Pipeline file is required for start command. Use --pipeline or set APARAVI_PIPELINE in .env file');
+                process.exit(1);
+            }
+            this.args = {
+                command: 'start',
+                ...options,
+                pipeline: options.pipeline,
+                port: parseInt(options.port),
+                threads: parseInt(options.threads)
+            };
+            const protocol = this.args.port === 443 ? 'wss' : 'ws';
+            this.uri = `${protocol}://${this.args.host}:${this.args.port}`;
+            try {
+                const exitCode = await this.cmdStart();
+                process.exit(exitCode);
+            }
+            finally {
+                this.cancel();
+                await this.cleanupClient();
+            }
+        });
+        addCommonOptions(startCmd);
+        // Upload command
+        const uploadCmd = program
+            .command('upload')
+            .description('Upload files using --pipeline or an existing task token')
+            .argument('<files...>', 'Files, wildcards, or directories to upload')
+            .option('--pipeline <file>', 'Pipeline file to start new task (can use APARAVI_PIPELINE in .env or env var)', process.env.APARAVI_PIPELINE)
+            .option('--token <token>', 'Existing task token to use for uploads (can use APARAVI_TOKEN in .env or env var)', process.env.APARAVI_TOKEN)
+            .option('--threads <num>', 'Number of threads to use for pipeline execution', '4')
+            .option('--max-concurrent <num>', 'Maximum number of concurrent file uploads', '5')
+            .option('--args <args...>', 'Additional arguments to pass to pipeline execution')
+            .action(async (files, options) => {
+            // Validate required arguments - validation will happen in createAndConnectClient
+            if (!options.pipeline && !options.token) {
+                console.error('Error: Either --pipeline or --token must be specified for upload command. Use --pipeline/--token or set APARAVI_PIPELINE/APARAVI_TOKEN in .env file');
+                process.exit(1);
+            }
+            this.args = {
+                command: 'upload',
+                ...options,
+                files,
+                port: parseInt(options.port),
+                threads: parseInt(options.threads),
+                max_concurrent: parseInt(options.maxConcurrent || '5'),
+                pipeline_args: options.args
+            };
+            const protocol = this.args.port === 443 ? 'wss' : 'ws';
+            this.uri = `${protocol}://${this.args.host}:${this.args.port}`;
+            try {
+                const exitCode = await this.cmdUpload();
+                process.exit(exitCode);
+            }
+            finally {
+                this.cancel();
+                await this.cleanupClient();
+            }
+        });
+        addCommonOptions(uploadCmd);
+        // Status command
+        const statusCmd = program
+            .command('status')
+            .description('Monitor task status continuously')
+            .option('--token <token>', 'Task token to monitor (can use APARAVI_TOKEN in .env or env var)', process.env.APARAVI_TOKEN)
+            .action(async (options) => {
+            // Validate required arguments - validation will happen in createAndConnectClient
+            if (!options.token) {
+                console.error('Error: Token is required for status command. Use --token or set APARAVI_TOKEN in .env file');
+                process.exit(1);
+            }
+            this.args = {
+                command: 'status',
+                ...options,
+                port: parseInt(options.port)
+            };
+            const protocol = this.args.port === 443 ? 'wss' : 'ws';
+            this.uri = `${protocol}://${this.args.host}:${this.args.port}`;
+            try {
+                const exitCode = await this.cmdStatus();
+                process.exit(exitCode);
+            }
+            finally {
+                this.cancel();
+                await this.cleanupClient();
+            }
+        });
+        addCommonOptions(statusCmd);
+        // Stop command
+        const stopCmd = program
+            .command('stop')
+            .description('Stop a running task')
+            .option('--token <token>', 'Task token to stop (can use APARAVI_TOKEN in .env or env var)', process.env.APARAVI_TOKEN)
+            .action(async (options) => {
+            // Validate required arguments - validation will happen in createAndConnectClient
+            if (!options.token) {
+                console.error('Error: Token is required for stop command. Use --token or set APARAVI_TOKEN in .env file');
+                process.exit(1);
+            }
+            this.args = {
+                command: 'stop',
+                ...options,
+                port: parseInt(options.port)
+            };
+            const protocol = this.args.port === 443 ? 'wss' : 'ws';
+            this.uri = `${protocol}://${this.args.host}:${this.args.port}`;
+            try {
+                const exitCode = await this.cmdStop();
+                process.exit(exitCode);
+            }
+            finally {
+                this.cancel();
+                await this.cleanupClient();
+            }
+        });
+        addCommonOptions(stopCmd);
+        return program;
+    }
+    async handleEvent(message) {
+        if (this.monitor) {
+            this.monitor.onEvent(message);
+        }
+    }
+    async createAndConnectClient(onConnected, onDisconnected) {
+        const uri = `${this.uri}/task/service`;
+        this.client = new client_1.AparaviClient({
+            uri,
+            auth: this.args.apikey,
+            onEvent: this.handleEvent.bind(this),
+            onConnected,
+            onDisconnected
+        });
+        await this.client.connect();
+        return this.client;
+    }
+    async sendMonitorCommand(subscribe, token) {
+        try {
+            if (!this.client)
+                return false;
+            const arguments_ = { subscribe };
+            const monitorRequest = this.client.buildRequest('apaext_monitor', {
+                token,
+                arguments: arguments_
+            });
+            const monitorResponse = await this.client.request(monitorRequest);
+            return !this.client.didFail(monitorResponse);
+        }
+        catch {
+            return false;
+        }
+    }
+    async cleanupClient() {
+        if (this.client) {
+            try {
+                await this.client.disconnect();
+            }
+            catch {
+                // Ignore cleanup errors
+            }
+            finally {
+                this.client = undefined;
+            }
+        }
+    }
+    loadPipelineConfig(pipelineFile) {
+        if (!fs.existsSync(pipelineFile) || !fs.statSync(pipelineFile).isFile()) {
+            throw new Error(`Pipeline file not found: ${pipelineFile}`);
+        }
+        try {
+            const content = fs.readFileSync(pipelineFile, 'utf-8');
+            try {
+                return JSON.parse(content);
+            }
+            catch (error) {
+                throw new Error(`Invalid JSON format in ${pipelineFile}: ${error}`);
+            }
+        }
+        catch (error) {
+            if (error instanceof Error && (error.message.includes('not found') || error.message.includes('Invalid'))) {
+                throw error;
+            }
+            else {
+                throw new Error(`Error reading ${pipelineFile}: ${error}`);
+            }
+        }
+    }
+    async cmdStart() {
+        try {
+            this.monitor = new GenericMonitor(this, 'Aparavi Pipeline Execution');
+            this.monitor.setCommandStatus('Loading pipeline configuration...');
+            this.monitor.draw();
+            const pipelineData = this.loadPipelineConfig(this.args.pipeline);
+            this.monitor.setCommandStatus(['Pipeline loaded successfully', 'Connecting to server...']);
+            this.monitor.draw();
+            await this.createAndConnectClient();
+            this.monitor.setCommandStatus(['Connected to server', 'Starting pipeline execution...']);
+            this.monitor.draw();
+            const taskToken = await this.client.use({
+                pipeline: pipelineData,
+                threads: this.args.threads,
+                token: this.args.token,
+                args: this.args.pipeline_args || []
+            });
+            const executionLines = [
+                'Pipeline execution started successfully',
+                `Task token: ${taskToken}`,
+                '',
+                'Use the following command to monitor status:',
+                `aparavi status --token ${taskToken} --apikey ${this.args.apikey}`
+            ];
+            this.monitor.setCommandStatus(executionLines);
+            this.monitor.draw();
+            return 0;
+        }
+        catch (error) {
+            if (!this.monitor) {
+                this.monitor = new GenericMonitor(this, 'Aparavi Pipeline Execution');
+            }
+            if (error instanceof Error && (error.message.includes('not found') || error.message.includes('Invalid'))) {
+                this.monitor.setCommandStatus('Configuration error occurred');
+                this.monitor.addBox('Configuration Error', [error.message]);
+            }
+            else {
+                this.monitor.setCommandStatus('Execution failed');
+                this.monitor.addBox('Execution Error', [String(error)]);
+            }
+            this.monitor.draw();
+            return 1;
+        }
+        finally {
+            await this.cleanupClient();
+        }
+    }
+    async cmdUpload() {
+        try {
+            this.monitor = new UploadProgressMonitor(this);
+            this.uploadStats = {
+                files_processed: 0,
+                total_bytes: 0,
+                successful_uploads: 0,
+                failed_uploads: 0,
+                upload_times: []
+            };
+            let pipelineConfig;
+            let taskToken;
+            let shouldManagePipeline = false;
+            if (this.args.pipeline) {
+                this.monitor.setCommandStatus('Loading pipeline configuration...');
+                this.monitor.draw();
+                pipelineConfig = this.loadPipelineConfig(this.args.pipeline);
+                shouldManagePipeline = true;
+            }
+            else if (this.args.token) {
+                taskToken = this.args.token;
+                this.monitor.setCommandStatus('Using existing task token...');
+                this.monitor.draw();
+            }
+            else {
+                this.monitor.setCommandStatus('Configuration error');
+                this.monitor.addBox('Upload Error', ['Either --pipeline or --token must be specified for upload command']);
+                this.monitor.draw();
+                return 1;
+            }
+            // Find and validate files
+            this.monitor.setCommandStatus(`Discovering files from ${(this.args.files || []).length} patterns...`);
+            this.monitor.draw();
+            const allFiles = this.findFiles(this.args.files || []);
+            if (allFiles.length === 0) {
+                this.monitor.setCommandStatus('File discovery failed');
+                this.monitor.addBox('Upload Error', ['No files found matching the specified patterns!']);
+                this.monitor.draw();
+                return 1;
+            }
+            this.monitor.setCommandStatus(`Validating ${allFiles.length} files...`);
+            this.monitor.draw();
+            const [validFiles, invalidFiles] = this.validateFiles(allFiles);
+            if (invalidFiles.length > 0) {
+                const validationErrorLines = [];
+                const displayCount = Math.min(invalidFiles.length, 15);
+                for (const error of invalidFiles.slice(0, displayCount)) {
+                    validationErrorLines.push(`${ANSI_RED}${CHR_CROSS}${ANSI_RESET} ${error}`);
+                }
+                if (invalidFiles.length > 15) {
+                    const remaining = invalidFiles.length - 15;
+                    validationErrorLines.push(`... and ${remaining} more validation errors`);
+                }
+                this.monitor.setCommandStatus('File validation completed with errors');
+                this.monitor.addBox('File Validation Errors', validationErrorLines);
+                this.monitor.draw();
+                // Wait briefly to show errors
+                await new Promise(resolve => setTimeout(resolve, 3000));
+            }
+            if (validFiles.length === 0) {
+                this.monitor.setCommandStatus('File validation failed');
+                this.monitor.addBox('Upload Error', ['No valid files found!']);
+                this.monitor.draw();
+                return 1;
+            }
+            // Connect and start
+            this.monitor.setCommandStatus('Connecting to Aparavi server...');
+            this.monitor.draw();
+            await this.createAndConnectClient();
+            if (shouldManagePipeline && pipelineConfig) {
+                this.monitor.setCommandStatus('Starting pipeline...');
+                this.monitor.draw();
+                let result = await this.client.use({
+                    pipeline: pipelineConfig,
+                    threads: this.args.threads,
+                    token: 'UPLOAD_TASK',
+                    args: this.args.pipeline_args || []
+                });
+                taskToken = result.token;
+            }
+            // Start upload
+            this.monitor.setTotalFiles(validFiles.length);
+            this.monitor.draw();
+            const startTime = Date.now();
+            // Convert file paths to File objects for sendFiles
+            const fileObjects = validFiles.map(filePath => {
+                const fs = require('fs');
+                const stats = fs.statSync(filePath);
+                const content = fs.readFileSync(filePath);
+                return {
+                    file: new File([content], path.basename(filePath), {
+                        type: 'application/octet-stream',
+                        lastModified: stats.mtimeMs
+                    }),
+                    objinfo: {
+                        filepath: filePath,
+                        size: stats.size
+                    }
+                };
+            });
+            // Upload files - progress events come through event subscription
+            const results = await this.client.sendFiles(fileObjects, taskToken, this.args.max_concurrent || 5);
+            const endTime = Date.now();
+            // Analyze and show results
+            this.analyzeUploadResults(results, startTime / 1000, endTime / 1000);
+            // Cleanup pipeline if we created it
+            if (shouldManagePipeline && taskToken) {
+                try {
+                    this.monitor.setCommandStatus([
+                        'Upload completed successfully',
+                        'Cleaning up...',
+                        'Terminating pipeline...'
+                    ]);
+                    this.monitor.draw();
+                    await this.client.terminate(taskToken);
+                    // Re-show results after cleanup
+                    this.analyzeUploadResults(results, startTime / 1000, endTime / 1000);
+                }
+                catch (error) {
+                    this.monitor.setCommandStatus('Upload completed with cleanup warning');
+                    this.monitor.addBox('Cleanup Warning', [`Failed to terminate pipeline: ${error}`]);
+                    this.monitor.draw();
+                }
+            }
+            return 0;
+        }
+        catch (error) {
+            if (!this.monitor) {
+                this.monitor = new UploadProgressMonitor(this);
+            }
+            if (error instanceof Error && (error.message.includes('not found') || error.message.includes('Invalid'))) {
+                this.monitor.setCommandStatus('Configuration error occurred');
+                this.monitor.addBox('Configuration Error', [error.message]);
+            }
+            else {
+                this.monitor.setCommandStatus('Upload operation failed');
+                this.monitor.addBox('Upload Error', [String(error)]);
+            }
+            this.monitor.draw();
+            return 1;
+        }
+        finally {
+            await this.cleanupClient();
+        }
+    }
+    findFiles(patterns) {
+        const files = [];
+        for (const pattern of patterns) {
+            const fullPath = path.resolve(pattern);
+            try {
+                const stat = fs.statSync(fullPath);
+                if (stat.isFile()) {
+                    files.push(fullPath);
+                }
+                else if (stat.isDirectory()) {
+                    const dirFiles = glob.sync(path.join(fullPath, '**/*'), { nodir: true });
+                    files.push(...dirFiles.map(f => path.resolve(f)));
+                }
+            }
+            catch {
+                // Try glob pattern
+                const matches = glob.sync(pattern, { nodir: true });
+                files.push(...matches.map(f => path.resolve(f)));
+            }
+        }
+        // Remove duplicates
+        return [...new Set(files)];
+    }
+    validateFiles(filesList) {
+        const validFiles = [];
+        const invalidFiles = [];
+        for (const filepath of filesList) {
+            try {
+                if (fs.existsSync(filepath) && fs.statSync(filepath).isFile()) {
+                    // Try to read a byte to check accessibility
+                    const fd = fs.openSync(filepath, 'r');
+                    fs.closeSync(fd);
+                    validFiles.push(filepath);
+                }
+                else {
+                    invalidFiles.push(`File not found: ${path.basename(filepath)}`);
+                }
+            }
+            catch (error) {
+                invalidFiles.push(`Cannot read ${path.basename(filepath)}: ${error}`);
+            }
+        }
+        return [validFiles, invalidFiles];
+    }
+    analyzeUploadResults(results, startTime, endTime) {
+        if (!this.monitor)
+            return;
+        this.monitor.clear();
+        const successfulFiles = [];
+        const failedFiles = [];
+        for (const result of results) {
+            const filename = path.basename(result.filepath || '');
+            if (result.action === 'complete') {
+                this.uploadStats.successful_uploads++;
+                this.uploadStats.total_bytes += result.file_size || 0;
+                this.uploadStats.upload_times.push(result.upload_time || 0);
+                successfulFiles.push({
+                    name: filename,
+                    size: result.file_size || 0,
+                    time: result.upload_time || 0
+                });
+            }
+            else {
+                failedFiles.push({
+                    name: filename,
+                    error: result.error || 'Unknown error'
+                });
+                this.uploadStats.failed_uploads++;
+            }
+            this.uploadStats.files_processed++;
+        }
+        // Create summary
+        const successful = this.uploadStats.successful_uploads;
+        const failed = this.uploadStats.failed_uploads;
+        const totalBytes = this.uploadStats.total_bytes;
+        const summaryLines = [
+            `Total files processed: ${successful + failed}`,
+            `Successful uploads: ${ANSI_GREEN}${successful}${ANSI_RESET}`
+        ];
+        if (failed > 0) {
+            summaryLines.push(`Failed uploads: ${ANSI_RED}${failed}${ANSI_RESET}`);
+        }
+        summaryLines.push(`Total data uploaded: ${this.monitor.formatSize(totalBytes)}`);
+        if (startTime && endTime && endTime > startTime) {
+            const elapsedSeconds = endTime - startTime;
+            let elapsedStr;
+            if (elapsedSeconds < 60) {
+                elapsedStr = `${elapsedSeconds.toFixed(1)} seconds`;
+            }
+            else if (elapsedSeconds < 3600) {
+                const minutes = Math.floor(elapsedSeconds / 60);
+                const seconds = elapsedSeconds % 60;
+                elapsedStr = `${minutes}m ${seconds.toFixed(1)}s`;
+            }
+            else {
+                const hours = Math.floor(elapsedSeconds / 3600);
+                const minutes = Math.floor((elapsedSeconds % 3600) / 60);
+                const seconds = elapsedSeconds % 60;
+                elapsedStr = `${hours}h ${minutes}m ${seconds.toFixed(1)}s`;
+            }
+            summaryLines.push(`Total elapsed time: ${elapsedStr}`);
+            if (totalBytes > 0 && elapsedSeconds > 0) {
+                const throughputBps = totalBytes / elapsedSeconds;
+                const throughputStr = this.monitor.formatSize(Math.floor(throughputBps));
+                summaryLines.push(`Average throughput: ${throughputStr}/s`);
+            }
+        }
+        this.monitor.addBox('Upload Summary', summaryLines);
+        // Show failed files if any
+        if (failedFiles.length > 0) {
+            const failureLines = [];
+            for (const failedFile of failedFiles.slice(0, 10)) {
+                const filename = failedFile.name.length > 25 ?
+                    `${failedFile.name.substring(0, 25)}...` : failedFile.name;
+                const errorMsg = failedFile.error.length > 40 ?
+                    `${failedFile.error.substring(0, 40)}...` : failedFile.error;
+                failureLines.push(`${ANSI_RED}${CHR_CROSS}${ANSI_RESET} ${filename} - ${errorMsg}`);
+            }
+            if (failedFiles.length > 10) {
+                failureLines.push(`... and ${failedFiles.length - 10} more failures`);
+            }
+            this.monitor.addBox(`Failed Uploads (${failedFiles.length})`, failureLines);
+        }
+        // Show successful files summary
+        if (successfulFiles.length > 0) {
+            const successLines = [];
+            for (const successFile of successfulFiles.slice(-5)) {
+                const truncatedName = successFile.name.length > 35 ?
+                    `${successFile.name.substring(0, 35)}...` : successFile.name;
+                const sizeStr = this.monitor.formatSize(successFile.size);
+                const timeStr = `${successFile.time.toFixed(1)}s`;
+                successLines.push(`${ANSI_GREEN}${CHR_CHECK}${ANSI_RESET} ${truncatedName} (${sizeStr}, ${timeStr})`);
+            }
+            if (successfulFiles.length > 5) {
+                successLines.push(`... and ${successfulFiles.length - 5} more successful uploads`);
+            }
+            this.monitor.addBox('Recent Successful Uploads', successLines);
+        }
+        this.monitor.setCommandStatus('Completed');
+        this.monitor.draw();
+    }
+    async cmdStatus() {
+        try {
+            if (!this.args.token) {
+                console.error('Error: --token is required for status command');
+                return 1;
+            }
+            this.monitor = new StatusMonitor(this, this.args.token);
+            const onConnected = async (uri) => {
+                this.connected = true;
+                this.attempt = 0;
+                this.monitor.displayStatus({});
+                await this.sendMonitorCommand(true, this.args.token);
+            };
+            const onDisconnected = async (reason, hasError) => {
+                this.connected = false;
+            };
+            // Auto-reconnection loop
+            while (!this.isCancelled()) {
+                if (!this.connected) {
+                    this.monitor.displayConnecting(this.uri, this.attempt);
+                    try {
+                        await this.createAndConnectClient(onConnected, onDisconnected);
+                    }
+                    catch {
+                        this.attempt++;
+                        await new Promise(resolve => setTimeout(resolve, 5000));
+                        continue;
+                    }
+                }
+                await new Promise(resolve => setTimeout(resolve, 1000));
+            }
+            return 0;
+        }
+        catch {
+            console.log('\n\nStopping monitoring...');
+            return 0;
+        }
+        finally {
+            // Make sure we unsubscribe
+            if (this.client && this.connected) {
+                try {
+                    await this.sendMonitorCommand(false, this.args.token);
+                }
+                catch {
+                    // Ignore unsubscribe errors
+                }
+            }
+            await this.cleanupClient();
+        }
+    }
+    async cmdStop() {
+        try {
+            if (!this.args.token) {
+                console.error('Error: --token is required for stop command');
+                return 1;
+            }
+            this.monitor = new GenericMonitor(this, 'Aparavi Task Management');
+            this.monitor.setCommandStatus('Connecting to server...');
+            this.monitor.draw();
+            await this.createAndConnectClient();
+            this.monitor.setCommandStatus(`Terminating task: ${this.args.token}`);
+            this.monitor.draw();
+            await this.client.terminate(this.args.token);
+            const stopLines = [
+                `Task ${this.args.token} terminated successfully`,
+                '',
+                'The task has been stopped and resources cleaned up.'
+            ];
+            this.monitor.setCommandStatus(stopLines);
+            this.monitor.draw();
+            return 0;
+        }
+        catch (error) {
+            if (!this.monitor) {
+                this.monitor = new GenericMonitor(this, 'Aparavi Task Management');
+            }
+            this.monitor.setCommandStatus('Stop operation failed');
+            this.monitor.addBox('Stop Error', [String(error)]);
+            this.monitor.draw();
+            return 1;
+        }
+        finally {
+            await this.cleanupClient();
+        }
+    }
+    async run() {
+        const program = this.createProgram();
+        // Parse command line arguments - commander will handle command routing
+        try {
+            await program.parseAsync(process.argv);
+            return 0; // If we get here, a command was executed successfully
+        }
+        catch (error) {
+            if (error instanceof Error && error.message.includes('interrupted')) {
+                console.log('\nOperation interrupted by user');
+                return 1;
+            }
+            else {
+                console.error(`Error: ${error}`);
+                return 1;
+            }
+        }
+    }
+}
+exports.AparaviCLI = AparaviCLI;
+function formatError(e) {
+    const stack = e.stack?.split('\n');
+    if (stack && stack.length > 1) {
+        const frame = stack[1];
+        const match = frame.match(/at .+?\((.+):(\d+):\d+\)/) || frame.match(/at (.+):(\d+):\d+/);
+        if (match) {
+            const filename = path.basename(match[1]);
+            const lineno = match[2];
+            return `${e.constructor.name}: ${e.message} (in ${filename}:${lineno})`;
+        }
+    }
+    return `${e.constructor.name}: ${e.message}`;
+}
+async function main() {
+    try {
+        const aparavi = new AparaviCLI();
+        const exitCode = await aparavi.run();
+        process.exit(exitCode);
+    }
+    catch (error) {
+        if (error instanceof Error && error.message.includes('interrupted')) {
+            console.log('\n\nOperation interrupted by user');
+        }
+        else {
+            console.log(`\nOperation failed: ${formatError(error)}`);
+            process.exit(1);
+        }
+    }
+}
+// Entry point when script is run directly
+if (require.main === module) {
+    main().catch(error => {
+        console.error('Fatal error:', error);
+        process.exit(1);
+    });
+}
+//# sourceMappingURL=aparavi.js.map