@wwkit/opm 1.0.1 → 1.0.3

package/src/managers/proc.js

@@ -0,0 +1,424 @@
+/**
+ * proc 管理器 — 进程与系统信息管理
+ *
+ * 基于 systeminformation 库 + netstat 回退，提供：
+ *   系统信息、进程列表、进程搜索、端口列表、进程终止、进程树、进程详情
+ *
+ * 端口映射：优先 systeminformation.networkConnections()，
+ * 回退 netstat -tlnp（Linux）/ netstat -ano（Windows）。
+ */
+
+import si from 'systeminformation'
+import { spawn } from 'node:child_process'
+import { Shell } from '@wwkit/shared'
+
+const shell = new Shell()
+
+/**
+ * MB 字节数转换
+ * @param {number} bytes
+ * @returns {number}
+ */
+function toMB(bytes) {
+  return Math.round(bytes / 1024 / 1024)
+}
+
+/**
+ * 获取端口→进程映射
+ * @returns {Promise<Map<number, {pid: number, name: string}>>}
+ */
+export async function getPortMap() {
+  const map = new Map()
+
+  try {
+    const conns = await si.networkConnections()
+    for (const c of conns) {
+      if (c.state === 'listen' && c.localPort && c.pid) {
+        if (!map.has(c.localPort)) {
+          map.set(c.localPort, { pid: c.pid, name: c.process || '' })
+        }
+      }
+    }
+    if (map.size > 0) return map
+  } catch {}
+
+  const fallback = shell.isWindows ? 'netstat' : 'netstat'
+  const args = shell.isWindows ? ['-ano'] : ['-tlnp']
+
+  return new Promise((resolve) => {
+    const child = spawn(fallback, args, { stdio: ['pipe', 'pipe', 'pipe'] })
+    let stdout = ''
+    child.stdout.on('data', (d) => { stdout += d })
+    child.on('close', () => {
+      const lines = stdout.split('\n')
+      for (const line of lines) {
+        if (!line.includes('LISTEN')) continue
+        let port = null
+        let pid = null
+        let name = ''
+
+        if (shell.isWindows) {
+          const m = line.match(/(\d+)\s*$/)
+          if (m) pid = parseInt(m[1], 10)
+          const addrMatch = line.match(/[:\.](\d+)\s/)
+          if (addrMatch) port = parseInt(addrMatch[1], 10)
+        } else {
+          const parts = line.trim().split(/\s+/)
+          if (parts.length >= 6) {
+            const localAddr = parts[3] || parts[1] || ''
+            const portMatch = localAddr.match(/:(\d+)$/)
+            if (portMatch) port = parseInt(portMatch[1], 10)
+            const pidPart = parts[parts.length - 1] || ''
+            const pidMatch = pidPart.match(/^(\d+)\/(.+)/)
+            if (pidMatch) {
+              pid = parseInt(pidMatch[1], 10)
+              name = pidMatch[2]
+            }
+          }
+        }
+
+        if (port && pid && !map.has(port)) {
+          map.set(port, { pid, name })
+        }
+      }
+      resolve(map)
+    })
+    child.on('error', () => resolve(map))
+  })
+}
+
+/**
+ * 获取系统信息
+ * @returns {Promise<object>}
+ */
+export async function getSystemInfo() {
+  const [osInfo, cpuInfo, memInfo, fsInfo, timeInfo] = await Promise.all([
+    si.osInfo(),
+    si.cpu(),
+    si.mem(),
+    si.fsSize(),
+    si.time(),
+  ])
+
+  return {
+    os: {
+      platform: osInfo.platform,
+      distro: osInfo.distro,
+      release: osInfo.release,
+      arch: osInfo.arch,
+      hostname: osInfo.hostname,
+      kernel: osInfo.kernel,
+    },
+    cpu: {
+      manufacturer: cpuInfo.manufacturer,
+      brand: cpuInfo.brand,
+      cores: cpuInfo.cores,
+      speed: cpuInfo.speed ? `${cpuInfo.speed}GHz` : '',
+    },
+    memory: {
+      total: toMB(memInfo.total),
+      used: toMB(memInfo.active),
+      available: toMB(memInfo.available),
+      unit: 'MB',
+    },
+    disk: fsInfo.map((f) => ({
+      fs: f.fs,
+      mount: f.mount,
+      total: toMB(f.size),
+      used: toMB(f.used),
+      available: toMB(f.available),
+      use: f.use,
+      unit: 'MB',
+    })),
+    uptime: Math.round(timeInfo.uptime),
+  }
+}
+
+/**
+ * 获取进程列表（排序后取前 N 个）
+ * @param {number} count - 数量
+ * @param {'mem'|'cpu'} sortBy - 排序字段
+ * @returns {Promise<object>}
+ */
+export async function listProcesses(count, sortBy) {
+  const [procs, portMap] = await Promise.all([
+    si.processes(),
+    getPortMap(),
+  ])
+
+  const pidToPorts = new Map()
+  for (const [port, info] of portMap) {
+    const arr = pidToPorts.get(info.pid) || []
+    arr.push(port)
+    pidToPorts.set(info.pid, arr)
+  }
+
+  const list = procs.list.map((p) => ({
+    pid: p.pid,
+    parentPid: p.parentPid,
+    name: p.name,
+    mem: Math.round(p.memRss / 1024),
+    memPercent: Math.round(p.mem * 100) / 100,
+    cpu: Math.round(p.cpu * 100) / 100,
+    ports: pidToPorts.get(p.pid) || [],
+    user: p.user || '',
+    state: p.state || '',
+    started: p.started || '',
+  }))
+
+  list.sort((a, b) => {
+    if (sortBy === 'cpu') return b.cpu - a.cpu
+    return b.mem - a.mem
+  })
+
+  return {
+    count,
+    sortBy,
+    processes: list.slice(0, count),
+  }
+}
+
+/**
+ * 搜索进程
+ * @param {{name?: string, port?: string, exact?: boolean}} opts
+ * @returns {Promise<object>}
+ */
+export async function searchProcesses({ name, port, exact }) {
+  const [procs, portMap] = await Promise.all([
+    si.processes(),
+    getPortMap(),
+  ])
+
+  const pidToPorts = new Map()
+  for (const [p, info] of portMap) {
+    const arr = pidToPorts.get(info.pid) || []
+    arr.push(p)
+    pidToPorts.set(info.pid, arr)
+  }
+
+  let list = procs.list.map((p) => ({
+    pid: p.pid,
+    parentPid: p.parentPid,
+    name: p.name,
+    mem: Math.round(p.memRss / 1024),
+    memPercent: Math.round(p.mem * 100) / 100,
+    cpu: Math.round(p.cpu * 100) / 100,
+    ports: pidToPorts.get(p.pid) || [],
+    user: p.user || '',
+    state: p.state || '',
+    started: p.started || '',
+    command: p.command,
+    params: p.params,
+  }))
+
+  if (name) {
+    if (exact) {
+      list = list.filter((p) => p.name === name || p.command === name)
+    } else {
+      const lower = name.toLowerCase()
+      list = list.filter((p) =>
+        p.name.toLowerCase().includes(lower) ||
+        (p.command && p.command.toLowerCase().includes(lower))
+      )
+    }
+  }
+
+  if (port) {
+    const portNum = parseInt(port, 10)
+    list = list.filter((p) => p.ports.includes(portNum))
+  }
+
+  return {
+    name: name || null,
+    port: port || null,
+    exact: !!exact,
+    count: list.length,
+    processes: list,
+  }
+}
+
+/**
+ * 列出监听端口
+ * @param {string} [portFilter] - 可选端口过滤
+ * @returns {Promise<object>}
+ */
+export async function listPorts(portFilter) {
+  const portMap = await getPortMap()
+  const procs = await si.processes()
+  const procMap = new Map(procs.list.map((p) => [p.pid, p]))
+
+  let entries = []
+  for (const [port, info] of portMap) {
+    const proc = procMap.get(info.pid)
+    entries.push({
+      port,
+      pid: info.pid,
+      name: info.name || (proc ? proc.name : ''),
+      user: proc ? proc.user : '',
+      state: proc ? proc.state : '',
+      started: proc ? proc.started : '',
+    })
+  }
+
+  entries.sort((a, b) => a.port - b.port)
+
+  if (portFilter) {
+    const portNum = parseInt(portFilter, 10)
+    entries = entries.filter((e) => e.port === portNum)
+  }
+
+  return {
+    port: portFilter || null,
+    count: entries.length,
+    ports: entries,
+  }
+}
+
+/**
+ * 终止进程
+ * @param {number} pid
+ * @param {'SIGTERM'|'SIGKILL'} signal
+ * @returns {Promise<object>}
+ */
+export async function killByPid(pid, signal) {
+  try {
+    process.kill(pid, signal)
+    return { pid, signal, killed: true }
+  } catch (err) {
+    return { pid, signal, killed: false, error: err.message }
+  }
+}
+
+/**
+ * 按端口终止进程
+ * @param {number} port
+ * @param {'SIGTERM'|'SIGKILL'} signal
+ * @returns {Promise<object>}
+ */
+export async function killByPort(port, signal) {
+  const portMap = await getPortMap()
+  const info = portMap.get(port)
+  if (!info) {
+    return { port, signal, killed: [], error: `No process listening on port ${port}` }
+  }
+  const result = await killByPid(info.pid, signal)
+  return { port, signal, killed: [{ pid: info.pid, name: info.name, ...result }] }
+}
+
+/**
+ * 按名称终止进程
+ * @param {string} name - 进程名
+ * @param {'SIGTERM'|'SIGKILL'} signal
+ * @returns {Promise<object>}
+ */
+export async function killByName(name, signal) {
+  const procs = await si.processes()
+  const lower = name.toLowerCase()
+  const matched = procs.list.filter((p) =>
+    p.name.toLowerCase().includes(lower) ||
+    (p.command && p.command.toLowerCase().includes(lower))
+  )
+
+  if (matched.length === 0) {
+    return { name, signal, killed: [], error: `No process found matching "${name}"` }
+  }
+
+  const results = []
+  for (const p of matched) {
+    const result = await killByPid(p.pid, signal)
+    results.push({ pid: p.pid, name: p.name, ...result })
+  }
+
+  return { name, signal, killed: results }
+}
+
+/**
+ * 获取进程树
+ * @param {number} [rootPid] - 根 PID（可选，不传则显示所有顶层进程）
+ * @returns {Promise<object>}
+ */
+export async function getProcessTree(rootPid) {
+  const procs = await si.processes()
+  const procMap = new Map(procs.list.map((p) => [p.pid, p]))
+  const childrenMap = new Map()
+  for (const p of procs.list) {
+    const arr = childrenMap.get(p.parentPid) || []
+    arr.push(p)
+    childrenMap.set(p.parentPid, arr)
+  }
+
+  function buildNode(pid) {
+    const proc = procMap.get(pid)
+    if (!proc) return null
+    const children = (childrenMap.get(pid) || []).map((c) => buildNode(c.pid)).filter(Boolean)
+    return {
+      pid: proc.pid,
+      parentPid: proc.parentPid,
+      name: proc.name,
+      mem: Math.round(proc.memRss / 1024),
+      cpu: Math.round(proc.cpu * 100) / 100,
+      state: proc.state || '',
+      children,
+    }
+  }
+
+  if (rootPid) {
+    const tree = buildNode(rootPid)
+    return { rootPid, tree }
+  }
+
+  const topPids = procs.list
+    .filter((p) => !procMap.has(p.parentPid))
+    .map((p) => p.pid)
+    .sort((a, b) => a - b)
+
+  const trees = topPids.map((pid) => buildNode(pid)).filter(Boolean)
+  return { rootPid: null, trees }
+}
+
+/**
+ * 获取进程详情
+ * @param {number} pid
+ * @returns {Promise<object>}
+ */
+export async function getProcessDetail(pid) {
+  const [procs, portMap] = await Promise.all([
+    si.processes(),
+    getPortMap(),
+  ])
+
+  const proc = procs.list.find((p) => p.pid === pid)
+  if (!proc) {
+    return { pid, error: `Process ${pid} not found` }
+  }
+
+  const pidToPorts = new Map()
+  for (const [port, info] of portMap) {
+    if (info.pid === pid) {
+      const arr = pidToPorts.get(pid) || []
+      arr.push(port)
+      pidToPorts.set(pid, arr)
+    }
+  }
+
+  const childCount = procs.list.filter((p) => p.parentPid === pid).length
+
+  return {
+    pid: proc.pid,
+    parentPid: proc.parentPid,
+    name: proc.name,
+    command: proc.command,
+    params: proc.params,
+    path: proc.path,
+    user: proc.user,
+    state: proc.state,
+    priority: proc.priority,
+    mem: Math.round(proc.memRss / 1024),
+    memVsz: Math.round(proc.memVsz / 1024),
+    memPercent: Math.round(proc.mem * 100) / 100,
+    cpu: Math.round(proc.cpu * 100) / 100,
+    started: proc.started,
+    ports: pidToPorts.get(pid) || [],
+    childCount,
+  }
+}

package/src/managers/python.js

@@ -17,8 +17,8 @@ import fs from 'node:fs'
 import path from 'node:path'
 import os from 'node:os'
 import { RuntimeManager } from './runtime.js'
+import { getActiveRegistry } from '../config.js'
 
-const UV_INSTALL_URL = 'https://astral.sh/uv/install.sh'
 const UV_INSTALL_PS_URL = 'https://astral.sh/uv/install.ps1'
 
 /**
@@ -45,10 +45,13 @@ export function isUvInstalled() {
 }
 
 /**
- * 安装 uv（curl 安装脚本）
+ * 安装 uv（curl 安装脚本；脚本 URL 来自 uv.registry.active）
+ * @param {string} [proxy] - 代理地址
  * @returns {{ action: string, hint: string }}
  */
-export function installUv() {
+export function installUv(proxy) {
+  const installUrl = getActiveRegistry('uv') || 'https://astral.sh/uv/install.sh'
+  const proxyArg = proxy ? ` -x "${proxy}"` : ''
   if (process.platform === 'win32') {
     const r = spawnSync(
       'powershell',
@@ -59,7 +62,7 @@ export function installUv() {
       throw new Error('uv install failed (powershell exited non-zero)')
     }
   } else {
-    execSync(`curl -LsSf "${UV_INSTALL_URL}" | sh`, { stdio: 'inherit', shell: true })
+    execSync(`curl -LsSf${proxyArg} "${installUrl}" | sh`, { stdio: 'inherit', shell: true })
   }
   return { action: 'installed', hint: 'Restart shell or ensure ~/.local/bin is in PATH' }
 }

package/src/managers/wsl.js

@@ -0,0 +1,258 @@
+/**
+ * WSL2 管理器（Windows Subsystem for Linux）
+ *
+ * 通过 wsl.exe CLI 管理自身与发行版。仅 Windows 可用。
+ * wsl.exe 输出为 UTF-16LE 编码，需用对应 encoding 读取。
+ */
+
+import { execSync, spawnSync } from 'node:child_process'
+import fs from 'node:fs'
+import path from 'node:path'
+
+const WSL_EXE = 'wsl.exe'
+
+/**
+ * 要求 Windows 平台，否则抛出
+ * @private
+ */
+function requireWindows() {
+  if (process.platform !== 'win32') {
+    throw new Error('WSL is only available on Windows')
+  }
+}
+
+/**
+ * 检查 WSL 是否已安装（wsl.exe 是否可用）
+ * @returns {boolean}
+ */
+export function isWslInstalled() {
+  if (process.platform !== 'win32') return false
+  try {
+    execSync(`${WSL_EXE} --version`, { encoding: 'utf16le', stdio: ['pipe', 'pipe', 'pipe'] })
+    return true
+  } catch {
+    return false
+  }
+}
+
+/**
+ * 解析 wsl --version 输出，提取 WSL 版本号
+ * @param {string} out
+ * @returns {string}
+ */
+export function parseWslVersionOutput(out) {
+  const m = out.match(/WSL\s+(?:版本|version)[:\s]\s*([\d.]+)/i)
+  return m ? m[1] : out.trim().split('\n')[0].trim()
+}
+
+/**
+ * 获取 WSL 版本号
+ * @returns {string}
+ */
+export function getWslVersion() {
+  requireWindows()
+  const out = execSync(`${WSL_EXE} --version`, { encoding: 'utf16le', stdio: ['pipe', 'pipe', 'pipe'] })
+  return parseWslVersionOutput(out)
+}
+
+/**
+ * 安装 WSL2（含默认发行版）
+ * @returns {{ action: string, hint: string }}
+ */
+export function installWsl() {
+  requireWindows()
+  execSync(`${WSL_EXE} --install`, { stdio: 'inherit', shell: true })
+  return { action: 'installed', hint: 'Restart may be required' }
+}
+
+/**
+ * 更新 WSL 内核
+ * @returns {{ action: string }}
+ */
+export function updateWsl() {
+  requireWindows()
+  execSync(`${WSL_EXE} --update`, { stdio: 'inherit', shell: true })
+  return { action: 'updated' }
+}
+
+/**
+ * 卸载 WSL 提示（需通过 Windows 设置操作）
+ * @returns {{ action: string, hint: string }}
+ */
+export function uninstallWsl() {
+  return {
+    action: 'uninstall',
+    hint: 'Go to Settings > Apps > Optional Features > "Windows Subsystem for Linux" to uninstall',
+  }
+}
+
+/**
+ * 获取 WSL 数据目录
+ * @returns {string}
+ */
+export function getWslDir() {
+  if (process.platform !== 'win32') return ''
+  const localAppData = process.env.LOCALAPPDATA || ''
+  if (!localAppData) return ''
+  const packagesDir = path.join(localAppData, 'Packages')
+  try {
+    const entries = fs.readdirSync(packagesDir)
+    const wslEntry = entries.find((e) => /CanonicalGroupLimited|Microsoft\.WSL/i.test(e))
+    if (wslEntry) return path.join(packagesDir, wslEntry)
+  } catch {}
+  return packagesDir
+}
+
+/**
+ * 解析 wsl -l -v 输出为发行版列表
+ * @param {string} out
+ * @returns {{ name: string, state: string, version: string, default: boolean }[]}
+ */
+export function parseDistroList(out) {
+  const lines = out.split('\n').map((l) => l.trim()).filter(Boolean)
+  const distros = []
+  for (const line of lines) {
+    if (/NAME/i.test(line) && /STATE/i.test(line)) continue
+    const parts = line.split(/\s+/)
+    if (parts.length >= 3) {
+      const isDefault = parts[0] === '*'
+      const name = isDefault ? parts[1] : parts[0]
+      const state = isDefault ? parts[2] : parts[1]
+      const version = isDefault ? parts[3] : parts[2]
+      distros.push({ name, state, version, default: isDefault })
+    }
+  }
+  return distros
+}
+
+/**
+ * 列出已安装的发行版
+ * @returns {{ name: string, state: string, version: string, default: boolean }[]}
+ */
+export function listDistros() {
+  requireWindows()
+  const out = execSync(`${WSL_EXE} -l -v`, { encoding: 'utf16le', stdio: ['pipe', 'pipe', 'pipe'] })
+  return parseDistroList(out)
+}
+
+/**
+ * 解析 wsl -l -o 输出为可用发行版名称列表
+ * @param {string} out
+ * @returns {string[]}
+ */
+export function parseAvailableList(out) {
+  const lines = out.split('\n').map((l) => l.trim()).filter(Boolean)
+  return lines.slice(1).map((l) => l.split(/\s+/)[0]).filter(Boolean)
+}
+
+/**
+ * 列出可安装的发行版
+ * @returns {string[]}
+ */
+export function listAvailable() {
+  requireWindows()
+  const out = execSync(`${WSL_EXE} -l -o`, { encoding: 'utf16le', stdio: ['pipe', 'pipe', 'pipe'] })
+  return parseAvailableList(out)
+}
+
+/**
+ * 安装指定发行版
+ * @param {string} name
+ * @returns {{ name: string, action: string }}
+ */
+export function installDistro(name) {
+  requireWindows()
+  execSync(`${WSL_EXE} --install -d ${name}`, { stdio: 'inherit', shell: true })
+  return { name, action: 'installed' }
+}
+
+/**
+ * 移除指定发行版
+ * @param {string} name
+ * @returns {{ name: string, action: string }}
+ */
+export function removeDistro(name) {
+  requireWindows()
+  execSync(`${WSL_EXE} --unregister ${name}`, { stdio: 'inherit', shell: true })
+  return { name, action: 'removed' }
+}
+
+/**
+ * 在当前终端启动发行版
+ * @param {string} name
+ * @returns {{ name: string, action: string }}
+ */
+export function startDistro(name) {
+  requireWindows()
+  execSync(`${WSL_EXE} -d ${name}`, { stdio: 'inherit', shell: true })
+  return { name, action: 'started' }
+}
+
+/**
+ * 停止指定发行版
+ * @param {string} name
+ * @returns {{ name: string, action: string }}
+ */
+export function stopDistro(name) {
+  requireWindows()
+  execSync(`${WSL_EXE} --terminate ${name}`, { stdio: 'inherit', shell: true })
+  return { name, action: 'stopped' }
+}
+
+/**
+ * 停止所有发行版
+ * @returns {{ action: string }}
+ */
+export function stopAll() {
+  requireWindows()
+  execSync(`${WSL_EXE} --shutdown`, { stdio: 'inherit', shell: true })
+  return { action: 'all stopped' }
+}
+
+/**
+ * 设置默认发行版
+ * @param {string} name
+ * @returns {{ name: string, action: string }}
+ */
+export function setDefaultDistro(name) {
+  requireWindows()
+  execSync(`${WSL_EXE} --set-default ${name}`, { stdio: 'inherit', shell: true })
+  return { name, action: 'default set' }
+}
+
+/**
+ * 获取当前默认发行版名称
+ * @returns {string}
+ */
+export function getDefaultDistro() {
+  if (!isWslInstalled()) return ''
+  const distros = listDistros()
+  const def = distros.find((d) => d.default)
+  return def ? def.name : ''
+}
+
+/**
+ * 获取 WSL 状态
+ * @returns {{ installed: boolean, status?: string }}
+ */
+export function getWslStatus() {
+  if (!isWslInstalled()) return { installed: false }
+  try {
+    const out = execSync(`${WSL_EXE} --status`, { encoding: 'utf16le', stdio: ['pipe', 'pipe', 'pipe'] })
+    return { installed: true, status: out.trim() }
+  } catch {
+    return { installed: true, status: '' }
+  }
+}
+
+/**
+ * 打开 PowerShell 窗口并进入 WSL
+ * @param {string} [distro] - 发行版名称（空则用默认）
+ * @returns {{ distro: string, action: string }}
+ */
+export function openWsl(distro) {
+  requireWindows()
+  const wslCmd = distro ? `wsl -d ${distro}` : 'wsl'
+  spawnSync('cmd.exe', ['/c', 'start', '"WSL"', 'powershell', '-NoExit', '-Command', wslCmd], { stdio: 'inherit' })
+  return { distro: distro || 'default', action: 'opened' }
+}