node-os-utils 1.3.7 → 2.0.1-beta.2

package/dist/src/adapters/linux-adapter.js

@@ -0,0 +1,1308 @@
+"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 (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LinuxAdapter = void 0;
+const os_1 = __importDefault(require("os"));
+const fs_1 = require("fs");
+const fsSync = __importStar(require("fs"));
+const platform_adapter_1 = require("../core/platform-adapter");
+const command_executor_1 = require("../utils/command-executor");
+const errors_1 = require("../types/errors");
+/**
+ * Linux 平台适配器
+ *
+ * 实现 Linux 系统的监控功能，主要通过 /proc、/sys 文件系统和系统命令
+ */
+class LinuxAdapter extends platform_adapter_1.BasePlatformAdapter {
+    constructor() {
+        super('linux');
+        this.processListCommand = 'ps -eo pid=,ppid=,comm=,%cpu=,%mem=,rss=,stat=,user=,args=';
+        this.cpuUsageSamplingInterval = 200;
+        // Linux 系统路径常量
+        this.paths = {
+            cpuinfo: '/proc/cpuinfo',
+            meminfo: '/proc/meminfo',
+            stat: '/proc/stat',
+            loadavg: '/proc/loadavg',
+            uptime: '/proc/uptime',
+            diskstats: '/proc/diskstats',
+            netDev: '/proc/net/dev',
+            version: '/proc/version',
+            mounts: '/proc/mounts',
+            thermal: '/sys/class/thermal',
+            cpufreq: '/sys/devices/system/cpu'
+        };
+        this.executor = new command_executor_1.CommandExecutor('linux');
+        this.containerMode = this.detectContainerEnvironment();
+        if (this.containerMode) {
+            this.supportedFeatures.system.services = false;
+        }
+    }
+    /**
+     * 执行系统命令
+     */
+    async executeCommand(command, options) {
+        return this.executor.execute(command, options);
+    }
+    /**
+     * 读取文件内容
+     */
+    async readFile(path) {
+        try {
+            return await fs_1.promises.readFile(path, 'utf8');
+        }
+        catch (error) {
+            if (error.code === 'ENOENT') {
+                throw new errors_1.MonitorError(`File not found: ${path}`, errors_1.ErrorCode.FILE_NOT_FOUND, this.platformName, { path });
+            }
+            if (error.code === 'EACCES') {
+                throw new errors_1.MonitorError(`Permission denied: ${path}`, errors_1.ErrorCode.PERMISSION_DENIED, this.platformName, { path });
+            }
+            throw new errors_1.MonitorError(`Failed to read file: ${path}`, errors_1.ErrorCode.COMMAND_FAILED, this.platformName, { path, error: error.message });
+        }
+    }
+    /**
+     * 检查文件是否存在
+     */
+    async fileExists(path) {
+        try {
+            await fs_1.promises.access(path);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * 读取 /proc/cpuinfo 并解析成结构化 CPU 信息
+     */
+    async getCPUInfo() {
+        try {
+            const cpuinfoContent = await this.readFile(this.paths.cpuinfo);
+            return this.parseCPUInfo(cpuinfoContent);
+        }
+        catch (error) {
+            throw this.createCommandError('getCPUInfo', error);
+        }
+    }
+    /**
+     * 读取 /proc/stat，计算总体 CPU 使用情况
+     */
+    async getCPUUsage() {
+        try {
+            const firstSnapshot = await this.captureCpuStat();
+            await this.delay(this.cpuUsageSamplingInterval);
+            const secondSnapshot = await this.captureCpuStat();
+            return this.calculateCpuUsage(firstSnapshot, secondSnapshot);
+        }
+        catch (error) {
+            throw this.createCommandError('getCPUUsage', error);
+        }
+    }
+    /**
+     * 遍历 /sys/class/thermal，聚合 CPU 温度传感器
+     */
+    async getCPUTemperature() {
+        try {
+            const thermalExists = await this.fileExists(this.paths.thermal);
+            if (!thermalExists) {
+                throw this.createUnsupportedError('cpu.temperature');
+            }
+            // 尝试读取温度传感器
+            const thermalZones = await this.findThermalZones();
+            const temperatures = [];
+            for (const zone of thermalZones) {
+                try {
+                    const tempPath = `${this.paths.thermal}/${zone}/temp`;
+                    const tempContent = await this.readFile(tempPath);
+                    let typeContent = 'unknown';
+                    try {
+                        typeContent = await this.readFile(`${this.paths.thermal}/${zone}/type`);
+                    }
+                    catch {
+                        // 如果无法读取类型，使用默认值
+                    }
+                    const temp = this.safeParseInt(tempContent.trim()) / 1000; // 转换为摄氏度
+                    temperatures.push({
+                        zone,
+                        type: typeContent.trim(),
+                        temperature: temp
+                    });
+                }
+                catch {
+                    // 忽略无法读取的传感器
+                }
+            }
+            return temperatures;
+        }
+        catch (error) {
+            throw this.createCommandError('getCPUTemperature', error);
+        }
+    }
+    /**
+     * 读取 /proc/meminfo 解析内存占用
+     */
+    async getMemoryInfo() {
+        try {
+            const meminfoContent = await this.readFile(this.paths.meminfo);
+            return this.parseMemoryInfo(meminfoContent);
+        }
+        catch (error) {
+            throw this.createCommandError('getMemoryInfo', error);
+        }
+    }
+    /**
+     * 获取内存使用情况
+     */
+    async getMemoryUsage() {
+        // Linux 上内存信息和使用情况来自同一个文件
+        return this.getMemoryInfo();
+    }
+    /**
+     * 获取磁盘信息
+     */
+    async getDiskInfo() {
+        try {
+            const result = await this.executeCommand('df -h');
+            this.validateCommandResult(result, 'df -h');
+            return this.parseDiskInfo(result.stdout);
+        }
+        catch (error) {
+            throw this.createCommandError('getDiskInfo', error);
+        }
+    }
+    /**
+     * 获取磁盘 I/O 统计
+     */
+    async getDiskIO() {
+        try {
+            const diskstatsContent = await this.readFile(this.paths.diskstats);
+            return this.parseDiskStats(diskstatsContent);
+        }
+        catch (error) {
+            throw this.createCommandError('getDiskIO', error);
+        }
+    }
+    /**
+     * 获取网络接口列表
+     */
+    async getNetworkInterfaces() {
+        try {
+            const result = await this.executeCommand('ip addr show');
+            this.validateCommandResult(result, 'ip addr show');
+            return this.parseNetworkInterfaces(result.stdout);
+        }
+        catch (primaryError) {
+            // 回退到 ifconfig
+            try {
+                const result = await this.executeCommand('ifconfig');
+                this.validateCommandResult(result, 'ifconfig');
+                return this.parseIfconfigOutput(result.stdout);
+            }
+            catch (fallbackError) {
+                throw this.createCommandError('getNetworkInterfaces', {
+                    primary: this.summarizeErrorDetails(primaryError),
+                    fallback: this.summarizeErrorDetails(fallbackError)
+                });
+            }
+        }
+    }
+    /**
+     * 获取网络统计信息
+     */
+    async getNetworkStats() {
+        try {
+            const netdevContent = await this.readFile(this.paths.netDev);
+            return this.parseNetworkStats(netdevContent);
+        }
+        catch (error) {
+            throw this.createCommandError('getNetworkStats', error);
+        }
+    }
+    /**
+     * 获取进程列表
+     */
+    async getProcesses() {
+        try {
+            const result = await this.executeCommand(this.processListCommand);
+            this.validateCommandResult(result, 'ps command');
+            return this.parseProcessList(result.stdout);
+        }
+        catch (error) {
+            throw this.createCommandError('getProcesses', error);
+        }
+    }
+    /**
+     * 获取特定进程信息
+     */
+    async getProcessInfo(pid) {
+        try {
+            const procPath = `/proc/${pid}`;
+            const exists = await this.fileExists(procPath);
+            if (!exists) {
+                throw new errors_1.MonitorError(`Process ${pid} not found`, errors_1.ErrorCode.NOT_AVAILABLE, this.platformName, { pid });
+            }
+            const [stat, status, cmdline] = await Promise.allSettled([
+                this.readFile(`${procPath}/stat`),
+                this.readFile(`${procPath}/status`),
+                this.readFile(`${procPath}/cmdline`)
+            ]).then(results => [
+                results[0].status === 'fulfilled' ? results[0].value : '',
+                results[1].status === 'fulfilled' ? results[1].value : '',
+                results[2].status === 'fulfilled' ? results[2].value : ''
+            ]);
+            const statContent = stat || await this.readFile(`${procPath}/stat`).catch(() => '');
+            return this.parseProcessInfo(pid, statContent, status, cmdline);
+        }
+        catch (error) {
+            throw this.createCommandError('getProcessInfo', error);
+        }
+    }
+    /**
+     * 获取系统信息
+     */
+    async getSystemInfo() {
+        try {
+            const [uname, version, uptime, loadavg, machine] = await Promise.allSettled([
+                this.executeCommand('uname -a'),
+                this.readFile(this.paths.version),
+                this.readFile(this.paths.uptime),
+                this.readFile(this.paths.loadavg),
+                this.executeCommand('uname -m')
+            ]).then(results => [
+                results[0].status === 'fulfilled' ? results[0].value : null,
+                results[1].status === 'fulfilled' ? results[1].value : '',
+                results[2].status === 'fulfilled' ? results[2].value : '',
+                results[3].status === 'fulfilled' ? results[3].value : '',
+                results[4].status === 'fulfilled' ? results[4].value : null
+            ]);
+            const unameOutput = typeof uname === 'string' ? uname : uname?.stdout || '';
+            const versionOutput = typeof version === 'string' ? version : version?.stdout || '';
+            const uptimeOutput = typeof uptime === 'string' ? uptime : uptime?.stdout || '';
+            const loadavgOutput = typeof loadavg === 'string' ? loadavg : loadavg?.stdout || '';
+            const machineOutput = typeof machine === 'string' ? machine : machine?.stdout || '';
+            return this.parseSystemInfo(unameOutput, versionOutput, uptimeOutput, loadavgOutput, machineOutput);
+        }
+        catch (error) {
+            throw this.createCommandError('getSystemInfo', error);
+        }
+    }
+    /**
+     * 获取系统负载
+     */
+    async getSystemLoad() {
+        try {
+            const loadavgContent = await this.readFile(this.paths.loadavg);
+            return this.parseLoadAverage(loadavgContent);
+        }
+        catch (error) {
+            throw this.createCommandError('getSystemLoad', error);
+        }
+    }
+    /**
+     * 初始化支持的功能
+     */
+    initializeSupportedFeatures() {
+        return {
+            cpu: {
+                info: true,
+                usage: true,
+                temperature: true,
+                frequency: true,
+                cache: true,
+                perCore: true,
+                cores: true
+            },
+            memory: {
+                info: true,
+                usage: true,
+                swap: true,
+                pressure: false, // Linux 内存压力需要额外工具
+                detailed: true,
+                virtual: true
+            },
+            disk: {
+                info: true,
+                io: true,
+                health: false, // 需要 smartctl
+                smart: false,
+                filesystem: true,
+                usage: true,
+                stats: true,
+                mounts: true,
+                filesystems: true
+            },
+            network: {
+                interfaces: true,
+                stats: true,
+                connections: true,
+                bandwidth: true,
+                gateway: true
+            },
+            process: {
+                list: true,
+                details: true,
+                tree: true,
+                monitor: true,
+                info: true,
+                kill: true,
+                openFiles: true,
+                environment: true
+            },
+            system: {
+                info: true,
+                load: true,
+                uptime: true,
+                users: true,
+                services: false // 需要 systemctl
+            }
+        };
+    }
+    // 私有解析方法
+    parseCPUInfo(content) {
+        const lines = content.split('\n');
+        const cpus = [];
+        let currentCPU = {};
+        for (const line of lines) {
+            const trimmed = line.trim();
+            if (!trimmed) {
+                if (Object.keys(currentCPU).length > 0) {
+                    cpus.push(currentCPU);
+                    currentCPU = {};
+                }
+                continue;
+            }
+            const separatorIndex = trimmed.indexOf(':');
+            if (separatorIndex === -1)
+                continue;
+            const key = trimmed.substring(0, separatorIndex).trim();
+            const value = trimmed.substring(separatorIndex + 1).trim();
+            currentCPU[key] = value;
+        }
+        if (Object.keys(currentCPU).length > 0) {
+            cpus.push(currentCPU);
+        }
+        return {
+            cpus,
+            count: cpus.length,
+            model: cpus[0]?.['model name'] || 'Unknown',
+            vendor: cpus[0]?.['vendor_id'] || 'Unknown',
+            architecture: cpus[0]?.['cpu family'] || 'Unknown'
+        };
+    }
+    async captureCpuStat() {
+        const content = await this.readFile(this.paths.stat);
+        return this.parseCpuStat(content);
+    }
+    parseCpuStat(content) {
+        const lines = content
+            .split('\n')
+            .map(line => line.trim())
+            .filter(line => line.length > 0);
+        const summaryLine = lines.find(line => line.startsWith('cpu '));
+        if (!summaryLine) {
+            throw this.createParseError(content, 'CPU usage line not found');
+        }
+        const summary = this.parseCpuTimesFromLine(summaryLine);
+        const cores = [];
+        for (const line of lines) {
+            if (line.startsWith('cpu') && !line.startsWith('cpu ')) {
+                cores.push(this.parseCpuTimesFromLine(line));
+            }
+        }
+        return {
+            summary,
+            cores
+        };
+    }
+    parseCpuTimesFromLine(line) {
+        const parts = line.trim().split(/\s+/);
+        parts.shift(); // 移除 cpu 标识
+        const values = parts.map(value => this.safeParseInt(value));
+        return {
+            user: values[0] ?? 0,
+            nice: values[1] ?? 0,
+            system: values[2] ?? 0,
+            idle: values[3] ?? 0,
+            iowait: values[4] ?? 0,
+            irq: values[5] ?? 0,
+            softirq: values[6] ?? 0,
+            steal: values[7] ?? 0,
+            guest: values[8] ?? 0,
+            guestNice: values[9] ?? 0
+        };
+    }
+    calculateCpuUsage(previous, current) {
+        const summaryDelta = this.diffCpuTimes(previous.summary, current.summary);
+        const percentages = this.computeUsagePercentages(summaryDelta);
+        const cores = this.calculateCoreUsage(previous.cores, current.cores);
+        return {
+            overall: percentages.overall,
+            user: percentages.user,
+            system: percentages.system,
+            idle: percentages.idle,
+            iowait: percentages.iowait,
+            irq: percentages.irq,
+            softirq: percentages.softirq,
+            cores
+        };
+    }
+    calculateCoreUsage(previousCores, currentCores) {
+        const coreCount = Math.min(previousCores.length, currentCores.length);
+        const usages = [];
+        for (let i = 0; i < coreCount; i++) {
+            const delta = this.diffCpuTimes(previousCores[i], currentCores[i]);
+            const total = this.getCpuTotal(delta);
+            if (total <= 0) {
+                usages.push(0);
+                continue;
+            }
+            const busy = total - delta.idle;
+            usages.push((busy / total) * 100);
+        }
+        return usages;
+    }
+    diffCpuTimes(previous, current) {
+        return {
+            user: this.safeDiff(current.user, previous.user),
+            nice: this.safeDiff(current.nice, previous.nice),
+            system: this.safeDiff(current.system, previous.system),
+            idle: this.safeDiff(current.idle, previous.idle),
+            iowait: this.safeDiff(current.iowait, previous.iowait),
+            irq: this.safeDiff(current.irq, previous.irq),
+            softirq: this.safeDiff(current.softirq, previous.softirq),
+            steal: this.safeDiff(current.steal, previous.steal),
+            guest: this.safeDiff(current.guest, previous.guest),
+            guestNice: this.safeDiff(current.guestNice, previous.guestNice)
+        };
+    }
+    computeUsagePercentages(delta) {
+        const total = this.getCpuTotal(delta);
+        if (total <= 0) {
+            return {
+                overall: 0,
+                user: 0,
+                system: 0,
+                idle: 0,
+                iowait: 0,
+                irq: 0,
+                softirq: 0
+            };
+        }
+        return {
+            overall: ((total - delta.idle) / total) * 100,
+            user: ((delta.user + delta.nice) / total) * 100,
+            system: (delta.system / total) * 100,
+            idle: (delta.idle / total) * 100,
+            iowait: (delta.iowait / total) * 100,
+            irq: (delta.irq / total) * 100,
+            softirq: (delta.softirq / total) * 100
+        };
+    }
+    getCpuTotal(times) {
+        return times.user + times.nice + times.system + times.idle + times.iowait + times.irq + times.softirq + times.steal + times.guest + times.guestNice;
+    }
+    safeDiff(current, previous) {
+        const diff = current - previous;
+        return diff > 0 ? diff : 0;
+    }
+    parseMemoryInfo(content) {
+        const memInfo = this.parseKeyValueOutput(content);
+        const total = this.convertToBytes(memInfo['MemTotal'] || '0', 'kB');
+        const available = this.convertToBytes(memInfo['MemAvailable'] || memInfo['MemFree'] || '0', 'kB');
+        const free = this.convertToBytes(memInfo['MemFree'] || '0', 'kB');
+        const cached = this.convertToBytes(memInfo['Cached'] || '0', 'kB');
+        const buffers = this.convertToBytes(memInfo['Buffers'] || '0', 'kB');
+        const used = total - available;
+        return {
+            total,
+            available,
+            used,
+            free,
+            cached,
+            buffers,
+            usagePercentage: total > 0 ? (used / total) * 100 : 0,
+            swap: {
+                total: this.convertToBytes(memInfo['SwapTotal'] || '0', 'kB'),
+                free: this.convertToBytes(memInfo['SwapFree'] || '0', 'kB'),
+                used: this.convertToBytes(memInfo['SwapTotal'] || '0', 'kB') - this.convertToBytes(memInfo['SwapFree'] || '0', 'kB')
+            }
+        };
+    }
+    parseDiskInfo(output) {
+        const lines = output.split('\n').filter(line => line.trim());
+        if (lines.length < 2)
+            return [];
+        const disks = [];
+        for (let i = 1; i < lines.length; i++) {
+            const fields = lines[i].split(/\s+/);
+            if (fields.length >= 6) {
+                const [filesystem, size, used, available, usagePercent, mountpoint] = fields;
+                disks.push({
+                    filesystem,
+                    mountpoint,
+                    size: this.convertToBytes(size),
+                    used: this.convertToBytes(used),
+                    available: this.convertToBytes(available),
+                    usagePercentage: this.safeParseNumber(usagePercent.replace('%', ''))
+                });
+            }
+        }
+        return disks;
+    }
+    /**
+     * 解析 ip/ifconfig 输出的网卡信息，稳定提取接口名称
+     */
+    parseNetworkInterfaces(output) {
+        const interfaces = [];
+        const lines = output.split('\n');
+        let current = null;
+        const pushCurrent = () => {
+            if (current) {
+                interfaces.push({
+                    name: current.name,
+                    addresses: current.addresses,
+                    state: current.state,
+                    mtu: current.mtu,
+                    internal: current.internal || current.loopbackDetected
+                });
+            }
+            current = null;
+        };
+        for (const rawLine of lines) {
+            const headerMatch = rawLine.match(/^\s*(\d+):\s*([^:@]+)(?:@[^:]+)?:\s*(.*)$/);
+            if (headerMatch) {
+                pushCurrent();
+                const name = headerMatch[2];
+                const rest = headerMatch[3] || '';
+                const stateMatch = rest.match(/\bstate\s+([A-Z]+)/i);
+                const mtuMatch = rest.match(/\bmtu\s+(\d+)/i);
+                const isLoopback = /\bLOOPBACK\b/i.test(rest);
+                current = {
+                    name,
+                    addresses: [],
+                    state: stateMatch ? stateMatch[1].toLowerCase() : 'down',
+                    mtu: mtuMatch ? this.safeParseInt(mtuMatch[1]) : 0,
+                    internal: name === 'lo' || name === 'lo0',
+                    loopbackDetected: isLoopback
+                };
+                continue;
+            }
+            if (!current) {
+                continue;
+            }
+            const line = rawLine.trim();
+            if (!line) {
+                continue;
+            }
+            if (/loopback/i.test(line)) {
+                current.loopbackDetected = true;
+            }
+            const inetMatch = line.match(/^inet\s+([^\s/]+)(?:\/\d+)?/);
+            if (inetMatch) {
+                current.addresses.push({
+                    address: inetMatch[1],
+                    family: 'IPv4'
+                });
+                continue;
+            }
+            const inet6Match = line.match(/^inet6\s+([^\s/]+)(?:\/\d+)?/);
+            if (inet6Match) {
+                current.addresses.push({
+                    address: inet6Match[1],
+                    family: 'IPv6'
+                });
+            }
+        }
+        pushCurrent();
+        return interfaces;
+    }
+    parseIfconfigOutput(output) {
+        // 解析 ifconfig 输出的简化版本
+        const interfaces = [];
+        const blocks = output.split(/\n\n/);
+        for (const block of blocks) {
+            const lines = block.split('\n');
+            const interfaceLine = lines[0];
+            if (!interfaceLine)
+                continue;
+            const nameMatch = interfaceLine.match(/^(\w+):/);
+            if (!nameMatch)
+                continue;
+            const name = nameMatch[1];
+            const addresses = [];
+            for (const line of lines) {
+                const inetMatch = line.match(/inet\s+([^\s]+)/);
+                if (inetMatch) {
+                    addresses.push({
+                        address: inetMatch[1],
+                        family: 'IPv4'
+                    });
+                }
+            }
+            interfaces.push({
+                name,
+                addresses,
+                state: interfaceLine.includes('UP') ? 'up' : 'down'
+            });
+        }
+        return interfaces;
+    }
+    /**
+     * 解析 /proc/net/dev 网络统计数据
+     *
+     * 将原始列按接口拆分，并提取收发字节/错误/丢包等指标
+     */
+    parseNetworkStats(content) {
+        const lines = content.split('\n');
+        const stats = [];
+        for (let i = 2; i < lines.length; i++) { // 跳过头部
+            const line = lines[i].trim();
+            if (!line)
+                continue;
+            const fields = line.split(/\s+/);
+            if (fields.length >= 17) {
+                const [iface, ...values] = fields;
+                const name = iface.replace(':', '');
+                stats.push({
+                    interface: name,
+                    rxBytes: this.safeParseInt(values[0]),
+                    rxPackets: this.safeParseInt(values[1]),
+                    rxErrors: this.safeParseInt(values[2]),
+                    rxDropped: this.safeParseInt(values[3]),
+                    txBytes: this.safeParseInt(values[8]),
+                    txPackets: this.safeParseInt(values[9]),
+                    txErrors: this.safeParseInt(values[10]),
+                    txDropped: this.safeParseInt(values[11])
+                });
+            }
+        }
+        return stats;
+    }
+    parseProcessList(output) {
+        const lines = output.split('\n').filter(line => line.trim());
+        const processes = [];
+        for (const line of lines) {
+            const match = line.match(/^(\d+)\s+(\d+)\s+(\S+)\s+([\d.]+)\s+([\d.]+)\s+(\d+)\s+(\S+)\s+(\S+)\s*(.*)$/);
+            if (!match) {
+                continue;
+            }
+            const [, pid, ppid, comm, pcpu, pmem, rss, state, user, args] = match;
+            const command = args.trim() || comm;
+            processes.push({
+                pid: this.safeParseInt(pid),
+                ppid: this.safeParseInt(ppid),
+                name: comm,
+                command,
+                cpuUsage: this.safeParseNumber(pcpu),
+                memoryUsage: this.safeParseInt(rss) * 1024, // rss 以 KB 计，转换为字节
+                memoryPercentage: this.safeParseNumber(pmem),
+                state,
+                user
+            });
+        }
+        return processes;
+    }
+    /**
+     * 综合 /proc/[pid] 下多份文件，拼装进程详细信息
+     */
+    parseProcessInfo(pid, stat, status, cmdline) {
+        const statusInfo = this.parseKeyValueOutput(status, '\t');
+        const statFields = stat.split(' ');
+        const startTimeTicks = this.safeParseInt(statFields[21]);
+        const sysconf = os_1.default.constants?.sysconf;
+        const hertz = typeof sysconf?.SC_CLK_TCK === 'number' && sysconf.SC_CLK_TCK > 0
+            ? sysconf.SC_CLK_TCK
+            : 100;
+        let uptimeMs = 0;
+        try {
+            uptimeMs = os_1.default.uptime() * 1000;
+        }
+        catch {
+            uptimeMs = 0;
+        }
+        const bootTimeMs = uptimeMs > 0 ? Date.now() - uptimeMs : Date.now();
+        // 通过时钟节拍 + 开机时间估算进程启动时间，兼容无法访问 uptime 的环境
+        const computedStartTime = startTimeTicks > 0
+            ? bootTimeMs + (startTimeTicks / hertz) * 1000
+            : bootTimeMs;
+        const startTime = Math.min(computedStartTime, Date.now());
+        const rssPages = this.safeParseInt(statFields[23]);
+        const pageSize = typeof sysconf?.SC_PAGESIZE === 'number' && sysconf.SC_PAGESIZE > 0
+            ? sysconf.SC_PAGESIZE
+            : 4096;
+        const rssBytesFromStat = rssPages > 0 ? rssPages * pageSize : 0;
+        const vmRssRaw = statusInfo['VmRSS'] ?? statusInfo['VmRSS:'] ?? '0';
+        const vmSizeRaw = statusInfo['VmSize'] ?? statusInfo['VmSize:'] ?? '0';
+        const threadsRaw = statusInfo['Threads'] ?? statusInfo['Threads:'];
+        // 优先使用 /proc/[pid]/status 中的 KiB 数值，缺失时回退到 stat 的页数
+        const rssFromStatus = this.convertToBytes(vmRssRaw, 'kB');
+        const memoryUsage = rssFromStatus > 0 ? rssFromStatus : rssBytesFromStat;
+        return {
+            pid,
+            name: statusInfo['Name'] || 'Unknown',
+            command: cmdline.replace(/\0/g, ' ').trim(),
+            state: statFields[2] || 'Unknown',
+            ppid: this.safeParseInt(statFields[3]),
+            threads: this.safeParseInt(threadsRaw),
+            vmSize: this.convertToBytes(vmSizeRaw, 'kB'),
+            vmRSS: memoryUsage,
+            memoryUsage,
+            memory: memoryUsage,
+            rss: memoryUsage,
+            startTime
+        };
+    }
+    parseSystemInfo(uname, version, uptime, loadavg, machine) {
+        const unameFields = uname.trim().split(' ');
+        const uptimeFields = uptime.trim().split(' ');
+        const loadFields = loadavg.trim().split(' ');
+        const uptimeSeconds = this.safeParseNumber(uptimeFields[0]);
+        const uptimeMs = uptimeSeconds * 1000;
+        const bootTime = Date.now() - uptimeMs;
+        const architecture = this.resolveArchitecture(unameFields, machine);
+        return {
+            hostname: unameFields[1] || 'Unknown',
+            platform: 'linux', // 统一返回标准平台名称，与 os.platform() 保持一致
+            release: unameFields[2] || 'Unknown',
+            version: version.trim(),
+            arch: architecture,
+            uptime: uptimeMs,
+            uptimeSeconds,
+            bootTime,
+            loadAverage: {
+                load1: this.safeParseNumber(loadFields[0]),
+                load5: this.safeParseNumber(loadFields[1]),
+                load15: this.safeParseNumber(loadFields[2])
+            }
+        };
+    }
+    parseLoadAverage(content) {
+        const fields = content.trim().split(' ');
+        return {
+            load1: this.safeParseNumber(fields[0]),
+            load5: this.safeParseNumber(fields[1]),
+            load15: this.safeParseNumber(fields[2]),
+            processes: {
+                active: this.safeParseInt(fields[3]?.split('/')[0]),
+                total: this.safeParseInt(fields[3]?.split('/')[1])
+            }
+        };
+    }
+    async findThermalZones() {
+        try {
+            const items = await fs_1.promises.readdir(this.paths.thermal);
+            return items.filter(item => item.startsWith('thermal_zone'));
+        }
+        catch {
+            return [];
+        }
+    }
+    // 实现抽象方法
+    /**
+     * 获取磁盘使用情况
+     */
+    async getDiskUsage() {
+        try {
+            const result = await this.executeCommand('df -B1');
+            return this.parseDiskUsage(result.stdout);
+        }
+        catch (error) {
+            throw this.createCommandError('getDiskUsage', error);
+        }
+    }
+    /**
+     * 获取磁盘统计
+     */
+    async getDiskStats() {
+        try {
+            const diskstatsContent = await this.readFile(this.paths.diskstats);
+            return this.parseDiskStats(diskstatsContent);
+        }
+        catch (error) {
+            throw this.createCommandError('getDiskStats', error);
+        }
+    }
+    /**
+     * 获取挂载点
+     */
+    async getMounts() {
+        try {
+            const mountsContent = await this.readFile(this.paths.mounts);
+            return this.parseMounts(mountsContent);
+        }
+        catch (error) {
+            throw this.createCommandError('getMounts', error);
+        }
+    }
+    /**
+     * 获取文件系统
+     */
+    async getFileSystems() {
+        try {
+            const result = await this.executeCommand('cat /proc/filesystems');
+            return this.parseFileSystems(result.stdout);
+        }
+        catch (error) {
+            throw this.createCommandError('getFileSystems', error);
+        }
+    }
+    /**
+     * 获取网络连接
+     */
+    async getNetworkConnections() {
+        try {
+            const result = await this.executeCommand('ss -tuln');
+            return this.parseNetworkConnections(result.stdout);
+        }
+        catch (primaryError) {
+            try {
+                const result = await this.executeCommand('netstat -tuln');
+                this.validateCommandResult(result, 'netstat -tuln');
+                return this.parseNetstatConnections(result.stdout);
+            }
+            catch (fallbackError) {
+                throw this.createCommandError('getNetworkConnections', {
+                    primary: this.summarizeErrorDetails(primaryError),
+                    fallback: this.summarizeErrorDetails(fallbackError)
+                });
+            }
+        }
+    }
+    /**
+     * 获取默认网关
+     */
+    async getDefaultGateway() {
+        try {
+            const result = await this.executeCommand('ip route show default');
+            return this.parseDefaultGateway(result.stdout);
+        }
+        catch (error) {
+            throw this.createCommandError('getDefaultGateway', error);
+        }
+    }
+    /**
+     * 获取进程列表
+     */
+    async getProcessList() {
+        try {
+            const result = await this.executeCommand(this.processListCommand);
+            this.validateCommandResult(result, 'ps command');
+            return this.parseProcessList(result.stdout);
+        }
+        catch (error) {
+            throw this.createCommandError('getProcessList', error);
+        }
+    }
+    /**
+     * 杀死进程
+     */
+    async killProcess(pid, signal = 'TERM') {
+        try {
+            const result = await this.executeCommand(`kill -${signal} ${pid}`);
+            return result.exitCode === 0;
+        }
+        catch (error) {
+            return false;
+        }
+    }
+    /**
+     * 获取进程打开文件
+     */
+    async getProcessOpenFiles(pid) {
+        try {
+            const result = await this.executeCommand(`lsof -p ${pid} -Fn`);
+            return this.parseOpenFiles(result.stdout);
+        }
+        catch (error) {
+            return [];
+        }
+    }
+    /**
+     * 获取进程环境变量
+     */
+    async getProcessEnvironment(pid) {
+        try {
+            const environContent = await this.readFile(`/proc/${pid}/environ`);
+            return this.parseEnvironment(environContent);
+        }
+        catch (error) {
+            return {};
+        }
+    }
+    /**
+     * 获取系统运行时间
+     */
+    async getSystemUptime() {
+        try {
+            const uptimeContent = await this.readFile(this.paths.uptime);
+            const uptimeFields = uptimeContent.trim().split(' ');
+            return {
+                uptime: this.safeParseNumber(uptimeFields[0]) * 1000, // 转换为毫秒
+                idleTime: this.safeParseNumber(uptimeFields[1]) * 1000 // 转换为毫秒
+            };
+        }
+        catch (error) {
+            throw this.createCommandError('getSystemUptime', error);
+        }
+    }
+    /**
+     * 获取系统用户
+     */
+    async getSystemUsers() {
+        try {
+            const result = await this.executeCommand('who');
+            return this.parseSystemUsers(result.stdout);
+        }
+        catch (error) {
+            throw this.createCommandError('getSystemUsers', error);
+        }
+    }
+    /**
+     * 获取系统服务
+     */
+    async getSystemServices() {
+        if (this.containerMode) {
+            throw this.createUnsupportedError('system.services (container)');
+        }
+        try {
+            const result = await this.executeCommand('systemctl list-units --type=service --no-pager');
+            return this.parseSystemServices(result.stdout);
+        }
+        catch (error) {
+            throw this.createCommandError('getSystemServices', error);
+        }
+    }
+    // 私有解析方法
+    parseDiskUsage(output) {
+        const lines = output.split('\n').slice(1); // 跳过标题行
+        const disks = [];
+        for (const line of lines) {
+            const fields = line.trim().split(/\s+/);
+            if (fields.length >= 6) {
+                disks.push({
+                    device: fields[0],
+                    total: this.safeParseInt(fields[1]),
+                    used: this.safeParseInt(fields[2]),
+                    available: this.safeParseInt(fields[3]),
+                    usagePercentage: this.safeParseNumber(fields[4].replace('%', '')),
+                    mountPoint: fields[5]
+                });
+            }
+        }
+        return disks;
+    }
+    parseDiskStats(content) {
+        const lines = content.split('\n').filter(line => line.trim());
+        const stats = [];
+        for (const line of lines) {
+            const fields = line.trim().split(/\s+/);
+            if (fields.length >= 14) {
+                stats.push({
+                    device: fields[2],
+                    reads: this.safeParseInt(fields[3]),
+                    readsMerged: this.safeParseInt(fields[4]),
+                    readSectors: this.safeParseInt(fields[5]),
+                    readTime: this.safeParseInt(fields[6]),
+                    writes: this.safeParseInt(fields[7]),
+                    writesMerged: this.safeParseInt(fields[8]),
+                    writeSectors: this.safeParseInt(fields[9]),
+                    writeTime: this.safeParseInt(fields[10]),
+                    ioInProgress: this.safeParseInt(fields[11]),
+                    ioTime: this.safeParseInt(fields[12]),
+                    weightedIOTime: this.safeParseInt(fields[13])
+                });
+            }
+        }
+        return stats;
+    }
+    parseMounts(content) {
+        const lines = content.split('\n').filter(line => line.trim());
+        const mounts = [];
+        for (const line of lines) {
+            const fields = line.trim().split(/\s+/);
+            if (fields.length >= 6) {
+                mounts.push({
+                    device: fields[0],
+                    mountPoint: fields[1],
+                    filesystem: fields[2],
+                    options: fields[3].split(','),
+                    dump: this.safeParseInt(fields[4]),
+                    pass: this.safeParseInt(fields[5])
+                });
+            }
+        }
+        return mounts;
+    }
+    parseFileSystems(output) {
+        const lines = output.split('\n').filter(line => line.trim());
+        const filesystems = [];
+        for (const line of lines) {
+            const trimmed = line.trim();
+            if (trimmed) {
+                const isNodev = trimmed.startsWith('nodev\t');
+                const name = isNodev ? trimmed.substring(6) : trimmed;
+                filesystems.push({
+                    name,
+                    supported: !isNodev
+                });
+            }
+        }
+        return filesystems;
+    }
+    parseNetworkConnections(output) {
+        const lines = output.split('\n').slice(1); // 跳过标题行
+        const connections = [];
+        for (const line of lines) {
+            const fields = line.trim().split(/\s+/);
+            if (fields.length >= 5) {
+                connections.push({
+                    protocol: fields[0],
+                    state: fields[1],
+                    localAddress: fields[4],
+                    foreignAddress: fields[5] || '*:*'
+                });
+            }
+        }
+        return connections;
+    }
+    parseNetstatConnections(output) {
+        const lines = output.split('\n').filter(line => {
+            const trimmed = line.trim();
+            return trimmed && !trimmed.startsWith('Proto') && !trimmed.startsWith('Active');
+        });
+        const connections = [];
+        for (const line of lines) {
+            const fields = line.trim().split(/\s+/);
+            if (fields.length < 5) {
+                continue;
+            }
+            const protocol = fields[0].toLowerCase();
+            const hasState = fields.length >= 6;
+            const localFieldIndex = 3;
+            const foreignFieldIndex = 4;
+            connections.push({
+                protocol,
+                state: hasState ? fields[5].toLowerCase() : 'unknown',
+                localAddress: fields[localFieldIndex],
+                foreignAddress: fields[foreignFieldIndex] || '*:*'
+            });
+        }
+        return connections;
+    }
+    parseDefaultGateway(output) {
+        const lines = output.split('\n');
+        for (const line of lines) {
+            const trimmed = line.trim();
+            if (!trimmed || !trimmed.startsWith('default')) {
+                continue;
+            }
+            const fields = trimmed.split(/\s+/);
+            if (fields.length === 0) {
+                continue;
+            }
+            let gateway = null;
+            let interfaceName = null;
+            for (let i = 0; i < fields.length; i++) {
+                const token = fields[i];
+                if (token === 'via' && fields[i + 1]) {
+                    gateway = fields[i + 1];
+                }
+                else if (token === 'dev' && fields[i + 1]) {
+                    interfaceName = fields[i + 1];
+                }
+            }
+            if (!gateway && fields.length > 1) {
+                const candidate = fields[1];
+                if (candidate && candidate !== 'dev' && candidate !== 'proto' && candidate !== 'metric' && candidate !== 'scope') {
+                    gateway = candidate;
+                }
+            }
+            if (gateway !== null || interfaceName !== null) {
+                return {
+                    gateway: gateway ?? null,
+                    interface: interfaceName ?? 'unknown'
+                };
+            }
+        }
+        return null;
+    }
+    parseOpenFiles(output) {
+        const lines = output.split('\n');
+        const files = [];
+        for (const line of lines) {
+            if (line.startsWith('n')) {
+                files.push(line.substring(1));
+            }
+        }
+        return files;
+    }
+    parseEnvironment(content) {
+        const env = {};
+        const variables = content.split('\0').filter(v => v);
+        for (const variable of variables) {
+            const equalIndex = variable.indexOf('=');
+            if (equalIndex > 0) {
+                const key = variable.substring(0, equalIndex);
+                const value = variable.substring(equalIndex + 1);
+                env[key] = value;
+            }
+        }
+        return env;
+    }
+    parseSystemUsers(output) {
+        const lines = output.split('\n').filter(line => line.trim());
+        const users = [];
+        for (const line of lines) {
+            const fields = line.trim().split(/\s+/);
+            if (fields.length >= 3) {
+                users.push({
+                    user: fields[0],
+                    terminal: fields[1],
+                    loginTime: fields.slice(2).join(' ')
+                });
+            }
+        }
+        return users;
+    }
+    parseSystemServices(output) {
+        const lines = output.split('\n').slice(1); // 跳过标题行
+        const services = [];
+        for (const line of lines) {
+            const fields = line.trim().split(/\s+/);
+            if (fields.length >= 4) {
+                services.push({
+                    unit: fields[0],
+                    load: fields[1],
+                    active: fields[2],
+                    sub: fields[3],
+                    description: fields.slice(4).join(' ')
+                });
+            }
+        }
+        return services;
+    }
+    async delay(ms) {
+        if (ms <= 0) {
+            return;
+        }
+        await new Promise(resolve => setTimeout(resolve, ms));
+    }
+    /**
+     * 推断主机架构
+     *
+     * 同时考虑 `uname -m`、`uname -a` 末尾字段与 `os.arch()`，过滤掉 `SMP` 等噪声标记，
+     * 尽可能返回准确的 CPU 架构标识。
+     */
+    resolveArchitecture(unameFields, machineOutput) {
+        const archPattern = /^(x86_64|amd64|arm64|aarch64|armv\d+l?|i[3-6]86|ppc64le|ppc64|s390x|mips64el|mips64|mipsel|loongarch\d*|riscv\d+|sparc64)$/i;
+        const normalize = (value) => value?.trim() || '';
+        const candidates = [];
+        const normalizedMachine = normalize(machineOutput);
+        if (normalizedMachine) {
+            candidates.push(normalizedMachine);
+        }
+        for (let i = unameFields.length - 1; i >= 0; i--) {
+            const token = normalize(unameFields[i]);
+            if (token) {
+                candidates.push(token);
+            }
+        }
+        try {
+            const runtimeArch = normalize(os_1.default.arch());
+            if (runtimeArch) {
+                candidates.push(runtimeArch);
+            }
+        }
+        catch {
+            // ignore runtime arch fetch errors
+        }
+        for (const candidate of candidates) {
+            if (candidate && archPattern.test(candidate)) {
+                return candidate;
+            }
+        }
+        return 'Unknown';
+    }
+    /**
+     * 归纳命令执行阶段的错误信息
+     *
+     * 便于在调用栈中保留主、次命令的失败原因，帮助上层监控器输出更具可读性的诊断数据。
+     */
+    summarizeErrorDetails(error) {
+        if (!error) {
+            return { message: 'Unknown error' };
+        }
+        if (error instanceof errors_1.MonitorError) {
+            return {
+                code: error.code,
+                message: error.message,
+                details: error.details || null
+            };
+        }
+        if (error instanceof Error) {
+            return {
+                name: error.name,
+                message: error.message
+            };
+        }
+        return { message: String(error) };
+    }
+    /**
+     * 检测当前进程是否运行在容器环境中
+     *
+     * 通过常见标记文件和 cgroup 信息判断，若命中则代表部分系统能力（如 systemd）不可用。
+     */
+    detectContainerEnvironment() {
+        try {
+            const indicatorPaths = ['/.dockerenv', '/run/.containerenv'];
+            for (const path of indicatorPaths) {
+                if (fsSync.existsSync(path)) {
+                    return true;
+                }
+            }
+            const cgroupPath = '/proc/1/cgroup';
+            if (fsSync.existsSync(cgroupPath)) {
+                const content = fsSync.readFileSync(cgroupPath, 'utf8');
+                if (/(docker|containerd|kubepods|lxc|podman)/i.test(content)) {
+                    return true;
+                }
+            }
+            const envIndicators = ['CONTAINER', 'KUBERNETES_SERVICE_HOST'];
+            if (envIndicators.some(key => process.env[key])) {
+                return true;
+            }
+        }
+        catch {
+            // 检测失败时默认视为非容器环境
+        }
+        return false;
+    }
+}
+exports.LinuxAdapter = LinuxAdapter;
+//# sourceMappingURL=linux-adapter.js.map