@cvtoolman/huawei-lts-cli 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024
+
+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.

package/README.md

@@ -0,0 +1,193 @@
+# huawei-lts-cli
+
+Command-line tool for querying [Huawei Cloud Log Tank Service (LTS)](https://www.huaweicloud.com/intl/en-us/product/lts.html) logs from the terminal.
+
+[![npm version](https://img.shields.io/npm/v/huawei-lts-cli.svg)](https://www.npmjs.com/package/huawei-lts-cli)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE)
+
+## Features
+
+- 🔍 Query LTS logs by time range, keyword, and more
+- 📋 Multiple output formats: pretty (colored), JSON, table
+- 🚀 Auto-pagination — fetches all matching logs in one command
+- ⚙️ Persistent configuration — set credentials once, use forever
+- 🧙 Interactive setup wizard — `lts-cli init` guides you step by step
+- 🔐 Environment variable support — CI/CD friendly
+- 🐚 Shell completion for bash, zsh, and PowerShell
+
+## Quick Start
+
+### 1. Install
+
+```bash
+npm install -g huawei-lts-cli
+```
+
+### 2. Configure
+
+```bash
+lts-cli init
+```
+
+The wizard will ask for your AK, SK, Project ID, and Region. You can find your credentials in the Huawei Cloud console under **My Credentials > Access Keys**.
+
+Or set manually:
+
+```bash
+lts-cli config --set ak=YOUR_ACCESS_KEY
+lts-cli config --set sk=YOUR_SECRET_KEY
+lts-cli config --set projectId=YOUR_PROJECT_ID
+lts-cli config --set region=cn-south-1
+lts-cli config --set endpoint=https://lts.cn-south-1.myhuaweicloud.com
+lts-cli config --set groupId=YOUR_LOG_GROUP_ID      # optional — default
+lts-cli config --set streamId=YOUR_LOG_STREAM_ID    # optional — default
+```
+
+### 3. Query
+
+```bash
+# Basic query
+lts-cli query --st 2024-01-01T00:00:00Z --et 2024-01-02T00:00:00Z
+
+# With keyword filter
+lts-cli query --st 2024-01-01T00:00:00Z --et 2024-01-02T00:00:00Z -k "ERROR"
+
+# With explicit group/stream (overrides config defaults)
+lts-cli query -g <group-id> -s <stream-id> --st 2024-01-01T00:00:00Z --et 2024-01-02T00:00:00Z
+
+# JSON output (useful for piping to jq)
+lts-cli query --st 2024-01-01T00:00:00Z --et 2024-01-02T00:00:00Z -f json
+
+# Table output
+lts-cli query --st 2024-01-01T00:00:00Z --et 2024-01-02T00:00:00Z -f table
+```
+
+## Command Reference
+
+### `lts-cli query` — Query Logs
+
+```
+Usage: lts-cli query [options]
+
+Options:
+  -g, --group-id <groupId>      Log group ID (can be set in config)
+  -s, --stream-id <streamId>    Log stream ID (can be set in config)
+  --start-time, --st <time>     Start time in ISO 8601 (required)
+  --end-time, --et <time>       End time in ISO 8601 (required)
+  -k, --keyword <keyword>       Search keyword
+  -l, --limit <limit>           Results per page (default: 100)
+  -o, --offset <offset>         Pagination offset (default: 0)
+  -r, --reverse                 Show newest logs first
+  -f, --format <format>         Output format: pretty, json, table (default: pretty)
+  --no-paginate                 Disable auto-pagination (single page only)
+```
+
+### `lts-cli config` — Manage Configuration
+
+```
+Usage: lts-cli config [options]
+
+Options:
+  --set <key=value>             Set a configuration value
+  --get <key>                   Get a configuration value
+  --list                        List all configuration values
+  --unset <key>                 Remove a configuration value
+```
+
+### `lts-cli init` — Setup Wizard
+
+```
+Usage: lts-cli init
+
+Interactive wizard that guides you through setting up AK, SK, Project ID,
+region, endpoint, and optional default log group/stream.
+```
+
+### `lts-cli completion` — Shell Completion
+
+```
+Usage: lts-cli completion <shell>
+
+Generate completion script for bash, zsh, or powershell.
+
+Examples:
+  lts-cli completion bash >> ~/.bashrc
+  lts-cli completion zsh >> ~/.zshrc
+  lts-cli completion powershell >> $PROFILE
+```
+
+## Configuration
+
+Configuration is stored in `~/.lts-cli/config.json` (Linux/macOS) or `%USERPROFILE%\.lts-cli\config.json` (Windows).
+
+### Available Keys
+
+| Key | Required | Description |
+|---|---|---|
+| `ak` | Yes | Huawei Cloud Access Key |
+| `sk` | Yes | Huawei Cloud Secret Key |
+| `projectId` | Yes | Huawei Cloud Project ID |
+| `region` | No | Region (e.g. `cn-south-1`) |
+| `endpoint` | No | LTS service endpoint. Must include `https://` |
+| `groupId` | No | Default log group ID |
+| `streamId` | No | Default log stream ID |
+
+### Environment Variables
+
+All config keys can also be set via environment variables (useful for CI/CD):
+
+| Config Key | Environment Variable |
+|---|---|
+| `ak` | `LTS_AK` |
+| `sk` | `LTS_SK` |
+| `projectId` | `LTS_PROJECT_ID` |
+| `region` | `LTS_REGION` |
+| `endpoint` | `LTS_ENDPOINT` |
+| `groupId` | `LTS_GROUP_ID` |
+| `streamId` | `LTS_STREAM_ID` |
+
+Environment variables take precedence over config file values.
+
+## Supported Regions
+
+| Region ID | Region Name | Endpoint |
+|---|---|---|
+| `cn-north-1` | CN North-Beijing1 | `lts.cn-north-1.myhuaweicloud.com` |
+| `cn-north-4` | CN North-Beijing4 | `lts.cn-north-4.myhuaweicloud.com` |
+| `cn-east-2` | CN East-Shanghai2 | `lts.cn-east-2.myhuaweicloud.com` |
+| `cn-east-3` | CN East-Shanghai3 | `lts.cn-east-3.myhuaweicloud.com` |
+| `cn-south-1` | CN South-Guangzhou | `lts.cn-south-1.myhuaweicloud.com` |
+| `cn-south-4` | CN South-Shenzhen | `lts.cn-south-4.myhuaweicloud.com` |
+| `cn-southwest-2` | CN Southwest-Guiyang | `lts.cn-southwest-2.myhuaweicloud.com` |
+| `ap-southeast-1` | AP-Singapore | `lts.ap-southeast-1.myhuaweicloud.com` |
+| `ap-southeast-2` | AP-Bangkok | `lts.ap-southeast-2.myhuaweicloud.com` |
+| `ap-southeast-3` | AP-Jakarta | `lts.ap-southeast-3.myhuaweicloud.com` |
+| `af-south-1` | AF-Johannesburg | `lts.af-south-1.myhuaweicloud.com` |
+
+> For a complete list, see [Huawei Cloud LTS Endpoints](https://support.huaweicloud.com/intl/en-us/api-lts/lts_api_0011.html).
+
+## Development
+
+```bash
+# Clone and install
+git clone <repo-url>
+cd huawei-lts-cli
+npm install
+
+# Build
+npm run build
+
+# Run during development (no build step needed)
+npm run dev -- query --st 2024-01-01T00:00:00Z --et 2024-01-02T00:00:00Z
+
+# Run compiled version
+npm start -- query --st 2024-01-01T00:00:00Z --et 2024-01-02T00:00:00Z
+
+# Link for local testing
+npm link
+lts-cli query --st 2024-01-01T00:00:00Z --et 2024-01-02T00:00:00Z
+```
+
+## License
+
+[MIT](LICENSE)

package/dist/cli/commands/config.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createConfigCommand = createConfigCommand;
+const commander_1 = require("commander");
+const config_1 = require("../../config");
+function createConfigCommand() {
+    const cmd = new commander_1.Command('config');
+    cmd.description('Manage LTS CLI configuration')
+        .option('--set <key=value>', 'Set a configuration value')
+        .option('--get <key>', 'Get a configuration value')
+        .option('--list', 'List all configuration values')
+        .option('--unset <key>', 'Remove a configuration value')
+        .action((options) => {
+        if (options.set) {
+            const parts = options.set.split('=');
+            if (parts.length !== 2) {
+                console.error('Usage: config --set key=value');
+                process.exit(1);
+            }
+            const [key, value] = parts;
+            (0, config_1.setConfig)(key, value);
+            console.log(`Set ${key}=${value}`);
+        }
+        else if (options.get) {
+            const value = (0, config_1.getConfig)(options.get);
+            if (value !== undefined) {
+                console.log(value);
+            }
+            else {
+                console.error(`Config key '${options.get}' not found`);
+                process.exit(1);
+            }
+        }
+        else if (options.list) {
+            const config = (0, config_1.listConfig)();
+            const entries = Object.entries(config);
+            if (entries.length === 0) {
+                console.log('No configuration values set');
+            }
+            else {
+                for (const [key, value] of entries) {
+                    console.log(`${key}=${value}`);
+                }
+            }
+        }
+        else if (options.unset) {
+            (0, config_1.unsetConfig)(options.unset);
+            console.log(`Removed ${options.unset}`);
+        }
+        else {
+            console.error('Usage: lts-cli config [--set key=value | --get key | --list | --unset key]');
+            process.exit(1);
+        }
+    });
+    return cmd;
+}

package/dist/cli/commands/init.js

@@ -0,0 +1,156 @@
+"use strict";
+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.createInitCommand = createInitCommand;
+const commander_1 = require("commander");
+const readline = __importStar(require("readline"));
+const config_1 = require("../../config");
+function ask(rl, question) {
+    return new Promise((resolve) => {
+        rl.question(question, (answer) => resolve(answer.trim()));
+    });
+}
+const ENDPOINT_MAP = {
+    'cn-north-1': 'lts.cn-north-1.myhuaweicloud.com',
+    'cn-north-2': 'lts.cn-north-2.myhuaweicloud.com',
+    'cn-north-4': 'lts.cn-north-4.myhuaweicloud.com',
+    'cn-north-5': 'lts.cn-north-5.myhuaweicloud.com',
+    'cn-north-9': 'lts.cn-north-9.myhuaweicloud.com',
+    'cn-east-2': 'lts.cn-east-2.myhuaweicloud.com',
+    'cn-east-3': 'lts.cn-east-3.myhuaweicloud.com',
+    'cn-east-4': 'lts.cn-east-4.myhuaweicloud.com',
+    'cn-south-1': 'lts.cn-south-1.myhuaweicloud.com',
+    'cn-south-2': 'lts.cn-south-2.myhuaweicloud.com',
+    'cn-south-4': 'lts.cn-south-4.myhuaweicloud.com',
+    'cn-southwest-2': 'lts.cn-southwest-2.myhuaweicloud.com',
+    'ap-southeast-1': 'lts.ap-southeast-1.myhuaweicloud.com',
+    'ap-southeast-2': 'lts.ap-southeast-2.myhuaweicloud.com',
+    'ap-southeast-3': 'lts.ap-southeast-3.myhuaweicloud.com',
+    'af-south-1': 'lts.af-south-1.myhuaweicloud.com',
+    'la-south-2': 'lts.la-south-2.myhuaweicloud.com',
+    'sa-brazil-1': 'lts.sa-brazil-1.myhuaweicloud.com',
+    'na-mexico-1': 'lts.na-mexico-1.myhuaweicloud.com',
+    'la-north-2': 'lts.la-north-2.myhuaweicloud.com',
+};
+function createInitCommand() {
+    const cmd = new commander_1.Command('init');
+    cmd.description('Interactive setup wizard — configure credentials step by step')
+        .action(async () => {
+        const rl = readline.createInterface({
+            input: process.stdin,
+            output: process.stdout,
+        });
+        console.log('');
+        console.log('╔══════════════════════════════════════════════╗');
+        console.log('║   Huawei Cloud LTS CLI — Setup Wizard       ║');
+        console.log('╚══════════════════════════════════════════════╝');
+        console.log('');
+        console.log('This wizard will guide you through setting up your credentials.');
+        console.log('You can find AK/SK in the Huawei Cloud console under:');
+        console.log('  My Credentials > Access Keys');
+        console.log('');
+        console.log('Press Enter to skip any optional field.');
+        console.log('');
+        try {
+            // Required: AK
+            const ak = await ask(rl, 'Access Key (AK): ');
+            if (ak) {
+                (0, config_1.setConfig)('ak', ak);
+            }
+            // Required: SK
+            const sk = await ask(rl, 'Secret Key (SK): ');
+            if (sk) {
+                (0, config_1.setConfig)('sk', sk);
+            }
+            // Required: Project ID
+            const projectId = await ask(rl, 'Project ID: ');
+            if (projectId) {
+                (0, config_1.setConfig)('projectId', projectId);
+            }
+            // Required: Region
+            console.log('');
+            console.log('Common regions: cn-north-1, cn-north-4, cn-east-2, cn-east-3, cn-south-1');
+            const region = await ask(rl, 'Region (e.g. cn-south-1): ');
+            if (region) {
+                (0, config_1.setConfig)('region', region);
+                // Auto-suggest endpoint based on region
+                const autoEndpoint = ENDPOINT_MAP[region];
+                if (autoEndpoint) {
+                    const useDefault = await ask(rl, `Endpoint [https://${autoEndpoint}]: `);
+                    if (!useDefault) {
+                        (0, config_1.setConfig)('endpoint', `https://${autoEndpoint}`);
+                    }
+                    else {
+                        const customEndpoint = useDefault.startsWith('http') ? useDefault : `https://${useDefault}`;
+                        (0, config_1.setConfig)('endpoint', customEndpoint);
+                    }
+                }
+                else {
+                    const endpoint = await ask(rl, 'Endpoint (e.g. https://lts.cn-south-1.myhuaweicloud.com): ');
+                    if (endpoint) {
+                        const normalized = endpoint.startsWith('http') ? endpoint : `https://${endpoint}`;
+                        (0, config_1.setConfig)('endpoint', normalized);
+                    }
+                }
+            }
+            // Optional: default groupId & streamId
+            console.log('');
+            console.log('Optional — set default log group & stream so you can query without -g / -s:');
+            const groupId = await ask(rl, 'Default Log Group ID (optional): ');
+            if (groupId) {
+                (0, config_1.setConfig)('groupId', groupId);
+            }
+            const streamId = await ask(rl, 'Default Log Stream ID (optional): ');
+            if (streamId) {
+                (0, config_1.setConfig)('streamId', streamId);
+            }
+            console.log('');
+            console.log('✅ Configuration saved!');
+            console.log('');
+            console.log('Try it out:');
+            if (groupId && streamId) {
+                console.log('  lts-cli query --start-time 2024-01-01T00:00:00Z --end-time 2024-01-02T00:00:00Z');
+            }
+            else {
+                console.log('  lts-cli query -g <group-id> -s <stream-id> --start-time 2024-01-01T00:00:00Z --end-time 2024-01-02T00:00:00Z');
+            }
+            console.log('');
+        }
+        finally {
+            rl.close();
+        }
+    });
+    return cmd;
+}

package/dist/cli/commands/query.js

@@ -0,0 +1,126 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createQueryCommand = createQueryCommand;
+const commander_1 = require("commander");
+const client_1 = require("../../lts/client");
+const config_1 = require("../../config");
+const output_1 = require("../../output");
+function createQueryCommand() {
+    const cmd = new commander_1.Command('query');
+    cmd.description('Query LTS logs')
+        .option('-g, --group-id <groupId>', 'Log group ID (can also be set via config)')
+        .option('-s, --stream-id <streamId>', 'Log stream ID (can also be set via config)')
+        .requiredOption('--start-time <startTime>', 'Start time (ISO 8601, e.g. 2024-01-01T00:00:00Z)')
+        .requiredOption('--end-time <endTime>', 'End time (ISO 8601, e.g. 2024-01-02T00:00:00Z)')
+        .option('--st <startTime>', 'Alias for --start-time')
+        .option('--et <endTime>', 'Alias for --end-time')
+        .option('-k, --keyword <keyword>', 'Search keyword')
+        .option('-l, --limit <limit>', 'Limit number of results', parseInt, 100)
+        .option('-o, --offset <offset>', 'Offset for pagination', parseInt, 0)
+        .option('-r, --reverse', 'Reverse order (newest first)')
+        .option('-f, --format <format>', 'Output format: json, table, pretty', 'pretty')
+        .option('--no-paginate', 'Disable auto-pagination (single page only)')
+        .action(async (options) => {
+        const config = (0, config_1.loadConfig)();
+        // Validate required credentials
+        if (!config.ak || !config.sk || !config.projectId) {
+            console.error('Error: Missing required credentials. Please configure them first:');
+            console.error('');
+            console.error('  Quick setup (recommended):');
+            console.error('    lts-cli init');
+            console.error('');
+            console.error('  Or set individually:');
+            console.error('    lts-cli config --set ak=<your-access-key>');
+            console.error('    lts-cli config --set sk=<your-secret-key>');
+            console.error('    lts-cli config --set projectId=<your-project-id>');
+            process.exit(1);
+        }
+        // groupId & streamId: CLI args take priority over config
+        const groupId = options.groupId || config.groupId;
+        const streamId = options.streamId || config.streamId;
+        if (!groupId || !streamId) {
+            console.error('Error: groupId and streamId are required. Provide them via:');
+            console.error('  lts-cli config --set groupId=<your-group-id>');
+            console.error('  lts-cli config --set streamId=<your-stream-id>');
+            console.error('  or use -g <groupId> -s <streamId> flags');
+            process.exit(1);
+        }
+        // --st / --et are aliases for --start-time / --end-time
+        const startTime = options.startTime || options.st;
+        const endTime = options.endTime || options.et;
+        if (!startTime || !endTime) {
+            console.error('Error: --start-time and --end-time are required.');
+            process.exit(1);
+        }
+        const format = ['json', 'table', 'pretty'].includes(options.format)
+            ? options.format
+            : 'pretty';
+        const client = new client_1.LTSClient(config);
+        const params = {
+            groupId,
+            streamId,
+            startTime,
+            endTime,
+            keyword: options.keyword,
+            limit: options.limit,
+            offset: options.offset,
+            reverse: options.reverse,
+        };
+        try {
+            if (options.paginate) {
+                const result = await client.queryLogs(params);
+                console.log((0, output_1.formatOutput)(result, format));
+            }
+            else {
+                // Auto-pagination: fetch all logs
+                const allLogs = [];
+                let offset = options.offset || 0;
+                const limit = options.limit || 100;
+                let hasMore = true;
+                while (hasMore) {
+                    const pageParams = {
+                        ...params,
+                        offset,
+                        limit,
+                    };
+                    const result = await client.queryLogs(pageParams);
+                    allLogs.push(...result.logs);
+                    if (result.logs.length < limit) {
+                        hasMore = false;
+                    }
+                    else {
+                        offset += limit;
+                    }
+                }
+                const result = {
+                    logs: allLogs,
+                    total: allLogs.length,
+                };
+                console.log((0, output_1.formatOutput)(result, format));
+            }
+        }
+        catch (error) {
+            const msg = error.message || String(error);
+            // Friendlier error messages for common issues
+            if (msg.includes('Invalid URL')) {
+                console.error('Error: Invalid endpoint URL. Make sure it starts with https://');
+                console.error('  Example: https://lts.cn-south-1.myhuaweicloud.com');
+            }
+            else if (msg.includes('Authentication failed') || msg.includes('401') || msg.includes('403')) {
+                console.error('Error: Authentication failed. Please check your AK/SK credentials:');
+                console.error('  lts-cli config --list');
+            }
+            else if (msg.includes('ENOTFOUND') || msg.includes('ECONNREFUSED')) {
+                console.error('Error: Cannot reach the LTS service. Please check your endpoint and network connection.');
+            }
+            else if (msg.includes('Request failed after retries')) {
+                console.error('Error: The service is temporarily unavailable. Please try again later.');
+            }
+            else {
+                console.error('Error querying logs:', msg);
+            }
+            process.exit(1);
+        }
+    });
+    return cmd;
+}

package/dist/cli/index.js

@@ -0,0 +1,168 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const commander_1 = require("commander");
+const query_1 = require("./commands/query");
+const config_1 = require("./commands/config");
+const init_1 = require("./commands/init");
+const program = new commander_1.Command();
+program
+    .name('lts-cli')
+    .description('Huawei Cloud LTS (Log Tank Service) CLI — query logs from the terminal')
+    .version('1.0.0')
+    .addHelpText('after', `
+Examples:
+  $ lts-cli init                     Setup credentials interactively
+  $ lts-cli config --list            Show current configuration
+  $ lts-cli query --st 2024-01-01T00:00:00Z --et 2024-01-02T00:00:00Z
+
+Environment variables:
+  LTS_AK           Access Key
+  LTS_SK           Secret Key
+  LTS_PROJECT_ID   Project ID
+  LTS_REGION       Region
+  LTS_ENDPOINT     Service endpoint
+  LTS_GROUP_ID     Default log group ID
+  LTS_STREAM_ID    Default log stream ID
+`);
+program.addCommand((0, init_1.createInitCommand)());
+program.addCommand((0, query_1.createQueryCommand)());
+program.addCommand((0, config_1.createConfigCommand)());
+// Shell completion support
+const completionCmd = new commander_1.Command('completion')
+    .description('Generate shell completion script')
+    .argument('<shell>', 'Shell type: bash, zsh, or powershell')
+    .action((shell) => {
+    switch (shell) {
+        case 'bash':
+            console.log(`# lts-cli bash completion — add to ~/.bashrc or ~/.bash_profile
+_lts_cli_completion() {
+  local words cword
+  _get_comp_words_by_ref -n : words cword
+  local cur="\${words[cword]}"
+
+  if (( cword == 1 )); then
+    COMPREPLY=( $(compgen -W "query config init completion" -- "\$cur") )
+    return
+  fi
+
+  local cmd="\${words[1]}"
+  case "\$cmd" in
+    query)
+      case "\$prev" in
+        -g|--group-id|-s|--stream-id|-k|--keyword|-l|--limit|-o|--offset|-f|--format)
+          COMPREPLY=()
+          return
+          ;;
+        *)
+          COMPREPLY=( $(compgen -W "-g --group-id -s --stream-id --start-time --end-time --st --et -k --keyword -l --limit -o --offset -r --reverse -f --format --no-paginate" -- "\$cur") )
+          return
+          ;;
+      esac
+      ;;
+    config)
+      COMPREPLY=( $(compgen -W "--set --get --list --unset" -- "\$cur") )
+      return
+      ;;
+    completion)
+      COMPREPLY=( $(compgen -W "bash zsh powershell" -- "\$cur") )
+      return
+      ;;
+    *)
+      COMPREPLY=()
+      return
+      ;;
+  esac
+}
+complete -F _lts_cli_completion lts-cli`);
+            break;
+        case 'zsh':
+            console.log(`# lts-cli zsh completion — add to ~/.zshrc
+#compdef lts-cli
+_lts_cli() {
+  local -a commands
+  commands=(
+    'query:Query LTS logs'
+    'config:Manage configuration'
+    'init:Interactive setup wizard'
+    'completion:Generate shell completion script'
+  )
+
+  local context state state_descr line
+  typeset -A opt_args
+
+  _arguments -C \\
+    '1: :->command' \\
+    '*:: :->args'
+
+  case "\$state" in
+    command)
+      _describe 'command' commands
+      ;;
+    args)
+      case "\$line[1]" in
+        query)
+          _arguments \\
+            '-g[Log group ID]:group ID:' \\
+            '-s[Log stream ID]:stream ID:' \\
+            '--start-time[Start time (ISO 8601)]:time:' \\
+            '--end-time[End time (ISO 8601)]:time:' \\
+            '--st[Alias for --start-time]:time:' \\
+            '--et[Alias for --end-time]:time:' \\
+            '-k[Search keyword]:keyword:' \\
+            '-l[Limit]:number:' \\
+            '-o[Offset]:number:' \\
+            '-r[Reverse order]' \\
+            '-f[Output format]:format:(json table pretty)' \\
+            '--no-paginate[Disable pagination]'
+          ;;
+        config)
+          _arguments \\
+            '--set[Set config value]:key=value:' \\
+            '--get[Get config value]:key:' \\
+            '--list[List all config]' \\
+            '--unset[Remove config value]:key:'
+          ;;
+        completion)
+          _values 'shell' bash zsh powershell
+          ;;
+      esac
+      ;;
+  esac
+}
+compdef _lts_cli lts-cli`);
+            break;
+        case 'powershell':
+            console.log(`# lts-cli PowerShell completion — add to $PROFILE
+Register-ArgumentCompleter -CommandName lts-cli -ScriptBlock {
+  param(\$wordToComplete, \$commandAst, \$cursorPosition)
+
+  \$commands = @('query', 'config', 'init', 'completion')
+
+  \$args = \$commandAst.ToString() -split '\\s+'
+  if (\$args.Count -le 1) {
+    return \$commands | Where-Object { \$_ -like "\$wordToComplete*" }
+  }
+
+  switch (\$args[1]) {
+    'query' {
+      \$opts = @('-g', '-s', '--start-time', '--end-time', '--st', '--et', '-k', '-l', '-o', '-r', '-f', '--no-paginate')
+      return \$opts | Where-Object { \$_ -like "\$wordToComplete*" }
+    }
+    'config' {
+      \$opts = @('--set', '--get', '--list', '--unset')
+      return \$opts | Where-Object { \$_ -like "\$wordToComplete*" }
+    }
+    'completion' {
+      return @('bash', 'zsh', 'powershell') | Where-Object { \$_ -like "\$wordToComplete*" }
+    }
+  }
+}`);
+            break;
+        default:
+            console.error(`Unknown shell: ${shell}. Supported: bash, zsh, powershell`);
+            process.exit(1);
+    }
+});
+program.addCommand(completionCmd);
+program.parse();

package/dist/cli/options.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.queryOptions = void 0;
+exports.queryOptions = {
+    groupId: { short: '-g', long: '--group-id <groupId>', description: 'Log group ID', required: true },
+    streamId: { short: '-s', long: '--stream-id <streamId>', description: 'Log stream ID', required: true },
+    startTime: { short: '--start-time <startTime>', long: '--start-time <startTime>', description: 'Start time (ISO 8601)', required: true },
+    endTime: { short: '--end-time <endTime>', long: '--end-time <endTime>', description: 'End time (ISO 8601)', required: true },
+    keyword: { short: '-k', long: '--keyword <keyword>', description: 'Search keyword', required: false },
+    limit: { short: '-l', long: '--limit <limit>', description: 'Limit number of results', required: false },
+    offset: { short: '-o', long: '--offset <offset>', description: 'Offset for pagination', required: false },
+    reverse: { short: '-r', long: '--reverse', description: 'Reverse order', required: false },
+    format: { short: '-f', long: '--format <format>', description: 'Output format: json, table, pretty', required: false },
+    noPaginate: { short: '', long: '--no-paginate', description: 'Disable pagination', required: false },
+};

package/dist/config/index.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadConfig = loadConfig;
+exports.getConfig = getConfig;
+exports.setConfig = setConfig;
+exports.listConfig = listConfig;
+exports.unsetConfig = unsetConfig;
+const store_1 = require("./store");
+const ENV_MAP = {
+    ak: 'LTS_AK',
+    sk: 'LTS_SK',
+    projectId: 'LTS_PROJECT_ID',
+    region: 'LTS_REGION',
+    endpoint: 'LTS_ENDPOINT',
+    groupId: 'LTS_GROUP_ID',
+    streamId: 'LTS_STREAM_ID',
+};
+function getEnvValue(key) {
+    const envKey = ENV_MAP[key];
+    if (envKey) {
+        return process.env[envKey];
+    }
+    return undefined;
+}
+function loadConfig() {
+    const config = (0, store_1.readConfigFile)();
+    return {
+        ak: getEnvValue('ak') ?? config.ak ?? '',
+        sk: getEnvValue('sk') ?? config.sk ?? '',
+        projectId: getEnvValue('projectId') ?? config.projectId ?? '',
+        region: getEnvValue('region') ?? config.region ?? '',
+        endpoint: getEnvValue('endpoint') ?? config.endpoint ?? '',
+        groupId: getEnvValue('groupId') ?? config.groupId,
+        streamId: getEnvValue('streamId') ?? config.streamId,
+    };
+}
+function getConfig(key) {
+    const envValue = getEnvValue(key);
+    if (envValue !== undefined) {
+        return envValue;
+    }
+    const config = (0, store_1.readConfigFile)();
+    return config[key];
+}
+function setConfig(key, value) {
+    const config = (0, store_1.readConfigFile)();
+    config[key] = value;
+    (0, store_1.writeConfigFile)(config);
+}
+function listConfig() {
+    return (0, store_1.readConfigFile)();
+}
+function unsetConfig(key) {
+    const config = (0, store_1.readConfigFile)();
+    delete config[key];
+    (0, store_1.writeConfigFile)(config);
+}

package/dist/config/store.js

@@ -0,0 +1,67 @@
+"use strict";
+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.readConfigFile = readConfigFile;
+exports.writeConfigFile = writeConfigFile;
+exports.getConfigFilePath = getConfigFilePath;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+const CONFIG_DIR = path.join(os.homedir(), '.lts-cli');
+const CONFIG_FILE = path.join(CONFIG_DIR, 'config.json');
+function ensureDir(dir) {
+    if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+    }
+}
+function readConfigFile() {
+    try {
+        if (!fs.existsSync(CONFIG_FILE)) {
+            return {};
+        }
+        const data = fs.readFileSync(CONFIG_FILE, 'utf-8');
+        return JSON.parse(data);
+    }
+    catch {
+        return {};
+    }
+}
+function writeConfigFile(config) {
+    ensureDir(CONFIG_DIR);
+    fs.writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2), 'utf-8');
+}
+function getConfigFilePath() {
+    return CONFIG_FILE;
+}

package/dist/lts/client.js

@@ -0,0 +1,88 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LTSClient = void 0;
+const LtsClient_1 = require("@huaweicloud/huaweicloud-sdk-lts/v2/LtsClient");
+const ClientBuilder_1 = require("@huaweicloud/huaweicloud-sdk-core/ClientBuilder");
+const BasicCredentials_1 = require("@huaweicloud/huaweicloud-sdk-core/auth/BasicCredentials");
+const region_1 = require("@huaweicloud/huaweicloud-sdk-core/region/region");
+const ListLogsRequest_1 = require("@huaweicloud/huaweicloud-sdk-lts/v2/model/ListLogsRequest");
+const QueryLtsLogParams_1 = require("@huaweicloud/huaweicloud-sdk-lts/v2/model/QueryLtsLogParams");
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+class LTSClient {
+    client;
+    config;
+    constructor(config) {
+        this.config = config;
+        const credentials = new BasicCredentials_1.BasicCredentials()
+            .withAk(config.ak)
+            .withSk(config.sk)
+            .withProjectId(config.projectId);
+        const builder = new ClientBuilder_1.ClientBuilder((hcClient) => new LtsClient_1.LtsClient(hcClient));
+        if (config.endpoint) {
+            builder.withEndpoint(config.endpoint);
+        }
+        if (config.region) {
+            builder.withRegion(new region_1.Region(config.region, config.endpoint || ''));
+        }
+        builder.withCredential(credentials);
+        this.client = builder.build();
+    }
+    async queryLogs(params) {
+        const queryParams = new QueryLtsLogParams_1.QueryLtsLogParams()
+            .withStartTime(new Date(params.startTime).getTime().toString())
+            .withEndTime(new Date(params.endTime).getTime().toString())
+            .withLimit(params.limit ?? 100);
+        if (params.keyword) {
+            queryParams.withKeywords(params.keyword);
+        }
+        if (params.reverse !== undefined) {
+            queryParams.withIsDesc(params.reverse);
+        }
+        const request = new ListLogsRequest_1.ListLogsRequest(params.groupId, params.streamId, 'application/json')
+            .withBody(queryParams);
+        const response = await this.retryRequest(() => this.client.listLogs(request));
+        const logs = (response.logs || []).map((log) => ({
+            logTime: log.lineNum ?? '',
+            content: log.content ?? '',
+            labels: log.labels ?? {},
+        }));
+        return {
+            logs,
+            total: response.count ?? logs.length,
+        };
+    }
+    async retryRequest(fn, maxRetries = 3) {
+        let lastError;
+        for (let attempt = 0; attempt <= maxRetries; attempt++) {
+            try {
+                return await fn();
+            }
+            catch (error) {
+                lastError = error;
+                const statusCode = error.statusCode || error.httpStatusCode || 0;
+                if (statusCode === 401 || statusCode === 403) {
+                    throw new Error(`Authentication failed (HTTP ${statusCode}). Please check your AK/SK credentials.`);
+                }
+                if (statusCode === 429) {
+                    if (attempt < maxRetries) {
+                        const delay = Math.pow(2, attempt) * 1000;
+                        await sleep(delay);
+                        continue;
+                    }
+                }
+                if (statusCode >= 500) {
+                    if (attempt < maxRetries) {
+                        const delay = Math.pow(2, attempt) * 1000;
+                        await sleep(delay);
+                        continue;
+                    }
+                }
+                throw error;
+            }
+        }
+        throw lastError ?? new Error('Request failed after retries');
+    }
+}
+exports.LTSClient = LTSClient;

package/dist/lts/index.js

@@ -0,0 +1,20 @@
+"use strict";
+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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LTSClient = void 0;
+var client_1 = require("./client");
+Object.defineProperty(exports, "LTSClient", { enumerable: true, get: function () { return client_1.LTSClient; } });
+__exportStar(require("./types"), exports);

package/dist/lts/types.js

@@ -0,0 +1,5 @@
+"use strict";
+/**
+ * 华为云LTS API 请求和响应类型定义
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/output/index.js

@@ -0,0 +1,41 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatOutput = formatOutput;
+const chalk_1 = __importDefault(require("chalk"));
+const json_1 = require("./json");
+const table_1 = require("./table");
+function formatOutput(data, format) {
+    switch (format) {
+        case 'json':
+            return (0, json_1.formatJson)(data);
+        case 'table':
+            return (0, table_1.formatTable)(data);
+        case 'pretty':
+            return formatPretty(data);
+        default:
+            return (0, json_1.formatJson)(data);
+    }
+}
+function formatPretty(data) {
+    if (data.logs.length === 0) {
+        return chalk_1.default.yellow('No logs found.');
+    }
+    const lines = [];
+    lines.push(chalk_1.default.bold.green(`Found ${data.total} logs:`));
+    lines.push('');
+    for (const log of data.logs) {
+        lines.push(chalk_1.default.cyan(`[${log.logTime}]`));
+        lines.push(chalk_1.default.white(log.content));
+        if (Object.keys(log.labels).length > 0) {
+            const labels = Object.entries(log.labels)
+                .map(([k, v]) => `${k}=${v}`)
+                .join(', ');
+            lines.push(chalk_1.default.gray(`  labels: ${labels}`));
+        }
+        lines.push('');
+    }
+    return lines.join('\n');
+}

package/dist/output/json.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatJson = formatJson;
+function formatJson(data) {
+    return JSON.stringify(data, null, 2);
+}

package/dist/output/table.js

@@ -0,0 +1,24 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatTable = formatTable;
+const cli_table3_1 = __importDefault(require("cli-table3"));
+function formatTable(data) {
+    if (data.logs.length === 0) {
+        return 'No logs found.';
+    }
+    const table = new cli_table3_1.default({
+        head: ['Time', 'Content', 'Labels'],
+        colWidths: [25, 50, 30],
+        wordWrap: true,
+    });
+    for (const log of data.logs) {
+        const labelsStr = Object.entries(log.labels)
+            .map(([k, v]) => `${k}=${v}`)
+            .join(', ');
+        table.push([log.logTime, log.content, labelsStr]);
+    }
+    return table.toString();
+}

package/dist/types/index.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -0,0 +1,55 @@
+{
+  "name": "@cvtoolman/huawei-lts-cli",
+  "version": "1.0.0",
+  "description": "Command-line tool for querying Huawei Cloud Log Tank Service (LTS) logs",
+  "main": "dist/cli/index.js",
+  "bin": {
+    "lts-cli": "./dist/cli/index.js"
+  },
+  "files": [
+    "dist/"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsx src/cli/index.ts",
+    "start": "node dist/cli/index.js",
+    "clean": "node -e \"require('fs').rmSync('dist', {recursive: true, force: true})\"",
+    "prepublishOnly": "npm run clean && npm run build"
+  },
+  "keywords": [
+    "huawei-cloud",
+    "huawei",
+    "lts",
+    "log-tank-service",
+    "logs",
+    "cli",
+    "log-query",
+    "cloud-logging"
+  ],
+  "author": "cvtoolman",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/jcxy/huawei-lts-cli.git"
+  },
+  "bugs": {
+    "url": "https://github.com/jcxy/huawei-lts-cli/issues"
+  },
+  "homepage": "https://github.com/jcxy/huawei-lts-cli#readme",
+  "engines": {
+    "node": ">=16.0.0"
+  },
+  "dependencies": {
+    "@huaweicloud/huaweicloud-sdk-core": "latest",
+    "@huaweicloud/huaweicloud-sdk-lts": "latest",
+    "chalk": "^4.1.2",
+    "cli-table3": "latest",
+    "commander": "latest",
+    "uuid": "^9.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "latest",
+    "tsx": "latest",
+    "typescript": "latest"
+  }
+}