skill-os 0.1.0 → 0.1.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "skill-os",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "Skill-OS CLI for managing OS skills",
   "main": "skill-os.js",
   "bin": {
@@ -27,4 +27,4 @@
   "engines": {
     "node": ">=14.0.0"
   }
-}
+}

package/skill-os.js

@@ -61,20 +61,78 @@ function loadIndex() {
     return JSON.parse(raw);
 }
 
+// ----------------------------------------------------------------------
+// API Configuration
+// ----------------------------------------------------------------------
+
+const DEFAULT_API_BASE = "https://oscopilot.alibaba-inc.com/skills/api/v1";
+
+function getApiBase(options) {
+    let url = options?.url || process.env.SKILL_OS_REGISTRY || DEFAULT_API_BASE;
+    return url.replace(/\/$/, "");
+}
+
+async function fetchFromApi(endpoint, options = {}) {
+    // Only require node-fetch dynamically when needed
+    let fetchFn = require('node-fetch');
+    if (typeof fetchFn !== 'function' && fetchFn.default) {
+        fetchFn = fetchFn.default;
+    }
+
+    let baseUrl;
+    // Extract url option if passed inside options object
+    if (options && options.url) {
+        baseUrl = getApiBase({ url: options.url });
+        delete options.url;
+    } else {
+        baseUrl = getApiBase({});
+    }
+
+    const url = `${baseUrl}${endpoint}`;
+
+    try {
+        const response = await fetchFn(url, options);
+        if (!response.ok) {
+            throw new Error(`HTTP Error: ${response.status} ${response.statusText}`);
+        }
+        return await response.json();
+    } catch (error) {
+        console.error(chalk.red(`\n✗ Error connecting to remote registry at ${url}`));
+        console.error(chalk.dim(error.message));
+        process.exit(1);
+    }
+}
+
 // ----------------------------------------------------------------------
 // Commmands Implementations
 // ----------------------------------------------------------------------
 
-function cmdList() {
-    const index = loadIndex();
-    const skills = index.skills || {};
+async function cmdList(options) {
+    console.log(`\n${chalk.dim('Fetching skills from external registry...')}`);
+    const index = await fetchFromApi('/skills', options);
+
+    // API returns an array of skills, or an object with a data/skills array property
+    let skillsList = [];
+    if (Array.isArray(index)) {
+        skillsList = index;
+    } else if (Array.isArray(index.data)) {
+        skillsList = index.data;
+    } else if (Array.isArray(index.skills)) {
+        skillsList = index.skills;
+    } else if (typeof index === 'object') {
+        // Fallback if it is an object map
+        skillsList = Object.entries(index.skills || index).map(([k, v]) => ({ path: k, ...v }));
+    }
 
     console.log(`\n${chalk.bold('📚 Skill-OS Available Skills')}`);
     console.log(`${chalk.dim('─'.repeat(60))}\n`);
 
     const layers = {};
-    for (const [skillPath, info] of Object.entries(skills)) {
-        const layer = skillPath.split('/')[0];
+    for (const info of skillsList) {
+        // Fallback path resolution. If the API returns 'path', use it. Otherwise, construct it or use name.
+        const skillPath = info.path || (info.layer ? `${info.layer}/${info.category || 'misc'}/${info.name}` : info.name || 'unknown');
+        const layer = info.layer || (skillPath.includes('/') ? skillPath.split('/')[0] : 'misc');
+
         if (!layers[layer]) layers[layer] = [];
         layers[layer].push({ path: skillPath, info });
     }
@@ -99,16 +157,22 @@ function cmdList() {
     }
 }
 
-function cmdSearch(query) {
-    const lowercaseQuery = query.toLowerCase();
-    const index = loadIndex();
-    const skills = index.skills || {};
+async function cmdSearch(query, options) {
+    console.log(`\n${chalk.dim(`Searching remote registry for '${query}'...`)}`);
+
+    // API Endpoint: /api/v1/search?q={{skill.name}}
+    const encodedQuery = encodeURIComponent(query);
+    const response = await fetchFromApi(`/search?q=${encodedQuery}`, options);
 
-    const matches = [];
-    for (const [skillPath, info] of Object.entries(skills)) {
-        const searchable = `${skillPath} ${info.name || ''} ${info.description || ''}`.toLowerCase();
-        if (searchable.includes(lowercaseQuery)) {
-            matches.push({ path: skillPath, info });
+    // The API likely returns an array or an object map. Normalize to an array of objects.
+    let matches = [];
+    const rawResults = response.data || response.results || response.skills || response || [];
+
+    if (Array.isArray(rawResults)) {
+        matches = rawResults;
+    } else if (typeof rawResults === 'object') {
+        for (const [skillPath, info] of Object.entries(rawResults)) {
+            matches.push({ path: skillPath, ...info });
         }
     }
 
@@ -120,50 +184,45 @@ function cmdSearch(query) {
     console.log(`\n${chalk.bold(`🔍 Search Results for '${query}'`)}`);
     console.log(`${chalk.dim(`Found ${matches.length} skill(s)`)}\n`);
 
-    for (const { path: skillPath, info } of matches) {
+    for (const info of matches) {
+        const skillPath = info.path || info.name; // Fallback to name if path isn't provided separately
         const icon = formatLayerIcon(skillPath);
         const status = formatStatus(info.status);
-        const name = info.name || skillPath;
         const version = info.version || '?';
         const desc = info.description || '';
 
         console.log(`${icon} ${chalk.cyan(skillPath)}`);
-        console.log(`   ${chalk.bold(name)} (${version}) [${status}]`);
+        console.log(`   ${chalk.bold(info.name)} (${version}) [${status}]`);
         console.log(`   ${desc}\n`);
     }
 }
 
-function cmdInfo(skillPath) {
-    const index = loadIndex();
-    const skills = index.skills || {};
+async function cmdInfo(skillPath, options) {
+    console.log(`\n${chalk.dim(`Fetching details from remote registry...`)}`);
 
-    if (!skills[skillPath]) {
-        console.error(chalk.red(`Error: Skill '${skillPath}' not found`));
-        console.log(chalk.dim("Use 'skill-os list' to see available skills"));
-        process.exit(1);
-    }
+    // API Endpoint: /api/v1/skills/{{skill.path}}/content
+    const info = await fetchFromApi(`/skills/${skillPath}/content`, options);
 
-    const info = skills[skillPath];
     const icon = formatLayerIcon(skillPath);
-    const status = formatStatus(info.status);
+    const status = formatStatus(info.status || info.metadata?.status);
+    const metadata = info.metadata || info || {}; // Handle if nested or flat
 
-    console.log(`\n${icon} ${chalk.bold(info.name || skillPath)}`);
+    console.log(`\n${icon} ${chalk.bold(metadata.name || skillPath)}`);
     console.log(chalk.dim('─'.repeat(40)));
     console.log(`  Path:         ${chalk.cyan(skillPath)}`);
-    console.log(`  Version:      ${info.version || 'unknown'}`);
+    console.log(`  Version:      ${metadata.version || 'unknown'}`);
     console.log(`  Status:       ${status}`);
-    console.log(`  Description:  ${info.description || 'No description'}`);
+    console.log(`  Description:  ${metadata.description || 'No description'}`);
 
-    if (info.dependencies && info.dependencies.length > 0) {
-        console.log(`  Dependencies: ${info.dependencies.join(', ')}`);
+    if (metadata.dependencies && metadata.dependencies.length > 0) {
+        console.log(`  Dependencies: ${metadata.dependencies.join(', ')}`);
     } else {
         console.log(`  Dependencies: ${chalk.dim('None')}`);
     }
 
-    const repoRoot = getRepoRoot();
-    const skillMdPath = path.join(repoRoot, skillPath, 'SKILL.md');
-    if (fs.existsSync(skillMdPath)) {
-        console.log(`\n  ${chalk.dim(`SKILL.md: ${skillMdPath}`)}`);
+    // If the API returns the actual markdown content, display a snippet or note
+    if (info.content || info.markdown) {
+        console.log(`\n  ${chalk.dim('[Remote Document Content Available]')}`);
     }
     console.log();
 }
@@ -329,28 +388,38 @@ TODO: Add skill documentation here.
     console.log(`  3. Sync: ${chalk.dim(`skill-os sync ${skillPath}`)}`);
 }
 
-function cmdDownload(skillName, options) {
-    const targetDir = options.platform
-        ? path.join(process.cwd(), `.${options.platform}`, "skills")
-        : process.cwd();
+function cmdDownload(skillPath, options) {
+    // 1. Determine target directory
+    const homeDir = require('os').homedir();
+    let rawTarget = process.cwd();
 
-    fs.mkdirSync(targetDir, { recursive: true });
+    if (options.target) {
+        rawTarget = options.target.startsWith('~/') ?
+            path.join(homeDir, options.target.slice(2)) :
+            path.resolve(options.target);
+    } else if (options.platform) {
+        rawTarget = path.join(process.cwd(), `.${options.platform}`, "skills");
+    }
 
-    let serverUrl = options.url || process.env.SKILL_OS_REGISTRY || "https://example.com/skills";
-    serverUrl = serverUrl.replace(/\/$/, ""); // Trim trailing slash
+    const targetDir = path.resolve(rawTarget);
+    fs.mkdirSync(targetDir, { recursive: true });
 
-    const downloadUrl = `${serverUrl}/${skillName}.tar.gz`;
+    // 2. Determine API source
+    const serverUrl = getApiBase(options);
+    const downloadUrl = `${serverUrl}/skills/${skillPath}/download`;
 
-    console.log(`\n${chalk.bold(`📥 Downloading ${skillName}...`)}`);
+    console.log(`\n${chalk.bold(`📥 Downloading and extracting ${skillPath}...`)}`);
     console.log(`  Source: ${chalk.cyan(downloadUrl)}`);
     console.log(`  Target: ${chalk.cyan(targetDir)}\n`);
 
     try {
-        // Using curl synchronously for simplicity, similar to the bash version
-        execSync(`curl -L -O ${downloadUrl}`, { cwd: targetDir, stdio: 'inherit' });
-        console.log(`\n${chalk.green(`✓ Successfully downloaded ${skillName} to ${targetDir}`)}`);
+        // Stream the curl output directly into tar to extract the directory structure
+        // -s: silent curl, -L: follow redirects
+        // tar -xzf -: extract gzipped tar from stdin
+        execSync(`curl -s -L "${downloadUrl}" | tar -xzf -`, { cwd: targetDir, stdio: 'inherit' });
+        console.log(`\n${chalk.green(`✓ Successfully downloaded and extracted to: ${targetDir}`)}`);
     } catch (e) {
-        console.error(`\n${chalk.red(`✗ Failed to download ${skillName}: command returned error code ${e.status}`)}`);
+        console.error(`\n${chalk.red(`✗ Failed to download. The API may have returned an error instead of a tarball.`)}`);
         process.exit(1);
     }
 }
@@ -771,37 +840,41 @@ program
     .description('Skill-OS CLI');
 
 program.command('list')
-    .description('List all available skills')
+    .description('List all available skills from the remote registry')
+    .option('--url <url>', 'Override the base URL for the registry', DEFAULT_API_BASE)
     .action(cmdList);
 
 program.command('search')
-    .description('Search for skills')
+    .description('Search for skills in the remote registry')
     .argument('<query>', 'Search query')
+    .option('--url <url>', 'Override the base URL for the registry', DEFAULT_API_BASE)
     .action(cmdSearch);
 
 program.command('info')
-    .description('Show skill details')
-    .argument('<path>', 'Skill path (e.g., package/package/rpm_search)')
+    .description('Show skill details from the remote registry')
+    .argument('<path>', 'Skill path (e.g., package/rpm_search)')
+    .option('--url <url>', 'Override the base URL for the registry', DEFAULT_API_BASE)
     .action(cmdInfo);
 
 program.command('install')
-    .description('Install a skill to target directory')
+    .description('Install a skill to target directory locally from repository')
     .argument('<path>', 'Skill path to install')
     .option('-t, --target <dir>', 'Target directory', '~/.skills')
     .option('-f, --force', 'Force overwrite if exists', false)
     .action(cmdInstall);
 
 program.command('create')
-    .description('Create a new skill scaffold')
+    .description('Create a new skill scaffold locally')
     .argument('<path>', 'Skill path to create (e.g., system/migration)')
     .option('-f, --force', 'Force overwrite if exists', false)
     .action(cmdCreate);
 
 program.command('download')
-    .description('Download a skill package')
-    .argument('<skill_name>', 'Name of the skill to download')
+    .description('Download and extract a skill package from the remote registry')
+    .argument('<skill_path>', 'Path of the skill to download (e.g., core/kernel/kernel-info)')
+    .option('-t, --target <dir>', 'Target directory to extract into (defaults to current dir)')
     .option('--platform <platform>', 'Specify the platform (e.g., qoder will download to .qoder/skills/)')
-    .option('--url <url>', 'Specify the base URL for the registry (defaults to SKILL_OS_REGISTRY env var)')
+    .option('--url <url>', 'Override the base URL for the registry', DEFAULT_API_BASE)
     .action(cmdDownload);
 
 program.command('sync')

package/test-extract/rpm_find/SKILL.md

@@ -0,0 +1,97 @@
+---
+name: rpm-find
+version: 1.0.0
+description: 专业的 Alinux 系统 RPM 软件包搜索工具。支持解析复杂的包名查询，根据用户网络环境（内网/公网）智能提供有效下载链接。当用户请求查找、下载或查询 RPM 软件包时使用此技能。
+
+
+layer: runtime
+category: package
+lifecycle: usage
+
+# Tags: first tag MUST be the category name
+tags:
+  - package
+  - rpm
+  - alinux
+  - search
+
+status: stable
+dependencies:
+  - httpx>=0.24.0
+  - requests>=2.28.0
+---
+
+# RPM 软件包搜索技能
+
+当用户请求查找、下载或查询 Alinux 系统的 RPM 软件包时使用此技能。
+
+## 能力概览
+
+此技能能够解析模糊的包名（如 "nginx", "kernel 5.10"），并调用工具搜索实际的下载地址。它能根据用户的身份和网络环境，动态调整搜索策略和回复语气。
+
+## 核心流程
+
+### 步骤 1: 知识库加载 (必选)
+
+在开始任何搜索之前，必须使用 `read_file` 工具读取以下文档以了解 Alinux 的内核与版本命名规则：
+
+- [Alinux 内核与版本识别](./references/kernel_kb.md)
+
+### 步骤 2: 意图识别与扩展 (可选分支)
+
+在进行常规搜索前，请检查用户的具体意图。如果用户明确咨询 **"debuginfo"**, **"崩溃调试"**, **"内核调试"**, 或 **"debug 仓库"** 相关问题：
+
+- **加载**: [Alinux Debuginfo 包查找指南](./references/debuginfo_guide.md)
+- **执行**: 根据该指南中的 "标准用法" 或 "URL拼接" 规则回答用户的问题。
+
+### 步骤 3: 环境判断与 SOP 加载 (分支)
+
+请根据用户的 `source` 字段或当前对话上下文判断用户环境，并加载对应的 SOP 文档：
+
+- **情形 A: 内部开发环境** (例如 `source` 为 `cardbot_in` 或提到 "内部源")
+  - 加载: [内网 RPM 搜索 SOP](./references/inner_rules.md)
+  - 执行重点: 优先使用内网源，不过滤闭源包，回复简洁。
+
+- **情形 B: 外部公网环境** (默认情况，或 `source` 为 `other`)
+  - 加载: [公网 RPM 搜索 SOP](./references/outer_rules.md)
+  - 执行重点: **严禁泄露内网 IP**，必须转换为 `mirrors.aliyun.com`，语气亲切。
+
+### 步骤 4: 工具调用 (CLI 模式)
+
+使用 `execute_shell` 运行 Python 脚本执行操作。
+
+**脚本路径**: `./scripts/rpm_tool.py`
+
+#### 4.1 解析查询
+
+```bash
+uv run ./scripts/rpm_tool.py parse "kernel 5.10"
+```
+
+#### 4.2 搜索 RPM (API)
+
+将解析结果 (JSON) 中的字段传入:
+
+```bash
+uv run ./scripts/rpm_tool.py search "kernel" --version "5.10.134" --release "13.al8" --arch "x86_64"
+```
+
+#### 4.3 验证 URL
+
+将找到的 URL 列表传入验证:
+
+```bash
+uv run ./scripts/rpm_tool.py verify http://url1 http://url2 ...
+```
+
+#### 4.4 备用: URL 拼接 (仅当 API 无结果时)
+
+```bash
+uv run ./scripts/rpm_tool.py construct "kernel-debuginfo" "5.10.134" "13.al8" "x86_64" --is_kernel --alinux_version "3"
+```
+
+## 错误处理
+
+- 如果 API 返回空结果，尝试使用 `construct` 命令拼接 URL
+- 如果所有 URL 验证失败，建议用户检查包名或版本号是否正确
+- 对于闭源包（含 `ali3000`, `ali4000` 等标识），提示用户联系 OS 团队

package/test-extract/rpm_find/pyproject.toml

@@ -0,0 +1,12 @@
+[project]
+name = "package/rpm_search-skill"
+version = "1.0.0"
+description = "RPM package search skill for Alinux systems"
+requires-python = ">=3.9"
+dependencies = [
+    "httpx>=0.24",
+    "requests>=2.28",
+]
+
+[project.scripts]
+rpm-tool = "scripts.rpm_tool:main"

package/test-extract/rpm_find/references/debuginfo_guide.md

@@ -0,0 +1,29 @@
+# Alinux Debuginfo 包查找指南
+
+## 标准用法 (YUM/DNF)
+Alinux 系统找包的标准用法是通过 YUM/DNF 工具。对于 debuginfo 包，需要使用 `yum-utils` 提供的 `debuginfo-install` 命令，因为 debug 仓库默认未开启。
+
+### 常用命令
+- **安装常规包**: `debuginfo-install <pkg>` (例如 `debuginfo-install tree`)
+- **安装内核包**: `debuginfo-install kernel-debuginfo` (必须带后缀，否则安装不上)
+- **仅下载不安装**: `debuginfo-install --downloadonly kernel-debuginfo-$(uname -r)`
+    - 下载位置: `/var/cache/dnf/`
+
+## URL 拼接用法 (不推荐但可用)
+仅在不得不手动下载时使用。**注意**: 仅适用于公网镜像 `mirrors.aliyun.com`。闭源组件 (`ali3000`等) 不适用此法。
+
+### 拼接规则
+1.  **架构推断**:
+    - `.al7` -> Alinux 2
+    - `.al8` -> Alinux 3
+    - `.alnx4` -> Alinux 4
+2.  **内核包 URL**:
+    - **Alinux 2/3**: `<dist>/plus/<arch>/debug/kernels/`
+    - **Alinux 4**: `<dist>/os/<arch>/debug/` 或 `<dist>/updates/<arch>/debug/`
+    - 文件名: `kernel-debuginfo-<version>-<release>.rpm` 和 `kernel-debuginfo-common-<arch>-<version>-<release>.rpm`
+3.  **非内核包 URL**:
+    - 路径: `<dist>/<repo>/<arch>/debug/<pkg>-debuginfo-<version>-<release>.rpm`
+
+### 注意事项
+- 如果需要查找 debuginfo，若是内核包，需同时提供 `kernel-debuginfo` 和 `kernel-debuginfo-common`。
+- 若闭源包无 debuginfo，需联系 OS 团队。

package/test-extract/rpm_find/references/inner_rules.md

@@ -0,0 +1,17 @@
+# 内网 RPM 搜索 SOP (Inner)
+
+**适用场景**: 用户身份为内部员工 (`source: cardbot_in`) 或检测到内网环境。
+
+## 核心准则
+你是一名顶级的 Alinux 系统 RPM 包管理专家智能体。
+1.  **提供有效链接**: 必须提供 `yum.tbsite.net` 等内网源链接。
+2.  **验证**: 所有链接必须先通过 `check_url_availability_batch` 验证。
+3.  **语气**: 专业、直接、技术导向。
+
+## 执行步骤
+1.  **解析**: 调用 `parse_user_query_to_rpm_info` 解析包名。
+2.  **查询**: 调用 `get_rpm_list` 获取内网链接。
+3.  **闭源包处理**: 
+    - 如果发现 `apsara` 或 `aliXXXX` 等闭源包，**可以**显示，并标记为“内部闭源”。
+4.  **验证**: 并行验证所有 URL。
+5.  **输出**: 直接列出 Markdown 格式的下载链接。

package/test-extract/rpm_find/references/kernel_kb.md

@@ -0,0 +1,16 @@
+# Alinux 内核与版本识别知识库
+
+本参考文档包含识别 Alinux 内核及对应系统版本的核心规则。
+
+## 内核识别规则
+- **内核判断**: 版本号以 5.10, 6.6, 4.19, 4.9 等主线版本开头，或包含 `ali3000`, `ali4000`, `ali5000`, `ali6000`, `kernel`, `kmod` 字样，判定为内核。
+    - 注意：`ali5000`, `ali6000` 是内核标识符,而不是软件包名称。
+- **内核包名**: 内核对应 `kernel`, 包名一般为 `kernel`, `kernel-devel`, `kernel-core`, `kernel-modules` 等。
+- **闭源内核**: 包含 `ali3000`, `ali4000`, `ali5000`, `ali6000` 等字样, 或API返回的仓库路径包含 `apsara-xxxx` 等特殊标识, 代表内部闭源包。
+
+## 系统版本对应表
+| 标识符 | Alinux 版本 | 备注 |
+| :--- | :--- | :--- |
+| `.al7` | Alinux 2 | |
+| `.al8` | Alinux 3 | 内核主版本号 5.10 也对应 Alinux 3 |
+| `.alnx4`| Alinux 4 | 内核主版本号 6.6 也对应 Alinux 4 |

package/test-extract/rpm_find/references/outer_rules.md

@@ -0,0 +1,20 @@
+# 公网 RPM 搜索 SOP (Outer)
+
+**适用场景**: 用户身份为外部客户 (`source: other`) 或公网环境。
+
+## 核心准则
+你是一名服务于外部客户的 Alinux 系统专家。
+1.  **只提供公网链接**: *绝对禁止* 泄露 `yum.tbsite.net` 等内网链接。必须转换为 `mirrors.aliyun.com`。
+2.  **验证**: 所有链接必须通过 `check_url_availability_batch` 验证。
+3.  **语气**: 亲切、耐心、解释性强。
+
+## 执行步骤
+1.  **解析**: 调用 `parse_user_query_to_rpm_info`。
+2.  **查询**: 调用 `get_rpm_list`。
+3.  **安全过滤 (关键)**: 
+    - 检查是否为闭源包 (`apsara`, `aliXXXX`)。若是，**绝对不能**提供链接，告知用户“需联系售后获取”。
+    - 将所有内网 URL (`http://yum.tbsite.net/...`) 替换为公网镜像 (`https://mirrors.aliyun.com/...`)。
+4.  **兜底**: 如果转换失败，调用 `construct_url` 尝试拼接。
+5.  **输出**: 
+    - 使用表格形式展示结果。
+    - 对每个步骤做简单解释，帮助客户理解。

package/test-extract/rpm_find/scripts/rpm_tool.py

@@ -0,0 +1,417 @@
+#!/usr/bin/env python3
+"""
+RPM Search Tool Script
+此脚本封装了 RPM 搜索相关的核心功能，供 AI Agent 通过命令行调用。
+"""
+
+import argparse
+import asyncio
+import json
+import logging
+import re
+
+from typing import Any
+
+import httpx
+import requests
+
+
+# 设置日志
+logging.basicConfig(level=logging.ERROR, format="%(message)s")
+logger = logging.getLogger(__name__)
+
+# --- Core Functions from example_agent.py ---
+
+
+def fetch_webpage_content(
+    url: str, params: dict | None = None, timeout: int = 10
+) -> str:
+    """获取url返回的数据"""
+    try:
+        response = requests.get(url=url, params=params, timeout=timeout)
+        response.raise_for_status()
+        return response.text
+    except requests.exceptions.RequestException as e:
+        logger.error(f"网络请求失败: {e}")
+        return ""
+
+
+def parse_user_query_to_rpm_info(query: str) -> list[dict[str, Any]]:
+    query = query.replace("内核", " kernel ")
+    cleaned_query = re.sub(r"[\u4e00-\u9fa5]", " ", query)
+    work_str = " ".join(cleaned_query.split())
+    package_queries = re.findall(
+        r"[\w\.~-]*?(?:\d{1,2}\.\d{1,2}|al[78]|alnx4|x86_64|aarch64)[\w\.~-]*",
+        work_str,
+    )
+    if not package_queries:
+        package_queries = [work_str]
+    results = []
+    for part in package_queries:
+        if not part or len(part) < 5:
+            continue
+        info = {
+            "name": "",
+            "version": "",
+            "release": "",
+            "arch": "",
+            "type": "standard",
+            "is_kernel": False,
+            "alinux_version": "unknown",
+            "original_text": part,
+        }
+        arch_match = re.search(r"\b(x86_64|aarch64)\b", part)
+        if arch_match:
+            info["arch"] = arch_match.group(1)
+            part = part.replace(arch_match.group(0), "").strip()
+        dist_match = re.search(r"[\.-](al[78]|alnx4)", part)
+        if dist_match:
+            info["alinux_version"] = {"al7": "2", "al8": "3", "alnx4": "4"}.get(
+                dist_match.group(1)
+            )
+            part = part[: dist_match.start()]
+        ver_match = re.search(r"(\d{1,2}\.\d{1,2}(?:\.\d{1,3})?)", part)
+        if ver_match:
+            name_candidate = part[: ver_match.start()].strip("-_ ")
+            version_release_candidate = part[ver_match.start() :]
+            vr_parts = version_release_candidate.split("-", 1)
+            info["version"] = vr_parts[0]
+            if len(vr_parts) > 1:
+                info["release"] = vr_parts[1]
+            else:
+                final_vr_parts = info["version"].rsplit("-", 1)
+                if len(final_vr_parts) == 2:
+                    info["version"] = final_vr_parts[0]
+                    info["release"] = final_vr_parts[1]
+            info["name"] = name_candidate
+        else:
+            name_ver_parts = part.rsplit("-", 1)
+            if len(name_ver_parts) == 2 and re.match(r"\d", name_ver_parts[1]):
+                info["name"] = name_ver_parts[0]
+                ver_rel_parts = name_ver_parts[1].rsplit("-", 1)
+                info["version"] = ver_rel_parts[0]
+                if len(ver_rel_parts) > 1:
+                    info["release"] = ver_rel_parts[1]
+            else:
+                info["name"] = part
+        final_name = info["name"].replace(".rpm", "").strip("-_ ")
+        if not final_name and ("kernel" in work_str or "vmlinux" in work_str):
+            final_name = "kernel"
+        kernel_markers = [
+            "ali3000",
+            "ali4000",
+            "ali5000",
+            "ali6000",
+            "kernel",
+            "kmod",
+        ]
+        if any(marker in final_name for marker in kernel_markers) or (
+            ver_match and ver_match.group(1).startswith(("5.10", "4.19", "6.6"))
+        ):
+            info["is_kernel"] = True
+        if info["alinux_version"] == "unknown":
+            if info.get("release") and "al8" in info["release"]:
+                info["alinux_version"] = "3"
+            elif info.get("release") and "al7" in info["release"]:
+                info["alinux_version"] = "2"
+            elif info.get("release") and "alnx4" in info["release"]:
+                info["alinux_version"] = "4"
+            elif info["is_kernel"] and info.get("version", "").startswith(
+                "5.10"
+            ):
+                info["alinux_version"] = "3"
+            elif info["is_kernel"] and info.get("version", "").startswith(
+                "6.6"
+            ):
+                info["alinux_version"] = "4"
+        if (
+            "debug" in work_str
+            or "vmlinux" in work_str
+            or "debuginfo" in final_name
+        ):
+            info["type"] = "debuginfo"
+        if info["type"] == "debuginfo" and "debuginfo" not in final_name:
+            final_name += "-debuginfo"
+        info["name"] = final_name.strip("-")
+        if info["name"]:
+            results.append(info)
+    return results
+
+
+# 全局共享的AsyncClient实例,配置连接池以支持高并发
+_shared_http_client: httpx.AsyncClient | None = None
+
+
+def _get_shared_http_client() -> httpx.AsyncClient:
+    """获取共享的httpx AsyncClient实例,配置连接池支持高并发"""
+    global _shared_http_client
+    if _shared_http_client is None:
+        # 配置连接池限制,支持高并发请求
+        limits = httpx.Limits(
+            max_connections=200,  # 最大连接数
+            max_keepalive_connections=50,  # 保持活动的连接数
+        )
+        _shared_http_client = httpx.AsyncClient(
+            limits=limits,
+            timeout=1.5,
+            follow_redirects=True,
+        )
+    return _shared_http_client
+
+
+async def _check_single_url(client: httpx.AsyncClient, url: str) -> dict:
+    """
+    异步检查单个URL的可用性
+    """
+    headers = {
+        "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36"
+    }
+    result = {"url": url}
+    try:
+        response = await client.head(url, headers=headers)
+        if response.status_code == 200:
+            result["status"] = "valid"
+            result["status_code"] = "200"
+        else:
+            result["status"] = "invalid"
+            result["status_code"] = str(response.status_code)
+    except httpx.TimeoutException:
+        result["status"] = "error"
+        result["reason"] = "Request timed out"
+    except httpx.ConnectError as e:
+        result["status"] = "error"
+        result["reason"] = f"Connection error: {e}"
+    except httpx.HTTPError as e:
+        result["status"] = "error"
+        result["reason"] = f"An unexpected error occurred: {e}"
+    return result
+
+
+async def check_urls_availability_batch(
+    urls: list[str],
+) -> list[dict[str, Any]]:
+    """
+    并发检查一批URLs是否有效且可访问。
+    """
+    if not urls:
+        return []
+
+    client = _get_shared_http_client()
+    # 使用asyncio.gather并发执行所有URL检查
+    tasks = [_check_single_url(client, url) for url in urls]
+    results = await asyncio.gather(*tasks)
+    return list(results)
+
+
+def get_rpm_list(
+    name: str, version: str = "", release: str = "", arch: str = ""
+) -> list[dict[str, str]]:
+    """
+    通过内部API查询RPM包的详细信息。返回结果是内网URL,需要后续处理。
+    """
+    base_url = "http://opsx.vip.tbsite.net/gapi/v1/cms/rpm/list?"
+    # 确保version包含2位小数点,避免精确查询失败
+    if version and version.count(".") != 2:
+        version = ""
+    params = {
+        "name": name,
+        "version": version,
+        "release": release,
+        "arch": arch,
+    }
+
+    rep_text = fetch_webpage_content(base_url, params=params)
+    if not rep_text:
+        return []
+
+    try:
+        rep_json = json.loads(rep_text)
+        rpms = rep_json.get("data", {}).get("rpms", [])
+        return [
+            {
+                "name": item.get("name", ""),
+                "version": item.get("version", ""),
+                "release": item.get("release", ""),
+                "arch": item.get("arch", ""),
+                "internal_url": item.get("download_url", ""),
+            }
+            for item in rpms
+            if "alinux" in item.get("download_url", "")
+        ]
+    except (json.JSONDecodeError, TypeError) as e:
+        logger.error(f"API响应解析失败: {e}")
+        return []
+
+
+async def construct_url(
+    name: str,
+    version: str,
+    release: str,
+    arch: str,
+    is_kernel: bool = False,
+    alinux_version: str = "3",
+) -> list[str]:
+    """
+    根据包信息拼接公网URL作为备用方案,name大小写敏感。
+    """
+    # 步骤1: 输入验证
+    if (
+        not all([name, version, release, arch, alinux_version])
+        or alinux_version == "unknown"
+    ):
+        return []
+
+    urls = []
+    full_rpm_filename = f"{name}-{version}-{release}.{arch}.rpm"
+
+    # 步骤2: 根据包类型选择不同的拼接逻辑
+    # 逻辑分支 A: 内核Debuginfo包
+    if is_kernel and "debuginfo" in name:
+        full_ver_rel = f"{version}-{release}"
+        if alinux_version in ["2", "3"]:
+            # Alinux 2/3 的 debuginfo 在 plus 仓库的特定子目录
+            base_url = f"https://mirrors.aliyun.com/alinux/{alinux_version}/plus/{arch}/debug/kernels"
+            urls.append(
+                f"{base_url}/kernel-debuginfo-{full_ver_rel}.{arch}.rpm"
+            )
+            # 内核debuginfo需要common包
+            urls.append(
+                f"{base_url}/kernel-debuginfo-common-{arch}-{version}-{release}.rpm"
+            )
+        elif alinux_version == "4":
+            # Alinux 4 可能在 os 或 updates 仓库
+            for repo in ["os", "updates"]:
+                base_url = f"https://mirrors.aliyun.com/alinux/{alinux_version}/{repo}/{arch}/debug"
+                urls.append(
+                    f"{base_url}/kernel-debuginfo-{full_ver_rel}.{arch}.rpm"
+                )
+                urls.append(
+                    f"{base_url}/kernel-debuginfo-common-{arch}-{version}-{release}.rpm"
+                )
+
+    # 逻辑分支 B: 普通RPM包
+    else:
+        # common_repos = ['os', 'plus', 'updates', 'powertools', 'extras']
+        common_repos = ["os"]
+        for repo in common_repos:
+            url = f"https://mirrors.aliyun.com/alinux/{alinux_version}/{repo}/{arch}/Packages/{full_rpm_filename}"
+            urls.append(url)
+            # 对于debuginfo包,有可能在debug目录下
+            if "debuginfo" in name:
+                url_debug_repo = f"https://mirrors.aliyun.com/alinux/{alinux_version}/{repo}/{arch}/debug/Packages/{full_rpm_filename}"
+                urls.append(url_debug_repo)
+    # 使用并发批量检查所有URL
+    client = _get_shared_http_client()
+    tasks = [_check_single_url(client, url) for url in urls]
+    check_results = await asyncio.gather(*tasks)
+
+    return [
+        result["url"]
+        for result in check_results
+        if result.get("status") == "valid"
+    ]
+
+
+# --- CLI Wrappers ---
+
+
+def cmd_parse(args):
+    results = parse_user_query_to_rpm_info(args.query)
+    print(json.dumps(results, ensure_ascii=False, indent=2))
+
+
+def cmd_search(args):
+    results = get_rpm_list(
+        name=args.name,
+        version=args.version,
+        release=args.release,
+        arch=args.arch,
+    )
+    print(json.dumps(results, ensure_ascii=False, indent=2))
+
+
+async def async_cmd_verify(args):
+    urls = args.urls
+    results = await check_urls_availability_batch(urls)
+    print(json.dumps(results, ensure_ascii=False, indent=2))
+
+
+def cmd_verify(args):
+    asyncio.run(async_cmd_verify(args))
+
+
+async def async_cmd_construct(args):
+    results = await construct_url(
+        name=args.name,
+        version=args.version,
+        release=args.release,
+        arch=args.arch,
+        is_kernel=args.is_kernel,
+        alinux_version=args.alinux_version,
+    )
+    print(json.dumps(results, ensure_ascii=False, indent=2))
+
+
+def cmd_construct(args):
+    asyncio.run(async_cmd_construct(args))
+
+
+def main():
+    parser = argparse.ArgumentParser(description="RPM Search Tool CLI")
+    subparsers = parser.add_subparsers(
+        dest="command", help="Available commands"
+    )
+
+    # Command: parse
+    parser_parse = subparsers.add_parser(
+        "parse", help="Parse user query to RPM info"
+    )
+    parser_parse.add_argument("query", type=str, help="User query string")
+    parser_parse.set_defaults(func=cmd_parse)
+
+    # Command: search
+    parser_search = subparsers.add_parser("search", help="Search RPM via API")
+    parser_search.add_argument("name", type=str, help="Package name")
+    parser_search.add_argument(
+        "--version", type=str, default="", help="Package version"
+    )
+    parser_search.add_argument(
+        "--release", type=str, default="", help="Package release"
+    )
+    parser_search.add_argument(
+        "--arch", type=str, default="", help="Architecture"
+    )
+    parser_search.set_defaults(func=cmd_search)
+
+    # Command: verify
+    parser_verify = subparsers.add_parser(
+        "verify", help="Verify URLs availability"
+    )
+    parser_verify.add_argument("urls", nargs="+", help="List of URLs to verify")
+    parser_verify.set_defaults(func=cmd_verify)
+
+    # Command: construct
+    parser_construct = subparsers.add_parser(
+        "construct", help="Construct URL fallback"
+    )
+    parser_construct.add_argument("name", type=str, help="Package name")
+    parser_construct.add_argument("version", type=str, help="Package version")
+    parser_construct.add_argument("release", type=str, help="Package release")
+    parser_construct.add_argument("arch", type=str, help="Architecture")
+    parser_construct.add_argument(
+        "--is_kernel", action="store_true", help="Is kernel package"
+    )
+    parser_construct.add_argument(
+        "--alinux_version", type=str, default="3", help="Alinux version"
+    )
+    parser_construct.set_defaults(func=cmd_construct)
+
+    args = parser.parse_args()
+    if hasattr(args, "func"):
+        args.func(args)
+    else:
+        parser.print_help()
+
+
+if __name__ == "__main__":
+    main()