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

package/src/commands/install.ts

@@ -1,323 +1,242 @@
+/**
+ * install 命令 - 安装插件/套包
+ */
+
 import { Command } from 'commander';
-import path from 'path';
-import ora, { type Ora } from 'ora';
 import chalk from 'chalk';
-import { api } from '../services/api';
-import { downloadAndExtract } from '../services/download';
-import { getOrCreateProject, addProjectPlugin } from '../services/project';
-import { getCachedPlugin, cachePlugin } from '../services/cache';
-import { createLink } from '../services/link';
-import { parseTarget, TargetType } from '../utils/target';
-
-interface DownloadInfo {
-  type: string;
-  install_path: string;
-  full_name: string;
-  version: string;
-}
-
-interface InstallOptions {
-  global?: boolean;
-  optional?: boolean;
-  force?: boolean;
-  noCache?: boolean;
-}
+import ora from 'ora';
+import path from 'path';
+import os from 'os';
+import { confirm } from '@inquirer/prompts';
+import { api, QuotaExceededError } from '../api';
+import fs from 'fs/promises';
+import {
+  getSessionToken,
+  getOrCreateProject,
+  addInstallation,
+  createLink,
+  resolveCachePath,
+} from '../db';
+import { config } from '../config';
+import { parseTarget, getInstallPath, formatBytes, getTypeIcon } from '../utils';
+import { TargetType, type PluginDownloadInfo } from '../types';
 
 export const installCommand = new Command('install')
-  .description('安装插件或列表')
-  .argument('<target>', '插件或列表标识符')
-  .option('-g, --global', '全局安装')
-  .option('--optional', '仅安装列表中的可选项')
-  .option('--force', '强制重新安装')
-  .option('--no-cache', '不使用缓存')
-  .action(async (target: string, options: InstallOptions) => {
-    await install(target, options);
-  });
-
-async function install(target: string, options: InstallOptions) {
-  const spinner = ora('解析安装目标...').start();
-
-  try {
-    // 1. Parse target
-    const parsed = parseTarget(target);
-
-    // 2. Handle based on type
-    switch (parsed.type) {
-      case TargetType.Capability:
-        await installCapability(parsed.fullName, options, spinner);
-        break;
-
-      case TargetType.CapabilitySlug:
-        await installCapabilityBySlug(parsed.author!, parsed.slug!, options, spinner);
-        break;
-
-      case TargetType.Plugin:
-        await installPlugin(parsed.fullName, options, spinner);
-        break;
-
-      case TargetType.List:
-        await installList(parsed.fullName, options, spinner);
-        break;
-
-      default:
-        spinner.fail(`无法识别的安装目标: ${target}`);
-        process.exit(1);
+  .description('安装插件或套包')
+  .argument('<target>', '安装目标 (author/name 或 author/kit/slug)')
+  .option('-g, --global', '仅下载到缓存，不链接到项目')
+  .option('-f, --force', '强制重新下载')
+  .option('--no-cache', '跳过缓存检查')
+  .option('--optional', '安装套包时包含可选插件')
+  .action(async (target, options) => {
+    // 初始化 API token
+    const token = await getSessionToken();
+    if (token) {
+      api.setSessionToken(token);
     }
-  } catch (error) {
-    spinner.fail(`安装失败: ${(error as Error).message}`);
-    process.exit(1);
-  }
-}
 
-async function installCapability(
-  fullName: string,
-  options: InstallOptions,
-  spinner: Ora
-) {
-  spinner.text = `获取 ${fullName} 的安装信息...`;
-
-  // Get download info
-  const downloadInfo = await api.getCapabilityDownload(fullName);
-
-  // Check permissions
-  if (downloadInfo.requires_auth && !api.isAuthenticated()) {
-    spinner.fail('此插件需要登录才能安装');
-    console.log('使用 42plugin auth 登录');
-    process.exit(1);
-  }
-
-  // Check cache
-  if (!options.force && options.noCache !== true) {
-    const cached = await getCachedPlugin(fullName, downloadInfo.version);
-    if (cached && cached.checksum === downloadInfo.checksum) {
-      spinner.text = '使用缓存...';
-      await linkToProject(cached.cache_path, downloadInfo, options);
-      spinner.succeed(`${chalk.green('已安装')} ${fullName}`);
-      return;
+    try {
+      // 检测是否在 home 目录
+      const currentPath = path.resolve(process.cwd());
+      const homePath = path.resolve(os.homedir());
+      const isHomeDir = currentPath === homePath;
+
+      if (isHomeDir && !options.global) {
+        const answer = await confirm({
+          message: '您当前在根目录，是否将插件安装到全局用户目录？',
+          default: true,
+        });
+
+        if (answer) {
+          options.global = true;
+          // 确保全局目录存在
+          await fs.mkdir(config.globalDir, { recursive: true });
+          console.log(chalk.gray('将安装到全局目录: ~/.42plugin/global/'));
+        } else {
+          console.log(chalk.yellow('提示: 建议在具体项目目录下执行安装命令'));
+          return;
+        }
+      }
+
+      // 如果是全局安装，确保目录存在
+      if (options.global) {
+        await fs.mkdir(config.globalDir, { recursive: true });
+      }
+
+      const parsed = parseTarget(target);
+
+      if (parsed.type === TargetType.Kit) {
+        await installKit(parsed.author, parsed.name, options);
+      } else {
+        await installPlugin(parsed.author, parsed.name, options);
+      }
+    } catch (error) {
+      if (error instanceof QuotaExceededError) {
+        console.error(chalk.red(`\n${error.message}`));
+        if (error.isGuestQuota()) {
+          console.log(chalk.yellow('\n提示: 登录后可获得更高配额'));
+          console.log(chalk.gray('执行 42plugin auth 登录'));
+        }
+      } else {
+        const message = (error as Error).message;
+        console.error(chalk.red(message));
+
+        // 为常见错误提供更友好的提示
+        if (message.includes('no downloadable content')) {
+          console.log(chalk.yellow('\n该插件暂无可下载内容，可能是作者尚未上传文件'));
+        } else if (message.includes('not found') || message.includes('404')) {
+          console.log(chalk.yellow('\n插件不存在，请检查名称是否正确'));
+          console.log(chalk.gray('使用 42plugin search <关键词> 搜索插件'));
+        } else if (message.includes('CAPTCHA') || message.includes('验证码')) {
+          console.log(chalk.yellow('\n需要验证码验证，请先登录'));
+          console.log(chalk.gray('执行 42plugin auth 登录'));
+        }
+      }
+      process.exit(1);
     }
-  }
-
-  // Download
-  spinner.text = `下载 ${fullName}...`;
-  const cachePath = await downloadAndExtract(
-    downloadInfo.download_url,
-    downloadInfo.checksum,
-    fullName,
-    downloadInfo.version
-  );
-
-  // Update cache record
-  await cachePlugin({
-    full_name: fullName,
-    type: downloadInfo.type,
-    version: downloadInfo.version,
-    cache_path: cachePath,
-    checksum: downloadInfo.checksum,
   });
 
-  // Link to project
-  await linkToProject(cachePath, downloadInfo, options);
-
-  spinner.succeed(`${chalk.green('已安装')} ${fullName}`);
-}
-
-async function installCapabilityBySlug(
+async function installPlugin(
   author: string,
-  slug: string,
-  options: InstallOptions,
-  spinner: Ora
-) {
-  const displayName = `${author}/${slug}`;
-  spinner.text = `获取 ${displayName} 的安装信息...`;
-
-  // Get download info by slug
-  const downloadInfo = await api.getCapabilityDownloadBySlug(author, slug);
-
-  // Check permissions
-  if (downloadInfo.requires_auth && !api.isAuthenticated()) {
-    spinner.fail('此插件需要登录才能安装');
-    console.log('使用 42plugin auth 登录');
-    process.exit(1);
-  }
+  name: string,
+  options: { global?: boolean; force?: boolean; cache?: boolean }
+): Promise<void> {
+  const spinner = ora(`获取 ${author}/${name} 信息...`).start();
 
-  // Check cache
-  if (!options.force && options.noCache !== true) {
-    const cached = await getCachedPlugin(downloadInfo.full_name, downloadInfo.version);
-    if (cached && cached.checksum === downloadInfo.checksum) {
-      spinner.text = '使用缓存...';
-      await linkToProject(cached.cache_path, downloadInfo, options);
-      spinner.succeed(`${chalk.green('已安装')} ${displayName}`);
-      return;
+  try {
+    const pluginDownload = await api.getPluginDownload(author, name);
+    const downloadInfo = pluginDownload.download;
+
+    spinner.text = `安装 ${downloadInfo.fullName}...`;
+
+    // 解析缓存
+    const { cachePath, fromCache } = await resolveCachePath(
+      downloadInfo,
+      options.force || false,
+      options.cache !== false
+    );
+
+    // 确定安装路径
+    const projectPath = options.global ? config.globalDir : process.cwd();
+    const project = await getOrCreateProject(projectPath);
+    const linkPath = path.join(projectPath, downloadInfo.installPath);
+
+    await createLink(cachePath, linkPath);
+
+    await addInstallation({
+      projectId: project.id,
+      fullName: downloadInfo.fullName,
+      type: downloadInfo.type,
+      version: downloadInfo.version,
+      cachePath,
+      linkPath,
+      source: 'direct',
+    });
+
+    // 同步安装记录（静默）
+    if (api.isAuthenticated()) {
+      api.recordInstall(downloadInfo.fullName).catch(() => {});
     }
-  }
 
-  // Download
-  spinner.text = `下载 ${displayName}...`;
-  const cachePath = await downloadAndExtract(
-    downloadInfo.download_url,
-    downloadInfo.checksum,
-    downloadInfo.full_name,
-    downloadInfo.version
-  );
-
-  // Update cache record
-  await cachePlugin({
-    full_name: downloadInfo.full_name,
-    type: downloadInfo.type,
-    version: downloadInfo.version,
-    cache_path: cachePath,
-    checksum: downloadInfo.checksum,
-  });
-
-  // Link to project
-  await linkToProject(cachePath, downloadInfo, options);
-
-  spinner.succeed(`${chalk.green('已安装')} ${displayName}`);
-}
-
-async function installPlugin(
-  fullName: string,
-  options: InstallOptions,
-  spinner: Ora
-) {
-  spinner.text = `获取插件 ${fullName} 的信息...`;
-
-  // Get plugin details - for simple plugins, use the download endpoint
-  const [owner, plugin] = fullName.split('/');
-
-  // Try to get as a simple plugin first
-  const downloadInfo = await api.getPluginDownload(owner, plugin);
-
-  // Check permissions
-  if (downloadInfo.requires_auth && !api.isAuthenticated()) {
-    spinner.fail('此插件需要登录才能安装');
-    console.log('使用 42plugin auth 登录');
-    process.exit(1);
-  }
-
-  // Check cache
-  if (!options.force && options.noCache !== true) {
-    const cached = await getCachedPlugin(fullName, downloadInfo.version);
-    if (cached && cached.checksum === downloadInfo.checksum) {
-      spinner.text = '使用缓存...';
-      await linkToProject(cached.cache_path, downloadInfo, options);
-      spinner.succeed(`${chalk.green('已安装')} ${fullName}`);
-      return;
+    spinner.succeed(
+      `${getTypeIcon(downloadInfo.type)} ${downloadInfo.fullName} v${downloadInfo.version}` +
+        (fromCache ? chalk.gray(' (from cache)') : '')
+    );
+
+    if (options.global) {
+      console.log(chalk.green('✓ 已安装到全局用户目录'));
+      console.log(chalk.gray(`  → ~/.42plugin/global/${downloadInfo.installPath}`));
+    } else {
+      console.log(chalk.green(`✓ 已安装到当前项目: ${path.basename(projectPath)}`));
+      console.log(chalk.gray(`  → ${downloadInfo.installPath}`));
     }
+  } catch (error) {
+    spinner.fail('安装失败');
+    throw error;
   }
-
-  // Download
-  spinner.text = `下载 ${fullName}...`;
-  const cachePath = await downloadAndExtract(
-    downloadInfo.download_url,
-    downloadInfo.checksum,
-    fullName,
-    downloadInfo.version
-  );
-
-  // Update cache record
-  await cachePlugin({
-    full_name: fullName,
-    type: downloadInfo.type,
-    version: downloadInfo.version,
-    cache_path: cachePath,
-    checksum: downloadInfo.checksum,
-  });
-
-  // Link to project
-  await linkToProject(cachePath, downloadInfo, options);
-
-  spinner.succeed(`${chalk.green('已安装')} ${fullName}`);
 }
 
-async function installList(
-  fullName: string,
-  options: InstallOptions,
-  spinner: Ora
-) {
-  // Parse list identifier
-  const [username, , slugOrId] = fullName.split('/');
-  spinner.text = `获取列表 ${fullName}...`;
-
-  // Get list download info
-  const listDownload = await api.getListDownload(username, slugOrId);
-
-  console.log();
-  console.log(`列表: ${chalk.cyan(listDownload.list.name)}`);
-  console.log(`插件: ${listDownload.capabilities.length} 个`);
-  console.log();
-
-  // Filter optional items
-  let capabilities = listDownload.capabilities;
-  if (!options.optional) {
-    capabilities = capabilities.filter(c => c.required);
-  }
+async function installKit(
+  username: string,
+  slug: string,
+  options: { global?: boolean; force?: boolean; cache?: boolean; optional?: boolean }
+): Promise<void> {
+  const spinner = ora(`获取套包 ${username}/kit/${slug}...`).start();
 
-  // Install each capability
-  let installed = 0;
-  for (const cap of capabilities) {
-    try {
-      spinner.text = `安装 ${cap.name}...`;
-
-      const cachePath = await downloadAndExtract(
-        cap.download_url,
-        cap.checksum,
-        cap.full_name,
-        cap.version
-      );
-
-      await cachePlugin({
-        full_name: cap.full_name,
-        type: cap.type,
-        version: cap.version,
-        cache_path: cachePath,
-        checksum: cap.checksum,
-      });
-
-      await linkToProject(cachePath, cap as DownloadInfo, options, {
-        source: 'list',
-        source_list: fullName,
-      });
-
-      installed++;
-    } catch (error) {
-      console.log(chalk.yellow(`  跳过 ${cap.name}: ${(error as Error).message}`));
+  try {
+    const kitDownload = await api.getKitDownload(username, slug);
+
+    // 筛选插件
+    let plugins = kitDownload.plugins;
+    if (!options.optional) {
+      plugins = plugins.filter((p) => p.required);
     }
-  }
 
-  spinner.succeed(`${chalk.green('已安装')} ${installed}/${capabilities.length} 个插件`);
-}
+    spinner.succeed(`${kitDownload.kit.name} - ${plugins.length} 个插件`);
+    console.log();
+
+    // 获取项目
+    const projectPath = options.global ? config.globalDir : process.cwd();
+    const project = await getOrCreateProject(projectPath);
+
+    // 安装每个插件
+    let installed = 0;
+    let failed = 0;
+
+    for (const item of plugins) {
+      const pluginSpinner = ora(`  ${item.plugin.fullName}...`).start();
+
+      try {
+        const downloadInfo = item.download;
+
+        const { cachePath, fromCache } = await resolveCachePath(
+          downloadInfo,
+          options.force || false,
+          options.cache !== false
+        );
+
+        const linkPath = path.join(projectPath, downloadInfo.installPath);
+        await createLink(cachePath, linkPath);
+
+        await addInstallation({
+          projectId: project.id,
+          fullName: downloadInfo.fullName,
+          type: downloadInfo.type,
+          version: downloadInfo.version,
+          cachePath,
+          linkPath,
+          source: 'kit',
+          sourceKit: `${username}/kit/${slug}`,
+        });
+
+        if (api.isAuthenticated()) {
+          api.recordInstall(downloadInfo.fullName).catch(() => {});
+        }
+
+        pluginSpinner.succeed(
+          `  ${getTypeIcon(downloadInfo.type)} ${downloadInfo.fullName}` +
+            (fromCache ? chalk.gray(' (cached)') : '')
+        );
+        installed++;
+      } catch (error) {
+        pluginSpinner.fail(`  ${item.plugin.fullName}: ${(error as Error).message}`);
+        failed++;
+      }
+    }
 
-async function linkToProject(
-  cachePath: string,
-  info: { type: string; install_path: string; full_name: string; version: string },
-  options: InstallOptions,
-  extra?: { source?: string; source_list?: string }
-) {
-  if (options.global) {
-    // Global install doesn't link to project
-    return;
+    // 汇总
+    console.log();
+    if (failed === 0) {
+      if (options.global) {
+        console.log(chalk.green(`✓ 已安装 ${installed} 个插件到全局用户目录`));
+      } else {
+        console.log(chalk.green(`✓ 已安装 ${installed} 个插件到当前项目`));
+      }
+    } else {
+      console.log(chalk.yellow(`已安装 ${installed} 个，${failed} 个失败`));
+    }
+  } catch (error) {
+    spinner.fail('安装失败');
+    throw error;
   }
-
-  // Get or create project
-  const projectPath = process.cwd();
-  const project = await getOrCreateProject(projectPath);
-
-  // Target path
-  const targetPath = path.join(projectPath, info.install_path);
-
-  // Create link
-  await createLink(cachePath, targetPath);
-
-  // Record in database
-  await addProjectPlugin({
-    project_id: project.id,
-    full_name: info.full_name,
-    type: info.type,
-    version: info.version,
-    cache_path: cachePath,
-    link_path: targetPath,
-    source: extra?.source || 'direct',
-    source_list: extra?.source_list,
-  });
 }

package/src/commands/list.ts

@@ -1,80 +1,56 @@
+/**
+ * list 命令 - 查看已安装插件
+ */
+
 import { Command } from 'commander';
-import path from 'path';
 import chalk from 'chalk';
-import { getProject, getProjectPlugins } from '../services/project';
-import type { ProjectPlugin } from '../types/db';
-
-interface ListOptions {
-  type?: string;
-  json?: boolean;
-}
+import { getInstallations } from '../db';
+import { getTypeIcon, formatRelativeTime } from '../utils';
+import type { PluginType } from '../types';
 
 export const listCommand = new Command('list')
+  .alias('ls')
   .description('查看当前项目已安装的插件')
-  .option('--type <type>', '筛选类型')
-  .option('--json', 'JSON 格式输出')
-  .action(async (options: ListOptions) => {
-    await list(options);
-  });
-
-async function list(options: ListOptions) {
-  const projectPath = process.cwd();
-  const project = await getProject(projectPath);
-
-  if (!project) {
-    console.log(chalk.yellow('当前目录不是 42plugin 项目'));
-    console.log('使用 42plugin install <plugin> 安装第一个插件');
-    return;
-  }
-
-  let plugins = await getProjectPlugins(project.id);
-
-  if (options.type) {
-    plugins = plugins.filter(p => p.type === options.type);
-  }
+  .option('-t, --type <type>', '筛选类型 (skill, agent, command, hook, mcp)')
+  .option('--json', '输出 JSON 格式')
+  .action(async (options) => {
+    try {
+      let installations = await getInstallations(process.cwd());
+
+      // 类型筛选
+      if (options.type) {
+        installations = installations.filter((i) => i.type === options.type);
+      }
 
-  if (options.json) {
-    console.log(JSON.stringify(plugins, null, 2));
-    return;
-  }
+      if (options.json) {
+        console.log(JSON.stringify(installations, null, 2));
+        return;
+      }
 
-  if (plugins.length === 0) {
-    console.log(chalk.yellow('当前项目没有安装任何插件'));
-    return;
-  }
+      if (installations.length === 0) {
+        console.log(chalk.yellow('当前项目未安装任何插件'));
+        console.log(chalk.gray('执行 42plugin install <name> 安装插件'));
+        return;
+      }
 
-  console.log();
-  console.log(`项目: ${chalk.cyan(path.basename(projectPath))}`);
-  console.log(`路径: ${projectPath}`);
-  console.log();
-  console.log(`已安装 ${plugins.length} 个插件:`);
-  console.log();
+      console.log(chalk.gray(`已安装 ${installations.length} 个插件:\n`));
 
-  // Group by type
-  const grouped = groupBy(plugins, 'type');
+      for (const item of installations) {
+        const icon = getTypeIcon(item.type);
+        const time = formatRelativeTime(item.installedAt);
 
-  for (const [type, items] of Object.entries(grouped)) {
-    console.log(chalk.bold(`${type}:`));
+        console.log(`${icon} ${chalk.cyan.bold(item.fullName)} ${chalk.gray(`v${item.version}`)}`);
+        console.log(chalk.gray(`  → ${item.linkPath}`));
 
-    for (const plugin of items) {
-      const relativePath = path.relative(projectPath, plugin.link_path);
-      console.log(`  ${chalk.cyan(plugin.full_name)}`);
-      console.log(`    版本: ${plugin.version}`);
-      console.log(`    路径: ${chalk.gray(relativePath)}`);
+        if (item.source === 'kit' && item.sourceKit) {
+          console.log(chalk.gray(`  来自套包: ${item.sourceKit}`));
+        }
 
-      if (plugin.source === 'list') {
-        console.log(`    来源: ${chalk.gray(plugin.source_list)}`);
+        console.log(chalk.gray(`  安装于 ${time}`));
+        console.log();
       }
-
-      console.log();
+    } catch (error) {
+      console.error(chalk.red((error as Error).message));
+      process.exit(1);
     }
-  }
-}
-
-function groupBy<T>(arr: T[], key: keyof T): Record<string, T[]> {
-  return arr.reduce((acc, item) => {
-    const k = String(item[key]);
-    (acc[k] = acc[k] || []).push(item);
-    return acc;
-  }, {} as Record<string, T[]>);
-}
+  });