@wxuns/zp-cli 0.0.1

package/lib/commands/upload.js

@@ -0,0 +1,231 @@
+/**
+ * upload.js - 文件/目录上传命令
+ * 核心流程：检测 Git 仓库 → 匹配映射 → 确定服务器和路径 → 执行部署
+ */
+const fs = require('fs');
+const path = require('path');
+const chalk = require('chalk');
+const logger = require('../utils/logger');
+const configManager = require('../core/configManager');
+const gitHelper = require('../core/gitHelper');
+const sshDeployer = require('../core/sshDeployer');
+
+/**
+ * 执行 upload 命令
+ * @param {string} localPath - 本地文件/目录路径
+ * @param {Object} options - 命令行选项
+ * @param {string} [options.remotePath] - 指定远程目标路径
+ * @param {string} [options.server] - 指定服务器别名
+ */
+async function run(localPath, options) {
+  try {
+    // 1. 检查本地路径是否存在
+    const absPath = path.resolve(localPath);
+    if (!fs.existsSync(absPath)) {
+      logger.error(`路径不存在: ${absPath}`);
+      process.exit(1);
+    }
+
+    const isDir = fs.statSync(absPath).isDirectory();
+    logger.log(chalk.bold(`\n🚀 zp-cli 部署工具\n`));
+    logger.info(`本地路径: ${absPath}`);
+    logger.info(`类型: ${isDir ? '目录' : '文件'}`);
+    logger.newline();
+
+    // 2. 加载配置文件
+    const config = configManager.loadConfig();
+    if (!config) {
+      logger.error('配置文件不存在，请先执行 ' + chalk.cyan('zp-cli init') + ' 初始化配置');
+      process.exit(1);
+    }
+
+    // 3. 确定服务器和远程路径
+    let server = null;
+    let remoteBase = null;
+    let relativePath = null;
+
+    // 模式 A：命令行直接指定了服务器别名和远程路径
+    if (options.server && options.remotePath) {
+      server = configManager.findServerByAlias(config, options.server);
+      if (!server) {
+        logger.error(`未找到别名为 "${options.server}" 的服务器`);
+        process.exit(1);
+      }
+      remoteBase = options.remotePath;
+      relativePath = path.basename(absPath);
+      logger.info(`使用命令行指定的服务器: ${server.alias}`);
+    }
+    // 模式 B：命令行指定了服务器别名
+    // 优先从 Git 映射中取 remotePath，否则用服务器的 defaultRemotePath
+    else if (options.server) {
+      server = configManager.findServerByAlias(config, options.server);
+      if (!server) {
+        logger.error(`未找到别名为 "${options.server}" 的服务器`);
+        process.exit(1);
+      }
+
+      // 尝试从 Git 映射中获取远程路径
+      let mapped = false;
+      if (gitHelper.isGitRepo()) {
+        const gitUrl = gitHelper.getGitRemoteUrl();
+        if (gitUrl) {
+          const mapping = configManager.findMappingByGitUrl(config, gitUrl);
+          if (mapping) {
+            const repoRoot = gitHelper.getGitRoot();
+            const resolved = gitHelper.resolveRemotePath(absPath, mapping, repoRoot);
+            if (resolved.remoteBase) {
+              remoteBase = resolved.remoteBase;
+              relativePath = resolved.relativePath;
+              mapped = true;
+            }
+          }
+        }
+      }
+
+      // 没有映射则用服务器的 defaultRemotePath
+      if (!mapped) {
+        if (!server.defaultRemotePath) {
+          logger.error(`服务器 "${server.alias}" 未配置 defaultRemotePath，请通过 --remote-path 指定`);
+          process.exit(1);
+        }
+        remoteBase = server.defaultRemotePath;
+        relativePath = path.basename(absPath);
+      }
+
+      logger.info(`使用命令行指定的服务器: ${server.alias}`);
+    }
+    // 模式 C：命令行指定了远程路径（需要从映射或默认服务器推断）
+    else if (options.remotePath) {
+      // 尝试通过 Git 映射找到服务器
+      if (gitHelper.isGitRepo()) {
+        const gitUrl = gitHelper.getGitRemoteUrl();
+        if (gitUrl) {
+          const mapping = configManager.findMappingByGitUrl(config, gitUrl);
+          if (mapping) {
+            server = configManager.findServerByAlias(config, mapping.serverAlias);
+          }
+        }
+      }
+      if (!server && config.servers.length > 0) {
+        server = config.servers[0]; // 使用第一个服务器
+      }
+      if (!server) {
+        logger.error('无法确定目标服务器，请通过 --server 指定');
+        process.exit(1);
+      }
+      remoteBase = options.remotePath;
+      relativePath = path.basename(absPath);
+    }
+    // 模式 D：智能模式 - 通过 Git 仓库自动匹配
+    else {
+      const result = resolveFromGit(config, absPath);
+      if (!result) {
+        logger.error('无法自动确定部署目标。请检查以下可能的原因:');
+        logger.log('  1. 当前目录不在 Git 仓库内');
+        logger.log('  2. 配置文件中没有匹配的映射');
+        logger.log('  3. 请使用 --server 和 --remote-path 手动指定');
+        process.exit(1);
+      }
+      server = result.server;
+      remoteBase = result.remoteBase;
+      relativePath = result.relativePath;
+      logger.info(`Git 仓库匹配成功: ${result.gitUrl}`);
+      logger.info(`服务器: ${server.alias} (${server.host})`);
+    }
+
+    logger.newline();
+
+    // 4. 验证服务器配置
+    const validation = configManager.validateServer(server);
+    if (!validation.valid) {
+      logger.error('服务器配置不完整:');
+      validation.errors.forEach(e => logger.log(`  - ${e}`));
+      process.exit(1);
+    }
+
+    // 5. 执行部署
+    const permissions = (server.chown || server.chgrp)
+      ? { user: server.chown, group: server.chgrp }
+      : null;
+
+    await sshDeployer.deploy({
+      server,
+      localPath: absPath,
+      remoteBase,
+      relativePath,
+      isDir,
+      permissions
+    });
+
+  } catch (err) {
+    logger.error(`部署失败: ${err.message}`);
+    process.exit(1);
+  }
+}
+
+/**
+ * 通过 Git 仓库信息智能解析部署目标
+ * @param {Object} config - 配置对象
+ * @param {string} absPath - 本地文件的绝对路径
+ * @returns {Object|null} { server, remoteBase, relativePath, gitUrl }
+ */
+function resolveFromGit(config, absPath) {
+  if (!gitHelper.isGitRepo()) {
+    logger.warn('当前目录不在 Git 仓库内');
+    return null;
+  }
+
+  const gitUrl = gitHelper.getGitRemoteUrl();
+  if (!gitUrl) {
+    logger.warn('无法获取 Git 远程仓库地址');
+    return null;
+  }
+
+  logger.info(`检测到 Git 远程地址: ${gitUrl}`);
+
+  // 在映射中查找匹配项（支持 SSH / HTTPS 两种格式互相匹配）
+  const mapping = configManager.findMappingByGitUrl(config, gitUrl);
+  if (!mapping) {
+    logger.warn('在配置文件中未找到匹配的映射');
+    logger.log(chalk.gray('提示: 您可以在 ~/.zp-cli.json 的 mappings 中添加该仓库的映射'));
+    logger.log(chalk.gray('       配置中的 gitRemoteUrl 支持 SSH 和 HTTPS 两种格式，会自动匹配'));
+    return null;
+  }
+
+  // 显示匹配到的配置项（如果格式不同则同时显示）
+  if (mapping.gitRemoteUrl !== gitUrl) {
+    logger.info(`匹配到映射配置: ${mapping.gitRemoteUrl}`);
+  }
+
+  // 解析远程路径（优先子目录映射，回退到顶层配置）
+  const repoRoot = gitHelper.getGitRoot();
+  const resolved = gitHelper.resolveRemotePath(absPath, mapping, repoRoot);
+
+  // 确定服务器：子目录映射 > 映射顶层
+  const serverAlias = resolved.serverAlias || mapping.serverAlias;
+  if (!serverAlias) {
+    logger.error('无法确定目标服务器：映射中未配置 serverAlias，且未匹配到子目录映射');
+    return null;
+  }
+
+  const server = configManager.findServerByAlias(config, serverAlias);
+  if (!server) {
+    logger.error(`映射中指定的服务器 "${serverAlias}" 不存在`);
+    return null;
+  }
+
+  // 确定远程路径
+  if (!resolved.remoteBase) {
+    logger.error('无法确定远程路径：映射中未配置 remotePath，且未匹配到子目录映射');
+    return null;
+  }
+
+  return {
+    server,
+    remoteBase: resolved.remoteBase,
+    relativePath: resolved.relativePath,
+    gitUrl
+  };
+}
+
+module.exports = { run };

package/lib/core/configManager.js

@@ -0,0 +1,166 @@
+/**
+ * configManager.js - 配置文件管理模块
+ * 负责读取、写入和验证 ~/.zp-cli.json 配置文件
+ */
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const logger = require('../utils/logger');
+
+// 配置文件路径：~/.zp-cli.json
+const CONFIG_FILE = path.join(os.homedir(), '.zp-cli.json');
+
+/**
+ * 获取配置文件路径
+ * @returns {string} 配置文件的绝对路径
+ */
+function getConfigPath() {
+  return CONFIG_FILE;
+}
+
+/**
+ * 检查配置文件是否存在
+ * @returns {boolean}
+ */
+function configExists() {
+  return fs.existsSync(CONFIG_FILE);
+}
+
+/**
+ * 读取配置文件
+ * @returns {Object|null} 解析后的配置对象，不存在时返回 null
+ */
+function loadConfig() {
+  if (!configExists()) {
+    return null;
+  }
+  try {
+    const raw = fs.readFileSync(CONFIG_FILE, 'utf-8');
+    return JSON.parse(raw);
+  } catch (err) {
+    logger.error(`读取配置文件失败: ${err.message}`);
+    return null;
+  }
+}
+
+/**
+ * 将配置对象写入文件
+ * @param {Object} config - 配置对象
+ */
+function saveConfig(config) {
+  try {
+    const json = JSON.stringify(config, null, 2);
+    fs.writeFileSync(CONFIG_FILE, json, 'utf-8');
+  } catch (err) {
+    logger.error(`写入配置文件失败: ${err.message}`);
+    throw err;
+  }
+}
+
+/**
+ * 生成默认的空配置模板
+ * @returns {Object} 默认配置对象
+ */
+function getDefaultConfig() {
+  return {
+    servers: [],
+    mappings: []
+  };
+}
+
+/**
+ * 根据别名查找服务器配置
+ * @param {Object} config - 完整配置对象
+ * @param {string} alias - 服务器别名
+ * @returns {Object|null} 服务器配置，未找到时返回 null
+ */
+function findServerByAlias(config, alias) {
+  if (!config || !config.servers) return null;
+  return config.servers.find(s => s.alias === alias) || null;
+}
+
+/**
+ * 将 Git URL 归一化为统一的 host/path 格式
+ * 支持 SSH、HTTPS、ssh:// 等多种格式
+ *
+ * 示例:
+ *   git@github.com:org/repo.git          → github.com/org/repo
+ *   https://github.com/org/repo.git      → github.com/org/repo
+ *   ssh://git@github.com:22/org/repo.git → github.com/org/repo
+ *   git@gitlab.com:group/sub/repo.git    → gitlab.com/group/sub/repo
+ *
+ * @param {string} url - Git 远程地址
+ * @returns {string} 归一化后的 host/path（小写，去除 .git 后缀）
+ */
+function normalizeGitUrl(url) {
+  if (!url) return '';
+  let s = url.trim();
+
+  // 1. ssh://git@host:port/path.git → host/path
+  const sshSchemeMatch = s.match(/^ssh:\/\/(?:[^@]+@)?([^:/]+)(?::\d+)?[:/](.+?)(?:\.git)?$/i);
+  if (sshSchemeMatch) {
+    return `${sshSchemeMatch[1]}/${sshSchemeMatch[2]}`.toLowerCase().replace(/\.git$/, '');
+  }
+
+  // 2. git@host:path.git → host/path
+  const sshShortMatch = s.match(/^git@([^:]+):(.+?)(?:\.git)?$/i);
+  if (sshShortMatch) {
+    return `${sshShortMatch[1]}/${sshShortMatch[2]}`.toLowerCase().replace(/\.git$/, '');
+  }
+
+  // 3. https://host/path.git → host/path
+  const httpsMatch = s.match(/^https?:\/\/([^/]+)\/(.+?)(?:\.git)?(?:\/)?$/i);
+  if (httpsMatch) {
+    return `${httpsMatch[1]}/${httpsMatch[2]}`.toLowerCase().replace(/\.git$/, '');
+  }
+
+  // 4. 无法识别的格式，原样返回（小写、去尾部斜杠和 .git）
+  return s.toLowerCase().replace(/\.git$/, '').replace(/\/+$/, '');
+}
+
+/**
+ * 根据 Git 远程地址查找匹配的映射配置
+ * 支持 SSH（git@host:path）和 HTTPS（https://host/path）两种格式互相匹配
+ *
+ * @param {Object} config - 完整配置对象
+ * @param {string} gitRemoteUrl - Git 远程仓库地址
+ * @returns {Object|null} 匹配的映射配置，未找到时返回 null
+ */
+function findMappingByGitUrl(config, gitRemoteUrl) {
+  if (!config || !config.mappings) return null;
+  const normalizedInput = normalizeGitUrl(gitRemoteUrl);
+  if (!normalizedInput) return null;
+
+  return config.mappings.find(m => {
+    const normalizedMapping = normalizeGitUrl(m.gitRemoteUrl);
+    return normalizedInput === normalizedMapping;
+  }) || null;
+}
+
+/**
+ * 验证服务器配置是否完整
+ * @param {Object} server - 服务器配置对象
+ * @returns {Object} { valid: boolean, errors: string[] }
+ */
+function validateServer(server) {
+  const errors = [];
+  if (!server.alias) errors.push('缺少服务器别名 (alias)');
+  if (!server.host) errors.push('缺少服务器地址 (host)');
+  if (!server.username) errors.push('缺少登录用户名 (username)');
+  if (!server.password && !server.privateKeyPath) {
+    errors.push('至少需要配置密码 (password) 或私钥路径 (privateKeyPath)');
+  }
+  return { valid: errors.length === 0, errors };
+}
+
+module.exports = {
+  getConfigPath,
+  configExists,
+  loadConfig,
+  saveConfig,
+  getDefaultConfig,
+  findServerByAlias,
+  findMappingByGitUrl,
+  normalizeGitUrl,
+  validateServer
+};

package/lib/core/gitHelper.js

@@ -0,0 +1,167 @@
+/**
+ * gitHelper.js - Git 仓库辅助模块
+ * 负责读取当前目录的 Git 远程仓库地址，用于自动匹配部署映射
+ */
+const fs = require('fs');
+const path = require('path');
+const { execSync } = require('child_process');
+const logger = require('../utils/logger');
+
+/**
+ * 从 .git/config 文件中解析 origin 远程地址
+ * @param {string} repoRoot - Git 仓库根目录
+ * @returns {string|null} 远程仓库地址，解析失败时返回 null
+ */
+function parseGitRemoteFromConfig(repoRoot) {
+  const gitConfigPath = path.join(repoRoot, '.git', 'config');
+  if (!fs.existsSync(gitConfigPath)) return null;
+
+  try {
+    const content = fs.readFileSync(gitConfigPath, 'utf-8');
+    const lines = content.split('\n');
+    let inOriginSection = false;
+
+    for (const line of lines) {
+      const trimmed = line.trim();
+      // 检测 [remote "origin"] 段落
+      if (trimmed === '[remote "origin"]') {
+        inOriginSection = true;
+        continue;
+      }
+      // 遇到新的 section 则退出
+      if (trimmed.startsWith('[') && inOriginSection) {
+        break;
+      }
+      // 提取 url 字段
+      if (inOriginSection && trimmed.startsWith('url =')) {
+        return trimmed.replace('url =', '').trim();
+      }
+    }
+  } catch (err) {
+    // 读取失败时静默处理，回退到 git 命令
+  }
+  return null;
+}
+
+/**
+ * 使用 git 命令获取 origin 远程地址
+ * @returns {string|null} 远程仓库地址
+ */
+function getGitRemoteFromCommand() {
+  try {
+    const url = execSync('git remote get-url origin', {
+      encoding: 'utf-8',
+      stdio: ['pipe', 'pipe', 'pipe']
+    }).trim();
+    return url || null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * 判断当前目录是否在 Git 仓库内
+ * @returns {boolean}
+ */
+function isGitRepo() {
+  try {
+    execSync('git rev-parse --is-inside-work-tree', {
+      stdio: ['pipe', 'pipe', 'pipe']
+    });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * 获取 Git 仓库根目录
+ * @returns {string|null} 仓库根目录的绝对路径
+ */
+function getGitRoot() {
+  try {
+    return execSync('git rev-parse --show-toplevel', {
+      encoding: 'utf-8',
+      stdio: ['pipe', 'pipe', 'pipe']
+    }).trim();
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * 获取当前目录对应的 Git origin 远程地址
+ * 优先从 .git/config 解析，失败则使用 git 命令
+ * @returns {string|null} 远程仓库地址
+ */
+function getGitRemoteUrl() {
+  const repoRoot = getGitRoot();
+  if (!repoRoot) return null;
+
+  // 优先从配置文件解析（速度快，无需子进程）
+  const fromConfig = parseGitRemoteFromConfig(repoRoot);
+  if (fromConfig) return fromConfig;
+
+  // 回退到 git 命令
+  return getGitRemoteFromCommand();
+}
+
+/**
+ * 根据本地上传路径和映射配置，计算远程目标路径
+ *
+ * 优先级：子目录映射 > 映射顶层 serverAlias/remotePath
+ * - 有子目录映射且匹配 → 使用子映射的 serverAlias 和 remotePath
+ * 无子目录映射或未匹配 → 回退到顶层 serverAlias 和 remotePath
+ *
+ * subdirectoryMappings 的值支持两种格式：
+ *   - 字符串: "/var/www/frontend"              → 同服务器不同路径
+ *   - 对象:   { serverAlias, remotePath }      → 部署到不同服务器
+ *
+ * @param {string} localPath - 本地上传路径（相对于仓库根目录）
+ * @param {Object} mapping - 映射配置对象
+ * @param {string} repoRoot - Git 仓库根目录
+ * @returns {{ remoteBase?: string, relativePath: string, serverAlias?: string } | null}
+ */
+function resolveRemotePath(localPath, mapping, repoRoot) {
+  // 获取相对于仓库根目录的路径
+  const absLocal = path.resolve(localPath);
+  let relativePath = path.relative(repoRoot, absLocal).replace(/\\/g, '/');
+
+  // 有子目录映射时，优先尝试匹配
+  if (mapping.subdirectoryMappings && Object.keys(mapping.subdirectoryMappings).length > 0) {
+    const parts = relativePath.split('/');
+    const topDir = parts[0];
+
+    if (mapping.subdirectoryMappings[topDir]) {
+      const sub = mapping.subdirectoryMappings[topDir];
+
+      // 对象格式：{ serverAlias, remotePath }
+      if (typeof sub === 'object' && sub !== null) {
+        return {
+          remoteBase: sub.remotePath,
+          relativePath: parts.slice(1).join('/'),
+          serverAlias: sub.serverAlias
+        };
+      }
+
+      // 字符串格式：同服务器不同路径
+      return {
+        remoteBase: sub,
+        relativePath: parts.slice(1).join('/')
+      };
+    }
+  }
+
+  // 未匹配子目录映射，回退到顶层配置
+  return {
+    remoteBase: mapping.remotePath,
+    relativePath: relativePath
+  };
+}
+
+module.exports = {
+  isGitRepo,
+  getGitRoot,
+  getGitRemoteUrl,
+  resolveRemotePath
+};