clawflowbang 1.0.0

package/src/core/OpenClawCLI.js

@@ -0,0 +1,265 @@
+const path = require('path');
+const fs = require('fs-extra');
+const { promisify } = require('util');
+const { execFile, spawnSync } = require('child_process');
+
+const execFileAsync = promisify(execFile);
+
+class OpenClawCLI {
+  constructor(configManager) {
+    this.configManager = configManager;
+  }
+
+  getOpenClawBin() {
+    const config = this.configManager.getConfig();
+    return config.openclaw?.cliBin || 'openclaw';
+  }
+
+  getClawhubBin() {
+    const config = this.configManager.getConfig();
+    return config.openclaw?.clawhubBin || 'clawhub';
+  }
+
+  hasOpenClaw() {
+    return this.commandExists(this.getOpenClawBin(), ['--version']);
+  }
+
+  hasClawhub() {
+    return this.commandExists(this.getClawhubBin(), ['--version']);
+  }
+
+  hasGit() {
+    return this.commandExists('git', ['--version']);
+  }
+
+  commandExists(command, args = ['--help']) {
+    const result = spawnSync(command, args, {
+      encoding: 'utf8',
+      stdio: 'pipe',
+      windowsHide: true,
+    });
+
+    return result.status === 0;
+  }
+
+  async run(command, args, options = {}) {
+    try {
+      const { stdout, stderr } = await execFileAsync(command, args, {
+        cwd: options.cwd,
+        env: process.env,
+        maxBuffer: 1024 * 1024 * 4,
+        windowsHide: true,
+      });
+      return {
+        stdout: (stdout || '').trim(),
+        stderr: (stderr || '').trim(),
+      };
+    } catch (error) {
+      const stderr = error.stderr ? String(error.stderr).trim() : '';
+      const stdout = error.stdout ? String(error.stdout).trim() : '';
+      const detail = stderr || stdout || error.message;
+      throw new Error(`${command} ${args.join(' ')} ล้มเหลว: ${detail}`);
+    }
+  }
+
+  parseJson(text) {
+    if (!text) return null;
+    try {
+      return JSON.parse(text);
+    } catch (_error) {
+      return null;
+    }
+  }
+
+  async installSkill(skillName, skillVersion, skillsPath) {
+    if (!this.hasClawhub()) {
+      throw new Error('ไม่พบ CLI "clawhub" (ต้องใช้สำหรับติดตั้ง skill จาก registry)');
+    }
+
+    const workdir = path.dirname(skillsPath);
+    const dir = path.basename(skillsPath);
+    const args = ['install', skillName, '--workdir', workdir, '--dir', dir, '--force', '--no-input'];
+
+    if (skillVersion && skillVersion !== 'latest') {
+      args.push('--version', skillVersion);
+    }
+
+    await this.run(this.getClawhubBin(), args);
+    return true;
+  }
+
+  resolveGitRepository(skill = {}) {
+    const fromFields = [
+      skill.git,
+      skill.repo,
+      skill.url,
+      typeof skill.repository === 'string' ? skill.repository : skill.repository?.url,
+    ].find((value) => typeof value === 'string' && value.trim());
+
+    if (fromFields) {
+      return fromFields.trim();
+    }
+
+    if (skill.source === 'github' && typeof skill.name === 'string' && skill.name.includes('/')) {
+      return `https://github.com/${skill.name}.git`;
+    }
+
+    if (
+      (skill.source === 'git' || skill.source === 'github') &&
+      typeof skill.name === 'string' &&
+      /^(https?:\/\/|git@|ssh:\/\/)/i.test(skill.name)
+    ) {
+      return skill.name;
+    }
+
+    return null;
+  }
+
+  resolveSkillDirName(skill = {}) {
+    if (typeof skill.dir === 'string' && skill.dir.trim()) {
+      return skill.dir.trim();
+    }
+    if (typeof skill.localName === 'string' && skill.localName.trim()) {
+      return skill.localName.trim();
+    }
+
+    let name = (skill.name || '').trim();
+    if (!name) {
+      return null;
+    }
+
+    if (/^(https?:\/\/|git@|ssh:\/\/)/i.test(name)) {
+      name = name.split('/').pop() || name;
+      name = name.replace(/\.git$/i, '');
+    } else if (name.includes('/')) {
+      name = name.split('/').pop();
+    }
+
+    return name || null;
+  }
+
+  async installSkillFromGit(skill, skillsPath) {
+    if (!this.hasGit()) {
+      throw new Error('ไม่พบคำสั่ง "git" สำหรับ fallback install');
+    }
+
+    const repoUrl = this.resolveGitRepository(skill);
+    if (!repoUrl) {
+      throw new Error('ไม่มีข้อมูล git repository สำหรับ fallback install');
+    }
+
+    const skillDirName = this.resolveSkillDirName(skill);
+    if (!skillDirName) {
+      throw new Error('ไม่สามารถระบุชื่อโฟลเดอร์ skill จากข้อมูลที่มี');
+    }
+
+    const targetDir = path.join(skillsPath, skillDirName);
+    fs.ensureDirSync(skillsPath);
+    if (fs.existsSync(targetDir)) {
+      fs.removeSync(targetDir);
+    }
+
+    const args = ['clone', '--depth', '1'];
+    const gitRef = skill.gitRef || skill.ref || skill.branch || skill.tag;
+    if (typeof gitRef === 'string' && gitRef.trim()) {
+      args.push('--branch', gitRef.trim());
+    }
+    args.push(repoUrl, targetDir);
+
+    await this.run('git', args);
+
+    const skillFile = path.join(targetDir, 'SKILL.md');
+    if (!fs.existsSync(skillFile)) {
+      throw new Error(`repo "${repoUrl}" ไม่มีไฟล์ SKILL.md ที่ root`);
+    }
+
+    return {
+      name: skill.name,
+      dir: skillDirName,
+      repository: repoUrl,
+      path: targetDir,
+    };
+  }
+
+  async verifySkill(skillName) {
+    if (!this.hasOpenClaw()) {
+      return null;
+    }
+
+    await this.run(this.getOpenClawBin(), ['skills', 'info', skillName, '--json']);
+    return true;
+  }
+
+  async addCronJob({ name, description, schedule, message }) {
+    if (!this.hasOpenClaw()) {
+      throw new Error('ไม่พบ CLI "openclaw" (ต้องใช้สำหรับสร้าง cronjob แบบ native)');
+    }
+
+    const args = [
+      'cron',
+      'add',
+      '--name',
+      name,
+      '--cron',
+      schedule,
+      '--session',
+      'isolated',
+      '--message',
+      message,
+      '--json',
+    ];
+
+    if (description) {
+      args.push('--description', description);
+    }
+
+    const result = await this.run(this.getOpenClawBin(), args);
+    const payload = this.parseJson(result.stdout);
+    const jobId = payload?.job?.id || payload?.id || null;
+
+    return { jobId, raw: payload };
+  }
+
+  async listCronJobs() {
+    if (!this.hasOpenClaw()) {
+      throw new Error('ไม่พบ CLI "openclaw" (ต้องใช้สำหรับอ่าน cronjobs)');
+    }
+
+    const result = await this.run(this.getOpenClawBin(), ['cron', 'list', '--all', '--json']);
+    const payload = this.parseJson(result.stdout);
+    return payload?.jobs || [];
+  }
+
+  async removeCronJob(jobId) {
+    if (!this.hasOpenClaw()) {
+      throw new Error('ไม่พบ CLI "openclaw" (ต้องใช้สำหรับลบ cronjob)');
+    }
+
+    await this.run(this.getOpenClawBin(), ['cron', 'rm', jobId, '--json']);
+    return true;
+  }
+
+  async editCronJob(jobId, updates = {}) {
+    if (!this.hasOpenClaw()) {
+      throw new Error('ไม่พบ CLI "openclaw" (ต้องใช้สำหรับแก้ไข cronjob)');
+    }
+
+    const args = ['cron', 'edit', jobId];
+
+    if (updates.schedule) {
+      args.push('--cron', updates.schedule);
+    }
+    if (typeof updates.description === 'string') {
+      args.push('--description', updates.description);
+    }
+    if (updates.message) {
+      args.push('--message', updates.message);
+    }
+
+    args.push('--json');
+    const result = await this.run(this.getOpenClawBin(), args);
+    return this.parseJson(result.stdout);
+  }
+}
+
+module.exports = OpenClawCLI;

package/src/core/PackageResolver.js

@@ -0,0 +1,94 @@
+/**
+ * PackageResolver - จัดการ dependency resolution
+ */
+
+class PackageResolver {
+  constructor(registry) {
+    this.registry = registry;
+  }
+
+  /**
+   * แก้ไข dependencies ของ package
+   */
+  resolveDependencies(packageName, resolved = new Set(), unresolved = new Set()) {
+    // เพิ่มเข้า unresolved
+    unresolved.add(packageName);
+
+    const pkg = this.registry.getPackage(packageName);
+    if (!pkg) {
+      throw new Error(`Package "${packageName}" ไม่พบใน registry`);
+    }
+
+    // ดึง dependencies
+    const dependencies = this.registry.getDependencies(packageName);
+
+    for (const dep of dependencies) {
+      if (resolved.has(dep)) {
+        continue;
+      }
+
+      if (unresolved.has(dep)) {
+        throw new Error(`พบ circular dependency: ${packageName} -> ${dep}`);
+      }
+
+      this.resolveDependencies(dep, resolved, unresolved);
+    }
+
+    // ย้ายจาก unresolved ไป resolved
+    unresolved.delete(packageName);
+    resolved.add(packageName);
+
+    return Array.from(resolved);
+  }
+
+  /**
+   * ได้รับลำดับการติดตั้งที่ถูกต้อง
+   */
+  getInstallOrder(packageNames) {
+    const resolved = new Set();
+    const unresolved = new Set();
+
+    for (const name of packageNames) {
+      if (!resolved.has(name)) {
+        this.resolveDependencies(name, resolved, unresolved);
+      }
+    }
+
+    return Array.from(resolved);
+  }
+
+  /**
+   * ตรวจสอบ conflicts
+   */
+  checkConflicts(packages) {
+    const conflicts = [];
+    const skillVersions = new Map();
+
+    for (const pkgName of packages) {
+      const pkg = this.registry.getPackage(pkgName);
+      if (!pkg) continue;
+
+      for (const skill of pkg.skills) {
+        if (skillVersions.has(skill.name)) {
+          const existing = skillVersions.get(skill.name);
+          if (existing.version !== skill.version) {
+            conflicts.push({
+              skill: skill.name,
+              packages: [existing.package, pkgName],
+              versions: [existing.version, skill.version],
+            });
+          }
+        } else {
+          skillVersions.set(skill.name, {
+            package: pkgName,
+            version: skill.version,
+          });
+        }
+      }
+    }
+
+    return conflicts;
+  }
+}
+
+module.exports = PackageResolver;