@zhin.js/cli 1.0.5 → 1.0.7

package/src/commands/build.ts

@@ -5,48 +5,57 @@ import fs from 'fs-extra';
 import path from 'path';
 
 export const buildCommand = new Command('build')
-  .description('构建机器人项目')
+  .description('构建插件项目')
+  .argument('[plugin]', '插件名称（默认构建所有插件）')
   .option('--clean', '清理输出目录', false)
-  .action(async (options: { clean: boolean }) => {
+  .action(async (pluginName: string | undefined, options: { clean: boolean }) => {
     try {
       const cwd = process.cwd();
       
-      // 检查是否是Zhin项目
-      if (!isZhinProject(cwd)) {
-        logger.error('当前目录不是Zhin项目');
+      // 检查是否是 workspace 项目
+      if (!isWorkspaceProject(cwd)) {
+        logger.error('当前目录不是 Zhin workspace 项目');
         process.exit(1);
       }
       
-      const distPath = path.join(cwd, 'dist');
+      const pluginsDir = path.join(cwd, 'plugins');
       
-      // 清理输出目录
-      if (options.clean && fs.existsSync(distPath)) {
-        logger.info('正在清理输出目录...');
-        await fs.remove(distPath);
+      if (!fs.existsSync(pluginsDir)) {
+        logger.error('未找到 plugins 目录');
+        process.exit(1);
       }
       
-      logger.info('正在构建项目...');
-      
-      // 使用TypeScript编译
-      const child = spawn('npx', ['tsc','--project','tsconfig.json'], {
-        cwd,
-        stdio: 'inherit',
-        shell:true,
-      });
-      
-      child.on('close', (code) => {
-        if (code === 0) {
-          logger.info('构建完成！');
-        } else {
-          logger.error(`构建失败，退出码: ${code}`);
+      // 如果指定了插件名称
+      if (pluginName) {
+        const pluginPath = path.join(pluginsDir, pluginName);
+        
+        if (!fs.existsSync(pluginPath)) {
+          logger.error(`未找到插件: ${pluginName}`);
           process.exit(1);
         }
-      });
-      
-      child.on('error', (error) => {
-        logger.error(`构建失败: ${error.message}`);
-        process.exit(1);
-      });
+        
+        await buildPlugin(pluginPath, pluginName, options.clean);
+      } else {
+        // 构建所有插件
+        const plugins = await fs.readdir(pluginsDir);
+        const validPlugins = plugins.filter(p => {
+          const pluginPath = path.join(pluginsDir, p);
+          const stat = fs.statSync(pluginPath);
+          return stat.isDirectory() && fs.existsSync(path.join(pluginPath, 'package.json'));
+        });
+        
+        if (validPlugins.length === 0) {
+          logger.warn('未找到任何插件');
+          return;
+        }
+        
+        logger.info(`找到 ${validPlugins.length} 个插件，开始构建...`);
+        
+        for (const plugin of validPlugins) {
+          const pluginPath = path.join(pluginsDir, plugin);
+          await buildPlugin(pluginPath, plugin, options.clean);
+        }
+      }
       
     } catch (error) {
       logger.error(`构建失败: ${error}`);
@@ -54,9 +63,55 @@ export const buildCommand = new Command('build')
     }
   });
 
-function isZhinProject(cwd: string): boolean {
+async function buildPlugin(pluginPath: string, pluginName: string, clean: boolean): Promise<void> {
+  return new Promise((resolve, reject) => {
+    logger.info(`正在构建插件: ${pluginName}...`);
+    
+    // 清理输出目录
+    if (clean) {
+      const libPath = path.join(pluginPath, 'lib');
+      const distPath = path.join(pluginPath, 'dist');
+      
+      if (fs.existsSync(libPath)) {
+        fs.removeSync(libPath);
+        logger.info(`✓ 已清理 ${pluginName}/lib`);
+      }
+      
+      if (fs.existsSync(distPath)) {
+        fs.removeSync(distPath);
+        logger.info(`✓ 已清理 ${pluginName}/dist`);
+      }
+    }
+    
+    // 使用 pnpm build 构建插件
+    const child = spawn('pnpm', ['build'], {
+      cwd: pluginPath,
+      stdio: 'inherit',
+      shell: true,
+    });
+    
+    child.on('close', (code) => {
+      if (code === 0) {
+        logger.success(`✓ ${pluginName} 构建完成`);
+        resolve();
+      } else {
+        logger.error(`✗ ${pluginName} 构建失败，退出码: ${code}`);
+        reject(new Error(`Build failed with code ${code}`));
+      }
+    });
+    
+    child.on('error', (error) => {
+      logger.error(`✗ ${pluginName} 构建失败: ${error.message}`);
+      reject(error);
+    });
+  });
+}
+
+function isWorkspaceProject(cwd: string): boolean {
+  const workspaceYamlPath = path.join(cwd, 'pnpm-workspace.yaml');
   const packageJsonPath = path.join(cwd, 'package.json');
-  if (!fs.existsSync(packageJsonPath)) {
+  
+  if (!fs.existsSync(workspaceYamlPath) || !fs.existsSync(packageJsonPath)) {
     return false;
   }
   

package/src/commands/new.ts

@@ -0,0 +1,392 @@
+import { Command } from 'commander';
+import { logger } from '../utils/logger.js';
+import fs from 'fs-extra';
+import path from 'path';
+import inquirer from 'inquirer';
+import { execSync } from 'node:child_process';
+
+interface NewPluginOptions {
+  skipInstall?: boolean;
+}
+
+export const newCommand = new Command('new')
+  .description('创建插件包模板')
+  .argument('[plugin-name]', '插件名称（如: my-plugin）')
+  .option('--skip-install', '跳过依赖安装', false)
+  .action(async (pluginName: string, options: NewPluginOptions) => {
+    try {
+      let name = pluginName;
+      
+      if (!name) {
+        const { pluginName: inputName } = await inquirer.prompt([
+          {
+            type: 'input',
+            name: 'pluginName',
+            message: '请输入插件名称:',
+            default: 'my-plugin',
+            validate: (input: string) => {
+              if (!input.trim()) {
+                return '插件名称不能为空';
+              }
+              if (!/^[a-zA-Z0-9-_]+$/.test(input)) {
+                return '插件名称只能包含字母、数字、横线和下划线';
+              }
+              return true;
+            }
+          }
+        ]);
+        name = inputName;
+      }
+
+      // 确定插件目录
+      const pluginDir = path.resolve(process.cwd(), 'plugins', name);
+      
+      // 检查目录是否已存在
+      if (fs.existsSync(pluginDir)) {
+        logger.error(`插件目录已存在: ${pluginDir}`);
+        process.exit(1);
+      }
+
+      logger.info(`正在创建插件包 ${name}...`);
+      
+      // 创建插件包结构
+      await createPluginPackage(pluginDir, name, options);
+      
+      // 自动添加到 app/package.json
+      await addPluginToApp(name);
+      
+      logger.success(`✓ 插件包 ${name} 创建成功！`);
+      logger.log('');
+      logger.log('📝 下一步操作：');
+      logger.log(`  cd plugins/${name}`);
+      if (options.skipInstall) {
+        logger.log(`  pnpm install`);
+      }
+      logger.log(`  pnpm build`);
+      logger.log(`  pnpm dev # 开发模式（监听文件变化）`);
+      logger.log('');
+      logger.log('📦 发布到 npm：');
+      logger.log(`  pnpm publish`);
+      
+    } catch (error) {
+      logger.error(`创建插件失败: ${error}`);
+      process.exit(1);
+    }
+  });
+
+async function createPluginPackage(pluginDir: string, pluginName: string, options: NewPluginOptions) {
+  const capitalizedName = pluginName.charAt(0).toUpperCase() + pluginName.slice(1).replace(/-([a-z])/g, (_, c) => c.toUpperCase());
+  const packageName = `@zhin.js/${pluginName}`;
+  
+  // 创建目录结构
+  await fs.ensureDir(pluginDir);
+  await fs.ensureDir(path.join(pluginDir, 'app'));
+  await fs.ensureDir(path.join(pluginDir, 'client'));
+  await fs.ensureDir(path.join(pluginDir, 'lib'));
+  await fs.ensureDir(path.join(pluginDir, 'dist'));
+  
+  // 创建 package.json
+  const packageJson = {
+    name: packageName,
+    version: '0.1.0',
+    description: `Zhin.js ${capitalizedName} 插件`,
+    type: 'module',
+    main: './lib/index.js',
+    types: './lib/index.d.ts',
+    exports: {
+      '.': {
+        types: './lib/index.d.ts',
+        import: './lib/index.js'
+      },
+      './client': {
+        import: './dist/index.js'
+      }
+    },
+    files: [
+      'lib',
+      'app',
+      'dist',
+      'client',
+      'README.md',
+      'CHANGELOG.md'
+    ],
+    scripts: {
+      build: 'pnpm build:app && pnpm build:client',
+      'build:app': 'tsc --project tsconfig.app.json',
+      'build:client': 'tsc --project tsconfig.client.json',
+      dev: 'tsc --project tsconfig.app.json --watch',
+      clean: 'rm -rf lib dist',
+      prepublishOnly: 'pnpm build'
+    },
+    keywords: [
+      'zhin',
+      'zhin-plugin',
+      pluginName
+    ],
+    author: '',
+    license: 'MIT',
+    peerDependencies: {
+      'zhin.js': 'workspace:*'
+    },
+    dependencies: {
+      '@zhin.js/client': 'workspace:*'
+    },
+    devDependencies: {
+      '@zhin.js/types': 'workspace:*',
+      '@types/node': 'latest',
+      '@types/react': 'latest',
+      'typescript': 'latest',
+      'react': 'latest',
+      'react-dom': 'latest',
+      'lucide-react': 'latest'
+    }
+  };
+  
+  await fs.writeJson(path.join(pluginDir, 'package.json'), packageJson, { spaces: 2 });
+  
+  // 创建 tsconfig.app.json (插件代码)
+  const tsConfigApp = {
+    extends: '../../tsconfig.json',
+    compilerOptions: {
+      rootDir: './app',
+      outDir: './lib',
+      declaration: true,
+      noEmit: false
+    },
+    include: ['app/**/*'],
+    exclude: ['node_modules', 'lib', 'dist']
+  };
+  
+  await fs.writeJson(path.join(pluginDir, 'tsconfig.app.json'), tsConfigApp, { spaces: 2 });
+  
+  // 创建 tsconfig.client.json (客户端代码)
+  const tsConfigClient = {
+    compilerOptions: {
+      target: 'ES2022',
+      module: 'ESNext',
+      moduleResolution: 'bundler',
+      rootDir: './client',
+      outDir: './dist',
+      declaration: false,
+      jsx: 'react-jsx',
+      baseUrl: '.',
+      skipLibCheck: true,
+      esModuleInterop: true,
+      allowSyntheticDefaultImports: true
+    },
+    include: ['client/**/*'],
+    exclude: ['node_modules', 'lib', 'dist']
+  };
+  
+  await fs.writeJson(path.join(pluginDir, 'tsconfig.client.json'), tsConfigClient, { spaces: 2 });
+  
+  // 创建 tsconfig.json (编辑器支持)
+  const tsConfig = {
+    extends: '../../tsconfig.json',
+    include: ['app/**/*', 'client/**/*'],
+    exclude: ['node_modules', 'lib', 'dist']
+  };
+  
+  await fs.writeJson(path.join(pluginDir, 'tsconfig.json'), tsConfig, { spaces: 2 });
+  
+  // 创建插件主入口文件 app/index.ts
+  const appContent = `import {
+  useLogger,
+  useContext,
+  onDispose,
+} from 'zhin.js';
+import path from 'node:path';
+
+const logger = useLogger();
+
+// 注册客户端入口（如果有客户端代码）
+useContext('web', (web) => {
+  const dispose = web.addEntry(
+    path.resolve(import.meta.dirname, '../client/index.tsx')
+  );
+  return dispose;
+});
+
+// 插件销毁时的清理
+onDispose(() => {
+  logger.info('${capitalizedName} 插件已销毁');
+});
+
+logger.info('${capitalizedName} 插件已加载');
+`;
+  
+  await fs.writeFile(path.join(pluginDir, 'app', 'index.ts'), appContent);
+  
+  // 创建客户端入口文件 client/index.tsx
+  const clientContent = `import { addPage } from '@zhin.js/client';
+import { Component } from 'lucide-react';
+import ${capitalizedName}Page from './pages/${capitalizedName}Page';
+
+addPage({
+  key: '${pluginName}-page',
+  path: '/plugins/${pluginName}',
+  title: '${capitalizedName}',
+  icon: <Component className="w-5 h-5" />,
+  element: <${capitalizedName}Page />
+});
+
+export { ${capitalizedName}Page };
+`;
+  
+  await fs.writeFile(path.join(pluginDir, 'client', 'index.tsx'), clientContent);
+
+  // 创建 client/tsconfig.json
+  const clientTsConfig = {
+    extends: '@zhin.js/console/browser.tsconfig.json',
+    compilerOptions: {
+      target: 'ES2022',
+      module: 'ESNext',
+      moduleResolution: 'bundler',
+      jsx: 'react-jsx',
+      baseUrl: '.'
+    }
+  };
+  
+  await fs.writeJson(path.join(pluginDir, 'client', 'tsconfig.json'), clientTsConfig, { spaces: 2 });
+  
+  // 创建客户端页面组件
+  await fs.ensureDir(path.join(pluginDir, 'client', 'pages'));
+  const pageContent = `import { useEffect } from 'react';
+
+export default function ${capitalizedName}Page() {
+
+  useEffect(() => {
+    console.log('${capitalizedName} 页面已挂载');
+  }, []);
+
+  return (
+    <div className="p-6">
+      <h1 className="text-2xl font-bold mb-4">${capitalizedName}</h1>
+    </div>
+  );
+}
+`;
+  
+  await fs.writeFile(path.join(pluginDir, 'client', 'pages', `${capitalizedName}Page.tsx`), pageContent);
+  
+  // 创建 README.md
+  const readmeContent = `# ${packageName}
+
+${capitalizedName} 插件 for Zhin.js
+
+## 安装
+
+\`\`\`bash
+pnpm add ${packageName}
+\`\`\`
+
+## 使用
+
+在 \`zhin.config.ts\` 中添加插件：
+
+\`\`\`typescript
+export default defineConfig({
+  plugins: [
+    '${pluginName}'
+  ]
+});
+\`\`\`
+
+## 开发
+
+\`\`\`bash
+# 安装依赖
+pnpm install
+
+# 构建
+pnpm build
+
+# 开发模式
+pnpm dev
+\`\`\`
+
+## 许可证
+
+MIT
+`;
+  
+  await fs.writeFile(path.join(pluginDir, 'README.md'), readmeContent);
+  
+  // 创建 CHANGELOG.md
+  const changelogContent = `# ${packageName}
+
+## 0.1.0
+
+### Features
+
+- 初始版本
+`;
+  
+  await fs.writeFile(path.join(pluginDir, 'CHANGELOG.md'), changelogContent);
+  
+  // 创建 .gitignore
+  const gitignoreContent = `node_modules/
+lib/
+dist/
+*.log
+.DS_Store
+`;
+  
+  await fs.writeFile(path.join(pluginDir, '.gitignore'), gitignoreContent);
+  
+  // 安装依赖
+  if (!options.skipInstall) {
+    logger.info('正在安装依赖...');
+    try {
+      execSync('pnpm install', {
+        cwd: pluginDir,
+        stdio: 'inherit'
+      });
+      logger.success('✓ 依赖安装成功');
+    } catch (error) {
+      logger.warn('⚠ 依赖安装失败，请手动执行 pnpm install');
+    }
+  }
+}
+
+async function addPluginToApp(pluginName: string) {
+  try {
+    const rootPackageJsonPath = path.resolve(process.cwd(), 'package.json');
+    
+    // 检查根 package.json 是否存在
+    if (!fs.existsSync(rootPackageJsonPath)) {
+      logger.warn('⚠ 未找到根目录 package.json，跳过依赖添加');
+      return;
+    }
+    
+    const packageJson = await fs.readJson(rootPackageJsonPath);
+    const packageName = `@zhin.js/${pluginName}`;
+    
+    // 初始化 dependencies
+    if (!packageJson.dependencies) {
+      packageJson.dependencies = {};
+    }
+    
+    // 添加 workspace 依赖
+    packageJson.dependencies[packageName] = 'workspace:*';
+    
+    // 写回文件
+    await fs.writeJson(rootPackageJsonPath, packageJson, { spaces: 2 });
+    
+    logger.success(`✓ 已将 ${packageName} 添加到 package.json`);
+    
+    // 重新安装依赖
+    logger.info('正在更新依赖...');
+    try {
+      execSync('pnpm install', {
+        cwd: process.cwd(),
+        stdio: 'inherit'
+      });
+      logger.success('✓ 依赖更新成功');
+    } catch (error) {
+      logger.warn('⚠ 依赖更新失败，请手动执行 pnpm install');
+    }
+  } catch (error) {
+    logger.warn(`⚠ 添加到 package.json 失败: ${error}`);
+  }
+}

package/src/commands/start.ts

@@ -10,7 +10,7 @@ export const startCommand = new Command('start')
   .description('生产模式启动机器人')
   .option('-d, --daemon', '后台运行', false)
   .option('--log-file [file]', '日志文件路径')
-  .option('--bun', '使用 bun 运行（默认使用 node）', false)
+  .option('--bun', '使用 bun 运行（默认使用 tsx）', false)
   .action(async (options: { daemon: boolean; logFile?: string; bun: boolean }) => {
     try {
       const cwd = process.cwd();
@@ -27,7 +27,7 @@ export const startCommand = new Command('start')
       loadEnvFiles(cwd, 'production');
       
       // 检查构建产物
-      const distPath = path.join(cwd, 'dist');
+      const distPath = path.join(cwd, 'lib');
       const sourcePath = path.join(cwd, 'src');
       const sourceFile = path.join(sourcePath, 'index.ts');
       const distFile = path.join(distPath, 'index.js');
@@ -47,7 +47,6 @@ export const startCommand = new Command('start')
           ...process.env,
           NODE_ENV: 'production'
         };
-        
         // 配置stdio
         let stdio: any = 'inherit';
         if (options.daemon) {
@@ -57,11 +56,17 @@ export const startCommand = new Command('start')
         }
         
         // 选择运行时
-        const runtime = options.bun ? 'bun' : 'node';
+        const runtime = options.bun ? 'bun' : 'tsx';
         const args = options.bun ? [entryFile] : ['--expose-gc', entryFile];
         
         logger.info(`📦 启动命令: ${runtime} ${args.join(' ')}`);
-        return startProcess(runtime, args, cwd,options.daemon);
+        return startProcess(runtime, args, {
+          cwd,
+          env,
+          stdio,
+          shell:true,
+          detached: options.daemon,
+        });
       };
       
       let child = await startBot();

package/src/utils/process.ts

@@ -1,4 +1,4 @@
-import { spawn, ChildProcess, exec } from 'child_process';
+import { spawn, ChildProcess, exec, SpawnOptions } from 'child_process';
 import fs from 'fs-extra';
 import path from 'path';
 import { logger } from './logger.js';
@@ -60,21 +60,15 @@ async function killProcess(pid: number, signal: string = 'SIGTERM'): Promise<boo
   });
 }
 
-export async function startProcess(command: string, args: string[], cwd: string,daemon:boolean): Promise<ChildProcess> {
+export async function startProcess(command: string, args: string[], options:SpawnOptions): Promise<ChildProcess> {
   return new Promise((resolve, reject) => {
-    const child = spawn(command, args, {
-      cwd,
-      detached: daemon,
-      stdio: 'inherit',
-      shell:true,
-      env: { ...process.env }
-    });
+    const child = spawn(command, args, options);
 
-    if(daemon) child.unref();
+    if(options.detached) child.unref();
 
     child.on('spawn', () => {
       // 保存进程ID
-      const pidFile = path.join(cwd, PID_FILE);
+      const pidFile = path.join((options.cwd!).toString(), PID_FILE);
       fs.writeFileSync(pidFile, child.pid!.toString());
       logger.success(`机器人已启动，PID: ${child.pid}`);
       resolve(child);

package/lib/commands/init.d.ts

@@ -1,3 +0,0 @@
-import { Command } from 'commander';
-export declare const initCommand: Command;
-//# sourceMappingURL=init.d.ts.map

package/lib/commands/init.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"init.d.ts","sourceRoot":"","sources":["../../src/commands/init.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAcpC,eAAO,MAAM,WAAW,SA0HpB,CAAC"}