@botskill/cli 1.0.7 → 1.0.9

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@botskill/cli",
-  "version": "1.0.7",
+  "version": "1.0.9",
   "description": "CLI tool for BotSkill - AI agent skills platform",
   "main": "src/index.js",
   "bin": {

package/src/commands/get.js

@@ -27,7 +27,10 @@ getCommand
   .option('--api-url <url>', 'API base URL (overrides config for this command)')
   .action(async (specifier, options, command) => {
     const apiUrl = command.optsWithGlobals().apiUrl;
-    const { name, version } = parseSpecifier(specifier);
+    const spec = (specifier || '').trim();
+    const parsed = parseSpecifier(spec);
+    const name = spec.startsWith('@') ? spec : parsed.name;
+    const version = spec.startsWith('@') ? undefined : parsed.version;
     const outputDir = path.resolve(options.output || process.cwd());
 
     if (!name) {

package/src/commands/update.js

@@ -0,0 +1,115 @@
+import { Command } from 'commander';
+import path from 'path';
+import fs from 'fs-extra';
+import { createApiClient } from '../lib/auth.js';
+import { printApiError, printSimpleError } from '../lib/formatError.js';
+import { compareVersions, getLatestVersion, downloadSkillToDir } from '../lib/updateSkill.js';
+
+const updateCommand = new Command('update');
+updateCommand
+  .description('Update skill(s) to latest version')
+  .argument('[name]', 'Skill name to update (omit to update all in current/specified dir)')
+  .option('-d, --dir <path>', 'Directory containing skill(s) to update (default: current directory)')
+  .option('--dry-run', 'Show what would be updated without downloading')
+  .option('--api-url <url>', 'API base URL (overrides config for this command)')
+  .action(async (nameArg, options, command) => {
+    const apiUrl = command.optsWithGlobals().apiUrl;
+    const api = createApiClient(apiUrl);
+    const baseDir = path.resolve(options.dir || process.cwd());
+
+    if (!(await fs.pathExists(baseDir))) {
+      printSimpleError('Directory not found', baseDir);
+    }
+
+    let skillsToUpdate = [];
+    if (nameArg) {
+      const configPath = path.join(baseDir, nameArg, 'skill.config.json');
+      const skillMdPath = path.join(baseDir, nameArg, 'SKILL.md');
+      const dirPath = path.join(baseDir, nameArg);
+      if (!(await fs.pathExists(dirPath))) {
+        printSimpleError('Skill not found', `No directory: ${dirPath}`);
+      }
+      let name = nameArg;
+      let version = '0.0.0';
+      if (await fs.pathExists(configPath)) {
+        try {
+          const config = await fs.readJson(configPath);
+          name = config.name || nameArg;
+          version = config.version || '0.0.0';
+        } catch (_) {}
+      } else if (await fs.pathExists(skillMdPath)) {
+        try {
+          const content = await fs.readFile(skillMdPath, 'utf-8');
+          const match = content.match(/^name:\s*(.+)$/m);
+          const verMatch = content.match(/version:\s*["']?([\d.]+)/m);
+          name = match ? match[1].trim() : nameArg;
+          version = verMatch ? verMatch[1] : '0.0.0';
+        } catch (_) {}
+      }
+      skillsToUpdate = [{ name, version, dirPath, dirName: nameArg }];
+    } else {
+      let skillsToUpdateList = await findInstalledSkills(baseDir);
+      if (skillsToUpdateList.length === 0) {
+        const configPath = path.join(baseDir, 'skill.config.json');
+        const skillMdPath = path.join(baseDir, 'SKILL.md');
+        if (await fs.pathExists(configPath) || await fs.pathExists(skillMdPath)) {
+          let name = path.basename(baseDir);
+          let version = '0.0.0';
+          if (await fs.pathExists(configPath)) {
+            try {
+              const config = await fs.readJson(configPath);
+              name = config.name || name;
+              version = config.version || '0.0.0';
+            } catch (_) {}
+          } else if (await fs.pathExists(skillMdPath)) {
+            try {
+              const content = await fs.readFile(skillMdPath, 'utf-8');
+              const match = content.match(/^name:\s*(.+)$/m);
+              const verMatch = content.match(/version:\s*["']?([\d.]+)/m);
+              name = match ? match[1].trim() : name;
+              version = verMatch ? verMatch[1] : '0.0.0';
+            } catch (_) {}
+          }
+          skillsToUpdateList = [{ name, version, dirPath: baseDir, dirName: path.basename(baseDir) }];
+        }
+      }
+      skillsToUpdate = skillsToUpdateList;
+      if (skillsToUpdate.length === 0) {
+        console.log('No skills found. Run from a skills directory or use -d <path>.');
+        return;
+      }
+    }
+
+    if (options.dryRun) {
+      console.log('[DRY RUN] Would check and update:');
+      skillsToUpdate.forEach((s) => console.log(`  - ${s.name} (${s.version})`));
+      return;
+    }
+
+    let updated = 0;
+    for (const skill of skillsToUpdate) {
+      try {
+        const latest = await getLatestVersion(api, skill.name);
+        if (!latest) {
+          console.log(`Skip ${skill.name}: not found`);
+          continue;
+        }
+        if (compareVersions(latest, skill.version) <= 0) {
+          console.log(`${skill.name}: already at ${skill.version}`);
+          continue;
+        }
+        const parentDir = path.dirname(skill.dirPath);
+        await downloadSkillToDir(api, skill.name, latest, parentDir);
+        console.log(`${skill.name}: ${skill.version} → ${latest}`);
+        updated++;
+      } catch (err) {
+        if (err.response?.data?.error) err._overrideMsg = err.response.data.error;
+        printApiError(err, { prefix: `Update ${skill.name} failed` });
+      }
+    }
+    if (updated > 0) {
+      console.log(`\nUpdated ${updated} skill(s).`);
+    }
+  });
+
+export { updateCommand };

package/src/commands/upgrade.js

@@ -0,0 +1,75 @@
+import { Command } from 'commander';
+import path from 'path';
+import os from 'os';
+import fs from 'fs-extra';
+import { createApiClient } from '../lib/auth.js';
+import { printApiError, printSimpleError } from '../lib/formatError.js';
+import { compareVersions, getLatestVersion, downloadSkillToDir, findInstalledSkills } from '../lib/updateSkill.js';
+import { DEFAULT_SKILLS_DIR } from '../lib/constants.js';
+
+function resolveSkillsDir(dir) {
+  const p = dir || DEFAULT_SKILLS_DIR;
+  return p.replace(/^~/, os.homedir());
+}
+
+const upgradeCommand = new Command('upgrade');
+upgradeCommand
+  .description('Upgrade all skills in the skills directory to latest version')
+  .option('-d, --dir <path>', `Skills directory (default: ${DEFAULT_SKILLS_DIR})`)
+  .option('--dry-run', 'Show what would be upgraded without downloading')
+  .option('--api-url <url>', 'API base URL (overrides config for this command)')
+  .action(async (options, command) => {
+    const apiUrl = command.optsWithGlobals().apiUrl;
+    const api = createApiClient(apiUrl);
+    const skillsDir = path.resolve(resolveSkillsDir(options.dir));
+
+    if (!(await fs.pathExists(skillsDir))) {
+      printSimpleError('Skills directory not found', skillsDir);
+    }
+
+    const skills = await findInstalledSkills(skillsDir);
+    if (skills.length === 0) {
+      console.log('No skills found in', skillsDir);
+      return;
+    }
+
+    if (options.dryRun) {
+      console.log(`[DRY RUN] Would check ${skills.length} skill(s) in ${skillsDir}`);
+      for (const s of skills) {
+        try {
+          const latest = await getLatestVersion(api, s.name);
+          const needUpgrade = latest && compareVersions(latest, s.version) > 0;
+          console.log(`  ${s.name}: ${s.version}${needUpgrade ? ` → ${latest}` : ' (latest)'}`);
+        } catch (_) {
+          console.log(`  ${s.name}: ${s.version} (check failed)`);
+        }
+      }
+      return;
+    }
+
+    let updated = 0;
+    for (const skill of skills) {
+      try {
+        const latest = await getLatestVersion(api, skill.name);
+        if (!latest) {
+          console.log(`Skip ${skill.name}: not found`);
+          continue;
+        }
+        if (compareVersions(latest, skill.version) <= 0) {
+          console.log(`${skill.name}: already at ${skill.version}`);
+          continue;
+        }
+        await downloadSkillToDir(api, skill.name, latest, skillsDir);
+        console.log(`${skill.name}: ${skill.version} → ${latest}`);
+        updated++;
+      } catch (err) {
+        if (err.response?.data?.error) err._overrideMsg = err.response.data.error;
+        printApiError(err, { prefix: `Upgrade ${skill.name} failed` });
+      }
+    }
+    if (updated > 0) {
+      console.log(`\nUpgraded ${updated} skill(s).`);
+    }
+  });
+
+export { upgradeCommand };

package/src/commands/versions.js

@@ -0,0 +1,58 @@
+import { Command } from 'commander';
+import { createApiClient } from '../lib/auth.js';
+import { printApiError } from '../lib/formatError.js';
+
+function parseSpecifier(spec) {
+  const s = spec.trim();
+  const atIdx = s.lastIndexOf('@');
+  if (atIdx < 0) return { name: s, version: undefined };
+  return {
+    name: s.slice(0, atIdx).trim(),
+    version: s.slice(atIdx + 1).trim() || undefined,
+  };
+}
+
+const versionsCommand = new Command('versions');
+versionsCommand
+  .description('List all versions of a skill')
+  .argument('<name>', 'Skill name (e.g. learn-skills)')
+  .option('--api-url <url>', 'API base URL (overrides config for this command)')
+  .action(async (nameArg, options, command) => {
+    const apiUrl = command.optsWithGlobals().apiUrl;
+    const name = nameArg?.startsWith('@') ? nameArg.trim() : parseSpecifier(nameArg).name;
+
+    if (!name) {
+      console.error('Error: skill name is required');
+      process.exit(1);
+    }
+
+    try {
+      const api = createApiClient(apiUrl);
+      const resolveRes = await api.get(`/skills/by-name/${encodeURIComponent(name)}`);
+      const skill = resolveRes.data?.skill ?? resolveRes.data;
+      if (!skill?._id) {
+        console.error('Skill not found');
+        process.exit(1);
+      }
+
+      const versions = skill.versions || [];
+      const versionList = versions.length > 0 ? versions : (skill.version ? [{ version: skill.version }] : []);
+
+      if (versionList.length === 0) {
+        console.log(`No versions found for ${skill.name}`);
+        return;
+      }
+
+      console.log(`\n${skill.name} - ${versionList.length} version(s):`);
+      console.log('─'.repeat(40));
+      versionList.forEach((v) => {
+        const date = v.createdAt ? new Date(v.createdAt).toLocaleDateString() : '';
+        console.log(`  ${v.version}${date ? `  (${date})` : ''}`);
+      });
+      console.log('\nUse "skm get ' + skill.name + '@<version>" to download.');
+    } catch (err) {
+      printApiError(err, { prefix: 'Versions failed' });
+    }
+  });
+
+export { versionsCommand };

package/src/index.js

@@ -15,6 +15,9 @@ import { publishCommand } from './commands/publish.js';
 import { listCommand } from './commands/list.js';
 import { searchCommand } from './commands/search.js';
 import { infoCommand } from './commands/info.js';
+import { versionsCommand } from './commands/versions.js';
+import { updateCommand } from './commands/update.js';
+import { upgradeCommand } from './commands/upgrade.js';
 import { helpCommand } from './commands/help.js';
 
 // 读取 package.json 中的版本号
@@ -43,6 +46,9 @@ program.addCommand(publishCommand);
 program.addCommand(listCommand);
 program.addCommand(searchCommand);
 program.addCommand(infoCommand);
+program.addCommand(versionsCommand);
+program.addCommand(updateCommand);
+program.addCommand(upgradeCommand);
 program.addCommand(helpCommand);
 
 program.parse();

package/src/lib/constants.js

@@ -8,3 +8,6 @@ export const FALLBACK_API_URL = 'http://localhost:3000/api';
 
 export const getDefaultApiUrl = () =>
   DEFAULT_API_URL === '__DEFAULT_API_URL__' ? FALLBACK_API_URL : DEFAULT_API_URL;
+
+/** Default skills directory for upgrade (Cursor) */
+export const DEFAULT_SKILLS_DIR = '~/.cursor/skills';

package/src/lib/updateSkill.js

@@ -0,0 +1,101 @@
+import path from 'path';
+import fs from 'fs-extra';
+import AdmZip from 'adm-zip';
+import { createApiClient } from './auth.js';
+
+/**
+ * Compare semver versions: returns 1 if a > b, -1 if a < b, 0 if equal
+ */
+export function compareVersions(a, b) {
+  if (!a || !b) return 0;
+  const pa = String(a).split('.').map(Number);
+  const pb = String(b).split('.').map(Number);
+  for (let i = 0; i < Math.max(pa.length, pb.length); i++) {
+    const va = pa[i] || 0;
+    const vb = pb[i] || 0;
+    if (va > vb) return 1;
+    if (va < vb) return -1;
+  }
+  return 0;
+}
+
+/**
+ * Get latest version from API for a skill (by semver)
+ */
+export async function getLatestVersion(api, name) {
+  const res = await api.get(`/skills/by-name/${encodeURIComponent(name)}`);
+  const skill = res.data?.skill ?? res.data;
+  if (!skill?._id) return null;
+  const versions = skill.versions || [];
+  if (versions.length === 0) return skill.version || null;
+  let latest = versions[0].version;
+  for (const v of versions) {
+    if (compareVersions(v.version, latest) > 0) latest = v.version;
+  }
+  return latest;
+}
+
+/**
+ * Download skill to directory (replaces existing)
+ */
+export async function downloadSkillToDir(api, name, version, outputDir) {
+  const fullSpec = version ? `${name}@${version}` : name;
+  const resolveRes = await api.get(`/skills/by-name/${encodeURIComponent(fullSpec)}`);
+  const skill = resolveRes.data?.skill ?? resolveRes.data;
+  if (!skill?._id) throw new Error('Skill not found');
+
+  const versionParam = version ? `?version=${encodeURIComponent(version)}` : '';
+  const url = `/skills/${encodeURIComponent(skill._id)}/download${versionParam}`;
+  const res = await api.get(url, { responseType: 'arraybuffer' });
+  const buffer = Buffer.from(res.data);
+
+  const zip = new AdmZip(buffer);
+  const entries = zip.getEntries();
+  const rootEntry = entries.find(e => e.isDirectory)?.entryName || entries[0]?.entryName?.split('/')[0] || 'skill';
+  const skillDirName = rootEntry.replace(/\/$/, '');
+
+  const targetPath = path.join(outputDir, skillDirName);
+  await fs.remove(targetPath).catch(() => {});
+  zip.extractAllTo(outputDir, true);
+
+  return path.join(outputDir, skillDirName);
+}
+
+/**
+ * Find installed skills in a directory (subdirs with skill.config.json or SKILL.md)
+ */
+export async function findInstalledSkills(skillsDir) {
+  if (!(await fs.pathExists(skillsDir))) return [];
+  const entries = await fs.readdir(skillsDir, { withFileTypes: true });
+  const skills = [];
+  for (const e of entries) {
+    if (!e.isDirectory()) continue;
+    const dirPath = path.join(skillsDir, e.name);
+    const configPath = path.join(dirPath, 'skill.config.json');
+    const skillMdPath = path.join(dirPath, 'SKILL.md');
+    let name, version;
+    if (await fs.pathExists(configPath)) {
+      try {
+        const config = await fs.readJson(configPath);
+        name = config.name || e.name;
+        version = config.version || '0.0.0';
+      } catch (_) {
+        continue;
+      }
+    } else if (await fs.pathExists(skillMdPath)) {
+      try {
+        const content = await fs.readFile(skillMdPath, 'utf-8');
+        const match = content.match(/^name:\s*(.+)$/m);
+        const verMatch = content.match(/version:\s*["']?([\d.]+)/m);
+        name = match ? match[1].trim() : e.name;
+        version = verMatch ? verMatch[1] : '0.0.0';
+      } catch (_) {
+        continue;
+      }
+    } else {
+      continue;
+    }
+    skills.push({ name, version, dirPath, dirName: e.name });
+  }
+  return skills;
+}