@airmoney-degn/airmoney-cli 0.16.2 → 0.18.0

package/dist/index.js

@@ -8,8 +8,10 @@ const create_1 = require("./cli/create");
 const serve_1 = require("./cli/serve");
 const upload_1 = require("./cli/upload");
 const setup_1 = require("./cli/setup");
+const dapp_1 = require("./cli/dapp");
 const wallet_1 = require("./cli/wallet");
 const config_json_1 = require("./config.json");
+const LogService_1 = require("./service/log/LogService");
 // Load environment from config
 (0, env_1.loadEnvFromConfig)();
 const program = new commander_1.Command();
@@ -22,7 +24,7 @@ program
     .description('Setup env with userAddress, apiKey, rpc')
     .requiredOption('-u, --user <string>', 'developer user')
     .requiredOption('-k, --key <string>', 'API key')
-    .option('-n, --network <string>', 'network devnet|mainnet', 'devnet')
+    .option('-n, --network <string>', 'network devnet|mainnet')
     .action(opts => {
     const { user, key, network } = opts;
     (0, setup_1.setupCommand)({ network, userId: user, apiKey: key });
@@ -31,12 +33,11 @@ program
     .command('create')
     .description('Initialize a new project')
     .requiredOption('-N, --name <string>', 'Project name')
-    // .option('-n, --network <string>', 'network devnet|mainnet', 'devnet')
     .option('-f, --app-path <string>', 'path where project will be created')
     .option('--template', 'initialize project based on git quickstart')
-    .action(async (opts) => {
+    .action(opts => {
     const { name, appPath, template } = opts;
-    await (0, create_1.createCommand)({ name, template, locationFolder: appPath });
+    (0, create_1.createCommand)({ name, template, locationFolder: appPath });
 });
 program
     .command('serve')
@@ -44,16 +45,20 @@ program
     .option('-f, --index-app-path <string>', 'path for the index.html', './')
     .option('--no-browser', 'stop browser from being open')
     .option('-u, --app-url <string>', 'url where the app is running')
-    .action(async (opts) => {
+    .action(opts => {
     let { indexAppPath, browser, appUrl } = opts;
     if (indexAppPath == './') {
         indexAppPath = undefined;
     }
     if (indexAppPath && appUrl) {
-        console.error('both --index-app-path and --app-url must not be used simuntaniusly');
+        (0, LogService_1.log)('both --index-app-path and --app-url must not be used simuntaniusly').red();
         return;
     }
-    await (0, serve_1.serveCommand)({ noBrowser: !browser, locationFolder: indexAppPath, appUrl });
+    (0, serve_1.serveCommand)({
+        noBrowser: !browser,
+        locationFolder: indexAppPath,
+        appUrl,
+    });
 });
 program
     .command('wallet')
@@ -93,16 +98,26 @@ program
 program
     .command('upload')
     .description('Publish the app to the DEGN Dapp Store')
-    .option('-n, --network <string>', 'network devnet|mainnet', 'https://rpc-dev.air.fun')
+    .option('-n, --network <string>', 'network devnet|mainnet')
     .option('-f, --index-app-path <string>', 'path for the index.html', './')
     .option('-i, --button-image <string>', 'path for the button images', 'assets')
-    .action(async (opts) => {
+    .action(opts => {
     let { network, indexAppPath, buttonImage } = opts;
     if (indexAppPath == './') {
         indexAppPath = undefined;
     }
-    // user and key are read from store config within uploadCommand
-    await (0, upload_1.uploadCommand)({ network, locationFolder: indexAppPath, buttonImages: buttonImage });
+    (0, upload_1.uploadCommand)({
+        network,
+        locationFolder: indexAppPath,
+        buttonImages: buttonImage,
+    });
+});
+program
+    .command('dapp')
+    .description('Manage dapps')
+    .option('-s, --status', 'show all dapps list')
+    .action(() => {
+    (0, dapp_1.dappStatusCommand)();
 });
 program
     .command('demo')

package/dist/service/airmoney/AirmoneyService.js

@@ -7,6 +7,7 @@ exports.AirmoneyService = void 0;
 const express_1 = __importDefault(require("express"));
 const cors_1 = __importDefault(require("cors"));
 const server_1 = require("../../util/server");
+const LogService_1 = require("../log/LogService");
 class AirmoneyService {
     constructor(config) {
         this.simulatorClient = null;
@@ -40,7 +41,7 @@ class AirmoneyService {
                     return;
                 }
                 else {
-                    console.log('\x1b[33mNo simulator client connected\x1b[0m');
+                    (0, LogService_1.log)('No simulator client connected').white();
                     res.status(503).json({ error: 'Simulator not connected' });
                     return;
                 }
@@ -62,7 +63,7 @@ class AirmoneyService {
         return new Promise(resolve => {
             this.server = this.app.listen(this.config.port, () => {
                 const url = `http://localhost:${this.config.port}`;
-                console.log(`\x1b[32mStarting airmoney service server at ${url}\x1b[0m`);
+                (0, LogService_1.log)(`Starting airmoney service server at ${url}`).green();
                 resolve();
             });
         });

package/dist/service/dapp/DappService.js

@@ -0,0 +1,162 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DappService = void 0;
+const node_fetch_1 = __importDefault(require("node-fetch"));
+const network_1 = require("../../util/network");
+/**
+ * Service for fetching and managing dapp information
+ */
+class DappService {
+    constructor(userId, apiKey, network) {
+        this.userId = userId;
+        this.apiKey = apiKey;
+        this.network = network;
+    }
+    /**
+     * Parses JSON-RPC error response and extracts error message
+     * Combines error.message and error.data fields (message first, then data)
+     */
+    parseJsonRpcError(json) {
+        if (!json.error) {
+            return 'Unknown error';
+        }
+        let errorMessageParts = [];
+        // Add message field first if it exists
+        if (json.error.message) {
+            errorMessageParts.push(json.error.message);
+        }
+        // Parse and add data field if it exists and is different from message
+        if (json.error.data !== undefined) {
+            let dataMessage = '';
+            if (typeof json.error.data === 'string') {
+                try {
+                    const parsed = JSON.parse(json.error.data);
+                    dataMessage = parsed;
+                }
+                catch {
+                    dataMessage = json.error.data.replace(/^"|"$/g, '');
+                }
+            }
+            else {
+                dataMessage = String(json.error.data);
+            }
+            // Only add data if it's different from message
+            if (dataMessage && dataMessage !== json.error.message) {
+                errorMessageParts.push(dataMessage);
+            }
+        }
+        // Combine into final error message
+        return errorMessageParts.length > 0
+            ? errorMessageParts.join(' - ')
+            : 'Unknown error';
+    }
+    /**
+     * Makes a JSON-RPC request and handles common response patterns
+     * Throws error for HTTP errors or JSON-RPC errors
+     */
+    async makeJsonRpcRequest(method, params) {
+        const apiUrl = (0, network_1.networkToRpcUrl)(this.network);
+        const body = JSON.stringify({
+            jsonrpc: '2.0',
+            id: 1,
+            method,
+            params,
+        });
+        const res = await (0, node_fetch_1.default)(apiUrl, {
+            method: 'POST',
+            body,
+            headers: {
+                'Content-Type': 'application/json',
+            },
+        });
+        if (!res.ok) {
+            throw new Error(`HTTP ${res.status} - ${await res.text()}`);
+        }
+        const json = (await res.json());
+        if ('error' in json) {
+            throw new Error(this.parseJsonRpcError(json));
+        }
+        return json.result;
+    }
+    /**
+     * Validates API key before making dapp API calls
+     */
+    async validateApiKey() {
+        return await this.makeJsonRpcRequest('checkApiKey', [this.userId, this.apiKey]);
+    }
+    /**
+     * Fetches dapp list from API
+     */
+    async fetchDappList() {
+        return await this.makeJsonRpcRequest('getDappList', [this.userId, this.apiKey]);
+    }
+    /**
+     * Fetches dapp versions/builds from API
+     */
+    async fetchDappVersions(dappName) {
+        return await this.makeJsonRpcRequest('checkDappVersions', [this.userId, this.apiKey, dappName]);
+    }
+    /**
+     * Fetches JSON from an external URL
+     * Used for fetching metadata from meta_url
+     */
+    async fetchJsonFromUrl(url) {
+        try {
+            const res = await (0, node_fetch_1.default)(url);
+            if (!res.ok) {
+                return null;
+            }
+            return await res.json();
+        }
+        catch (err) {
+            return null;
+        }
+    }
+    /**
+     * Fetches metadata for builds
+     */
+    async fetchMetaForBuilds(builds) {
+        const updatedBuilds = [];
+        for (const b of builds) {
+            let metaAuthor = 'N/A';
+            let metaIdentifier = 'N/A';
+            let metaMaintainer = 'N/A';
+            if (b.meta_url) {
+                const metaJson = await this.fetchJsonFromUrl(b.meta_url);
+                if (metaJson) {
+                    if (metaJson.author)
+                        metaAuthor = metaJson.author;
+                    if (metaJson.identifier)
+                        metaIdentifier = metaJson.identifier;
+                    if (metaJson.maintainer)
+                        metaMaintainer = metaJson.maintainer;
+                }
+            }
+            updatedBuilds.push({
+                ...b,
+                author: metaAuthor,
+                identifier: metaIdentifier,
+                maintainer: metaMaintainer,
+            });
+        }
+        return updatedBuilds;
+    }
+    /**
+     * Fetches dapp details including builds with metadata
+     */
+    async fetchDappDetails(dappName) {
+        const builds = await this.fetchDappVersions(dappName);
+        const buildsWithMeta = await this.fetchMetaForBuilds(builds);
+        // Sort by version (descending)
+        buildsWithMeta.sort((a, b) => {
+            const aVer = parseFloat(a.version || '0') || 0;
+            const bVer = parseFloat(b.version || '0') || 0;
+            return bVer - aVer;
+        });
+        return buildsWithMeta;
+    }
+}
+exports.DappService = DappService;

package/dist/service/log/LogService.js

@@ -0,0 +1,85 @@
+"use strict";
+/**
+ * Logging service with chainable API support
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.log = log;
+/**
+ * LogBuilder class for chainable logging
+ */
+class LogBuilder {
+    constructor(message) {
+        this.isBold = false;
+        this.isItalic = false;
+        this.color = null;
+        this.message = message;
+    }
+    /**
+     * Makes the message bold
+     */
+    bold() {
+        this.isBold = true;
+        return this;
+    }
+    /**
+     * Makes the message italic
+     */
+    italic() {
+        this.isItalic = true;
+        return this;
+    }
+    /**
+     * Sets the color to red and logs
+     */
+    red() {
+        this.color = 'red';
+        this.execute();
+    }
+    /**
+     * Sets the color to green and logs
+     */
+    green() {
+        this.color = 'green';
+        this.execute();
+    }
+    /**
+     * Sets the color to white and logs
+     */
+    white() {
+        this.color = 'white';
+        this.execute();
+    }
+    /**
+     * Executes the log with all formatting applied
+     */
+    execute() {
+        const codes = [];
+        if (this.isBold)
+            codes.push('1');
+        if (this.isItalic)
+            codes.push('3');
+        if (this.color === 'red') {
+            codes.push('31');
+        }
+        else if (this.color === 'green') {
+            codes.push('32');
+        }
+        else if (this.color === 'white') {
+            // White is default, no color code needed
+        }
+        if (codes.length > 0) {
+            const escapeCode = '\x1b[' + codes.join(';') + 'm';
+            console.log(escapeCode + this.message + '\x1b[0m');
+        }
+        else {
+            console.log(this.message);
+        }
+    }
+}
+/**
+ * Creates a log builder for chainable logging
+ * Usage: log('message').italic().red()
+ */
+function log(message) {
+    return new LogBuilder(message);
+}

package/dist/service/port/PortManager.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PortManager = void 0;
 const cryptoProcess_1 = require("../../util/cryptoProcess");
+const LogService_1 = require("../log/LogService");
 class PortManager {
     /**
      * Check if any of the required ports are in use
@@ -9,11 +10,11 @@ class PortManager {
     static async checkPortConflicts(ports = this.DEFAULT_PORTS) {
         const inUsePorts = await (0, cryptoProcess_1.checkPortsInUse)(ports);
         if (inUsePorts.length > 0) {
-            console.error('\x1b[31m❌ Port conflict detected!\x1b[0m');
-            console.error(`\x1b[31mThe following ports are already in use: ${inUsePorts.join(', ')}\x1b[0m`);
-            console.error('\x1b[31m\nPlease kill the processes using these ports before running serve:\x1b[0m');
+            (0, LogService_1.log)('Port conflict detected!').red();
+            (0, LogService_1.log)(`The following ports are already in use: ${inUsePorts.join(', ')}`).red();
+            (0, LogService_1.log)('\nPlease kill the processes using these ports before running serve:').red();
             const killCommand = `lsof -ti:${inUsePorts.join(',')} | xargs kill -9`;
-            console.error(`\x1b[31m  ${killCommand}\x1b[0m`);
+            (0, LogService_1.log)(`  ${killCommand}`).red();
             process.exit(1);
         }
     }

package/dist/service/serve/ServeOrchestrator.js

@@ -10,6 +10,7 @@ const cryptoProcess_1 = require("../../util/cryptoProcess");
 const PortManager_1 = require("../port/PortManager");
 const SimulatorService_1 = require("../simulator/SimulatorService");
 const AirmoneyService_1 = require("../airmoney/AirmoneyService");
+const LogService_1 = require("../log/LogService");
 class ServeOrchestrator {
     constructor(config) {
         this.config = config;
@@ -40,7 +41,7 @@ class ServeOrchestrator {
         await PortManager_1.PortManager.checkPortConflicts();
         // Validate metadata
         if (!this.metadata) {
-            console.log('\x1b[33mNo metadata found. Skipping some possible checks.\x1b[0m');
+            (0, LogService_1.log)('No metadata found. Skipping some possible checks.').white();
         }
         // Start simulator service
         await this.simulatorService.start();

package/dist/service/simulator/BaseSimulatorService.js

@@ -10,6 +10,7 @@ const express_ws_1 = __importDefault(require("express-ws"));
 const cors_1 = __importDefault(require("cors"));
 const open_1 = __importDefault(require("open"));
 const http_proxy_middleware_1 = require("http-proxy-middleware");
+const LogService_1 = require("../log/LogService");
 class BaseSimulatorService {
     constructor(config) {
         this.simulatorClient = null;
@@ -37,7 +38,7 @@ class BaseSimulatorService {
                 this.onClientConnectedCallback(this.getClient());
             }
             ws.on('message', (msg) => {
-                console.log(msg);
+                (0, LogService_1.log)(String(msg)).white();
             });
             ws.on('close', () => {
                 this.simulatorClient = null;
@@ -47,7 +48,7 @@ class BaseSimulatorService {
                 }
             });
             ws.on('error', (error) => {
-                console.error('WebSocket error:', error);
+                (0, LogService_1.log)(`WebSocket error: ${error}`).red();
                 this.simulatorClient = null;
                 // Notify callback about disconnection due to error
                 if (this.onClientConnectedCallback) {
@@ -81,7 +82,7 @@ class BaseSimulatorService {
                 await (0, open_1.default)(url);
             }
             catch (err) {
-                console.error('\x1b[31mFailed to open web browser\x1b[0m', err);
+                (0, LogService_1.log)(`Failed to open web browser ${err}`).red();
             }
         }
     }
@@ -114,7 +115,7 @@ class BaseSimulatorService {
         return new Promise(resolve => {
             this.server = this.app.listen(this.config.port, () => {
                 const url = `http://localhost:${this.config.port}/simulator`;
-                console.log(`\x1b[32mStarting simulator server at ${url}\x1b[0m`);
+                (0, LogService_1.log)(`Starting simulator server at ${url}`).green();
                 this.openBrowser();
                 resolve();
             });

package/dist/util/cryptoProcess.js

@@ -16,6 +16,7 @@ const path_1 = __importDefault(require("path"));
 const child_process_1 = require("child_process");
 const env_1 = require("./env");
 const CryptoService_1 = require("../service/crypto/CryptoService");
+const LogService_1 = require("../service/log/LogService");
 // Utility functions for port management
 function isPortInUse(port) {
     return new Promise(resolve => {
@@ -102,29 +103,29 @@ function startCryptoService() {
         }, (error, stdout, stderr) => {
             // Ignore errors if the process was intentionally killed
             if (error && !isKilled && !hasResolved) {
-                console.error('\x1b[31m❌ Crypto service failed to start:\x1b[0m');
-                console.error('\x1b[31mError details:\x1b[0m', error.message);
+                (0, LogService_1.log)('Crypto service failed to start:').red();
+                (0, LogService_1.log)(`Error details: ${error.message}`).red();
                 // Check for specific Rust panic errors
                 if (stderr &&
                     stderr.includes('Cannot drop a runtime in a context where blocking is not allowed')) {
-                    console.error('\x1b[31m\n🔧 This appears to be a Rust/tokio runtime issue in the crypto service binary.\x1b[0m');
-                    console.error('\x1b[31mPossible solutions:\x1b[0m');
-                    console.error('\x1b[31m1. The binary may be corrupted - try rebuilding: npm run build\x1b[0m');
-                    console.error('\x1b[31m2. There may be a compatibility issue with your system\x1b[0m');
-                    console.error('\x1b[31m3. Try running the binary directly to see more details:\x1b[0m');
-                    console.error(`\x1b[31m   ${bin}\x1b[0m`);
+                    (0, LogService_1.log)('\n🔧 This appears to be a Rust/tokio runtime issue in the crypto service binary.').red();
+                    (0, LogService_1.log)('Possible solutions:').red();
+                    (0, LogService_1.log)('1. The binary may be corrupted - try rebuilding: npm run build').red();
+                    (0, LogService_1.log)('2. There may be a compatibility issue with your system').red();
+                    (0, LogService_1.log)('3. Try running the binary directly to see more details:').red();
+                    (0, LogService_1.log)(`   ${bin}`).red();
                 }
                 else if (stderr) {
-                    console.error('Stderr:', stderr);
+                    (0, LogService_1.log)(`Stderr: ${stderr}`).red();
                 }
                 reject(new Error(`Crypto service failed: ${error.message}`));
                 return;
             }
             if (stdout) {
-                // console.log('Crypto service stdout:', stdout);
+                // log(`Crypto service stdout: ${stdout}`).white();
             }
             if (stderr && !isKilled) {
-                console.error('\x1b[31mCrypto service stderr:\x1b[0m', stderr);
+                (0, LogService_1.log)(`Crypto service stderr: ${stderr}`).red();
             }
         });
         // Wait 2 seconds before resolving to ensure service is ready
@@ -153,10 +154,10 @@ function getCryptoServicePath() {
 function startCryptoServiceSimple() {
     const bin = getCryptoServicePath();
     if (!(0, fs_1.existsSync)(bin)) {
-        console.log('\x1b[31mcrypto service not found at ' + bin + '\x1b[0m');
+        (0, LogService_1.log)(`crypto service not found at ${bin}`).red();
         return;
     }
-    console.log('\x1b[32mStarting crypto service at http://localhost:5050\x1b[0m');
+    (0, LogService_1.log)('Starting crypto service at http://localhost:5050').green();
     (0, child_process_1.exec)(bin, { env: { SECURE_STORAGE: (0, env_1.configDir)(), RUST_BACKTRACE: '1' } }, (_, stdout, stderr) => {
         // console.log("stdout", stdout);
         // console.log("stderr", stderr);
@@ -182,17 +183,17 @@ async function withCryptoService(operation) {
             startedCryptoService = true;
         }
         catch (error) {
-            console.error('\x1b[31m❌ Failed to start crypto service:\x1b[0m');
-            console.error('\x1b[31mThis might be due to:\x1b[0m');
-            console.error('\x1b[31m- Missing or corrupted binary files\x1b[0m');
-            console.error('\x1b[31m- Insufficient permissions\x1b[0m');
-            console.error('\x1b[31m- System compatibility issues\x1b[0m');
-            console.error('\x1b[31m- Port conflicts\x1b[0m');
-            console.error('\x1b[31m\nTry running: npm run build\x1b[0m');
+            (0, LogService_1.log)('Failed to start crypto service:').red();
+            (0, LogService_1.log)('This might be due to:').red();
+            (0, LogService_1.log)('- Missing or corrupted binary files').red();
+            (0, LogService_1.log)('- Insufficient permissions').red();
+            (0, LogService_1.log)('- System compatibility issues').red();
+            (0, LogService_1.log)('- Port conflicts').red();
+            (0, LogService_1.log)('\nTry running: npm run build').red();
             throw error;
         }
         const cryptoServiceClient = new CryptoService_1.CryptoService();
-        // console.log('Crypto service client created');
+        // log('Crypto service client created').white();
         return await operation(cryptoServiceClient);
     }
     catch (error) {

package/dist/util/env.js

@@ -35,10 +35,15 @@ var __importStar = (this && this.__importStar) || (function () {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.configDir = configDir;
 exports.loadEnvFromConfig = loadEnvFromConfig;
+exports.getDeveloperAddress = getDeveloperAddress;
+exports.getApiKey = getApiKey;
+exports.getRpc = getRpc;
+exports.validateCredential = validateCredential;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const os = __importStar(require("os"));
 const dotenv = __importStar(require("dotenv"));
+const network_1 = require("./network");
 function configDir() {
     // similar to Rust's ProjectDirs::from("fun", "air", "simulator");
     // We'll do a rough approach
@@ -54,3 +59,42 @@ function loadEnvFromConfig() {
         dotenv.config({ path: envPath });
     }
 }
+/**
+ * Gets the developer address from environment variables
+ */
+function getDeveloperAddress() {
+    return process.env.DEVELOPER_ADDRESS || '';
+}
+/**
+ * Gets the API key from environment variables
+ */
+function getApiKey() {
+    return process.env.API_KEY || '';
+}
+/**
+ * Gets the RPC/network from environment variables
+ */
+function getRpc() {
+    return process.env.RPC;
+}
+/**
+ * Validates that credentials exist and returns them
+ * Throws error if credentials are missing
+ */
+function validateCredential() {
+    const userId = getDeveloperAddress();
+    const apiKey = getApiKey();
+    const rpc = getRpc();
+    if (!userId || !apiKey) {
+        throw new Error('Missing credentials. Run "airmoney-cli setup" to configure your credentials.');
+    }
+    if ((0, network_1.validateNetwork)(rpc)) {
+        return {
+            userId,
+            apiKey,
+            rpc,
+        };
+    }
+    throw new Error('Invalid network. Must be "devnet" or "mainnet". Your current network is: ' +
+        rpc);
+}

package/dist/util/format.js

@@ -0,0 +1,74 @@
+"use strict";
+/**
+ * Formatting utilities for CLI output
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stripAnsiCodes = stripAnsiCodes;
+exports.padString = padString;
+exports.printTableRow = printTableRow;
+exports.printSeparator = printSeparator;
+exports.shortenString = shortenString;
+const LogService_1 = require("../service/log/LogService");
+/**
+ * Strips ANSI color codes from a string
+ */
+function stripAnsiCodes(str) {
+    // Remove ANSI escape codes (CSI escape sequences)
+    return str.replace(/\x1b\[[0-9;]*m/g, '');
+}
+/**
+ * Formats a string to fixed width for table display
+ * Handles ANSI color codes by only counting visible characters for width calculation
+ */
+function padString(str, width) {
+    const s = String(str || 'N/A');
+    const visibleLength = stripAnsiCodes(s).length;
+    if (visibleLength > width) {
+        // Truncate the visible text, keeping color codes
+        const visibleText = stripAnsiCodes(s);
+        const truncated = visibleText.substring(0, width - 3) + '...';
+        // Try to preserve color codes at the beginning
+        const colorMatch = s.match(/^(\x1b\[[0-9;]*m)/);
+        const resetCode = '\x1b[0m';
+        if (colorMatch) {
+            return colorMatch[1] + truncated + resetCode;
+        }
+        return truncated;
+    }
+    // Pad with spaces, but only count visible characters
+    const padding = ' '.repeat(width - visibleLength);
+    return s + padding;
+}
+/**
+ * Prints a table row
+ */
+function printTableRow(columns, widths, isHeader = false) {
+    const row = columns.map((col, i) => padString(col, widths[i])).join(' | ');
+    if (isHeader) {
+        (0, LogService_1.log)(row).bold().white();
+    }
+    else {
+        (0, LogService_1.log)(row).white();
+    }
+}
+/**
+ * Prints a separator line
+ */
+function printSeparator(widths) {
+    const line = widths.map(w => '-'.repeat(w)).join('-|-');
+    (0, LogService_1.log)(line).white();
+}
+/**
+ * Shortens a string to show first N and last N characters with ellipsis
+ * @param str - The string to shorten
+ * @param maxLength - Maximum length before shortening (default: 14)
+ * @param prefixLength - Number of characters to show at start (default: 6)
+ * @param suffixLength - Number of characters to show at end (default: 6)
+ * @returns Shortened string or original if not long enough
+ */
+function shortenString(str, maxLength = 14, prefixLength = 6, suffixLength = 6) {
+    if (!str || str.length <= maxLength) {
+        return str;
+    }
+    return str.substring(0, prefixLength) + '…' + str.substring(str.length - suffixLength);
+}