@42ailab/42plugin 0.1.0-beta.1 → 0.1.5

package/src/services/packager.ts

@@ -0,0 +1,177 @@
+/**
+ * 插件打包器
+ *
+ * 负责：
+ * - 计算内容哈希（基于源文件）
+ * - 打包为 .tar.gz
+ * - 计算包哈希（基于打包后文件）
+ */
+
+import fs from 'fs/promises';
+import path from 'path';
+import crypto from 'crypto';
+import * as tar from 'tar';
+import { config } from '../config';
+import type { PackageResult } from '../types';
+
+// 需要保留的功能性隐藏文件
+const ALLOWED_HIDDEN_FILES = [
+  '.mcp.json',
+  '.tool.json',
+  '.plugin.json',
+  '.claude',
+];
+
+export class Packager {
+  /**
+   * 打包插件
+   */
+  async pack(sourcePath: string, pluginName: string): Promise<PackageResult> {
+    const stat = await fs.stat(sourcePath);
+    const isFile = stat.isFile();
+
+    // 计算内容哈希
+    const contentHash = isFile
+      ? await this.hashFile(sourcePath)
+      : await this.hashDirectory(sourcePath);
+
+    // 创建临时目录
+    const tempDir = path.join(config.cacheDir, 'publish', crypto.randomUUID());
+    await fs.mkdir(tempDir, { recursive: true });
+
+    const tarballPath = path.join(tempDir, `${pluginName}.tar.gz`);
+
+    try {
+      // 打包
+      if (isFile) {
+        await this.packFile(sourcePath, tarballPath);
+      } else {
+        await this.packDirectory(sourcePath, tarballPath);
+      }
+
+      // 计算包哈希和大小
+      const tarballBuffer = await fs.readFile(tarballPath);
+      const packageHash = 'sha256:' + crypto.createHash('sha256').update(tarballBuffer).digest('hex');
+      const sizeBytes = tarballBuffer.length;
+
+      return {
+        tarballPath,
+        contentHash,
+        packageHash,
+        sizeBytes,
+      };
+    } catch (error) {
+      // 清理临时文件
+      await fs.rm(tempDir, { recursive: true, force: true }).catch(() => {});
+      throw error;
+    }
+  }
+
+  /**
+   * 清理打包临时文件
+   */
+  async cleanup(tarballPath: string): Promise<void> {
+    const tempDir = path.dirname(tarballPath);
+    await fs.rm(tempDir, { recursive: true, force: true }).catch(() => {});
+  }
+
+  /**
+   * 计算单文件哈希
+   */
+  private async hashFile(filePath: string): Promise<string> {
+    const content = await fs.readFile(filePath);
+    return 'sha256:' + crypto.createHash('sha256').update(content).digest('hex');
+  }
+
+  /**
+   * 计算目录内容哈希（类似 Git tree hash）
+   */
+  private async hashDirectory(dirPath: string): Promise<string> {
+    const files = await this.walkDir(dirPath);
+
+    // 按路径排序以保证一致性
+    files.sort((a, b) => a.relativePath.localeCompare(b.relativePath));
+
+    // 构建哈希输入：每个文件的哈希+相对路径
+    const hashInput = files.map((f) => `${f.hash}:${f.relativePath}`).join('\n');
+
+    return 'sha256:' + crypto.createHash('sha256').update(hashInput).digest('hex');
+  }
+
+  /**
+   * 遍历目录，计算每个文件的哈希
+   */
+  private async walkDir(
+    dirPath: string,
+    basePath: string = dirPath
+  ): Promise<Array<{ relativePath: string; hash: string }>> {
+    const results: Array<{ relativePath: string; hash: string }> = [];
+    const entries = await fs.readdir(dirPath, { withFileTypes: true });
+
+    for (const entry of entries) {
+      // 跳过 node_modules
+      if (entry.name === 'node_modules') {
+        continue;
+      }
+
+      // 跳过非功能性隐藏文件（保留 .mcp.json 等）
+      if (entry.name.startsWith('.') && !ALLOWED_HIDDEN_FILES.includes(entry.name)) {
+        continue;
+      }
+
+      const fullPath = path.join(dirPath, entry.name);
+      const relativePath = path.relative(basePath, fullPath);
+
+      if (entry.isDirectory()) {
+        const subResults = await this.walkDir(fullPath, basePath);
+        results.push(...subResults);
+      } else if (entry.isFile()) {
+        const content = await fs.readFile(fullPath);
+        const hash = crypto.createHash('sha256').update(content).digest('hex');
+        results.push({ relativePath, hash });
+      }
+    }
+
+    return results;
+  }
+
+  /**
+   * 打包单文件
+   */
+  private async packFile(filePath: string, tarballPath: string): Promise<void> {
+    const dir = path.dirname(filePath);
+    const file = path.basename(filePath);
+
+    await tar.create(
+      {
+        gzip: true,
+        file: tarballPath,
+        cwd: dir,
+      },
+      [file]
+    );
+  }
+
+  /**
+   * 打包目录
+   */
+  private async packDirectory(dirPath: string, tarballPath: string): Promise<void> {
+    const entries = await fs.readdir(dirPath);
+
+    // 过滤掉非功能性隐藏文件和 node_modules
+    const filesToPack = entries.filter((e) => {
+      if (e === 'node_modules') return false;
+      if (e.startsWith('.') && !ALLOWED_HIDDEN_FILES.includes(e)) return false;
+      return true;
+    });
+
+    await tar.create(
+      {
+        gzip: true,
+        file: tarballPath,
+        cwd: dirPath,
+      },
+      filesToPack
+    );
+  }
+}

package/src/services/publisher.ts

@@ -0,0 +1,237 @@
+/**
+ * 发布流程编排器
+ *
+ * 协调各个服务完成发布流程：
+ * 1. 验证插件结构
+ * 2. 计算版本
+ * 3. 打包
+ * 4. 上传
+ * 5. 确认发布
+ */
+
+import ora from 'ora';
+import chalk from 'chalk';
+import { confirm } from '@inquirer/prompts';
+import { api } from '../api';
+import { PluginValidator } from '../validators/plugin-validator';
+import { Packager } from './packager';
+import { VersionManager } from './version-manager';
+import { Uploader } from './upload';
+import { formatBytes } from '../utils';
+import { ValidationError } from '../errors';
+import type {
+  PublishOptions,
+  PublishResult,
+  PackageResult,
+  ValidationResult,
+} from '../types';
+
+export class Publisher {
+  private validator: PluginValidator;
+  private packager: Packager;
+  private versionManager: VersionManager;
+  private uploader: Uploader;
+
+  constructor() {
+    this.validator = new PluginValidator();
+    this.packager = new Packager();
+    this.versionManager = new VersionManager();
+    this.uploader = new Uploader();
+  }
+
+  /**
+   * 执行发布流程
+   */
+  async publish(options: PublishOptions): Promise<PublishResult> {
+    const spinner = ora('准备发布...').start();
+    let pkg: PackageResult | null = null;
+
+    try {
+      // Phase 1: 完整验证
+      spinner.text = '验证插件...';
+      const validation = await this.validator.validateFull(options.path, options.name);
+
+      // 显示验证结果
+      spinner.stop();
+      this.displayValidationResult(validation);
+
+      // 如果有错误，阻止发布
+      if (!validation.valid) {
+        throw new ValidationError('验证失败，请修复上述错误后重试', 'VALIDATION_FAILED');
+      }
+
+      const metadata = validation.metadata;
+      console.log(chalk.green(`✔ 验证通过: ${metadata.name} (${metadata.type})`));
+
+      // Phase 2: 打包
+      spinner.start('打包中...');
+      pkg = await this.packager.pack(metadata.sourcePath, metadata.name);
+      spinner.succeed(`打包完成: ${formatBytes(pkg.sizeBytes)}`);
+
+      // Phase 3: 版本决策
+      spinner.start('检查版本...');
+      const versionDecision = await this.versionManager.getNextVersion(
+        metadata.name,
+        pkg.contentHash
+      );
+
+      // 处理不同的版本决策
+      if (versionDecision.action === 'skip' && !options.force) {
+        spinner.info('插件内容未变化，无需发布');
+        await this.packager.cleanup(pkg.tarballPath);
+        return {
+          fullName: `${await this.getUsername()}/${metadata.name}`,
+          version: versionDecision.version,
+          storageKey: '',
+          type: metadata.type,
+          action: 'unchanged',
+        };
+      }
+
+      if (versionDecision.action === 'update') {
+        spinner.stop();
+        // 询问确认更新
+        const shouldUpdate = await confirm({
+          message: `发现已存在版本，是否更新到 v${versionDecision.version}?`,
+          default: true,
+        });
+
+        if (!shouldUpdate) {
+          console.log(chalk.yellow('已取消发布'));
+          await this.packager.cleanup(pkg.tarballPath);
+          return {
+            fullName: `${await this.getUsername()}/${metadata.name}`,
+            version: versionDecision.version,
+            storageKey: '',
+            type: metadata.type,
+            action: 'unchanged',
+          };
+        }
+        spinner.succeed(
+          `版本: v${versionDecision.version} (更新)`
+        );
+      } else {
+        spinner.succeed(
+          `版本: v${versionDecision.version} (${versionDecision.action === 'create' ? '新建' : '更新'})`
+        );
+      }
+
+      // Dry run 模式
+      if (options.dryRun) {
+        console.log();
+        console.log(chalk.cyan('=== Dry Run 预览 ==='));
+        console.log(`  插件名: ${metadata.name}`);
+        console.log(`  类型: ${metadata.type}`);
+        console.log(`  版本: v${versionDecision.version}`);
+        console.log(`  大小: ${formatBytes(pkg.sizeBytes)}`);
+        console.log(`  内容哈希: ${pkg.contentHash.slice(0, 20)}...`);
+        console.log(`  可见性: ${options.visibility || 'self'}`);
+        console.log(chalk.cyan('=================='));
+
+        await this.packager.cleanup(pkg.tarballPath);
+        return {
+          fullName: `${await this.getUsername()}/${metadata.name}`,
+          version: versionDecision.version,
+          storageKey: '',
+          type: metadata.type,
+          action: versionDecision.action === 'create' ? 'created' : 'updated',
+        };
+      }
+
+      // Phase 4: 上传
+      spinner.start('上传中...');
+      const uploadResult = await this.uploader.upload(metadata, pkg, versionDecision.version);
+      spinner.succeed('上传完成');
+
+      // Phase 5: 确认发布
+      spinner.start('确认发布...');
+      const result = await api.confirmPublish({
+        name: metadata.name,
+        type: metadata.type,
+        version: versionDecision.version,
+        contentHash: pkg.contentHash,
+        packageHash: pkg.packageHash,
+        storageKey: uploadResult.storageKey,
+        sizeBytes: pkg.sizeBytes,
+        title: metadata.title,
+        description: metadata.description,
+        tags: metadata.tags,
+        visibility: options.visibility || 'self',
+      });
+      spinner.succeed('发布成功');
+
+      // 清理临时文件
+      await this.packager.cleanup(pkg.tarballPath);
+
+      return {
+        fullName: result.plugin.fullName,
+        version: result.plugin.version,
+        storageKey: uploadResult.storageKey,
+        type: metadata.type,
+        action: result.action,
+      };
+    } catch (error) {
+      spinner.fail('发布失败');
+      // 清理临时文件
+      if (pkg) {
+        await this.packager.cleanup(pkg.tarballPath);
+      }
+      throw error;
+    }
+  }
+
+  /**
+   * 显示验证结果
+   */
+  private displayValidationResult(result: ValidationResult): void {
+    console.log();
+    console.log(chalk.bold('📋 验证结果'));
+    console.log();
+
+    // 显示元信息
+    const { metadata } = result;
+    console.log(`  名称: ${metadata.name || chalk.gray('(未指定)')}`);
+    console.log(`  类型: ${metadata.type}`);
+    if (metadata.description) {
+      const desc =
+        metadata.description.length > 50
+          ? metadata.description.slice(0, 50) + '...'
+          : metadata.description;
+      console.log(`  描述: ${desc}`);
+    }
+
+    // 显示错误
+    if (result.errors.length > 0) {
+      console.log();
+      console.log(chalk.red.bold(`❌ 错误 (${result.errors.length})：`));
+      for (const error of result.errors) {
+        console.log(chalk.red(`  [${error.code}] ${error.message}`));
+        if (error.suggestion) {
+          console.log(chalk.gray(`       💡 ${error.suggestion}`));
+        }
+      }
+    }
+
+    // 显示警告
+    if (result.warnings.length > 0) {
+      console.log();
+      console.log(chalk.yellow.bold(`⚠️  警告 (${result.warnings.length})：`));
+      for (const warning of result.warnings) {
+        console.log(chalk.yellow(`  [${warning.code}] ${warning.message}`));
+        if (warning.suggestion) {
+          console.log(chalk.gray(`       💡 ${warning.suggestion}`));
+        }
+      }
+    }
+
+    console.log();
+  }
+
+  /**
+   * 获取当前登录用户的用户名
+   */
+  private async getUsername(): Promise<string> {
+    const session = await api.getSession();
+    return session.user.username || session.user.name || 'unknown';
+  }
+}

package/src/services/upload.ts

@@ -0,0 +1,52 @@
+/**
+ * 文件上传服务
+ *
+ * 使用预签名 URL 直接上传到 COS
+ */
+
+import fs from 'fs/promises';
+import { api } from '../api';
+import { UploadError } from '../errors';
+import type { PluginMetadata, PackageResult, UploadUrlResponse } from '../types';
+
+export class Uploader {
+  /**
+   * 上传插件包到 COS
+   */
+  async upload(
+    metadata: PluginMetadata,
+    pkg: PackageResult,
+    version: string
+  ): Promise<UploadUrlResponse> {
+    // 1. 获取上传签名 URL
+    const uploadInfo = await api.getUploadUrl({
+      name: metadata.name,
+      type: metadata.type,
+      version,
+      contentHash: pkg.contentHash,
+      sizeBytes: pkg.sizeBytes,
+    });
+
+    // 2. 上传文件到 COS
+    const tarballBuffer = await fs.readFile(pkg.tarballPath);
+
+    const response = await fetch(uploadInfo.uploadUrl, {
+      method: 'PUT',
+      headers: {
+        'Content-Type': 'application/gzip',
+        'Content-Length': String(pkg.sizeBytes),
+      },
+      body: tarballBuffer,
+    });
+
+    if (!response.ok) {
+      const text = await response.text().catch(() => '');
+      throw new UploadError(
+        `上传失败: ${response.status} ${text}`,
+        response.status
+      );
+    }
+
+    return uploadInfo;
+  }
+}

package/src/services/version-manager.ts

@@ -0,0 +1,65 @@
+/**
+ * 版本管理器
+ *
+ * 策略：
+ * - 新插件：从 1.0.0 开始
+ * - 内容变化：patch 版本自动递增（1.0.0 → 1.0.1）
+ * - 内容未变化：跳过发布
+ */
+
+import { api } from '../api';
+import type { VersionDecision } from '../types';
+
+export class VersionManager {
+  /**
+   * 计算下一个版本号
+   */
+  async getNextVersion(
+    pluginName: string,
+    contentHash: string
+  ): Promise<VersionDecision> {
+    // 查询插件当前状态
+    const status = await api.getPluginStatus(pluginName);
+
+    // 新插件
+    if (!status.exists) {
+      return {
+        version: '1.0.0',
+        action: 'create',
+      };
+    }
+
+    // 内容未变化
+    if (status.contentHash === contentHash) {
+      return {
+        version: status.version!,
+        action: 'skip',
+        existingHash: status.contentHash,
+      };
+    }
+
+    // 内容变化，递增 patch 版本
+    const newVersion = this.incrementPatch(status.version || '1.0.0');
+    return {
+      version: newVersion,
+      action: 'update',
+      existingHash: status.contentHash,
+    };
+  }
+
+  /**
+   * 递增 patch 版本
+   * 1.0.0 → 1.0.1
+   * 1.2.3 → 1.2.4
+   */
+  private incrementPatch(version: string): string {
+    const parts = version.split('.');
+    if (parts.length !== 3) {
+      return '1.0.1'; // fallback
+    }
+
+    const [major, minor, patch] = parts;
+    const newPatch = parseInt(patch, 10) + 1;
+    return `${major}.${minor}.${newPatch}`;
+  }
+}