@aflueza/dev-tools 0.0.0-stage → 0.2.1-rc.2

package/lib/process-manager/service.js

@@ -0,0 +1,708 @@
+import { execFile } from 'node:child_process';
+import { mkdtemp, opendir, rm, stat, writeFile } from 'node:fs/promises';
+import { tmpdir, totalmem } from 'node:os';
+import { join, resolve } from 'node:path';
+import { promisify } from 'node:util';
+import * as systeminformation from 'systeminformation';
+const execFileAsync = promisify(execFile);
+const FILE_LOCK_BATCH_SIZE = 64;
+export class ProcessManagerError extends Error {
+    code;
+    details;
+    constructor(code, message, details = {}) {
+        super(message);
+        this.name = 'ProcessManagerError';
+        this.code = code;
+        this.details = details;
+    }
+}
+export async function listProcesses(query) {
+    const snapshot = await buildProcessSnapshot();
+    const normalizedQuery = normalizeQuery(query);
+    const summaries = snapshot.processes.flatMap((process) => {
+        const { summary, commandLine } = summarizeProcess(process, snapshot.portMap);
+        const matchReason = matchesQuery(summary, commandLine, normalizedQuery);
+        if (normalizedQuery !== null && matchReason === null)
+            return [];
+        return [{ ...summary, matchReason }];
+    });
+    summaries.sort((left, right) => {
+        return (right.cpuPercent - left.cpuPercent ||
+            right.memoryBytes - left.memoryBytes ||
+            left.name.localeCompare(right.name) ||
+            left.pid - right.pid);
+    });
+    return summaries;
+}
+export async function getProcessDetail(pid) {
+    const snapshot = await buildProcessSnapshot();
+    const process = snapshot.processes.find((item) => item.pid === pid);
+    if (process === undefined) {
+        throw new ProcessManagerError('process-not-found', `process ${pid} was not found`);
+    }
+    const { summary, commandLine, bindings } = summarizeProcess(process, snapshot.portMap);
+    return {
+        ...summary,
+        commandLine,
+        parentPid: process.parentPid > 0 ? process.parentPid : null,
+        userName: process.user || null,
+        portBindings: bindings,
+    };
+}
+export async function findFileLockers(path) {
+    const normalizedPath = normalizeFilePath(path);
+    const target = await resolveFileLockTarget(normalizedPath);
+    const scan = target.targetType === 'directory'
+        ? await scanDirectoryFileLockers(target.path)
+        : {
+            candidates: await queryFileLockerCandidates([target.path]),
+            scannedFileCount: null,
+        };
+    if (scan.candidates.length === 0) {
+        return {
+            path: target.path,
+            targetType: target.targetType,
+            scannedFileCount: scan.scannedFileCount,
+            lockers: [],
+        };
+    }
+    const snapshot = await buildProcessSnapshot();
+    const processMap = new Map(snapshot.processes.map((process) => [process.pid, process]));
+    const lockers = scan.candidates.map((candidate) => {
+        const process = processMap.get(candidate.pid);
+        const summary = process
+            ? summarizeProcess(process, snapshot.portMap).summary
+            : emptyProcessSummary(candidate.pid, candidate.applicationName);
+        return {
+            ...summary,
+            matchReason: 'fileLock',
+            applicationName: candidate.applicationName,
+            applicationType: candidate.applicationType,
+            restartable: candidate.restartable,
+        };
+    });
+    lockers.sort((left, right) => {
+        return left.name.localeCompare(right.name) || left.pid - right.pid;
+    });
+    return {
+        path: target.path,
+        targetType: target.targetType,
+        scannedFileCount: scan.scannedFileCount,
+        lockers,
+    };
+}
+export function terminateProcess(pid, force = false) {
+    const signalMode = force ? 'force' : 'graceful';
+    const signal = force ? 'SIGKILL' : 'SIGTERM';
+    try {
+        process.kill(pid, signal);
+    }
+    catch (error) {
+        throw mapKillError(error, pid, force);
+    }
+    return {
+        success: true,
+        pid,
+        action: 'terminate',
+        signalMode,
+        message: force ? '进程已强制结束' : '进程已发送结束信号',
+    };
+}
+function summarizeProcess(process, portMap) {
+    const bindings = portMap.get(process.pid) ?? [];
+    const commandLine = commandLineOf(process);
+    return {
+        summary: {
+            pid: process.pid,
+            name: process.name || process.command || `PID ${process.pid}`,
+            exePath: process.path || null,
+            commandPreview: commandPreview(commandLine),
+            ports: uniquePorts(bindings),
+            cpuPercent: roundCpu(process.cpu),
+            memoryBytes: memoryBytesOf(process),
+            status: mapProcessStatus(process.state),
+            startedAt: normalizeStartedAt(process.started),
+            matchReason: null,
+        },
+        commandLine,
+        bindings,
+    };
+}
+function emptyProcessSummary(pid, applicationName) {
+    return {
+        pid,
+        name: applicationName || `PID ${pid}`,
+        exePath: null,
+        commandPreview: null,
+        ports: [],
+        cpuPercent: 0,
+        memoryBytes: 0,
+        status: 'unknown',
+        startedAt: null,
+        matchReason: 'fileLock',
+    };
+}
+async function buildProcessSnapshot() {
+    try {
+        const [processInfo, connections] = await Promise.all([
+            systeminformation.processes(),
+            systeminformation.networkConnections(),
+        ]);
+        return {
+            processes: processInfo.list,
+            portMap: collectPortMap(connections),
+        };
+    }
+    catch (error) {
+        throw new ProcessManagerError('collection-failed', error instanceof Error ? error.message : String(error));
+    }
+}
+async function queryFileLockerCandidates(paths) {
+    if (process.platform === 'win32') {
+        return queryWindowsFileLockers(paths);
+    }
+    return queryUnixFileLockers(paths);
+}
+async function queryWindowsFileLockers(paths) {
+    let tempDirectory = null;
+    try {
+        tempDirectory = await mkdtemp(join(tmpdir(), 'dsh-dev-tools-lock-'));
+        const manifestPath = join(tempDirectory, 'paths.json');
+        await writeFile(manifestPath, JSON.stringify(paths), 'utf8');
+        const { stdout } = await execFileAsync('powershell.exe', [
+            '-NoLogo',
+            '-NoProfile',
+            '-NonInteractive',
+            '-ExecutionPolicy',
+            'Bypass',
+            '-Command',
+            WINDOWS_FILE_LOCK_SCRIPT,
+        ], {
+            encoding: 'utf8',
+            env: { ...process.env, DEV_TOOLS_LOCK_PATHS_PATH: manifestPath },
+            maxBuffer: 1024 * 1024,
+            windowsHide: true,
+        });
+        const parsed = JSON.parse(stdout.trim() || '[]');
+        const rows = Array.isArray(parsed) ? parsed : [parsed];
+        const candidates = rows.flatMap((value) => {
+            if (typeof value !== 'object' || value === null)
+                return [];
+            const row = value;
+            const pid = Number(row.ProcessId ?? row.processId);
+            if (!Number.isInteger(pid) || pid <= 0)
+                return [];
+            return [
+                {
+                    pid,
+                    applicationName: stringOrNull(row.ApplicationName ?? row.applicationName),
+                    applicationType: mapWindowsApplicationType(Number(row.ApplicationType ?? row.applicationType)),
+                    restartable: booleanOrNull(row.Restartable ?? row.restartable),
+                },
+            ];
+        });
+        return dedupeFileLockerCandidates(candidates);
+    }
+    catch (error) {
+        if (isExecFileError(error) && error.code === 'ENOENT') {
+            throw new ProcessManagerError('unsupported-platform', '未找到 powershell.exe，当前系统无法查询文件占用进程。');
+        }
+        throw new ProcessManagerError('file-lock-query-failed', fileLockErrorMessage(error), {
+            fileCount: paths.length,
+        });
+    }
+    finally {
+        if (tempDirectory !== null) {
+            await rm(tempDirectory, { recursive: true, force: true }).catch(() => undefined);
+        }
+    }
+}
+async function queryUnixFileLockers(paths) {
+    const candidates = [];
+    const batchSize = 128;
+    for (let index = 0; index < paths.length; index += batchSize) {
+        const batch = paths.slice(index, index + batchSize);
+        try {
+            const { stdout } = await execFileAsync('lsof', ['-t', '--', ...batch], {
+                encoding: 'utf8',
+                maxBuffer: 1024 * 1024,
+            });
+            candidates.push(...stdout
+                .split(/\r?\n/)
+                .map((line) => Number(line.trim()))
+                .filter((pid) => Number.isInteger(pid) && pid > 0)
+                .map((pid) => ({
+                pid,
+                applicationName: null,
+                applicationType: null,
+                restartable: null,
+            })));
+        }
+        catch (error) {
+            if (isExecFileError(error) && error.code === 'ENOENT') {
+                throw new ProcessManagerError('unsupported-platform', '当前系统未安装 lsof，无法查询文件占用进程。');
+            }
+            if (isExecFileError(error) && String(error.code) === '1') {
+                continue;
+            }
+            throw new ProcessManagerError('file-lock-query-failed', fileLockErrorMessage(error), {
+                fileCount: paths.length,
+            });
+        }
+    }
+    return dedupeFileLockerCandidates(candidates);
+}
+function dedupeFileLockerCandidates(candidates) {
+    return [...new Map(candidates.map((candidate) => [candidate.pid, candidate])).values()];
+}
+function normalizeFilePath(value) {
+    const trimmed = value.trim().replace(/^"(.*)"$/, '$1');
+    if (!trimmed) {
+        throw new ProcessManagerError('invalid-payload', '文件路径不能为空');
+    }
+    return resolve(trimmed);
+}
+async function resolveFileLockTarget(path) {
+    let info;
+    try {
+        info = await stat(path);
+    }
+    catch (error) {
+        throw mapPathAccessError(error, path);
+    }
+    if (info.isFile()) {
+        return {
+            path,
+            targetType: 'file',
+        };
+    }
+    if (info.isDirectory()) {
+        return {
+            path,
+            targetType: 'directory',
+        };
+    }
+    throw new ProcessManagerError('invalid-payload', '仅支持查询文件或目录的占用进程', {
+        path,
+    });
+}
+async function scanDirectoryFileLockers(rootPath) {
+    let scannedFileCount = 0;
+    for await (const batch of iterateDirectoryFileBatches(rootPath)) {
+        scannedFileCount += batch.length;
+        const candidates = await queryFileLockerCandidates(batch);
+        if (candidates.length > 0) {
+            return { candidates, scannedFileCount };
+        }
+    }
+    return { candidates: [], scannedFileCount };
+}
+async function* iterateDirectoryFileBatches(rootPath) {
+    const pendingDirectories = [rootPath];
+    let batch = [];
+    while (pendingDirectories.length > 0) {
+        const directory = pendingDirectories.pop();
+        let directoryHandle;
+        try {
+            directoryHandle = await opendir(directory);
+        }
+        catch (error) {
+            if (directory === rootPath)
+                throw mapPathAccessError(error, rootPath);
+            continue;
+        }
+        try {
+            for await (const entry of directoryHandle) {
+                const entryPath = join(directory, entry.name);
+                if (entry.isDirectory()) {
+                    pendingDirectories.push(entryPath);
+                    continue;
+                }
+                if (entry.isFile()) {
+                    batch.push(entryPath);
+                }
+                else if (entry.isSymbolicLink()) {
+                    try {
+                        const targetInfo = await stat(entryPath);
+                        if (targetInfo.isFile())
+                            batch.push(entryPath);
+                    }
+                    catch {
+                        // A broken or inaccessible link cannot contribute to a directory lock scan.
+                    }
+                }
+                if (batch.length >= FILE_LOCK_BATCH_SIZE) {
+                    yield batch;
+                    batch = [];
+                }
+            }
+        }
+        finally {
+            await directoryHandle.close().catch(() => undefined);
+        }
+    }
+    if (batch.length > 0)
+        yield batch;
+}
+function mapPathAccessError(error, path) {
+    if (isNodeError(error) && error.code === 'ENOENT') {
+        return new ProcessManagerError('file-not-found', `路径不存在: ${path}`, { path });
+    }
+    if (isNodeError(error) && (error.code === 'EACCES' || error.code === 'EPERM')) {
+        return new ProcessManagerError('permission-denied', `没有权限读取路径: ${path}`, { path });
+    }
+    return new ProcessManagerError('file-lock-query-failed', fileLockErrorMessage(error), {
+        path,
+    });
+}
+function collectPortMap(connections) {
+    const result = new Map();
+    for (const connection of connections) {
+        if (connection.pid <= 0)
+            continue;
+        const protocol = mapPortProtocol(connection.protocol);
+        if (protocol === null)
+            continue;
+        const localPort = parsePort(connection.localPort);
+        if (localPort === null)
+            continue;
+        const binding = {
+            protocol,
+            localAddress: connection.localAddress || '-',
+            localPort,
+            remoteAddress: normalizePeerValue(connection.peerAddress),
+            remotePort: parsePort(connection.peerPort),
+            state: connection.state || null,
+        };
+        const bindings = result.get(connection.pid) ?? [];
+        bindings.push(binding);
+        result.set(connection.pid, bindings);
+    }
+    return result;
+}
+function mapPortProtocol(protocol) {
+    const normalized = protocol.toLowerCase();
+    if (normalized.startsWith('tcp'))
+        return 'tcp';
+    if (normalized.startsWith('udp'))
+        return 'udp';
+    return null;
+}
+function parsePort(value) {
+    if (!value || value === '*')
+        return null;
+    const port = Number.parseInt(value, 10);
+    if (!Number.isInteger(port) || port < 0 || port > 65535)
+        return null;
+    return port;
+}
+function normalizePeerValue(value) {
+    if (!value || value === '*' || value === '0.0.0.0' || value === '::')
+        return null;
+    return value;
+}
+function commandLineOf(process) {
+    const command = process.command.trim();
+    const params = process.params.trim();
+    const value = params && !command.includes(params) ? `${command} ${params}` : command;
+    return value ? [value] : [];
+}
+function commandPreview(commandLine) {
+    const value = commandLine.join(' ').trim();
+    return value || null;
+}
+function memoryBytesOf(process) {
+    const rssBytes = Math.max(0, process.memRss) * 1024;
+    if (rssBytes > 0)
+        return rssBytes;
+    return Math.max(0, Math.round((Math.max(0, process.mem) / 100) * totalmem()));
+}
+function uniquePorts(bindings) {
+    return [...new Set(bindings.map((binding) => binding.localPort))].sort((left, right) => left - right);
+}
+function normalizeQuery(query) {
+    const normalized = query.trim().toLowerCase();
+    return normalized || null;
+}
+function matchesQuery(summary, commandLine, query) {
+    if (query === null)
+        return null;
+    if (summary.name.toLowerCase().includes(query))
+        return 'name';
+    if (String(summary.pid).includes(query))
+        return 'pid';
+    if (summary.ports.some((port) => String(port).includes(query)))
+        return 'port';
+    if (summary.exePath?.toLowerCase().includes(query))
+        return 'path';
+    if (commandLine.some((segment) => segment.toLowerCase().includes(query)))
+        return 'commandLine';
+    return null;
+}
+function roundCpu(value) {
+    return Math.round(Math.max(0, value) * 10) / 10;
+}
+function normalizeStartedAt(value) {
+    const trimmed = value.trim();
+    if (!trimmed)
+        return null;
+    const timestamp = new Date(trimmed);
+    return Number.isNaN(timestamp.getTime()) ? trimmed : timestamp.toISOString();
+}
+function mapProcessStatus(value) {
+    const status = value.toLowerCase();
+    if (status.includes('running') || status === 'run' || status === 'ready')
+        return 'running';
+    if (status.includes('sleeping') || status === 'sleep')
+        return 'sleeping';
+    if (status.includes('idle'))
+        return 'idle';
+    if (status.includes('zombie'))
+        return 'zombie';
+    if (status.includes('tracing') || status.includes('trace'))
+        return 'tracing';
+    if (status.includes('dead') || status.includes('terminated'))
+        return 'dead';
+    if (status.includes('wakekill'))
+        return 'wakekill';
+    if (status.includes('waking'))
+        return 'waking';
+    if (status.includes('parked'))
+        return 'parked';
+    if (status.includes('uninterruptible'))
+        return 'uninterruptibleDiskSleep';
+    if (status.includes('blocked'))
+        return 'lockBlocked';
+    if (status.includes('stop') || status.includes('suspended'))
+        return 'stopped';
+    return 'unknown';
+}
+function mapKillError(error, pid, force) {
+    const code = errorCode(error);
+    const action = force ? '强制结束' : '结束';
+    if (code === 'ESRCH') {
+        return new ProcessManagerError('process-not-found', `process ${pid} was not found`, { pid });
+    }
+    if (code === 'EPERM' || code === 'EACCES') {
+        return new ProcessManagerError('permission-denied', `没有权限${action}进程 ${pid}`, { pid });
+    }
+    return new ProcessManagerError('terminate-failed', error instanceof Error ? error.message : String(error), { pid });
+}
+function errorCode(error) {
+    if (typeof error !== 'object' || error === null || !('code' in error))
+        return null;
+    const code = error.code;
+    return typeof code === 'string' ? code : null;
+}
+function stringOrNull(value) {
+    return typeof value === 'string' && value.trim() ? value.trim() : null;
+}
+function booleanOrNull(value) {
+    return typeof value === 'boolean' ? value : null;
+}
+function mapWindowsApplicationType(value) {
+    if (!Number.isInteger(value))
+        return null;
+    switch (value) {
+        case 0:
+            return 'unknown';
+        case 1:
+            return 'mainWindow';
+        case 2:
+            return 'otherWindow';
+        case 3:
+            return 'service';
+        case 4:
+            return 'explorer';
+        case 5:
+            return 'console';
+        case 1000:
+            return 'critical';
+        default:
+            return `type${value}`;
+    }
+}
+function isExecFileError(error) {
+    return error instanceof Error && 'code' in error;
+}
+function isNodeError(error) {
+    return error instanceof Error && 'code' in error;
+}
+function fileLockErrorMessage(error) {
+    if (isExecFileError(error)) {
+        const stderr = Buffer.isBuffer(error.stderr) ? error.stderr.toString('utf8') : error.stderr;
+        const detail = stderr
+            ?.split(/\r?\n/)
+            .map((line) => line.trim())
+            .filter((line) => line && !line.startsWith('+') && !line.startsWith('At line'))
+            .find((line) => /exception|异常|failed/i.test(line)) ??
+            stderr
+                ?.split(/\r?\n/)
+                .map((line) => line.trim())
+                .filter((line) => line && !line.startsWith('+') && !line.startsWith('At line'))
+                .at(-1);
+        if (detail)
+            return detail;
+    }
+    return error instanceof Error ? error.message : String(error);
+}
+const WINDOWS_FILE_LOCK_SCRIPT = String.raw `
+$ErrorActionPreference = 'Stop'
+[Console]::OutputEncoding = [System.Text.UTF8Encoding]::new($false)
+
+$source = @'
+using System;
+using System.Runtime.InteropServices;
+using System.Text;
+
+public static class RestartManagerProbe
+{
+    private const int ERROR_SUCCESS = 0;
+    private const int ERROR_MORE_DATA = 234;
+
+    [StructLayout(LayoutKind.Sequential)]
+    private struct RM_UNIQUE_PROCESS
+    {
+        public int dwProcessId;
+        public System.Runtime.InteropServices.ComTypes.FILETIME ProcessStartTime;
+    }
+
+    [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
+    private struct RM_PROCESS_INFO
+    {
+        public RM_UNIQUE_PROCESS Process;
+        [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 256)]
+        public string strAppName;
+        [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 64)]
+        public string strServiceShortName;
+        public int ApplicationType;
+        public uint AppStatus;
+        public uint TSSessionId;
+        [MarshalAs(UnmanagedType.Bool)]
+        public bool bRestartable;
+    }
+
+    [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
+    public struct RestartManagerEntry
+    {
+        public int ProcessId;
+        [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 256)]
+        public string ApplicationName;
+        [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 64)]
+        public string ServiceShortName;
+        public int ApplicationType;
+        public uint ApplicationStatus;
+        public uint TerminalSessionId;
+        [MarshalAs(UnmanagedType.Bool)]
+        public bool Restartable;
+    }
+
+    [DllImport("rstrtmgr.dll", CharSet = CharSet.Unicode)]
+    private static extern int RmStartSession(
+        out uint pSessionHandle,
+        int dwSessionFlags,
+        StringBuilder strSessionKey);
+
+    [DllImport("rstrtmgr.dll", CharSet = CharSet.Unicode)]
+    private static extern int RmRegisterResources(
+        uint dwSessionHandle,
+        uint nFiles,
+        [In, MarshalAs(UnmanagedType.LPArray, ArraySubType = UnmanagedType.LPWStr)]
+        string[] rgsFilenames,
+        uint nApplications,
+        RM_UNIQUE_PROCESS[] rgApplications,
+        uint nServices,
+        [MarshalAs(UnmanagedType.LPArray, ArraySubType = UnmanagedType.LPWStr)]
+        string[] rgsServiceNames);
+
+    [DllImport("rstrtmgr.dll")]
+    private static extern int RmGetList(
+        uint dwSessionHandle,
+        out uint pnProcInfoNeeded,
+        ref uint pnProcInfo,
+        [In, Out] RM_PROCESS_INFO[] rgAffectedApps,
+        ref uint lpdwRebootReasons);
+
+    [DllImport("rstrtmgr.dll")]
+    private static extern int RmEndSession(uint dwSessionHandle);
+
+    public static RestartManagerEntry[] Lockers(string[] paths)
+    {
+        if (paths == null || paths.Length == 0)
+        {
+            return Array.Empty<RestartManagerEntry>();
+        }
+
+        uint session;
+        var key = new StringBuilder(33);
+        var result = RmStartSession(out session, 0, key);
+        if (result != ERROR_SUCCESS)
+        {
+            throw new System.ComponentModel.Win32Exception(result);
+        }
+
+        try
+        {
+            result = RmRegisterResources(session, (uint)paths.Length, paths, 0, null, 0, null);
+            if (result != ERROR_SUCCESS)
+            {
+                throw new System.ComponentModel.Win32Exception(
+                    result,
+                    "RmRegisterResources failed for " + paths.Length + " files");
+            }
+
+            uint needed = 0;
+            uint count = 0;
+            uint reasons = 0;
+            result = RmGetList(session, out needed, ref count, null, ref reasons);
+            if (result == ERROR_SUCCESS)
+            {
+                return Array.Empty<RestartManagerEntry>();
+            }
+            if (result != ERROR_MORE_DATA)
+            {
+                throw new System.ComponentModel.Win32Exception(
+                    result,
+                    "RmGetList size query failed (" + result + ": "
+                        + new System.ComponentModel.Win32Exception(result).Message + ")");
+            }
+
+            count = needed;
+            var processes = new RM_PROCESS_INFO[count];
+            result = RmGetList(session, out needed, ref count, processes, ref reasons);
+            if (result != ERROR_SUCCESS)
+            {
+                throw new System.ComponentModel.Win32Exception(
+                    result,
+                    "RmGetList result read failed");
+            }
+
+            var lockers = new RestartManagerEntry[count];
+            for (var index = 0; index < count; index += 1)
+            {
+                lockers[index] = new RestartManagerEntry
+                {
+                    ProcessId = processes[index].Process.dwProcessId,
+                    ApplicationName = processes[index].strAppName,
+                    ServiceShortName = processes[index].strServiceShortName,
+                    ApplicationType = processes[index].ApplicationType,
+                    ApplicationStatus = processes[index].AppStatus,
+                    TerminalSessionId = processes[index].TSSessionId,
+                    Restartable = processes[index].bRestartable,
+                };
+            }
+            return lockers;
+        }
+        finally
+        {
+            RmEndSession(session);
+        }
+    }
+}
+'@
+
+Add-Type -TypeDefinition $source -Language CSharp
+$paths = [string[]](Get-Content -Raw -LiteralPath $env:DEV_TOOLS_LOCK_PATHS_PATH | ConvertFrom-Json)
+$lockers = @([RestartManagerProbe]::Lockers([string[]]$paths))
+ConvertTo-Json -InputObject $lockers -Compress -Depth 4
+`;

package/lib/shared/api-runner.js

@@ -0,0 +1 @@
+export {};