clawflowbang 1.0.2 → 1.1.0

package/src/commands/register.js

@@ -0,0 +1,83 @@
+/**
+ * Register command - Register a local skill or agent via symlink
+ */
+
+const chalk = require("chalk");
+const fs = require("fs-extra");
+const path = require("path");
+const ClawFlow = require("../index");
+
+module.exports = async function registerCommand(targetPath) {
+  const hub = new ClawFlow();
+  const sourcePath = path.resolve(process.cwd(), targetPath || ".");
+
+  console.log(chalk.cyan.bold("\n🏷️  ClawFlow Register\n"));
+
+  // 1. Verify source
+  const skillYaml = path.join(sourcePath, "skill.yaml");
+  const agentYaml = path.join(sourcePath, "agent.yaml");
+  const skillMd = path.join(sourcePath, "SKILL.md");
+
+  if (
+    !fs.existsSync(skillYaml) &&
+    !fs.existsSync(agentYaml) &&
+    !fs.existsSync(skillMd)
+  ) {
+    console.error(
+      chalk.red(
+        `❌ Error: No skill.yaml, agent.yaml, or SKILL.md found at ${sourcePath}`,
+      ),
+    );
+    console.log(
+      chalk.gray(
+        "   Please make sure you are in the correct directory or provide a path.",
+      ),
+    );
+    process.exit(1);
+  }
+
+  const name = path.basename(sourcePath);
+  const skillsPath = hub.config.getSkillsPath();
+  const targetPathInWorkspace = path.join(skillsPath, name);
+
+  // 2. Register via symlink
+  try {
+    process.stdout.write(chalk.white(`  Registering ${chalk.bold(name)}... `));
+
+    fs.ensureDirSync(path.dirname(targetPathInWorkspace));
+    if (fs.existsSync(targetPathInWorkspace)) {
+      // Check if it's already a symlink
+      const stats = fs.lstatSync(targetPathInWorkspace);
+      if (stats.isSymbolicLink()) {
+        fs.removeSync(targetPathInWorkspace);
+      } else {
+        const { overwrite } = await require("inquirer").prompt([
+          {
+            type: "confirm",
+            name: "overwrite",
+            message: `\n     Directory ${name} already exists in skills workspace. Overwrite with symlink?`,
+            default: false,
+          },
+        ]);
+        if (!overwrite) {
+          console.log(chalk.yellow("\n     Aborted."));
+          return;
+        }
+        fs.removeSync(targetPathInWorkspace);
+      }
+    }
+
+    fs.ensureSymlinkSync(sourcePath, targetPathInWorkspace, "junction");
+    process.stdout.write(chalk.green("✓\n"));
+
+    // 3. Verification
+    console.log(chalk.gray(`  Path: ${targetPathInWorkspace}`));
+    console.log(chalk.green("\n✅ Successfully registered to OpenClaw!"));
+    console.log(chalk.white("\nNext steps:"));
+    console.log(chalk.gray('  - Run "clawflow status" to see your skill'));
+    console.log(chalk.gray('  - Use "clawflow cron-add" to schedule it\n'));
+  } catch (err) {
+    console.error(chalk.red("\n❌ Registration failed:"), err.message);
+    process.exit(1);
+  }
+};

package/src/commands/update.js

@@ -0,0 +1,35 @@
+/**
+ * Update command - Check for updates
+ */
+
+const chalk = require("chalk");
+const pkg = require("../../package.json");
+const { execSync } = require("child_process");
+
+module.exports = async function updateCommand() {
+  console.log(chalk.cyan.bold("\n🔄 Checking for ClawFlow updates...\n"));
+  console.log(chalk.gray(`  Current version: ${pkg.version}`));
+
+  try {
+    const latest = execSync(`npm show ${pkg.name} version`, { stdio: "pipe" })
+      .toString()
+      .trim();
+
+    if (latest === pkg.version) {
+      console.log(chalk.green("✨ You are already using the latest version!"));
+    } else {
+      console.log(
+        chalk.yellow(`🚀 A new version is available: ${chalk.bold(latest)}`),
+      );
+      console.log(chalk.white("\nTo update, run:"));
+      console.log(chalk.cyan(`   npm install -g ${pkg.name}`));
+    }
+  } catch (e) {
+    console.log(
+      chalk.red(
+        "❌ Failed to check for updates. Please check your internet connection.",
+      ),
+    );
+  }
+  console.log();
+};

package/src/core/Installer.js

@@ -2,12 +2,12 @@
  * Installer - Manage installation and uninstallation of 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');
+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) {
@@ -22,85 +22,124 @@ class Installer {
   }
 
   /**
-  * Install package
+   * Install package
    */
   async install(packageName, options = {}) {
-    const { global = false, cron: withCron = true, dryRun = false } = options;
+    const {
+      global = false,
+      cron: withCron = true,
+      dryRun = false,
+      dev = false,
+      bundle = false,
+    } = options;
 
     // Check whether the package exists (supports built-in and npm)
     const pkg = await this.registry.getPackage(packageName);
-    if (!pkg) {
-      throw new Error(`Package "${packageName}" not found in registry (check package name or internet connection)`);
+
+    // Create package object if it's a URL or local path but not in registry
+    let targetPkg = pkg;
+    if (
+      !targetPkg &&
+      (packageName.includes("://") ||
+        packageName.startsWith(".") ||
+        packageName.startsWith("/"))
+    ) {
+      targetPkg = {
+        name: path.basename(packageName).replace(/\.git$/, ""),
+        version: "local",
+        skills: [
+          {
+            name: path.basename(packageName),
+            source: "git",
+            repository: packageName,
+          },
+        ],
+        config: {},
+      };
+    }
+
+    if (!targetPkg) {
+      throw new Error(
+        `Package "${packageName}" not found in registry and is not a valid URL/Path`,
+      );
     }
 
     // ตรวจสอบว่าติดตั้งแล้วหรือยัง
     const installed = this.configManager.getInstalledPackages();
-    if (installed[packageName]) {
-      console.log(chalk.yellow(`⚠️  Package "${packageName}" is already installed`));
-      const { reinstall } = await inquirer.prompt([{
-        type: 'confirm',
-        name: 'reinstall',
-        message: 'Do you want to reinstall?',
-        default: false,
-      }]);
+    if (installed[targetPkg.name] && !dev) {
+      console.log(
+        chalk.yellow(`⚠️  Package "${targetPkg.name}" is already installed`),
+      );
+      const { reinstall } = await inquirer.prompt([
+        {
+          type: "confirm",
+          name: "reinstall",
+          message: "Do you want to reinstall?",
+          default: false,
+        },
+      ]);
       if (!reinstall) {
-        return { success: false, reason: 'already_installed' };
+        return { success: false, reason: "already_installed" };
       }
     }
 
-    console.log(chalk.cyan(`📦 Installing ${chalk.bold(packageName)}...\n`));
+    console.log(
+      chalk.cyan(
+        `📦 Installing ${chalk.bold(targetPkg.name)}${dev ? chalk.yellow(" [DEV MODE]") : ""}...\n`,
+      ),
+    );
 
     // Dry run - แสดงเฉพาะข้อมูล
     if (dryRun) {
-      this.showDryRunInfo(pkg, withCron);
+      this.showDryRunInfo(targetPkg, withCron);
       return { success: true, dryRun: true };
     }
 
-    const spinner = ora('Processing...').start();
+    const spinner = ora("Processing...").start();
 
     try {
       // 1. ติดตั้ง skills
-      spinner.text = 'Installing skills...';
-      await this.installSkills(pkg.skills, global);
+      spinner.text = "Installing skills...";
+      await this.installSkills(targetPkg.skills, { global, dev, bundle });
 
       // 2. ตั้งค่า config
-      spinner.text = 'Setting up configuration...';
-      await this.setupConfig(packageName, pkg.config);
+      spinner.text = "Setting up configuration...";
+      await this.setupConfig(targetPkg.name, targetPkg.config);
 
       // 3. ตั้ง cronjobs (ถ้าเปิดใช้งาน)
       let crons = [];
-      if (withCron && pkg.crons && pkg.crons.length > 0) {
-        spinner.text = 'Setting up cronjobs...';
-        crons = await this.setupCrons(pkg.crons);
+      if (withCron && targetPkg.crons && targetPkg.crons.length > 0) {
+        spinner.text = "Setting up cronjobs...";
+        crons = await this.setupCrons(targetPkg.crons);
       }
 
       // 4. บันทึกว่าติดตั้งแล้ว
-      spinner.text = 'Saving state...';
-      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.text = "Saving state...";
+      this.configManager.addInstalledPackage(targetPkg.name, {
+        version: targetPkg.version,
+        skills: targetPkg.skills.map((s) => s.name),
+        crons: crons.map((c) => c.id),
+        configPath: this.getPackageConfigPath(targetPkg.name),
+        dev: dev,
       });
 
-      spinner.succeed(chalk.green(`Installed ${packageName} successfully!`));
+      spinner.succeed(chalk.green(`Installed ${targetPkg.name} successfully!`));
 
       // แสดงข้อมูลสรุป
-      this.showInstallSummary(pkg, crons);
+      this.showInstallSummary(targetPkg, crons);
 
       // แสดง post-install message
-      if (pkg.postInstall) {
-        console.log(chalk.yellow('\n📋 Next steps:'));
-        console.log(chalk.gray(`   ${pkg.postInstall}`));
+      if (targetPkg.postInstall) {
+        console.log(chalk.yellow("\n📋 Next steps:"));
+        console.log(chalk.gray(`   ${targetPkg.postInstall}`));
       }
 
       return {
         success: true,
-        package: packageName,
-        skills: pkg.skills.map(s => s.name),
+        package: targetPkg.name,
+        skills: targetPkg.skills.map((s) => s.name),
         crons: crons,
       };
-
     } catch (error) {
       spinner.fail(chalk.red(`Installation failed: ${error.message}`));
       throw error;
@@ -108,62 +147,123 @@ class Installer {
   }
 
   /**
-  * Install skills
+   * Install skills
    */
-  async installSkills(skills, global = false) {
+  async installSkills(skills, options = {}) {
+    const { global = false, dev = false, bundle = false } = options;
     for (const skill of skills) {
-      console.log(chalk.gray(`   → Installing skill: ${skill.name}@${skill.version}`));
-      
-      // Install skill via OpenClaw
-      // In production this would call OpenClaw API or CLI
-      await this.installSkillToOpenClaw(skill, global);
+      console.log(
+        chalk.gray(
+          `   → Installing skill: ${skill.name}${dev ? " (link)" : ""}`,
+        ),
+      );
+
+      await this.installSkillToOpenClaw(skill, { global, dev, bundle });
     }
   }
 
   /**
    * ติดตั้ง skill ไปยัง OpenClaw
    */
-  async installSkillToOpenClaw(skill, global = false) {
-    void global;
+  async installSkillToOpenClaw(skill, options = {}) {
+    const { _global = false, dev = false, bundle = false } = options;
+
     const skillsPath = this.configManager.getSkillsPath();
 
-    try {
-      await this.openclawCLI.installSkill(skill.name, skill.version, skillsPath);
+    // Dev mode - Symlink
+    if (
+      dev &&
+      (skill.repository?.startsWith(".") ||
+        skill.repository?.startsWith("/") ||
+        fs.existsSync(skill.name))
+    ) {
+      const sourcePath = path.resolve(
+        process.cwd(),
+        skill.repository || skill.name,
+      );
+      const targetPath = path.join(skillsPath, path.basename(sourcePath));
 
-      // ตรวจสอบหลังติดตั้ง (best effort)
-      await this.openclawCLI.verifySkill(skill.name).catch(() => null);
+      console.log(chalk.gray(`   ↳ Symlinking: ${sourcePath} → ${targetPath}`));
+      fs.ensureDirSync(path.dirname(targetPath));
+      if (fs.existsSync(targetPath)) fs.removeSync(targetPath);
+      fs.ensureSymlinkSync(sourcePath, targetPath, "junction");
+      return;
+    }
 
+    try {
+      await this.openclawCLI.installSkill(
+        skill.name,
+        skill.version,
+        skillsPath,
+      );
+      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 succeeded: ${cloned.repository}`));
+        const cloned = await this.openclawCLI.installSkillFromGit(
+          skill,
+          skillsPath,
+        );
+
+        // Bundle detection
+        if (bundle) {
+          await this.detectAndInstallSubSkills(cloned.path, skillsPath);
+        }
+
+        console.log(
+          chalk.yellow(`   ↳ git clone succeeded: ${cloned.repository}`),
+        );
         return;
       } catch (gitError) {
         throw new Error(
           `Failed to install skill "${skill.name}" from both clawhub and git clone\n` +
-          `clawhub: ${error.message}\n` +
-          `git: ${gitError.message}`,
+            `clawhub: ${error.message}\n` +
+            `git: ${gitError.message}`,
         );
       }
     }
   }
 
   /**
-  * Setup config for package
+   * ตรวจสอบและลง Sub-skills (Bundle mode)
+   */
+  async detectAndInstallSubSkills(mainSkillPath, targetSkillsPath) {
+    const items = fs.readdirSync(mainSkillPath);
+    for (const item of items) {
+      const subPath = path.join(mainSkillPath, item);
+      if (fs.statSync(subPath).isDirectory()) {
+        const isSkill =
+          fs.existsSync(path.join(subPath, "skill.yaml")) ||
+          fs.existsSync(path.join(subPath, "SKILL.md"));
+
+        if (isSkill) {
+          const targetPath = path.join(targetSkillsPath, item);
+          if (!fs.existsSync(targetPath)) {
+            console.log(
+              chalk.gray(`   ↳ Bundle detected: linking sub-skill ${item}`),
+            );
+            fs.ensureSymlinkSync(subPath, targetPath, "junction");
+          }
+        }
+      }
+    }
+  }
+
+  /**
+   * Setup config for package
    */
   async setupConfig(packageName, configSchema) {
     if (!configSchema) return;
 
     const configPath = this.getPackageConfigPath(packageName);
-    const existingConfig = fs.existsSync(configPath) 
-      ? fs.readJsonSync(configPath) 
+    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) {
           // Pull value from environment variable
@@ -172,23 +272,29 @@ class Installer {
             newConfig[skillName][key] = envValue;
           } else if (value.required && !existingConfig[skillName]?.[key]) {
             // If not in env and required
-            const answer = await inquirer.prompt([{
-              type: 'input',
-              name: key,
-              message: `Please enter ${key} for ${skillName} (or set ${value.env}):`,
-              validate: (input) => input.length > 0 || 'This field is required',
-            }]);
+            const answer = await inquirer.prompt([
+              {
+                type: "input",
+                name: key,
+                message: `Please enter ${key} for ${skillName} (or set ${value.env}):`,
+                validate: (input) =>
+                  input.length > 0 || "This field is required",
+              },
+            ]);
             newConfig[skillName][key] = answer[key];
           }
         } else if (value.default !== undefined) {
-          newConfig[skillName][key] = existingConfig[skillName]?.[key] ?? value.default;
+          newConfig[skillName][key] =
+            existingConfig[skillName]?.[key] ?? value.default;
         } else if (value.required && !existingConfig[skillName]?.[key]) {
-            const answer = await inquirer.prompt([{
-            type: 'input',
-            name: key,
+          const answer = await inquirer.prompt([
+            {
+              type: "input",
+              name: key,
               message: `Please enter ${key} for ${skillName}:`,
-              validate: (input) => input.length > 0 || 'This field is required',
-          }]);
+              validate: (input) => input.length > 0 || "This field is required",
+            },
+          ]);
           newConfig[skillName][key] = answer[key];
         }
       }
@@ -204,13 +310,13 @@ class Installer {
    */
   async setupCrons(cronsConfig) {
     const crons = [];
-    
+
     for (const cronConfig of cronsConfig) {
       const cronInfo = await this.cronManager.add(
         cronConfig.skill,
         cronConfig.schedule,
         cronConfig.params,
-        cronConfig.description
+        cronConfig.description,
       );
       crons.push(cronInfo);
     }
@@ -226,20 +332,24 @@ class Installer {
 
     const installed = this.configManager.getInstalledPackages();
     if (!installed[packageName]) {
-      console.log(chalk.yellow(`⚠️  Package "${packageName}" ไม่ได้ถูกติดตั้ง`));
-      return { success: false, reason: 'not_installed' };
+      console.log(
+        chalk.yellow(`⚠️  Package "${packageName}" ไม่ได้ถูกติดตั้ง`),
+      );
+      return { success: false, reason: "not_installed" };
     }
 
-    console.log(chalk.cyan(`🗑️  กำลังถอนการติดตั้ง ${chalk.bold(packageName)}...`));
+    console.log(
+      chalk.cyan(`🗑️  กำลังถอนการติดตั้ง ${chalk.bold(packageName)}...`),
+    );
 
-    const spinner = ora('กำลังดำเนินการ...').start();
+    const spinner = ora("กำลังดำเนินการ...").start();
 
     try {
       const pkgInfo = installed[packageName];
 
       // 1. ลบ cronjobs
       if (pkgInfo.crons && pkgInfo.crons.length > 0) {
-        spinner.text = 'กำลังลบ cronjobs...';
+        spinner.text = "กำลังลบ cronjobs...";
         for (const cronId of pkgInfo.crons) {
           await this.cronManager.remove(cronId);
         }
@@ -247,7 +357,7 @@ class Installer {
 
       // 2. ลบ skills
       if (pkgInfo.skills && pkgInfo.skills.length > 0) {
-        spinner.text = 'กำลังลบ skills...';
+        spinner.text = "กำลังลบ skills...";
         for (const skillName of pkgInfo.skills) {
           await this.removeSkillFromOpenClaw(skillName);
         }
@@ -255,7 +365,7 @@ class Installer {
 
       // 3. ลบ config (ถ้าไม่ได้ระบุให้เก็บไว้)
       if (!keepConfig) {
-        spinner.text = 'กำลังลบ config...';
+        spinner.text = "กำลังลบ config...";
         const configPath = this.getPackageConfigPath(packageName);
         if (fs.existsSync(configPath)) {
           fs.removeSync(configPath);
@@ -265,10 +375,11 @@ class Installer {
       // 4. ลบจาก installed list
       this.configManager.removeInstalledPackage(packageName);
 
-      spinner.succeed(chalk.green(`ถอนการติดตั้ง ${packageName} เสร็จสมบูรณ์!`));
+      spinner.succeed(
+        chalk.green(`ถอนการติดตั้ง ${packageName} เสร็จสมบูรณ์!`),
+      );
 
       return { success: true, package: packageName };
-
     } catch (error) {
       spinner.fail(chalk.red(`ถอนการติดตั้งไม่สำเร็จ: ${error.message}`));
       throw error;
@@ -289,63 +400,69 @@ class Installer {
    * แสดงข้อมูล 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(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(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 ที่จะตั้ง:'));
+    console.log(chalk.yellow("\n⚙️  Config ที่จะตั้ง:"));
     if (pkg.config) {
       console.log(JSON.stringify(pkg.config, null, 2));
     } else {
-      console.log('  (ไม่มี config พิเศษ)');
+      console.log("  (ไม่มี config พิเศษ)");
     }
 
-    console.log(chalk.gray('\n(ไม่ได้ทำการติดตั้งจริง - dry run mode)'));
+    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(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(chalk.white("\n⏰ Cronjobs ที่ตั้ง:"));
+      crons.forEach((cron) => {
         console.log(`   ✓ ${cron.skill} (${cron.schedule})`);
       });
     }
 
-    console.log(chalk.white('\n📁 Config path:'), this.getPackageConfigPath(pkg.name));
+    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`);
+    return path.join(
+      this.configManager.getSkillsPath(),
+      `${packageName}.config.json`,
+    );
   }
 }