@wwkit/opm 1.0.1 → 1.0.3

package/src/cli/groups/proc.js

@@ -0,0 +1,232 @@
+/**
+ * proc 命令组 — 进程与系统信息管理
+ *
+ * 用法：
+ *   opm proc info          系统信息（OS、CPU、内存、磁盘、运行时间）
+ *   opm proc list          列出前 N 个进程（默认按内存排序，默认 10）
+ *   opm proc search        按进程名或端口号搜索
+ *   opm proc port          列出监听端口及其进程
+ *   opm proc kill          终止进程（按 ID / 端口 / 名称）
+ *   opm proc tree          显示进程树
+ *   opm proc detail        显示指定 PID 的详细信息
+ *
+ * 基于 systeminformation（随包安装）+ netstat 回退获取端口映射。
+ */
+
+import { parseFlags } from '../helpers/args.js'
+import { output } from '../../formatter.js'
+import {
+  getSystemInfo,
+  listProcesses,
+  searchProcesses,
+  listPorts,
+  killByPid,
+  killByPort,
+  killByName,
+  getProcessTree,
+  getProcessDetail,
+} from '../../managers/proc.js'
+
+const ACTIONS = {
+  info:    { desc: 'Show system information (OS, CPU, memory, disk, uptime)' },
+  list:    { desc: 'List top N processes by memory or CPU (default: 10, by mem)' },
+  search:  { desc: 'Search processes by name or port' },
+  port:    { desc: 'List listening ports and their processes' },
+  kill:    { desc: 'Kill process by ID, port, or name' },
+  tree:    { desc: 'Show process tree (by PID or all top-level)' },
+  detail:  { desc: 'Show detailed info for a specific PID' },
+  help:    { desc: 'Show this help' },
+}
+
+export class ProcGroup {
+  constructor() {
+    this.name = 'proc'
+    this.desc = 'Process & system info management (list/search/kill/port/tree)'
+  }
+
+  async run(argv) {
+    const [action, ...rest] = argv
+
+    if (!action || action === '-h' || action === '--help' || action === 'help') {
+      this.printHelp()
+      return
+    }
+
+    const parsed = parseFlags(rest)
+
+    switch (action) {
+      case 'info':
+        return this._info()
+      case 'list':
+        return this._list(parsed)
+      case 'search':
+        return this._search(parsed)
+      case 'port':
+        return this._port(parsed)
+      case 'kill':
+        return this._kill(parsed)
+      case 'tree':
+        return this._tree(parsed)
+      case 'detail':
+        return this._detail(parsed)
+      default:
+        console.error(`Unknown action: ${action}`)
+        this.printHelp()
+        process.exit(1)
+    }
+  }
+
+  async _info() {
+    const info = await getSystemInfo()
+    output(info)
+  }
+
+  async _list(parsed) {
+    const count = parseInt(parsed.flags.n || parsed.flags.count || '10', 10)
+    const n = (isNaN(count) || count < 1) ? 10 : count
+    const by = parsed.flags.b || parsed.flags.by || 'mem'
+    const sortBy = by === 'cpu' ? 'cpu' : 'mem'
+    const result = await listProcesses(n, sortBy)
+    output(result)
+  }
+
+  async _search(parsed) {
+    const name = parsed.flags.n || parsed.flags.name || ''
+    const port = parsed.flags.p || parsed.flags.port || ''
+    const exact = parsed.flags.exact === 'true'
+
+    if (!name && !port) {
+      console.error('Usage: opm proc search -n <name> [-p <port>] [--exact]')
+      console.error('At least one of -n/--name or -p/--port is required')
+      process.exit(1)
+    }
+
+    const result = await searchProcesses({ name: name || undefined, port: port || undefined, exact })
+    output(result)
+  }
+
+  async _port(parsed) {
+    const port = parsed.flags.p || parsed.flags.port || ''
+    const result = await listPorts(port || undefined)
+    output(result)
+  }
+
+  async _kill(parsed) {
+    const id = parsed.flags.i || parsed.flags.id || ''
+    const port = parsed.flags.p || parsed.flags.port || ''
+    const name = parsed.flags.n || parsed.flags.name || ''
+    const force = parsed.flags.f === 'true' || parsed.flags.force === 'true'
+    const yes = parsed.flags.y === 'true' || parsed.flags.yes === 'true'
+    const signal = force ? 'SIGKILL' : 'SIGTERM'
+
+    if (!id && !port && !name) {
+      console.error('Usage: opm proc kill -i <pid> | -p <port> | -n <name> [-f] [-y]')
+      console.error('At least one of -i/--id, -p/--port, or -n/--name is required')
+      process.exit(1)
+    }
+
+    if (!yes) {
+      const targets = []
+      if (id) targets.push(`PID ${id}`)
+      if (port) targets.push(`port ${port}`)
+      if (name) targets.push(`name "${name}"`)
+      const msg = `Kill process by ${targets.join(', ')} with ${signal}? [y/N] `
+      const answer = await this._confirm(msg)
+      if (!answer) {
+        output({ action: 'kill', signal, cancelled: true })
+        return
+      }
+    }
+
+    if (id) {
+      const pid = parseInt(id, 10)
+      const result = await killByPid(pid, signal)
+      output({ action: 'kill', signal, killed: [result] })
+      return
+    }
+
+    if (port) {
+      const portNum = parseInt(port, 10)
+      const result = await killByPort(portNum, signal)
+      output({ action: 'kill', signal, ...result })
+      return
+    }
+
+    if (name) {
+      const result = await killByName(name, signal)
+      output({ action: 'kill', signal, ...result })
+      return
+    }
+  }
+
+  async _tree(parsed) {
+    const pidArg = parsed.positional[0] || parsed.flags.pid || ''
+    const rootPid = pidArg ? parseInt(pidArg, 10) : null
+    const result = await getProcessTree(rootPid)
+    output(result)
+  }
+
+  async _detail(parsed) {
+    const pidArg = parsed.positional[0] || parsed.flags.pid || ''
+    if (!pidArg) {
+      console.error('Usage: opm proc detail <pid>')
+      process.exit(1)
+    }
+    const pid = parseInt(pidArg, 10)
+    const result = await getProcessDetail(pid)
+    output(result)
+  }
+
+  _confirm(msg) {
+    return new Promise((resolve) => {
+      process.stderr.write(msg)
+      process.stdin.setEncoding('utf8')
+      process.stdin.resume()
+      process.stdin.once('data', (data) => {
+        process.stdin.pause()
+        const answer = data.trim().toLowerCase()
+        resolve(answer === 'y' || answer === 'yes')
+      })
+    })
+  }
+
+  printHelp() {
+    const actionLines = Object.entries(ACTIONS)
+      .map(([sig, { desc }]) => `  ${sig.padEnd(12)} ${desc}`)
+      .join('\n')
+
+    console.log(`
+Usage: opm proc <action> [options]
+
+Actions:
+${actionLines}
+
+Options:
+  -n, --count <n>       Number of processes (list, default: 10)
+  -n, --name <name>     Process name pattern (search/kill, fuzzy by default)
+  -b, --by <mem|cpu>    Sort by memory or CPU (list, default: mem)
+  -p, --port <port>     Port number (search/kill/port)
+  -i, --id <pid>        Process ID (kill)
+  --exact               Exact match (search, default: fuzzy)
+  -f, --force           Use SIGKILL instead of SIGTERM (kill)
+  -y, --yes             Skip confirmation prompt (kill)
+  -h, --help            Show this help
+
+Examples:
+  opm proc info
+  opm proc list
+  opm proc list -n 20 -b cpu
+  opm proc search -n node
+  opm proc search -n node -p 3000
+  opm proc search -n node --exact
+  opm proc port
+  opm proc port -p 8080
+  opm proc kill -i 1234
+  opm proc kill -p 8080 -f -y
+  opm proc kill -n node -y
+  opm proc tree
+  opm proc tree 1234
+  opm proc detail 1234
+`)
+  }
+}

package/src/cli/groups/uv.js

@@ -2,9 +2,8 @@
  * uv 命令组 — 管理 uv 自身
  *
  * uv 是 Astral 出品的快速 Python 包/版本管理器（Rust 实现）。
- * 安装方式：curl 安装脚本（非 git clone）；
+ * 安装方式：curl 安装脚本（非 git clone）；脚本 URL 由 uv.registry.active 提供；
  * upgrade = uv self update；uninstall = rm 二进制 + 数据目录。
- * uv 无镜像源，故无 registry action。
  */
 
 import { execSync, spawnSync } from 'node:child_process'
@@ -14,15 +13,11 @@ import os from 'node:os'
 import { ToolManagerGroup } from './version-manager.js'
 import { installUv, getUvBin } from '../../managers/python.js'
 
-const UV_INSTALL_URL = 'https://astral.sh/uv/install.sh'
-const UV_INSTALL_PS_URL = 'https://astral.sh/uv/install.ps1'
-
 export class UvGroup extends ToolManagerGroup {
   constructor() {
     super({
       name: 'uv',
       desc: 'uv version manager (manage uv itself)',
-      hasRegistry: false,
       isInstalled: () => {
         try {
           execSync(`${getUvBin()} --version`, { encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe'] })
@@ -34,7 +29,7 @@ export class UvGroup extends ToolManagerGroup {
       getPath: () => getUvBin(),
       versionCmd: () => `${getUvBin()} --version`,
       parseVersion: (out) => out.trim(),
-      install: () => installUv(),
+      install: (proxy) => installUv(proxy),
       upgrade: () => {
         execSync(`${getUvBin()} self update`, { stdio: 'inherit' })
         return { action: 'upgraded' }
@@ -54,7 +49,10 @@ export class UvGroup extends ToolManagerGroup {
       actions: [
         ['version', 'Show uv version'],
         ['installed', 'Check if uv is installed'],
-        ['install', 'Install uv (curl installer from astral.sh)'],
+        ['registry', 'Show active uv install script URL (from opm config)'],
+        ['registry set <url|preset>', 'Set active uv install script URL (writes opm config)'],
+        ['registry presets', 'List available mirror presets'],
+        ['install', 'Install uv (curl installer)'],
         ['upgrade', 'Update uv (uv self update)'],
         ['uninstall', 'Remove uv (~/.local/bin/uv + ~/.local/share/uv)'],
         ['dir', 'Show uv install directory'],
@@ -63,6 +61,9 @@ export class UvGroup extends ToolManagerGroup {
       examples: [
         'opm uv version',
         'opm uv installed',
+        'opm uv registry',
+        'opm uv registry set official',
+        'opm uv registry presets',
         'opm uv install',
         'opm uv upgrade',
         'opm uv dir',

package/src/cli/groups/version-manager.js

@@ -7,9 +7,10 @@
  */
 
 import { execSync } from 'node:child_process'
+import readline from 'node:readline'
 import { parseFlags } from '../helpers/args.js'
 import { Shell } from '@wwkit/shared'
-import { getActiveRegistry, setActiveRegistry, getPresets } from '../../config.js'
+import { getActiveRegistry, setActiveRegistry, getPresets, getActiveProxy } from '../../config.js'
 import { output } from '../../formatter.js'
 
 const shell = new Shell()
@@ -24,7 +25,7 @@ const shell = new Shell()
  * @property {() => string} getPath - view 展示的安装路径
  * @property {() => string} versionCmd - 返回查询版本的 shell 命令
  * @property {(out: string) => string} [parseVersion] - 解析版本输出
- * @property {() => Object} install - 安装并返回结果字段（失败时 throw）
+ * @property {(proxy?: string) => Object} install - 安装并返回结果字段（失败时 throw）
  * @property {() => Object} upgrade - 升级并返回结果字段（失败时 throw）
  * @property {() => Object} uninstall - 卸载并返回结果字段（失败时 throw）
  * @property {string} usage - 帮助 usage 行
@@ -44,7 +45,8 @@ export class ToolManagerGroup {
   }
 
   async run(argv) {
-    const [action, ...rest] = argv
+    const parsed = parseFlags(argv)
+    const [action, ...rest] = parsed.positional
 
     if (!action || action === '-h' || action === '--help' || action === 'help') {
       this.printHelp()
@@ -57,6 +59,13 @@ export class ToolManagerGroup {
       process.exit(1)
     }
 
+    let proxy = ''
+    if ('p' in parsed.flags || 'proxy' in parsed.flags) {
+      let raw = parsed.flags.proxy || parsed.flags.p || ''
+      if (raw === 'true') raw = ''
+      proxy = raw || getActiveProxy()
+    }
+
     switch (action) {
       case 'version':
         return this._version()
@@ -65,11 +74,11 @@ export class ToolManagerGroup {
       case 'registry':
         return this._registry(parseFlags(rest))
       case 'install':
-        return this._install()
+        return this._install(proxy)
       case 'upgrade':
         return this._upgrade()
       case 'uninstall':
-        return this._uninstall()
+        return this._uninstall(parsed)
       case 'dir':
         return this._dir()
       default:
@@ -110,13 +119,15 @@ export class ToolManagerGroup {
     }
   }
 
-  _install() {
+  _install(proxy) {
     if (this.cfg.isInstalled()) {
       output({ name: this.name, installed: true, hint: `${this.name} already installed, run \`opm ${this.name} upgrade\` to update` })
       return
     }
     try {
-      output({ name: this.name, installed: true, ...(this.cfg.install() || {}) })
+      const installFn = this.cfg.install
+      const result = installFn.length >= 1 ? installFn(proxy) : installFn()
+      output({ name: this.name, installed: true, ...(result || {}) })
     } catch (err) {
       console.error(err.message || `Failed to install ${this.name}`)
       process.exit(1)
@@ -136,11 +147,26 @@ export class ToolManagerGroup {
     }
   }
 
-  _uninstall() {
+  async _uninstall(parsed) {
     if (!this.cfg.isInstalled()) {
       output({ name: this.name, installed: false, hint: `${this.name} not installed` })
       return
     }
+    const force = parsed.flags.y || parsed.flags.yes || parsed.flags.force
+    if (force !== 'true' && force !== true) {
+      console.error(`WARNING: This will remove ${this.name} and all its data.`)
+      const rl = readline.createInterface({ input: process.stdin, output: process.stderr })
+      const answer = await new Promise((resolve) => {
+        rl.question(`Are you sure? [y/N] `, (ans) => {
+          rl.close()
+          resolve(ans.trim().toLowerCase())
+        })
+      })
+      if (answer !== 'y' && answer !== 'yes') {
+        output({ name: this.name, installed: true, hint: 'Uninstall cancelled' })
+        return
+      }
+    }
     try {
       output({ name: this.name, ...(this.cfg.uninstall() || {}) })
     } catch (err) {

package/src/cli/groups/wsl.js

@@ -0,0 +1,220 @@
+/**
+ * wsl 命令组 — 管理 WSL2 自身与发行版
+ *
+ * 继承 ToolManagerGroup 复用 version/installed/upgrade/uninstall/dir，
+ * 额外增加发行版管理动作（list/available/remove/start/stop/stop-all/
+ * set-default/default/status/open）与带可选参数的 install。
+ * 仅 Windows 可用；wsl.exe 输出为 UTF-16LE，需 override _version/_installed。
+ */
+
+import { execSync } from 'node:child_process'
+import { ToolManagerGroup } from './version-manager.js'
+import { parseFlags } from '../helpers/args.js'
+import { output } from '../../formatter.js'
+import {
+  isWslInstalled,
+  getWslVersion,
+  installWsl,
+  updateWsl,
+  uninstallWsl,
+  getWslDir,
+  listDistros,
+  listAvailable,
+  installDistro,
+  removeDistro,
+  startDistro,
+  stopDistro,
+  stopAll,
+  setDefaultDistro,
+  getDefaultDistro,
+  getWslStatus,
+  openWsl,
+} from '../../managers/wsl.js'
+
+export class WslGroup extends ToolManagerGroup {
+  constructor() {
+    super({
+      name: 'wsl',
+      desc: 'WSL2 manager (install/upgrade/list/open distros)',
+      hasRegistry: false,
+      isInstalled: () => isWslInstalled(),
+      getPath: () => getWslDir(),
+      versionCmd: () => 'wsl.exe --version',
+      parseVersion: (out) => out.trim().split('\n')[0].trim(),
+      install: () => installWsl(),
+      upgrade: () => updateWsl(),
+      uninstall: () => uninstallWsl(),
+      usage: 'opm wsl <action> [args] [options]',
+      actions: [
+        ['version', 'Show WSL version'],
+        ['installed', 'Check if WSL is installed'],
+        ['install [distro]', 'Install WSL2 (or a specific distribution)'],
+        ['upgrade', 'Update WSL kernel (wsl --update)'],
+        ['uninstall', 'Show uninstall instructions'],
+        ['dir', 'Show WSL data directory'],
+        ['list', 'List installed distributions'],
+        ['available', 'List available distributions'],
+        ['remove <distro>', 'Remove a distribution'],
+        ['start [distro]', 'Start a distribution in current terminal'],
+        ['stop <distro>', 'Stop a distribution'],
+        ['stop-all', 'Stop all distributions'],
+        ['set-default <distro>', 'Set default distribution'],
+        ['default', 'Show default distribution'],
+        ['status', 'Show WSL status'],
+        ['open [distro]', 'Open PowerShell window and enter WSL'],
+        ['help', 'Show this help'],
+      ],
+      examples: [
+        'opm wsl version',
+        'opm wsl installed',
+        'opm wsl install',
+        'opm wsl install Ubuntu',
+        'opm wsl list',
+        'opm wsl available',
+        'opm wsl open',
+        'opm wsl open Ubuntu',
+        'opm wsl start Ubuntu',
+        'opm wsl stop Ubuntu',
+        'opm wsl stop-all',
+        'opm wsl set-default Ubuntu',
+        'opm wsl default',
+        'opm wsl status',
+        'opm wsl dir',
+      ],
+    })
+  }
+
+  async run(argv) {
+    const [action, ...rest] = argv
+
+    if (!action || action === '-h' || action === '--help' || action === 'help') {
+      this.printHelp()
+      return
+    }
+
+    switch (action) {
+      case 'list':
+        return this._list()
+      case 'available':
+        return this._available()
+      case 'remove':
+        return this._remove(parseFlags(rest))
+      case 'start':
+        return this._start(parseFlags(rest))
+      case 'stop':
+        return this._stop(parseFlags(rest))
+      case 'stop-all':
+        return this._stopAll()
+      case 'set-default':
+        return this._setDefault(parseFlags(rest))
+      case 'default':
+        return this._default()
+      case 'status':
+        return this._status()
+      case 'open':
+        return this._open(parseFlags(rest))
+      case 'install':
+        return this._installDistro(parseFlags(rest))
+    }
+
+    return super.run(argv)
+  }
+
+  _version() {
+    if (!isWslInstalled()) {
+      output('')
+      return
+    }
+    try {
+      output(getWslVersion())
+    } catch {
+      output('')
+    }
+  }
+
+  _installed() {
+    const installed = isWslInstalled()
+    const result = { name: 'wsl', installed }
+    if (installed) {
+      result.path = getWslDir()
+      try {
+        result.version = getWslVersion()
+      } catch {}
+    }
+    output(result)
+  }
+
+  _installDistro(parsed) {
+    const distro = parsed.positional[0]
+    if (distro) {
+      output(installDistro(distro))
+      return
+    }
+    if (isWslInstalled()) {
+      output({ name: 'wsl', installed: true, hint: 'WSL already installed, use "opm wsl install <distro>" to install a distribution' })
+      return
+    }
+    output(installWsl())
+  }
+
+  _list() {
+    output(listDistros())
+  }
+
+  _available() {
+    output(listAvailable().map((name) => ({ name })))
+  }
+
+  _remove(parsed) {
+    const distro = parsed.positional[0]
+    if (!distro) {
+      console.error('Usage: opm wsl remove <distro>')
+      process.exit(1)
+    }
+    output(removeDistro(distro))
+  }
+
+  _start(parsed) {
+    const distro = parsed.positional[0] || getDefaultDistro()
+    if (!distro) {
+      console.error('Usage: opm wsl start [distro]')
+      process.exit(1)
+    }
+    output(startDistro(distro))
+  }
+
+  _stop(parsed) {
+    const distro = parsed.positional[0]
+    if (!distro) {
+      console.error('Usage: opm wsl stop <distro>')
+      process.exit(1)
+    }
+    output(stopDistro(distro))
+  }
+
+  _stopAll() {
+    output(stopAll())
+  }
+
+  _setDefault(parsed) {
+    const distro = parsed.positional[0]
+    if (!distro) {
+      console.error('Usage: opm wsl set-default <distro>')
+      process.exit(1)
+    }
+    output(setDefaultDistro(distro))
+  }
+
+  _default() {
+    output({ default: getDefaultDistro() })
+  }
+
+  _status() {
+    output(getWslStatus())
+  }
+
+  _open(parsed) {
+    const distro = parsed.positional[0] || getDefaultDistro()
+    output(openWsl(distro || ''))
+  }
+}

package/src/cli/index.js

@@ -15,7 +15,13 @@ import { NvmGroup } from './groups/nvm.js'
 import { PhpenvGroup } from './groups/phpenv.js'
 import { UvGroup } from './groups/uv.js'
 import { HomebrewGroup } from './groups/homebrew.js'
+import { WslGroup } from './groups/wsl.js'
+import { DockerGroup } from './groups/docker.js'
 import { EnsureGroup } from './groups/ensure.js'
+import { PingGroup } from './groups/ping.js'
+import { ProcGroup } from './groups/proc.js'
+import { FtpGroup } from '../tools/ftp/index.js'
+import { GitGroup } from '../tools/git/index.js'
 import { HarnessGroup } from '../harnesses/base.js'
 import { opencodeHarness } from '../harnesses/opencode/index.js'
 import { CftGroup } from '../binaries/cft/index.js'
@@ -33,6 +39,10 @@ const GROUPS = {
   apt: new PackageGroup('apt'),
   brew: new PackageGroup('brew'),
   homebrew: new HomebrewGroup(),
+  wsl: new WslGroup(),
+  docker: new DockerGroup(),
+  ftp: new FtpGroup(),
+  git: new GitGroup(),
   composer: new PackageGroup('composer'),
   bun: new PackageGroup('bun'),
   winget: new PackageGroup('winget'),
@@ -46,6 +56,8 @@ const GROUPS = {
   opencode: new HarnessGroup(opencodeHarness),
   cft: new CftGroup(),
   ensure: new EnsureGroup(),
+  ping: new PingGroup(),
+  proc: new ProcGroup(),
 }
 
 class CLI {