clawflowbang 1.0.0

package/src/core/Installer.js

@@ -0,0 +1,352 @@
+/**
+ * Installer - จัดการการติดตั้งและถอนการติดตั้ง packages
+ */
+
+const fs = require('fs-extra');
+const path = require('path');
+const chalk = require('chalk');
+const ora = require('ora');
+const inquirer = require('inquirer');
+const OpenClawCLI = require('./OpenClawCLI');
+
+class Installer {
+  constructor(configManager, registry) {
+    this.configManager = configManager;
+    this.registry = registry;
+    this.cronManager = null; // จะ set จากภายนอก
+    this.openclawCLI = new OpenClawCLI(configManager);
+  }
+
+  setCronManager(cronManager) {
+    this.cronManager = cronManager;
+  }
+
+  /**
+   * ติดตั้ง package
+   */
+  async install(packageName, options = {}) {
+    const { global = false, cron: withCron = true, dryRun = false } = options;
+
+    // ตรวจสอบว่า package มีอยู่หรือไม่ (รองรับทั้ง built-in และ npm)
+    const pkg = await this.registry.getPackage(packageName);
+    if (!pkg) {
+      throw new Error(`Package "${packageName}" ไม่พบใน registry (ลองตรวจสอบชื่อ package หรือเชื่อมต่ออินเทอร์เน็ต)`);
+    }
+
+    // ตรวจสอบว่าติดตั้งแล้วหรือยัง
+    const installed = this.configManager.getInstalledPackages();
+    if (installed[packageName]) {
+      console.log(chalk.yellow(`⚠️  Package "${packageName}" ติดตั้งแล้ว`));
+      const { reinstall } = await inquirer.prompt([{
+        type: 'confirm',
+        name: 'reinstall',
+        message: 'ต้องการติดตั้งใหม่หรือไม่?',
+        default: false,
+      }]);
+      if (!reinstall) {
+        return { success: false, reason: 'already_installed' };
+      }
+    }
+
+    console.log(chalk.cyan(`📦 กำลังติดตั้ง ${chalk.bold(packageName)}...\n`));
+
+    // Dry run - แสดงเฉพาะข้อมูล
+    if (dryRun) {
+      this.showDryRunInfo(pkg, withCron);
+      return { success: true, dryRun: true };
+    }
+
+    const spinner = ora('กำลังดำเนินการ...').start();
+
+    try {
+      // 1. ติดตั้ง skills
+      spinner.text = 'กำลังติดตั้ง skills...';
+      await this.installSkills(pkg.skills, global);
+
+      // 2. ตั้งค่า config
+      spinner.text = 'กำลังตั้งค่า configuration...';
+      await this.setupConfig(packageName, pkg.config);
+
+      // 3. ตั้ง cronjobs (ถ้าเปิดใช้งาน)
+      let crons = [];
+      if (withCron && pkg.crons && pkg.crons.length > 0) {
+        spinner.text = 'กำลังตั้ง cronjobs...';
+        crons = await this.setupCrons(pkg.crons);
+      }
+
+      // 4. บันทึกว่าติดตั้งแล้ว
+      spinner.text = 'กำลังบันทึกข้อมูล...';
+      this.configManager.addInstalledPackage(packageName, {
+        version: pkg.version,
+        skills: pkg.skills.map(s => s.name),
+        crons: crons.map(c => c.id),
+        configPath: this.getPackageConfigPath(packageName),
+      });
+
+      spinner.succeed(chalk.green(`ติดตั้ง ${packageName} เสร็จสมบูรณ์!`));
+
+      // แสดงข้อมูลสรุป
+      this.showInstallSummary(pkg, crons);
+
+      // แสดง post-install message
+      if (pkg.postInstall) {
+        console.log(chalk.yellow('\n📋 ขั้นตอนถัดไป:'));
+        console.log(chalk.gray(`   ${pkg.postInstall}`));
+      }
+
+      return {
+        success: true,
+        package: packageName,
+        skills: pkg.skills.map(s => s.name),
+        crons: crons,
+      };
+
+    } catch (error) {
+      spinner.fail(chalk.red(`ติดตั้งไม่สำเร็จ: ${error.message}`));
+      throw error;
+    }
+  }
+
+  /**
+   * ติดตั้ง skills
+   */
+  async installSkills(skills, global = false) {
+    for (const skill of skills) {
+      console.log(chalk.gray(`   → ติดตั้ง skill: ${skill.name}@${skill.version}`));
+      
+      // ติดตั้ง skill ผ่าน OpenClaw
+      // ในโลกจริงจะเรียก OpenClaw API หรือ CLI
+      await this.installSkillToOpenClaw(skill, global);
+    }
+  }
+
+  /**
+   * ติดตั้ง skill ไปยัง OpenClaw
+   */
+  async installSkillToOpenClaw(skill, global = false) {
+    void global;
+    const skillsPath = this.configManager.getSkillsPath();
+
+    try {
+      await this.openclawCLI.installSkill(skill.name, skill.version, skillsPath);
+
+      // ตรวจสอบหลังติดตั้ง (best effort)
+      await this.openclawCLI.verifySkill(skill.name).catch(() => null);
+
+    } catch (error) {
+      try {
+        const cloned = await this.openclawCLI.installSkillFromGit(skill, skillsPath);
+        console.log(chalk.yellow(`   ↳ fallback git clone สำเร็จ: ${cloned.repository}`));
+        return;
+      } catch (gitError) {
+        throw new Error(
+          `ไม่สามารถติดตั้ง skill "${skill.name}" ได้ทั้งจาก clawhub และ git clone\n` +
+          `clawhub: ${error.message}\n` +
+          `git: ${gitError.message}`,
+        );
+      }
+    }
+  }
+
+  /**
+   * ตั้งค่า config สำหรับ package
+   */
+  async setupConfig(packageName, configSchema) {
+    if (!configSchema) return;
+
+    const configPath = this.getPackageConfigPath(packageName);
+    const existingConfig = fs.existsSync(configPath) 
+      ? fs.readJsonSync(configPath) 
+      : {};
+
+    const newConfig = {};
+
+    for (const [skillName, schema] of Object.entries(configSchema)) {
+      newConfig[skillName] = {};
+      
+      for (const [key, value] of Object.entries(schema)) {
+        if (value.env) {
+          // ดึงค่าจาก environment variable
+          const envValue = process.env[value.env];
+          if (envValue) {
+            newConfig[skillName][key] = envValue;
+          } else if (value.required && !existingConfig[skillName]?.[key]) {
+            // ถ้าไม่มีใน env และจำเป็นต้องมี
+            const answer = await inquirer.prompt([{
+              type: 'input',
+              name: key,
+              message: `กรุณากรอก ${key} สำหรับ ${skillName} (หรือตั้งค่า ${value.env}):`,
+              validate: (input) => input.length > 0 || 'จำเป็นต้องกรอก',
+            }]);
+            newConfig[skillName][key] = answer[key];
+          }
+        } else if (value.default !== undefined) {
+          newConfig[skillName][key] = existingConfig[skillName]?.[key] ?? value.default;
+        } else if (value.required && !existingConfig[skillName]?.[key]) {
+          const answer = await inquirer.prompt([{
+            type: 'input',
+            name: key,
+            message: `กรุณากรอก ${key} สำหรับ ${skillName}:`,
+            validate: (input) => input.length > 0 || 'จำเป็นต้องกรอก',
+          }]);
+          newConfig[skillName][key] = answer[key];
+        }
+      }
+    }
+
+    // รวมกับ config เดิม
+    const mergedConfig = { ...existingConfig, ...newConfig };
+    fs.writeJsonSync(configPath, mergedConfig, { spaces: 2 });
+  }
+
+  /**
+   * ตั้งค่า cronjobs
+   */
+  async setupCrons(cronsConfig) {
+    const crons = [];
+    
+    for (const cronConfig of cronsConfig) {
+      const cronInfo = await this.cronManager.add(
+        cronConfig.skill,
+        cronConfig.schedule,
+        cronConfig.params,
+        cronConfig.description
+      );
+      crons.push(cronInfo);
+    }
+
+    return crons;
+  }
+
+  /**
+   * ถอนการติดตั้ง package
+   */
+  async remove(packageName, options = {}) {
+    const { keepConfig = false } = options;
+
+    const installed = this.configManager.getInstalledPackages();
+    if (!installed[packageName]) {
+      console.log(chalk.yellow(`⚠️  Package "${packageName}" ไม่ได้ถูกติดตั้ง`));
+      return { success: false, reason: 'not_installed' };
+    }
+
+    console.log(chalk.cyan(`🗑️  กำลังถอนการติดตั้ง ${chalk.bold(packageName)}...`));
+
+    const spinner = ora('กำลังดำเนินการ...').start();
+
+    try {
+      const pkgInfo = installed[packageName];
+
+      // 1. ลบ cronjobs
+      if (pkgInfo.crons && pkgInfo.crons.length > 0) {
+        spinner.text = 'กำลังลบ cronjobs...';
+        for (const cronId of pkgInfo.crons) {
+          await this.cronManager.remove(cronId);
+        }
+      }
+
+      // 2. ลบ skills
+      if (pkgInfo.skills && pkgInfo.skills.length > 0) {
+        spinner.text = 'กำลังลบ skills...';
+        for (const skillName of pkgInfo.skills) {
+          await this.removeSkillFromOpenClaw(skillName);
+        }
+      }
+
+      // 3. ลบ config (ถ้าไม่ได้ระบุให้เก็บไว้)
+      if (!keepConfig) {
+        spinner.text = 'กำลังลบ config...';
+        const configPath = this.getPackageConfigPath(packageName);
+        if (fs.existsSync(configPath)) {
+          fs.removeSync(configPath);
+        }
+      }
+
+      // 4. ลบจาก installed list
+      this.configManager.removeInstalledPackage(packageName);
+
+      spinner.succeed(chalk.green(`ถอนการติดตั้ง ${packageName} เสร็จสมบูรณ์!`));
+
+      return { success: true, package: packageName };
+
+    } catch (error) {
+      spinner.fail(chalk.red(`ถอนการติดตั้งไม่สำเร็จ: ${error.message}`));
+      throw error;
+    }
+  }
+
+  /**
+   * ลบ skill จาก OpenClaw
+   */
+  async removeSkillFromOpenClaw(skillName) {
+    const skillPath = path.join(this.configManager.getSkillsPath(), skillName);
+    if (fs.existsSync(skillPath)) {
+      fs.removeSync(skillPath);
+    }
+  }
+
+  /**
+   * แสดงข้อมูล dry run
+   */
+  showDryRunInfo(pkg, withCron) {
+    console.log(chalk.cyan('\n📋 ข้อมูลการติดตั้ง (Dry Run):\n'));
+    
+    console.log(chalk.white('Package:'), chalk.bold(pkg.name));
+    console.log(chalk.white('Version:'), pkg.version);
+    console.log(chalk.white('Description:'), pkg.description);
+    
+    console.log(chalk.yellow('\n📦 Skills ที่จะติดตั้ง:'));
+    pkg.skills.forEach(skill => {
+      console.log(`  • ${skill.name}@${skill.version}`);
+    });
+
+    if (withCron && pkg.crons && pkg.crons.length > 0) {
+      console.log(chalk.yellow('\n⏰ Cronjobs ที่จะตั้ง:'));
+      pkg.crons.forEach(cron => {
+        console.log(`  • ${cron.skill}`);
+        console.log(`    Schedule: ${cron.schedule}`);
+        console.log(`    Description: ${cron.description}`);
+      });
+    }
+
+    console.log(chalk.yellow('\n⚙️  Config ที่จะตั้ง:'));
+    if (pkg.config) {
+      console.log(JSON.stringify(pkg.config, null, 2));
+    } else {
+      console.log('  (ไม่มี config พิเศษ)');
+    }
+
+    console.log(chalk.gray('\n(ไม่ได้ทำการติดตั้งจริง - dry run mode)'));
+  }
+
+  /**
+   * แสดงสรุปการติดตั้ง
+   */
+  showInstallSummary(pkg, crons) {
+    console.log(chalk.green('\n✅ สรุปการติดตั้ง:\n'));
+    
+    console.log(chalk.white('📦 Package:'), pkg.name);
+    console.log(chalk.white('🛠️  Skills ที่ติดตั้ง:'));
+    pkg.skills.forEach(skill => {
+      console.log(`   ✓ ${skill.name}`);
+    });
+
+    if (crons.length > 0) {
+      console.log(chalk.white('\n⏰ Cronjobs ที่ตั้ง:'));
+      crons.forEach(cron => {
+        console.log(`   ✓ ${cron.skill} (${cron.schedule})`);
+      });
+    }
+
+    console.log(chalk.white('\n📁 Config path:'), this.getPackageConfigPath(pkg.name));
+  }
+
+  /**
+   * ดึง path ของ config สำหรับ package
+   */
+  getPackageConfigPath(packageName) {
+    return path.join(this.configManager.getSkillsPath(), `${packageName}.config.json`);
+  }
+}
+
+module.exports = Installer;

package/src/core/NPMRegistry.js

@@ -0,0 +1,285 @@
+/**
+ * NPMRegistry - Client สำหรับค้นหาและดึง packages จาก npm registry
+ */
+
+const axios = require('axios');
+
+const NPM_REGISTRY_URL = 'https://registry.npmjs.org';
+const NPM_SEARCH_URL = 'https://api.npms.io/v2';
+
+class NPMRegistry {
+  constructor(cacheDir = null) {
+    this.cache = new Map();
+    this.cacheExpiry = 5 * 60 * 1000; // 5 minutes
+    this.cacheDir = cacheDir;
+  }
+
+  /**
+   * ค้นหา packages ที่เป็น clawflow packages
+   * โดยใช้ keyword 'clawflow' หรือ scope @clawflow
+   */
+  async searchClawFlowPackages(query = '') {
+    try {
+      // ค้นหาด้วย keyword 'clawflow'
+      const searchQuery = query ? `${query} clawflow` : 'clawflow';
+      const response = await axios.get(`${NPM_SEARCH_URL}/search`, {
+        params: {
+          q: searchQuery,
+          size: 50,
+        },
+        timeout: 10000,
+      });
+
+      const results = response.data.results || [];
+      return results
+        .filter((item) => this.isClawFlowPackage(item.package))
+        .map((item) => this.normalizePackage(item.package));
+    } catch (error) {
+      console.error('Error searching npm packages:', error.message);
+      return [];
+    }
+  }
+
+  /**
+   * ตรวจสอบว่าเป็น clawflow package หรือไม่
+   */
+  isClawFlowPackage(pkg) {
+    if (!pkg) return false;
+
+    // ตรวจสอบ scope @clawflow/
+    if (pkg.name.startsWith('@clawflow/')) {
+      return true;
+    }
+
+    // ตรวจสอบ keywords
+    const keywords = pkg.keywords || [];
+    if (keywords.includes('clawflow')) {
+      return true;
+    }
+
+    // ตรวจสอบ field clawflow ใน package.json
+    if (pkg.clawflow || (pkg.manifest && pkg.manifest.clawflow)) {
+      return true;
+    }
+
+    return false;
+  }
+
+  /**
+   * ดึงข้อมูล package จาก npm registry
+   */
+  async getPackage(name, version = 'latest') {
+    const cacheKey = `${name}@${version}`;
+
+    // ตรวจสอบ cache
+    if (this.cache.has(cacheKey)) {
+      const cached = this.cache.get(cacheKey);
+      if (Date.now() - cached.timestamp < this.cacheExpiry) {
+        return cached.data;
+      }
+    }
+
+    try {
+      const encodedName = this.encodePackageName(name);
+      const url =
+        version === 'latest'
+          ? `${NPM_REGISTRY_URL}/${encodedName}/latest`
+          : `${NPM_REGISTRY_URL}/${encodedName}/${version}`;
+
+      const response = await axios.get(url, {
+        timeout: 10000,
+        headers: {
+          Accept: 'application/vnd.npm.install-v1+json',
+        },
+      });
+
+      const pkg = this.normalizePackage(response.data);
+
+      // ถ้าเป็น clawflow package ให้ดึง clawflow.json เพิ่ม
+      if (this.isClawFlowPackage(response.data)) {
+        const clawflowConfig = await this.fetchClawflowConfig(name, response.data.version);
+        if (clawflowConfig) {
+          Object.assign(pkg, clawflowConfig);
+        }
+      }
+
+      // เก็บ cache
+      this.cache.set(cacheKey, {
+        data: pkg,
+        timestamp: Date.now(),
+      });
+
+      return pkg;
+    } catch (error) {
+      if (error.response?.status === 404) {
+        return null;
+      }
+      throw new Error(`Failed to fetch package ${name}: ${error.message}`);
+    }
+  }
+
+  /**
+   * ดึง clawflow.json จาก package
+   */
+  async fetchClawflowConfig(name, version) {
+    try {
+      // ดึงจาก unpkg หรือ jsDelivr
+      const urls = [
+        `https://unpkg.com/${name}@${version}/clawflow.json`,
+        `https://cdn.jsdelivr.net/npm/${name}@${version}/clawflow.json`,
+      ];
+
+      for (const url of urls) {
+        try {
+          const response = await axios.get(url, { timeout: 5000 });
+          return response.data;
+        } catch (e) {
+          continue;
+        }
+      }
+
+      return null;
+    } catch (error) {
+      return null;
+    }
+  }
+
+  /**
+   * ดึงข้อมูล package ทั้งหมด (รวมทุก versions)
+   */
+  async getPackageManifest(name) {
+    const cacheKey = `manifest:${name}`;
+
+    if (this.cache.has(cacheKey)) {
+      const cached = this.cache.get(cacheKey);
+      if (Date.now() - cached.timestamp < this.cacheExpiry) {
+        return cached.data;
+      }
+    }
+
+    try {
+      const encodedName = this.encodePackageName(name);
+      const response = await axios.get(`${NPM_REGISTRY_URL}/${encodedName}`, {
+        timeout: 10000,
+      });
+
+      const data = response.data;
+
+      this.cache.set(cacheKey, {
+        data,
+        timestamp: Date.now(),
+      });
+
+      return data;
+    } catch (error) {
+      if (error.response?.status === 404) {
+        return null;
+      }
+      throw error;
+    }
+  }
+
+  /**
+   * ดึง latest version ของ package
+   */
+  async getLatestVersion(name) {
+    const manifest = await this.getPackageManifest(name);
+    if (!manifest) return null;
+
+    return manifest['dist-tags']?.latest || null;
+  }
+
+  /**
+   * ตรวจสอบว่า package มีอยู่จริงบน npm หรือไม่
+   */
+  async exists(name) {
+    const pkg = await this.getLatestVersion(name);
+    return pkg !== null;
+  }
+
+  /**
+   * แปลงชื่อ package สำหรับ URL (handle scoped packages)
+   */
+  encodePackageName(name) {
+    if (name.startsWith('@')) {
+      return `@${encodeURIComponent(name.substring(1))}`;
+    }
+    return encodeURIComponent(name);
+  }
+
+  /**
+   * Normalize package data จาก npm ให้เป็นรูปแบบ clawflow
+   */
+  normalizePackage(pkg) {
+    const clawflowField = pkg.clawflow || {};
+
+    return {
+      name: pkg.name,
+      version: pkg.version,
+      description: pkg.description || '',
+      author: this.normalizeAuthor(pkg.author),
+      keywords: pkg.keywords || [],
+      homepage: pkg.homepage || '',
+      repository: pkg.repository?.url || pkg.repository || '',
+      license: pkg.license || '',
+      source: 'npm',
+
+      // ClawFlow specific fields
+      skills: clawflowField.skills || [],
+      crons: clawflowField.crons || [],
+      config: clawflowField.config || {},
+      postInstall: clawflowField.postInstall || '',
+      dependencies: pkg.dependencies || {},
+
+      // Raw npm data
+      _npm: {
+        dist: pkg.dist,
+        maintainers: pkg.maintainers,
+        time: pkg.time,
+      },
+    };
+  }
+
+  /**
+   * Normalize author field
+   */
+  normalizeAuthor(author) {
+    if (!author) return 'Unknown';
+    if (typeof author === 'string') return author;
+    if (typeof author === 'object') {
+      return author.name || 'Unknown';
+    }
+    return 'Unknown';
+  }
+
+  /**
+   * ดึงรายการ popular clawflowhub packages
+   */
+  async getPopularPackages(limit = 20) {
+    try {
+      const response = await axios.get(`${NPM_SEARCH_URL}/search`, {
+        params: {
+          q: 'keywords:clawflowhub',
+          sort: 'popularity',
+          size: limit,
+        },
+        timeout: 10000,
+      });
+
+      const results = response.data.results || [];
+      return results.map((item) => this.normalizePackage(item.package));
+    } catch (error) {
+      console.error('Error fetching popular packages:', error.message);
+      return [];
+    }
+  }
+
+  /**
+   * ล้าง cache
+   */
+  clearCache() {
+    this.cache.clear();
+  }
+}
+
+module.exports = NPMRegistry;