Skip to content

AI Agents & MCPs & AI Workflow Automation • (~400 MCP servers for AI agents) • AI Automation / AI Agent with MCPs • AI Workflows & AI Agents • MCPs for AI Agents

13.2 KB
Raw Blame
import os from 'os'
import { systemUsage } from '../src/system-usage'

vi.mock('fs', () => ({
    default: {
        promises: {
            readFile: vi.fn(),
        },
    },
}))

vi.mock('../src/file-system-utils', () => ({
    fileSystemUtils: {
        fileExists: vi.fn().mockResolvedValue(false),
    },
}))

vi.mock('systeminformation', () => ({
    default: {
        mem: vi.fn(),
    },
}))

vi.mock('pidtree', () => ({
    default: vi.fn(),
}))

vi.mock('pidusage', () => ({
    default: vi.fn(),
}))

vi.mock('check-disk-space', () => ({
    default: vi.fn(),
}))

import fs from 'fs'
import checkDiskSpace from 'check-disk-space'
import pidtree from 'pidtree'
import pidusage from 'pidusage'
import si from 'systeminformation'
import { fileSystemUtils } from '../src/file-system-utils'

const mockFileExists = vi.mocked(fileSystemUtils.fileExists)
const mockReadFile = vi.mocked(fs.promises.readFile)
const mockMem = vi.mocked(si.mem)
const mockPidtree = vi.mocked(pidtree)
const mockPidusage = vi.mocked(pidusage)
const mockCheckDiskSpace = vi.mocked(checkDiskSpace)

function mockCgroupFile(path: string, content: string) {
    mockFileExists.mockImplementation(async (p: string) => p === path)
    mockReadFile.mockImplementation(async (p: unknown) => {
        if (p === path) return content as never
        throw new Error('ENOENT')
    })
}

function mockCgroupFiles(files: Record<string, string>) {
    const paths = new Set(Object.keys(files))
    mockFileExists.mockImplementation(async (p: string) => paths.has(p))
    mockReadFile.mockImplementation(async (p: unknown) => {
        if (typeof p === 'string' && paths.has(p)) return files[p] as never
        throw new Error('ENOENT')
    })
}

beforeEach(() => {
    vi.restoreAllMocks()
    mockFileExists.mockResolvedValue(false)
})

describe('getContainerMemoryUsage', () => {
    it('should return cgroup v2 values when limit is valid', async () => {
        const totalBytes = 1024 * 1024 * 512 // 512 MiB
        const usedBytes = 1024 * 1024 * 256  // 256 MiB
        mockCgroupFiles({
            '/sys/fs/cgroup/memory.max': String(totalBytes),
            '/sys/fs/cgroup/memory.current': String(usedBytes),
            '/sys/fs/cgroup/memory.stat': 'inactive_file 0',
        })

        const result = await systemUsage.getContainerMemoryUsage()
        expect(result.totalRamInBytes).toBe(totalBytes)
        expect(result.ramUsage).toBeCloseTo(50)
    })

    it('should keep container-scoped cgroup usage when memory.stat is unreadable, never host memory', async () => {
        const totalBytes = 1024 * 1024 * 1024 // 1 GiB cap
        const currentBytes = 1024 * 1024 * 760 // 760 MiB
        mockCgroupFiles({
            '/sys/fs/cgroup/memory.max': String(totalBytes),
            '/sys/fs/cgroup/memory.current': String(currentBytes),
        })

        // si.mem() would report a much larger host total; it must not be used here.
        mockMem.mockResolvedValue({ total: 32_000_000_000, used: 1_000_000_000 } as never)

        const result = await systemUsage.getContainerMemoryUsage()
        expect(result.totalRamInBytes).toBe(totalBytes)
        expect(result.ramUsage).toBeCloseTo((currentBytes / totalBytes) * 100)
    })

    it('should subtract inactive_file (reclaimable cache) from cgroup v2 usage, matching docker stats', async () => {
        const totalBytes = 1024 * 1024 * 1024 // 1 GiB
        const currentBytes = 1024 * 1024 * 760 // 760 MiB reported by memory.current
        const inactiveFileBytes = 1024 * 1024 * 600 // 600 MiB reclaimable page cache
        mockCgroupFiles({
            '/sys/fs/cgroup/memory.max': String(totalBytes),
            '/sys/fs/cgroup/memory.current': String(currentBytes),
            '/sys/fs/cgroup/memory.stat': `anon 167772160\nfile 629145600\ninactive_file ${inactiveFileBytes}\nactive_file 31457280`,
        })

        const result = await systemUsage.getContainerMemoryUsage()
        expect(result.totalRamInBytes).toBe(totalBytes)
        expect(result.ramUsage).toBeCloseTo(((currentBytes - inactiveFileBytes) / totalBytes) * 100)
    })

    it('should subtract total_inactive_file from cgroup v1 usage', async () => {
        const totalBytes = 1024 * 1024 * 512 // 512 MiB
        const usageBytes = 1024 * 1024 * 400 // 400 MiB
        const inactiveFileBytes = 1024 * 1024 * 200 // 200 MiB
        mockCgroupFiles({
            '/sys/fs/cgroup/memory/memory.limit_in_bytes': String(totalBytes),
            '/sys/fs/cgroup/memory/memory.usage_in_bytes': String(usageBytes),
            '/sys/fs/cgroup/memory/memory.stat': `total_inactive_file ${inactiveFileBytes}\ntotal_active_file 100000`,
        })

        const result = await systemUsage.getContainerMemoryUsage()
        expect(result.totalRamInBytes).toBe(totalBytes)
        expect(result.ramUsage).toBeCloseTo(((usageBytes - inactiveFileBytes) / totalBytes) * 100)
    })

    it('should clamp usage to zero when inactive_file exceeds reported usage', async () => {
        const totalBytes = 1024 * 1024 * 512 // 512 MiB
        mockCgroupFiles({
            '/sys/fs/cgroup/memory.max': String(totalBytes),
            '/sys/fs/cgroup/memory.current': String(1024 * 1024 * 100),
            '/sys/fs/cgroup/memory.stat': `inactive_file ${1024 * 1024 * 200}`,
        })

        const result = await systemUsage.getContainerMemoryUsage()
        expect(result.ramUsage).toBe(0)
    })

    it('should skip cgroup v1 when limit is sentinel (unlimited)', async () => {
        const sentinel = '9223372036854771712'
        mockCgroupFiles({
            '/sys/fs/cgroup/memory/memory.limit_in_bytes': sentinel,
            '/sys/fs/cgroup/memory/memory.usage_in_bytes': '100000',
        })

        mockMem.mockResolvedValue({ total: 8_000_000_000, used: 4_000_000_000 } as never)

        const result = await systemUsage.getContainerMemoryUsage()
        expect(result.totalRamInBytes).toBe(8_000_000_000)
        expect(result.ramUsage).toBeCloseTo(50)
    })

    it('should skip cgroup v2 when limit is "max"', async () => {
        mockCgroupFiles({
            '/sys/fs/cgroup/memory.max': 'max',
            '/sys/fs/cgroup/memory.current': '100000',
        })

        mockMem.mockResolvedValue({ total: 16_000_000_000, used: 8_000_000_000 } as never)

        const result = await systemUsage.getContainerMemoryUsage()
        expect(result.totalRamInBytes).toBe(16_000_000_000)
        expect(result.ramUsage).toBeCloseTo(50)
    })

    it('should use process.constrainedMemory() when valid and no cgroup', async () => {
        const constrained = 2_000_000_000
        const available = 500_000_000
        vi.stubGlobal('process', {
            ...process,
            constrainedMemory: () => constrained,
            availableMemory: () => available,
        })

        const result = await systemUsage.getContainerMemoryUsage()
        expect(result.totalRamInBytes).toBe(constrained)
        expect(result.ramUsage).toBeCloseTo(((constrained - available) / constrained) * 100)

        vi.unstubAllGlobals()
    })

    it('should skip constrainedMemory when it returns sentinel value', async () => {
        vi.stubGlobal('process', {
            ...process,
            constrainedMemory: () => 18446744073709551615,
            availableMemory: () => 0,
        })

        mockMem.mockResolvedValue({ total: 32_000_000_000, used: 16_000_000_000 } as never)

        const result = await systemUsage.getContainerMemoryUsage()
        expect(result.totalRamInBytes).toBe(32_000_000_000)
        expect(result.ramUsage).toBeCloseTo(50)

        vi.unstubAllGlobals()
    })

    it('should fallback to si.mem() when no cgroup and no constrainedMemory', async () => {
        vi.stubGlobal('process', {
            ...process,
            constrainedMemory: undefined,
        })

        mockMem.mockResolvedValue({ total: 4_000_000_000, used: 1_000_000_000 } as never)

        const result = await systemUsage.getContainerMemoryUsage()
        expect(result.totalRamInBytes).toBe(4_000_000_000)
        expect(result.ramUsage).toBeCloseTo(25)

        vi.unstubAllGlobals()
    })
})

describe('getDiskInfo', () => {
    it('should return disk info', async () => {
        mockCheckDiskSpace.mockResolvedValue({ diskPath: '/', size: 100_000_000_000, free: 40_000_000_000 })

        const result = await systemUsage.getDiskInfo()
        expect(result).toEqual({
            total: 100_000_000_000,
            free: 40_000_000_000,
            used: 60_000_000_000,
            percentage: 60,
        })
    })

    it('should fall back to cwd when root mount fails', async () => {
        mockCheckDiskSpace
            .mockRejectedValueOnce(new Error('no root mount'))
            .mockResolvedValueOnce({ diskPath: '/app', size: 50_000_000_000, free: 25_000_000_000 })

        const result = await systemUsage.getDiskInfo()
        expect(result).toEqual({
            total: 50_000_000_000,
            free: 25_000_000_000,
            used: 25_000_000_000,
            percentage: 50,
        })
    })

    it('should return zeros when all disk lookups fail', async () => {
        mockCheckDiskSpace.mockRejectedValue(new Error('disk error'))

        const result = await systemUsage.getDiskInfo()
        expect(result).toEqual({ total: 0, free: 0, used: 0, percentage: 0 })
    })
})

describe('getCpuCores', () => {
    it('should return cgroup v2 CPU cores', async () => {
        mockCgroupFile('/sys/fs/cgroup/cpu.max', '200000 100000')

        const result = await systemUsage.getCpuCores()
        expect(result).toBe(2)
    })

    it('should return cgroup v1 CPU cores', async () => {
        mockCgroupFiles({
            '/sys/fs/cgroup/cpu/cpu.cfs_quota_us': '400000',
            '/sys/fs/cgroup/cpu/cpu.cfs_period_us': '100000',
        })

        const result = await systemUsage.getCpuCores()
        expect(result).toBe(4)
    })

    it('should fallback to os.availableParallelism()', async () => {
        const result = await systemUsage.getCpuCores()
        expect(result).toBe(os.availableParallelism?.() ?? os.cpus().length)
    })
})

describe('getCpuUsage', () => {
    it('should return a percentage between 0 and 100', () => {
        const result = systemUsage.getCpuUsage()
        expect(result).toBeGreaterThanOrEqual(0)
        expect(result).toBeLessThanOrEqual(100)
    })
})

describe('getProcessTreeMemoryBytesByPids', () => {
    function mockProcessTable(list: { pid: number, ppid: number, memory: number }[]) {
        mockPidtree.mockResolvedValue(list.map(({ pid, ppid }) => ({ pid, ppid })) as never)
        mockPidusage.mockImplementation((async (pids: number[]) => Object.fromEntries(
            list.filter(({ pid }) => pids.includes(pid)).map(({ pid, memory }) => [pid, { memory }]),
        )) as never)
    }

    it('returns an empty map without scanning when given no pids', async () => {
        const result = await systemUsage.getProcessTreeMemoryBytesByPids([])
        expect(result.size).toBe(0)
        expect(mockPidtree).not.toHaveBeenCalled()
    })

    it('sums the memory of each pid and its descendants', async () => {
        mockProcessTable([
            { pid: 100, ppid: 1, memory: 10 },
            { pid: 200, ppid: 100, memory: 20 },
            { pid: 300, ppid: 200, memory: 30 },
            { pid: 999, ppid: 1, memory: 50 },
        ])
        const result = await systemUsage.getProcessTreeMemoryBytesByPids([100, 999])
        expect(result.get(100)).toBe(10 + 20 + 30)
        expect(result.get(999)).toBe(50)
    })

    it('scans the process table and reads usage only once for many pids', async () => {
        mockProcessTable([
            { pid: 100, ppid: 1, memory: 10 },
            { pid: 200, ppid: 1, memory: 20 },
        ])
        await systemUsage.getProcessTreeMemoryBytesByPids([100, 200])
        expect(mockPidtree).toHaveBeenCalledTimes(1)
        expect(mockPidusage).toHaveBeenCalledTimes(1)
    })

    it('counts a pid that exited between the scan and the read as 0', async () => {
        mockPidtree.mockResolvedValue([{ pid: 100, ppid: 1 }, { pid: 200, ppid: 100 }] as never)
        mockPidusage.mockResolvedValue({ 100: { memory: 10 } } as never)
        const result = await systemUsage.getProcessTreeMemoryBytesByPids([100])
        expect(result.get(100)).toBe(10)
    })

    it('counts a pid that exited before its tree was read as 0 without affecting the others', async () => {
        mockProcessTable([
            { pid: 200, ppid: 1, memory: 20 },
        ])
        const result = await systemUsage.getProcessTreeMemoryBytesByPids([100, 200])
        expect(result.get(100)).toBe(0)
        expect(result.get(200)).toBe(20)
    })

    it('maps every pid to 0 when scanning the process table fails', async () => {
        mockPidtree.mockRejectedValue(new Error('ps failed'))
        const result = await systemUsage.getProcessTreeMemoryBytesByPids([100, 200])
        expect(result.get(100)).toBe(0)
        expect(result.get(200)).toBe(0)
        expect(mockPidusage).not.toHaveBeenCalled()
    })

    it('maps every pid to 0 when reading usage fails', async () => {
        mockPidtree.mockResolvedValue([{ pid: 100, ppid: 1 }] as never)
        mockPidusage.mockRejectedValue(new Error('read failed'))
        const result = await systemUsage.getProcessTreeMemoryBytesByPids([100, 200])
        expect(result.get(100)).toBe(0)
        expect(result.get(200)).toBe(0)
    })
})