@wwkit/opm 1.0.1 → 1.0.3

package/src/presets.js

@@ -19,6 +19,9 @@ export const NODE_PRESETS = _getPresets('node')
 export const PHPENV_PRESETS = _getPresets('phpenv')
 export const PHP_PRESETS = _getPresets('php')
 export const PYTHON_PRESETS = _getPresets('python')
+export const UV_PRESETS = _getPresets('uv')
+export const DOCKER_PRESETS = _getPresets('docker')
+export const HOMEBREW_PRESETS = _getPresets('homebrew')
 
 export const getPresets = _getPresets
 export const resolveRegistryInput = _resolveRegistryInput

package/src/tools/ftp/client.js

@@ -0,0 +1,214 @@
+/**
+ * FTP 客户端封装 — 基于 basic-ftp
+ *
+ * 提供连接、上传、下载、列表、删除、建目录等操作。
+ * 自动重试 + 超时 + 被动模式由配置驱动。
+ */
+
+import ftp from 'basic-ftp'
+import { Readable } from 'node:stream'
+import { getConfig } from '../../config.js'
+
+const { Client } = ftp
+
+/**
+ * 从 opm config 读取 FTP 配置
+ * @returns {{ host: string, port: number, user: string, password: string, remote_root: string, base_url: string, timeout: number, max_retries: number, pasv: boolean }}
+ */
+export function getFtpConfig() {
+  const cfg = getConfig().ftp || {}
+  return {
+    host: cfg.host || '',
+    port: parseInt(cfg.port, 10) || 21,
+    user: cfg.user || '',
+    password: cfg.password || '',
+    remote_root: (cfg.remote_root || '/htdocs/webwork').replace(/\/+$/, ''),
+    base_url: (cfg.base_url || '').replace(/\/+$/, ''),
+    timeout: parseInt(cfg.timeout, 10) || 120,
+    max_retries: parseInt(cfg.max_retries, 10) || 2,
+    pasv: cfg.pasv !== undefined ? cfg.pasv : false,
+  }
+}
+
+/**
+ * 创建并连接 FTP 客户端
+ * @returns {Promise<import('basic-ftp').Client>}
+ */
+export async function connect() {
+  const cfg = getFtpConfig()
+  const client = new Client(cfg.timeout * 1000)
+  await client.access({
+    host: cfg.host,
+    port: cfg.port,
+    user: cfg.user,
+    password: cfg.password,
+    secure: false,
+  })
+  return client
+}
+
+/**
+ * 测试连接
+ * @returns {Promise<boolean>}
+ */
+export async function checkConnection() {
+  let client
+  try {
+    client = await connect()
+    return true
+  } catch {
+    return false
+  } finally {
+    if (client) client.close()
+  }
+}
+
+/**
+ * 确保远程目录存在（递归创建）
+ * @param {import('basic-ftp').FTPClient} client
+ * @param {string} dirPath - 绝对路径
+ */
+export async function ensureDir(client, dirPath) {
+  const parts = dirPath.split('/').filter(Boolean)
+  let current = ''
+  for (const part of parts) {
+    current += '/' + part
+    try {
+      await client.cd(current)
+    } catch {
+      await client.send('MKD ' + current)
+    }
+  }
+}
+
+/**
+ * 上传 Buffer 到远程路径
+ * @param {Buffer} data
+ * @param {string} remotePath - 绝对路径
+ * @param {number} [maxRetries]
+ * @returns {Promise<boolean>}
+ */
+export async function uploadBuffer(data, remotePath, maxRetries) {
+  const cfg = getFtpConfig()
+  const retries = maxRetries !== undefined ? maxRetries : cfg.max_retries
+  for (let attempt = 0; attempt <= retries; attempt++) {
+    let client
+    try {
+      client = await connect()
+      const dir = remotePath.substring(0, remotePath.lastIndexOf('/'))
+      if (dir) await ensureDir(client, dir)
+      await client.uploadFrom(Readable.from(data), remotePath)
+      return true
+    } catch (err) {
+      if (attempt === retries) throw err
+    } finally {
+      if (client) client.close()
+    }
+  }
+  return false
+}
+
+/**
+ * 上传本地文件到远程路径
+ * @param {string} localPath
+ * @param {string} remotePath - 绝对路径
+ * @param {number} [maxRetries]
+ * @returns {Promise<boolean>}
+ */
+export async function uploadFile(localPath, remotePath, maxRetries) {
+  const cfg = getFtpConfig()
+  const retries = maxRetries !== undefined ? maxRetries : cfg.max_retries
+  for (let attempt = 0; attempt <= retries; attempt++) {
+    let client
+    try {
+      client = await connect()
+      const dir = remotePath.substring(0, remotePath.lastIndexOf('/'))
+      if (dir) await ensureDir(client, dir)
+      await client.uploadFrom(localPath, remotePath)
+      return true
+    } catch (err) {
+      if (attempt === retries) throw err
+    } finally {
+      if (client) client.close()
+    }
+  }
+  return false
+}
+
+/**
+ * 下载远程文件到本地
+ * @param {string} remotePath - 绝对路径
+ * @param {string} localPath
+ * @returns {Promise<boolean>}
+ */
+export async function downloadFile(remotePath, localPath) {
+  let client
+  try {
+    client = await connect()
+    const dir = localPath.substring(0, localPath.lastIndexOf('/'))
+    if (dir) {
+      const fs = await import('node:fs')
+      fs.mkdirSync(dir, { recursive: true })
+    }
+    await client.downloadTo(localPath, remotePath)
+    return true
+  } catch {
+    return false
+  } finally {
+    if (client) client.close()
+  }
+}
+
+/**
+ * 列出远程目录下的文件（递归），返回相对路径 + size
+ * @param {string} remoteDir - 绝对路径
+ * @returns {Promise<Map<string, number>>} Map<relPath, size>
+ */
+export async function listRemoteFiles(remoteDir) {
+  let client
+  try {
+    client = await connect()
+    const result = new Map()
+    await walkRemote(client, remoteDir, '', result)
+    return result
+  } finally {
+    if (client) client.close()
+  }
+}
+
+async function walkRemote(client, baseDir, relDir, result) {
+  let entries
+  try {
+    entries = await client.list(baseDir + '/' + relDir)
+  } catch {
+    return
+  }
+  for (const entry of entries) {
+    const name = entry.name
+    if (name === '.' || name === '..') continue
+    const rel = relDir ? `${relDir}/${name}` : name
+    if (entry.isDirectory) {
+      await walkRemote(client, baseDir, rel, result)
+    } else if (entry.isFile) {
+      result.set(rel, entry.size)
+    }
+  }
+}
+
+/**
+ * 删除远程文件
+ * @param {string} remotePath - 绝对路径
+ * @returns {Promise<boolean>}
+ */
+export async function removeFile(remotePath) {
+  let client
+  try {
+    client = await connect()
+    await client.remove(remotePath)
+    return true
+  } catch {
+    return false
+  } finally {
+    if (client) client.close()
+  }
+}

package/src/tools/ftp/index.js

@@ -0,0 +1,406 @@
+/**
+ * opm ftp 命令组 — FTP 文件管理
+ *
+ * 命令：version / installed / install / uninstall / upgrade /
+ *       connect / upload / rsync / download / root
+ */
+
+import path from 'node:path'
+import fs from 'node:fs'
+import { fileURLToPath } from 'node:url'
+import { createRequire } from 'node:module'
+import { spawnSync } from 'node:child_process'
+import { parseFlags } from '../../cli/helpers/args.js'
+import { getActiveProxy, getActiveRegistry } from '../../config.js'
+import { output } from '../../formatter.js'
+import {
+  getFtpConfig, checkConnection, uploadBuffer, uploadFile,
+  downloadFile, listRemoteFiles, removeFile, ensureDir, connect,
+} from './client.js'
+import {
+  isExcluded, md5File, detectImageExt, extFromName, makeFilename,
+  todayStr, readData, collectFiles,
+} from './util.js'
+
+const FTP_DEP = 'basic-ftp'
+
+/**
+ * 检查 basic-ftp 是否已安装，返回版本号或 null
+ * @returns {string|null}
+ */
+function checkBasicFtp() {
+  try {
+    const require = createRequire(import.meta.url)
+    const pkg = require(`${FTP_DEP}/package.json`)
+    return pkg.version || 'unknown'
+  } catch {
+    return null
+  }
+}
+
+/**
+ * 获取 opm 包根目录（package.json 所在目录）
+ * @returns {string}
+ */
+function getPkgRoot() {
+  const here = path.dirname(fileURLToPath(import.meta.url))
+  return path.resolve(here, '../../..')
+}
+
+export class FtpGroup {
+  constructor() {
+    this.name = 'ftp'
+    this.desc = 'FTP file management (upload/rsync/download)'
+  }
+
+  async run(argv) {
+    const [action, ...rest] = argv
+
+    if (!action || action === '-h' || action === '--help' || action === 'help') {
+      this.printHelp()
+      return
+    }
+
+    switch (action) {
+      case 'version':
+        return this._version()
+      case 'installed':
+        return this._installed()
+      case 'install':
+        return this._install(rest)
+      case 'uninstall':
+        return this._uninstall()
+      case 'upgrade':
+        return this._upgrade(rest)
+      case 'connect':
+        return this._guard(() => this._connect())
+      case 'upload':
+        return this._guard(() => this._upload(parseFlags(rest)))
+      case 'rsync':
+        return this._guard(() => this._rsync(parseFlags(rest)))
+      case 'download':
+        return this._guard(() => this._download(parseFlags(rest)))
+      case 'root':
+        return this._root()
+      default:
+        console.error(`Unknown action: ${action}`)
+        this.printHelp()
+        process.exit(1)
+    }
+  }
+
+  /**
+   * 检查 basic-ftp 是否可用，不可用则提示安装并退出
+   * @param {() => Promise<void>} fn
+   * @private
+   */
+  async _guard(fn) {
+    const ver = checkBasicFtp()
+    if (!ver) {
+      console.error(`basic-ftp is not installed. Run \`opm ftp install\` to install it.`)
+      process.exit(1)
+    }
+    return fn()
+  }
+
+  /**
+   * 解析 proxy（-p/--proxy 优先，否则回退配置 active proxy）
+   * @param {string[]} argv
+   * @returns {string}
+   * @private
+   */
+  _resolveProxy(argv) {
+    const parsed = parseFlags(argv)
+    let proxy = parsed.flags.proxy || parsed.flags.p || ''
+    if (proxy === 'true') proxy = ''
+    if (!proxy) proxy = getActiveProxy()
+    return proxy
+  }
+
+  /**
+   * 在 opm 包根目录执行 npm 命令（自动附加 registry + proxy）
+   * @param {string[]} args - npm 子命令参数
+   * @param {string} proxy
+   * @private
+   */
+  _npmExec(args, proxy) {
+    const registry = getActiveRegistry('npm')
+    const fullArgs = [...args]
+    if (registry) fullArgs.push('--registry', registry)
+    if (proxy) fullArgs.push('--proxy', proxy)
+
+    const pkgRoot = getPkgRoot()
+    const result = spawnSync('npm', fullArgs, { stdio: 'inherit', shell: true, cwd: pkgRoot })
+    if (result.error) {
+      throw new Error(result.error.message)
+    }
+    if (result.status !== 0) {
+      throw new Error(`npm ${fullArgs.join(' ')} exited with code ${result.status}`)
+    }
+  }
+
+  async _version() {
+    const ver = checkBasicFtp()
+    output(ver || '')
+  }
+
+  async _installed() {
+    const ver = checkBasicFtp()
+    output({
+      name: FTP_DEP,
+      installed: !!ver,
+      ...(ver ? { version: ver } : { hint: `Run \`opm ftp install\` to install` }),
+    })
+  }
+
+  async _install(rest) {
+    const ver = checkBasicFtp()
+    if (ver) {
+      output({ name: FTP_DEP, installed: true, version: ver })
+      return
+    }
+    const proxy = this._resolveProxy(rest)
+    console.log(`Installing ${FTP_DEP} ...`)
+    this._npmExec(['install', FTP_DEP], proxy)
+    const newVer = checkBasicFtp()
+    output({ name: FTP_DEP, installed: true, version: newVer || 'unknown', action: 'installed' })
+  }
+
+  async _uninstall() {
+    const ver = checkBasicFtp()
+    if (!ver) {
+      output({ name: FTP_DEP, installed: false, action: 'not installed' })
+      return
+    }
+    console.log(`Uninstalling ${FTP_DEP} ...`)
+    this._npmExec(['uninstall', FTP_DEP], '')
+    output({ name: FTP_DEP, action: 'uninstalled' })
+  }
+
+  async _upgrade(rest) {
+    const proxy = this._resolveProxy(rest)
+    console.log(`Upgrading ${FTP_DEP} ...`)
+    this._npmExec(['install', `${FTP_DEP}@latest`], proxy)
+    const newVer = checkBasicFtp()
+    output({ name: FTP_DEP, installed: true, version: newVer || 'unknown', action: 'upgraded' })
+  }
+
+  async _connect() {
+    const ok = await checkConnection()
+    output({ connected: ok })
+  }
+
+  async _upload(parsed) {
+    const file = parsed.positional[0]
+    if (!file) {
+      console.error('Usage: opm ftp upload <file> [-n name] [-s subdir]')
+      process.exit(1)
+    }
+    const name = parsed.flags.name || parsed.flags.n || ''
+    const subdir = parsed.flags.subdir || parsed.flags.s || ''
+    const cfg = getFtpConfig()
+
+    const data = await readData(file, cfg.timeout * 1000)
+    if (!data || data.length === 0) {
+      console.error('Failed to read data (empty or not found)')
+      process.exit(1)
+    }
+
+    let ext = detectImageExt(data) || extFromName(name || file) || ''
+    if (!ext) {
+      const fromPath = path.extname(file).slice(1).toLowerCase()
+      ext = fromPath || 'bin'
+    }
+
+    let filename
+    if (name) {
+      const nameExt = path.extname(name).slice(1).toLowerCase()
+      if (nameExt && nameExt !== ext) ext = nameExt
+      filename = name.endsWith(`.${ext}`) ? name : `${name}.${ext}`
+    } else {
+      filename = makeFilename(ext)
+    }
+
+    const date = todayStr()
+    const parts = [cfg.remote_root, date]
+    if (subdir) parts.push(subdir.replace(/^\/+/, ''))
+    parts.push(filename)
+    const remotePath = parts.join('/')
+
+    const ok = await uploadBuffer(data, remotePath)
+    if (!ok) {
+      console.error('Upload failed')
+      process.exit(1)
+    }
+
+    const urlParts = [cfg.base_url, date]
+    if (subdir) urlParts.push(subdir.replace(/^\/+/, ''))
+    urlParts.push(filename)
+    output({ uploaded: true, remote: remotePath, url: urlParts.join('/') })
+  }
+
+  async _rsync(parsed) {
+    const local = parsed.positional[0]
+    if (!local) {
+      console.error('Usage: opm ftp rsync <local> [-s subdir] [-x pattern] [--dry-run] [--prune]')
+      process.exit(1)
+    }
+    const subdir = parsed.flags.subdir || parsed.flags.s || ''
+    const excludes = parsed.flags.exclude || parsed.flags.x || []
+    const excludeList = Array.isArray(excludes) ? excludes : [excludes]
+    const dryRun = parsed.flags['dry-run'] === 'true'
+    const prune = parsed.flags.prune === 'true'
+
+    const cfg = getFtpConfig()
+    const localDir = path.resolve(local)
+    if (!fs.existsSync(localDir) || !fs.statSync(localDir).isDirectory()) {
+      console.error(`Local directory not found: ${localDir}`)
+      process.exit(1)
+    }
+
+    const remoteBase = subdir
+      ? `${cfg.remote_root}/${subdir.replace(/^\/+/, '')}`
+      : cfg.remote_root
+
+    const allFiles = collectFiles(localDir)
+    const toUpload = allFiles.filter((rel) => !isExcluded(rel, excludeList))
+    const skippedExcluded = allFiles.filter((rel) => isExcluded(rel, excludeList))
+
+    const remoteFiles = await listRemoteFiles(remoteBase)
+
+    const uploadPlan = []
+    const skippedSame = []
+    for (const rel of toUpload) {
+      const localPath = path.join(localDir, ...rel.split('/'))
+      const stat = fs.statSync(localPath)
+      const remoteSize = remoteFiles.get(rel)
+      if (remoteSize !== undefined && remoteSize === stat.size) {
+        skippedSame.push(rel)
+      } else {
+        uploadPlan.push(rel)
+      }
+    }
+
+    const deletePlan = []
+    if (prune) {
+      for (const [rel] of remoteFiles) {
+        if (!toUpload.includes(rel)) {
+          deletePlan.push(rel)
+        }
+      }
+    }
+
+    if (dryRun) {
+      output({
+        dryRun: true,
+        remote: remoteBase,
+        upload: uploadPlan,
+        skipSame: skippedSame.length,
+        skipExcluded: skippedExcluded,
+        delete: deletePlan,
+      })
+      return
+    }
+
+    const uploaded = []
+    const failed = []
+    const total = uploadPlan.length
+    for (let i = 0; i < uploadPlan.length; i++) {
+      const rel = uploadPlan[i]
+      const localPath = path.join(localDir, ...rel.split('/'))
+      const remotePath = `${remoteBase}/${rel}`
+      try {
+        await uploadFile(localPath, remotePath)
+        uploaded.push(rel)
+      } catch (err) {
+        failed.push({ path: rel, error: err.message })
+      }
+      process.stderr.write(`\r[${i + 1}/${total}] ${rel}`)
+    }
+    if (total > 0) process.stderr.write('\n')
+
+    const deleted = []
+    const deleteFailed = []
+    for (const rel of deletePlan) {
+      const remotePath = `${remoteBase}/${rel}`
+      const ok = await removeFile(remotePath)
+      if (ok) deleted.push(rel)
+      else deleteFailed.push(rel)
+    }
+
+    output({
+      remote: remoteBase,
+      uploaded: uploaded.length,
+      uploadedFiles: uploaded,
+      skippedSame: skippedSame.length,
+      skippedExcluded,
+      failed,
+      pruned: deleted.length,
+      prunedFiles: deleted,
+      pruneFailed: deleteFailed,
+    })
+  }
+
+  async _download(parsed) {
+    const remote = parsed.positional[0]
+    const local = parsed.positional[1]
+    if (!remote || !local) {
+      console.error('Usage: opm ftp download <remote> <local>')
+      process.exit(1)
+    }
+    const cfg = getFtpConfig()
+    const remotePath = remote.startsWith('/') ? remote : `${cfg.remote_root}/${remote}`
+    const ok = await downloadFile(remotePath, local)
+    output({ downloaded: ok, remote: remotePath, local })
+  }
+
+  _root() {
+    const cfg = getFtpConfig()
+    output({ remote_root: cfg.remote_root })
+  }
+
+  printHelp() {
+    console.log(`
+Usage: opm ftp <action> [args] [options]
+
+Actions:
+  version                              Show installed basic-ftp version
+  installed                            Check if basic-ftp is installed
+  install                              Install basic-ftp (uses opm npm registry + proxy)
+  uninstall                            Uninstall basic-ftp
+  upgrade                              Upgrade basic-ftp to latest (uses opm npm registry + proxy)
+  connect                              Test FTP connection
+  upload <file> [-n name] [-s subdir]  Upload file (local path or HTTP URL)
+  rsync <local> [options]              Recursive upload directory (FTP-side dedup)
+  download <remote> <local>            Download file from FTP
+  root                                 Show configured remote root directory
+  help                                 Show this help
+
+rsync options:
+  -s, --subdir <dir>                   Remote subdirectory (under remote_root)
+  -x, --exclude <pattern>              Exclude glob pattern (repeatable)
+  --dry-run                            Preview without uploading
+  --prune                              Delete remote files not in local
+
+Options:
+  -p, --proxy <url>                   Proxy for install/upgrade (overrides config proxy.active)
+  -h, --help                           Show this help
+
+Examples:
+  opm ftp version
+  opm ftp installed
+  opm ftp install
+  opm ftp upgrade
+  opm ftp connect
+  opm ftp upload ./img.png
+  opm ftp upload ./img.png -n cover -s banner
+  opm ftp upload https://example.com/a.jpg -n cover.jpg
+  opm ftp rsync ./webwork/
+  opm ftp rsync ./webwork/ -s deploy -x "vendor/*" -x "*.log"
+  opm ftp rsync ./webwork/ --dry-run
+  opm ftp rsync ./webwork/ --prune
+  opm ftp download 20260913/cover.jpg ./cover.jpg
+  opm ftp root
+`)
+  }
+}