@botskill/cli 1.0.1-alpha.1

package/README.md

@@ -0,0 +1,160 @@
+# BotSkill CLI (skm)
+
+The official command-line interface for BotSkill, a platform for managing and sharing AI agent skills.
+
+## Installation
+
+```bash
+npm install -g @botskill/cli
+```
+
+Or use without installing:
+
+```bash
+npx @botskill/cli [command]
+```
+
+## Commands
+
+### init
+Initialize a new skill project (creates skill.config.json):
+```bash
+skm init --name my-skill --description "A new AI skill"
+skm init -y   # Use defaults without prompting
+```
+
+### login
+Login to BotSkill platform:
+```bash
+skm login --token YOUR_TOKEN
+```
+
+### config
+Manage CLI configuration:
+```bash
+# List all configurations
+skm config --list
+
+# Get specific configuration
+skm config --get apiUrl
+
+# Set configuration
+skm config --set apiUrl=https://api.botskill.ai
+```
+
+### get
+Download a skill from BotSkill and extract to directory (default: current directory). Use `name@version` for a specific version, or `name` for latest. API URL from config (optional):
+```bash
+skm get pdf-processing
+skm get pdf-processing@1.0.0
+skm get pdf-processing -o ./my-skills
+skm get pdf-processing --dry-run
+```
+
+### push / publish
+Upload/push or publish a skill to BotSkill (requires login, publisher or admin role):
+```bash
+# From a directory with skill.config.json
+skm push
+
+# Or use publish (alias)
+skm publish
+
+# With options
+skm push --name my-skill --description "My AI skill" --category ai
+skm push --dry-run   # Validate without uploading
+```
+
+### list
+List skills from BotSkill (fetches from API):
+```bash
+skm list
+skm list --category ai --limit 10
+skm list --search translator
+skm list --mine   # Your skills (requires login)
+```
+
+### search
+Search skills by name or description:
+```bash
+skm search pdf
+skm search translator --category ai
+skm search "data analysis" --limit 10
+```
+
+### info
+Show skill details (without downloading):
+```bash
+skm info pdf-processing
+skm info pdf-processing@1.0.0
+```
+
+## Configuration
+
+安装后会在用户主目录下自动创建 `~/.skm/` 目录及默认配置：
+- **macOS / Linux**: `~/.skm/config.json`
+- **Windows**: `%USERPROFILE%\.skm\config.json`
+
+使用 `skm config` 管理配置，`skm config --path` 查看配置文件路径。
+
+### 默认配置
+- `apiUrl`: API 地址，优先级：环境变量 `BOTSKILL_API_URL` > 配置文件 > 构建时默认值
+- `token` / `refreshToken`: 登录后自动保存
+
+### 环境变量
+- **BOTSKILL_API_URL**：运行时覆盖 API 地址（不修改配置文件）
+
+### 发布时指定默认 API 和作者
+```bash
+# 开发/本地默认 localhost
+npm run build
+
+# 生产环境
+BOTSKILL_API_URL=https://api.botskill.ai npm run build
+BOTSKILL_API_URL=https://api.botskill.ai npm publish
+```
+
+## Usage Examples
+
+### Creating a new skill
+```bash
+# Initialize a new skill project
+skm init --name my-translator --description "AI translation skill"
+
+# Edit skill.config.json (add tags, URLs, etc.)
+# Login to BotSkill
+skm login
+
+# Push or publish to BotSkill
+skm push
+# or
+skm publish
+```
+
+### Using an existing skill
+```bash
+# Search for skills
+skm list --search translator --category ai
+
+# Download a skill (latest version)
+skm get pdf-processing
+skm get pdf-processing@1.0.0 -o ./skills
+```
+
+## Development
+
+To run the CLI locally during development:
+
+```bash
+cd skm-cli
+npm install
+node src/index.js [command]
+```
+
+## Contributing
+
+See our contributing guide for more information on how to contribute to the BotSkill CLI.
+
+## License
+
+MIT

package/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "@botskill/cli",
+  "version": "1.0.1-alpha.1",
+  "description": "CLI tool for BotSkill - AI agent skills platform",
+  "main": "src/index.js",
+  "bin": {
+    "skm": "src/index.js"
+  },
+  "type": "module",
+  "scripts": {
+    "start": "node src/index.js",
+    "dev": "node src/index.js",
+    "build": "node scripts/build.js",
+    "build:restore": "node scripts/build.js --restore",
+    "prepublishOnly": "npm run build",
+    "postpublish": "npm run build:restore",
+    "test": "echo \"Error: no test specified\" && exit 1",
+    "postinstall": "node scripts/postinstall.js"
+  },
+  "files": [
+    "src",
+    "scripts"
+  ],
+  "keywords": [
+    "cli",
+    "ai",
+    "skills",
+    "agents",
+    "management",
+    "tool"
+  ],
+  "author": "BotSkill Team",
+  "license": "MIT",
+  "dependencies": {
+    "adm-zip": "^0.5.16",
+    "axios": "^1.6.0",
+    "commander": "^11.0.0",
+    "configstore": "^6.0.0",
+    "form-data": "^4.0.5",
+    "fs-extra": "^11.1.1",
+    "inquirer": "^9.2.0",
+    "tar": "^6.2.0"
+  },
+  "engines": {
+    "node": ">=16.0.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/scripts/build.js

@@ -0,0 +1,35 @@
+#!/usr/bin/env node
+/**
+ * 构建脚本：根据环境变量注入默认配置
+ * 用法:
+ *   npm run build                    # 使用 localhost（开发）
+ *   BOTSKILL_API_URL=https://api.botskill.ai npm run build      # 生产 API
+ *   npm run build:restore            # 发布后恢复占位符，便于继续开发
+ */
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const constantsPath = path.join(__dirname, '../src/lib/constants.js');
+
+const isRestore = process.argv.includes('--restore');
+
+if (isRestore) {
+  let content = fs.readFileSync(constantsPath, 'utf8');
+  content = content.replace(
+    /export const DEFAULT_API_URL = .+;/,
+    "export const DEFAULT_API_URL = '__DEFAULT_API_URL__';"
+  );
+  fs.writeFileSync(constantsPath, content);
+  console.log('Build: restored placeholder');
+} else {
+  const apiUrl = process.env.BOTSKILL_API_URL || 'http://localhost:3001/api';
+  let content = fs.readFileSync(constantsPath, 'utf8');
+  content = content.replace(
+    /export const DEFAULT_API_URL = .+;/,
+    `export const DEFAULT_API_URL = ${JSON.stringify(apiUrl)};`
+  );
+  fs.writeFileSync(constantsPath, content);
+  console.log(`Build: DEFAULT_API_URL = ${apiUrl}`);
+}

package/scripts/postinstall.js

@@ -0,0 +1,25 @@
+#!/usr/bin/env node
+/**
+ * postinstall: 在用户目录下创建默认配置文件
+ * 路径: ~/.skm/config.json
+ * 默认 API 来自构建时 BOTSKILL_API_URL，未构建时用 localhost
+ */
+import path from 'path';
+import os from 'os';
+import fs from 'fs';
+import Configstore from 'configstore';
+import { getDefaultApiUrl } from '../src/lib/constants.js';
+
+const CONFIG_PATH = path.join(os.homedir(), '.skm', 'config.json');
+const defaultUrl = getDefaultApiUrl();
+
+try {
+  const config = new Configstore('botskill-cli', { apiUrl: defaultUrl }, {
+    configPath: CONFIG_PATH,
+  });
+  if (!fs.existsSync(config.path)) {
+    config.set('apiUrl', defaultUrl);
+  }
+} catch {
+  // 静默失败，首次运行 skm 时 Configstore 会创建
+}

package/src/commands/config.js

@@ -0,0 +1,65 @@
+import { Command } from 'commander';
+import { getApiUrl, setApiUrl, getToken, getUser, clearAuth, getConfigPath } from '../lib/auth.js';
+import { getDefaultApiUrl } from '../lib/constants.js';
+
+const configCommand = new Command('config');
+configCommand
+  .description('Manage CLI configuration')
+  .option('-g, --get <key>', 'Get configuration value')
+  .option('-s, --set <key=value>', 'Set configuration value')
+  .option('-l, --list', 'List all configurations')
+  .option('-p, --path', 'Show config file path')
+  .option('--reset', 'Reset configuration to defaults')
+  .action(async (options) => {
+    if (options.path) {
+      console.log(getConfigPath());
+      return;
+    }
+    if (options.list) {
+      const apiUrl = getApiUrl();
+      const token = getToken();
+      const user = getUser();
+      console.log('Current configuration:');
+      console.log(`  config: ${getConfigPath()}`);
+      console.log(`  apiUrl: ${apiUrl}`);
+      console.log(`  token: ${token ? '***' : '(not set)'}`);
+      if (user) {
+        console.log(`  user: ${user.username || user.email || user.id}`);
+      }
+    } else if (options.get) {
+      const key = options.get;
+      if (key === 'apiUrl') {
+        console.log(getApiUrl());
+      } else if (key === 'token') {
+        console.log(getToken() ? '***' : '(not set)');
+      } else {
+        console.error(`Unknown key: ${key}`);
+        process.exit(1);
+      }
+    } else if (options.set) {
+      const [key, value] = options.set.split('=');
+      if (!key || value === undefined) {
+        console.error('Use --set key=value');
+        process.exit(1);
+      }
+      if (key === 'apiUrl') {
+        setApiUrl(value.trim());
+        console.log(`apiUrl set to ${value}`);
+      } else {
+        console.error(`Unknown key: ${key}`);
+        process.exit(1);
+      }
+    } else if (options.reset) {
+      clearAuth();
+      setApiUrl(getDefaultApiUrl());
+      console.log('Configuration reset to defaults.');
+    } else {
+      console.log('Usage:');
+      console.log('  skm config --list          List configuration');
+      console.log('  skm config --get apiUrl    Get apiUrl');
+      console.log('  skm config --set apiUrl=URL  Set apiUrl');
+      console.log('  skm config --reset         Reset to defaults');
+    }
+  });
+
+export { configCommand };

package/src/commands/get.js

@@ -0,0 +1,88 @@
+import { Command } from 'commander';
+import path from 'path';
+import AdmZip from 'adm-zip';
+import { createApiClient } from '../lib/auth.js';
+
+/**
+ * Parse specifier: name@version or name
+ * Returns { name, version } for API
+ */
+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 getCommand = new Command('get');
+getCommand
+  .description('Download a skill from BotSkill and extract to directory')
+  .argument('<specifier>', 'Skill name or name@version (e.g. pdf-parser or pdf-parser@1.0.0)')
+  .option('-o, --output <dir>', 'Output directory (default: current directory)')
+  .option('--dry-run', 'Show what would be downloaded without actually downloading')
+  .action(async (specifier, options) => {
+    const { name, version } = parseSpecifier(specifier);
+    const outputDir = path.resolve(options.output || process.cwd());
+
+    if (!name) {
+      console.error('Error: skill name is required');
+      process.exit(1);
+    }
+
+    if (options.dryRun) {
+      console.log('[DRY RUN] Would download skill:', name);
+      console.log('[DRY RUN] Version:', version || 'latest');
+      console.log('[DRY RUN] Output:', outputDir);
+      return;
+    }
+
+    try {
+      const api = createApiClient();
+
+      const fullSpec = version ? `${name}@${version}` : name;
+      console.log(`Downloading skill: ${fullSpec}`);
+      console.log(`Version: ${version || 'latest'}`);
+      console.log(`Output: ${outputDir}`);
+
+      const resolveRes = await api.get(`/skills/by-name/${encodeURIComponent(fullSpec)}`);
+      const skill = resolveRes.data?.skill ?? resolveRes.data;
+      if (!skill?._id) {
+        console.error('Download failed: Skill not found');
+        process.exit(1);
+      }
+
+      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);
+      zip.extractAllTo(outputDir, true);
+
+      const entries = zip.getEntries();
+      const skillDir = entries.find(e => e.isDirectory)?.entryName || entries[0]?.entryName?.split('/')[0] || 'skill';
+      const targetPath = path.join(outputDir, skillDir);
+
+      console.log(`\nSkill downloaded successfully!`);
+      console.log(`Location: ${targetPath}`);
+    } catch (err) {
+      let msg = err.message;
+      if (err.response?.data) {
+        const raw = err.response.data;
+        const str = Buffer.isBuffer(raw) ? raw.toString() : (typeof raw === 'string' ? raw : JSON.stringify(raw));
+        try {
+          const obj = JSON.parse(str);
+          msg = obj.error || obj.message || msg;
+        } catch (_) {
+          msg = str || msg;
+        }
+      }
+      console.error('Download failed:', msg);
+      process.exit(1);
+    }
+  });
+
+export { getCommand };

package/src/commands/help.js

@@ -0,0 +1,34 @@
+import { Command } from 'commander';
+
+const helpCommand = new Command('help');
+helpCommand
+  .description('Show help information')
+  .action(async () => {
+    console.log('BotSkill Manager (skm) - CLI Tool');
+    console.log('');
+    console.log('Usage: skm [options] [command]');
+    console.log('');
+    console.log('Options:');
+    console.log('  -V, --version   output the version number');
+    console.log('  -h, --help      display help for command');
+    console.log('');
+    console.log('Commands:');
+    console.log('  init [options]     Initialize a new skill project');
+    console.log('  login [options]    Login to BotSkill platform');
+    console.log('  config [options]   Manage CLI configuration');
+    console.log('  get <skill-id>     Download a skill from BotSkill');
+    console.log('  push [options]     Upload/push a skill to BotSkill');
+    console.log('  list [options]     List skills from BotSkill');
+    console.log('  help [command]     display help for command');
+    console.log('');
+    console.log('Examples:');
+    console.log('  skm init --name my-skill');
+    console.log('  skm login --token abc123');
+    console.log('  skm list --category ai');
+    console.log('  skm get gpt-translator');
+    console.log('  skm push --public');
+    console.log('');
+    console.log('For detailed help on any command, use: skm [command] --help');
+  });
+
+export { helpCommand };

package/src/commands/info.js

@@ -0,0 +1,79 @@
+import { Command } from 'commander';
+import { createApiClient } from '../lib/auth.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 infoCommand = new Command('info');
+infoCommand
+  .description('Show skill details from BotSkill')
+  .argument('<specifier>', 'Skill name or name@version')
+  .action(async (specifier) => {
+    const { name, version } = parseSpecifier(specifier);
+
+    if (!name) {
+      console.error('Error: skill name is required');
+      process.exit(1);
+    }
+
+    try {
+      const api = createApiClient();
+      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) {
+        console.error('Skill not found');
+        process.exit(1);
+      }
+
+      console.log('\n' + '─'.repeat(50));
+      console.log(`  ${skill.name}`);
+      console.log('─'.repeat(50));
+      console.log(`  Description: ${skill.description || '—'}`);
+      const author = skill.author?.username || skill.author?.fullName || '—';
+      console.log(`  Author:      ${author}`);
+      console.log(`  Category:    ${skill.category || '—'}`);
+      console.log(`  Downloads:   ${(skill.downloads ?? 0).toLocaleString()}`);
+      console.log(`  License:     ${skill.license || 'MIT'}`);
+      if (skill.tags?.length) {
+        console.log(`  Tags:        ${skill.tags.join(', ')}`);
+      }
+      if (skill.repositoryUrl) {
+        console.log(`  Repository:  ${skill.repositoryUrl}`);
+      }
+      if (skill.documentationUrl) {
+        console.log(`  Docs:        ${skill.documentationUrl}`);
+      }
+
+      const versions = skill.versions || [];
+      const versionList = versions.length > 0 ? versions : (skill.version ? [{ version: skill.version, description: skill.description }] : []);
+      if (versionList.length > 0) {
+        console.log('\n  Versions:');
+        versionList.forEach((v) => {
+          const date = v.createdAt ? new Date(v.createdAt).toLocaleDateString() : '';
+          console.log(`    - ${v.version}${date ? ` (${date})` : ''}`);
+        });
+      }
+
+      console.log('\n  Use "skm get name" or "skm get name@version" to download.');
+      console.log('');
+    } catch (err) {
+      let msg = err.message;
+      if (err.response?.data) {
+        const d = err.response.data;
+        msg = d.error || d.message || msg;
+      }
+      console.error('Error:', msg);
+      process.exit(1);
+    }
+  });
+
+export { infoCommand };

package/src/commands/init.js

@@ -0,0 +1,128 @@
+import { Command } from 'commander';
+import path from 'path';
+import fs from 'fs-extra';
+import inquirer from 'inquirer';
+
+const initCommand = new Command('init');
+initCommand
+  .description('Initialize a new skill project')
+  .option('-n, --name <name>', 'Project/skill name')
+  .option('-d, --description <description>', 'Skill description')
+  .option('-c, --category <category>', 'Category: ai, data, web, devops, security, tools')
+  .option('-y, --yes', 'Use defaults without prompting')
+  .action(async (options) => {
+    const cwd = process.cwd();
+    const configPath = path.join(cwd, 'skill.config.json');
+
+    if (await fs.pathExists(configPath)) {
+      console.error('skill.config.json already exists in this directory.');
+      process.exit(1);
+    }
+
+    const validCategories = ['ai', 'data', 'web', 'devops', 'security', 'tools'];
+    let answers = {};
+
+    if (options.yes) {
+      answers = {
+        name: options.name || 'my-skill',
+        description: options.description || 'A new AI skill',
+        category: options.category || 'tools',
+        version: '1.0.0',
+        license: 'MIT',
+      };
+    } else {
+      answers = await inquirer.prompt([
+        {
+          type: 'input',
+          name: 'name',
+          message: 'Skill name:',
+          default: options.name || 'my-skill',
+          validate: (v) => (v && v.length >= 2 ? true : 'Name must be at least 2 characters'),
+        },
+        {
+          type: 'input',
+          name: 'description',
+          message: 'Description:',
+          default: options.description || 'A new AI skill',
+          validate: (v) => (v ? true : 'Description is required'),
+        },
+        {
+          type: 'list',
+          name: 'category',
+          message: 'Category:',
+          choices: validCategories,
+          default: options.category && validCategories.includes(options.category) ? options.category : 'tools',
+        },
+        {
+          type: 'input',
+          name: 'version',
+          message: 'Version:',
+          default: '1.0.0',
+        },
+        {
+          type: 'input',
+          name: 'license',
+          message: 'License:',
+          default: 'MIT',
+        },
+      ]);
+    }
+
+    const config = {
+      name: answers.name,
+      description: answers.description,
+      version: answers.version,
+      category: answers.category,
+      license: answers.license,
+      tags: [],
+      repositoryUrl: '',
+      documentationUrl: '',
+      demoUrl: '',
+    };
+
+    await fs.writeJson(configPath, config, { spaces: 2 });
+
+    // Agent Skills spec: https://agentskills.io/specification
+    // name: required, 1-64 chars, lowercase + hyphens
+    // description: required, max 1024 chars
+    // metadata.version, metadata.author: optional
+    const rawName = String(answers.name || 'my-skill').trim();
+    const skillName = rawName.toLowerCase().replace(/\s+/g, '-').replace(/[^a-z0-9-]/g, '').replace(/-+/g, '-').replace(/^-|-$/g, '') || 'my-skill';
+    const skillMd = `---
+name: ${skillName}
+description: ${answers.description}
+license: ${answers.license}
+metadata:
+  author: ${skillName}
+  version: "${answers.version}"
+# Platform-specific (optional)
+category: ${answers.category}
+tags: []
+---
+
+# ${answers.name}
+
+${answers.description}
+
+## Usage
+
+Add your usage documentation here. The Markdown body contains skill instructions for agents.
+
+## Installation
+
+\`\`\`bash
+# Add installation instructions
+\`\`\`
+`;
+
+    const skillMdPath = path.join(cwd, 'SKILL.md');
+    await fs.writeFile(skillMdPath, skillMd, 'utf-8');
+
+    console.log('Created skill.config.json and SKILL.md');
+    console.log('\nNext steps:');
+    console.log('1. Edit SKILL.md to add documentation (the content below the frontmatter)');
+    console.log('2. Run "skm login" to authenticate');
+    console.log('3. Run "skm push" or "skm publish" to upload your skill');
+  });
+
+export { initCommand };

package/src/commands/list.js

@@ -0,0 +1,84 @@
+import { Command } from 'commander';
+import { createApiClient } from '../lib/auth.js';
+import { isLoggedIn } from '../lib/auth.js';
+
+function formatSkillDisplay(skill) {
+  const name = skill.name || '?';
+  const version = skill.version || (skill.versions?.[0]?.version) || '—';
+  const downloads = skill.downloads ?? 0;
+  const category = skill.category || '—';
+  const status = skill.status || '—';
+  return { name, version, downloads, category, status };
+}
+
+const listCommand = new Command('list');
+listCommand
+  .alias('ls')
+  .description('List skills from BotSkill')
+  .option('-c, --category <category>', 'Filter by category (ai, data, web, devops, security, tools)')
+  .option('-s, --search <query>', 'Search skills by name or description')
+  .option('-m, --mine', 'Show only your skills (requires login)')
+  .option('-l, --limit <number>', 'Maximum number of results (default: 20)', '20')
+  .option('-p, --page <number>', 'Page number for pagination (default: 1)', '1')
+  .action(async (options) => {
+    const api = createApiClient();
+    const limit = parseInt(options.limit, 10) || 20;
+    const page = parseInt(options.page, 10) || 1;
+
+    try {
+      let res;
+      if (options.mine) {
+        if (!isLoggedIn()) {
+          console.error('Error: --mine requires login. Run "skm login" first.');
+          process.exit(1);
+        }
+        const params = { page, limit };
+        if (options.category) params.category = options.category;
+        if (options.search) params.q = options.search;
+        res = await api.get('/skills/my', { params });
+      } else {
+        const params = { page, limit };
+        if (options.category) params.category = options.category;
+        if (options.search) params.q = options.search;
+        if (params.q || params.category) {
+          res = await api.get('/skills/search', { params });
+        } else {
+          res = await api.get('/skills', { params });
+        }
+      }
+
+      const skills = res.data?.skills ?? res.data ?? [];
+      const pagination = res.data?.pagination ?? {};
+
+      if (skills.length === 0) {
+        console.log('No skills found.');
+        return;
+      }
+
+      console.log(`\nFound ${pagination.totalSkills ?? skills.length} skill(s):`);
+      console.log('─'.repeat(60));
+      skills.forEach((skill) => {
+        const { name, version, downloads, category, status } = formatSkillDisplay(skill);
+        const statusStr = options.mine ? ` | ${status}` : '';
+        console.log(`  ${name}`);
+        console.log(`    Version: ${version} | Downloads: ${downloads} | Category: ${category}${statusStr}`);
+      });
+      if (pagination.totalPages > 1) {
+        console.log(`\nPage ${pagination.currentPage}/${pagination.totalPages}`);
+      }
+      console.log('\nUse "skm get name" or "skm get name@version" to download.');
+    } catch (err) {
+      let msg = err.message;
+      if (err.response?.data) {
+        const d = err.response.data;
+        msg = d.error || d.message || msg;
+      }
+      if (err.response?.status === 401 && options.mine) {
+        msg = 'Login required. Run "skm login" first.';
+      }
+      console.error('Error:', msg);
+      process.exit(1);
+    }
+  });
+
+export { listCommand };

package/src/commands/login.js

@@ -0,0 +1,75 @@
+import { Command } from 'commander';
+import inquirer from 'inquirer';
+import axios from 'axios';
+import { getApiUrl, setAuth, setApiUrl } from '../lib/auth.js';
+
+const loginCommand = new Command('login');
+loginCommand
+  .description('Login to BotSkill platform')
+  .option('-u, --username <username>', 'Username')
+  .option('-e, --email <email>', 'Email address')
+  .option('-p, --password <password>', 'Password')
+  .option('-t, --token <token>', 'Use access token directly (from web)')
+  .option('--api-url <url>', 'API base URL')
+  .action(async (options) => {
+    const apiUrl = options.apiUrl || getApiUrl();
+    if (options.apiUrl) {
+      setApiUrl(options.apiUrl);
+    }
+
+    if (options.token) {
+      setAuth({ token: options.token });
+      console.log('Token saved. Logged in successfully.');
+      return;
+    }
+
+    let emailOrUsername = options.email || options.username;
+    let password = options.password;
+
+    if (!emailOrUsername || !password) {
+      const answers = await inquirer.prompt([
+        {
+          type: 'input',
+          name: 'emailOrUsername',
+          message: 'Email or Username:',
+          default: emailOrUsername,
+          validate: (v) => (v?.trim() ? true : 'Required'),
+        },
+        {
+          type: 'password',
+          name: 'password',
+          message: 'Password:',
+          mask: '*',
+          validate: (v) => (v ? true : 'Required'),
+        },
+      ]);
+      emailOrUsername = answers.emailOrUsername?.trim();
+      password = answers.password;
+    }
+
+    console.log('Logging in to BotSkill...');
+    try {
+      const res = await axios.post(`${apiUrl}/auth/login`, {
+        email: emailOrUsername,
+        password,
+      });
+      const data = res.data?.data || res.data;
+      const accessToken = data.accessToken || data.token;
+      const refreshToken = data.refreshToken;
+      const user = data.user;
+
+      if (!accessToken) {
+        console.error('Login failed: No token received');
+        process.exit(1);
+      }
+
+      setAuth({ token: accessToken, refreshToken, user });
+      console.log(`Logged in as ${user?.username || user?.email || 'user'}`);
+    } catch (err) {
+      const msg = err.response?.data?.error || err.message || 'Login failed';
+      console.error('Login failed:', msg);
+      process.exit(1);
+    }
+  });
+
+export { loginCommand };

package/src/commands/logout.js

@@ -0,0 +1,19 @@
+import { Command } from 'commander';
+import { clearAuth, getApiUrl, getRefreshToken } from '../lib/auth.js';
+import axios from 'axios';
+
+const logoutCommand = new Command('logout');
+logoutCommand
+  .description('Logout from BotSkill')
+  .action(async () => {
+    const refreshToken = getRefreshToken();
+    if (refreshToken) {
+      try {
+        await axios.post(`${getApiUrl()}/auth/logout`, { refreshToken });
+      } catch (_) {}
+    }
+    clearAuth();
+    console.log('Logged out successfully.');
+  });
+
+export { logoutCommand };

package/src/commands/publish.js

@@ -0,0 +1,62 @@
+import { Command } from 'commander';
+import path from 'path';
+import fs from 'fs-extra';
+import { getToken } from '../lib/auth.js';
+import { uploadSkillFile, findUploadFile } from '../lib/uploadSkill.js';
+
+const publishCommand = new Command('publish');
+publishCommand
+  .description('Publish a skill to BotSkill (alias for push)')
+  .option('-f, --file <path>', 'Path to SKILL.md, .zip, or .tar.gz')
+  .option('--dry-run', 'Validate without uploading')
+  .option('--api-url <url>', 'API base URL')
+  .action(async (options) => {
+    if (!getToken()) {
+      console.error('Not logged in. Run: skm login');
+      process.exit(1);
+    }
+
+    let filePath = options.file;
+    if (!filePath) {
+      filePath = await findUploadFile();
+      if (!filePath) {
+        console.error('No skill file found. Create SKILL.md or a .zip/.tar.gz package, or use --file <path>');
+        process.exit(1);
+      }
+    } else {
+      if (!await fs.pathExists(filePath)) {
+        console.error('File not found:', filePath);
+        process.exit(1);
+      }
+    }
+
+    if (options.dryRun) {
+      console.log('[DRY RUN] Would publish:', path.resolve(filePath));
+      return;
+    }
+
+    console.log(`Publishing skill from ${path.basename(filePath)}...`);
+    try {
+      const skill = await uploadSkillFile(filePath);
+      console.log('Skill published successfully!');
+      console.log(`Name: ${skill?.name}`);
+      console.log(`Version: ${skill?.version || (skill?.versions?.[0]?.version)}`);
+      console.log(`Status: ${skill?.status || 'pending_review'}`);
+    } catch (err) {
+      if (err.message === 'NOT_LOGGED_IN') {
+        console.error('Not logged in. Run: skm login');
+      } else if (err.message === 'FILE_NOT_FOUND') {
+        console.error('File not found');
+      } else {
+        const msg = err.response?.data?.error || err.response?.data?.details?.[0] || err.message || 'Publish failed';
+        if (err.response?.status === 401) {
+          console.error('Token expired or invalid. Run: skm login');
+        } else {
+          console.error('Publish failed:', msg);
+        }
+      }
+      process.exit(1);
+    }
+  });
+
+export { publishCommand };

package/src/commands/push.js

@@ -0,0 +1,62 @@
+import { Command } from 'commander';
+import path from 'path';
+import fs from 'fs-extra';
+import { getToken } from '../lib/auth.js';
+import { uploadSkillFile, findUploadFile, validCategories } from '../lib/uploadSkill.js';
+
+const pushCommand = new Command('push');
+pushCommand
+  .description('Upload/push a skill to BotSkill (SKILL.md, .zip, or .tar.gz)')
+  .option('-f, --file <path>', 'Path to SKILL.md, .zip, or .tar.gz')
+  .option('--dry-run', 'Validate without uploading')
+  .option('--api-url <url>', 'API base URL')
+  .action(async (options) => {
+    if (!getToken()) {
+      console.error('Not logged in. Run: skm login');
+      process.exit(1);
+    }
+
+    let filePath = options.file;
+    if (!filePath) {
+      filePath = await findUploadFile();
+      if (!filePath) {
+        console.error('No skill file found. Create SKILL.md or a .zip/.tar.gz package, or use --file <path>');
+        process.exit(1);
+      }
+    } else {
+      if (!await fs.pathExists(filePath)) {
+        console.error('File not found:', filePath);
+        process.exit(1);
+      }
+    }
+
+    if (options.dryRun) {
+      console.log('[DRY RUN] Would upload:', path.resolve(filePath));
+      return;
+    }
+
+    console.log(`Pushing skill from ${path.basename(filePath)}...`);
+    try {
+      const skill = await uploadSkillFile(filePath);
+      console.log('Skill uploaded successfully!');
+      console.log(`Name: ${skill?.name}`);
+      console.log(`Version: ${skill?.version || (skill?.versions?.[0]?.version)}`);
+      console.log(`Status: ${skill?.status || 'pending_review'}`);
+    } catch (err) {
+      if (err.message === 'NOT_LOGGED_IN') {
+        console.error('Not logged in. Run: skm login');
+      } else if (err.message === 'FILE_NOT_FOUND') {
+        console.error('File not found');
+      } else {
+        const msg = err.response?.data?.error || err.response?.data?.details?.[0] || err.message || 'Upload failed';
+        if (err.response?.status === 401) {
+          console.error('Token expired or invalid. Run: skm login');
+        } else {
+          console.error('Upload failed:', msg);
+        }
+      }
+      process.exit(1);
+    }
+  });
+
+export { pushCommand };

package/src/commands/search.js

@@ -0,0 +1,61 @@
+import { Command } from 'commander';
+import { createApiClient } from '../lib/auth.js';
+
+function formatSkillDisplay(skill) {
+  const author = skill.author?.username || skill.author?.fullName || '?';
+  const name = skill.name || '?';
+  const displayName = `@${author}/${name}`;
+  const version = skill.version || (skill.versions?.[0]?.version) || '—';
+  const downloads = skill.downloads ?? 0;
+  const category = skill.category || '—';
+  return { displayName, version, downloads, category };
+}
+
+const searchCommand = new Command('search');
+searchCommand
+  .description('Search skills from BotSkill')
+  .argument('<query>', 'Search query (name or description)')
+  .option('-c, --category <category>', 'Filter by category (ai, data, web, devops, security, tools)')
+  .option('-l, --limit <number>', 'Maximum number of results (default: 20)', '20')
+  .option('-p, --page <number>', 'Page number for pagination (default: 1)', '1')
+  .action(async (query, options) => {
+    const api = createApiClient();
+    const limit = parseInt(options.limit, 10) || 20;
+    const page = parseInt(options.page, 10) || 1;
+
+    try {
+      const params = { q: query, page, limit };
+      if (options.category) params.category = options.category;
+
+      const res = await api.get('/skills/search', { params });
+      const skills = res.data?.skills ?? res.data ?? [];
+      const pagination = res.data?.pagination ?? {};
+
+      if (skills.length === 0) {
+        console.log(`No skills found for "${query}".`);
+        return;
+      }
+
+      console.log(`\nFound ${pagination.totalSkills ?? skills.length} skill(s) for "${query}":`);
+      console.log('─'.repeat(60));
+      skills.forEach((skill) => {
+        const { displayName, version, downloads, category } = formatSkillDisplay(skill);
+        console.log(`  ${displayName}`);
+        console.log(`    Version: ${version} | Downloads: ${downloads} | Category: ${category}`);
+      });
+      if (pagination.totalPages > 1) {
+        console.log(`\nPage ${pagination.currentPage}/${pagination.totalPages}`);
+      }
+      console.log('\nUse "skm get @author/name" or "skm get @author/name@version" to download.');
+    } catch (err) {
+      let msg = err.message;
+      if (err.response?.data) {
+        const d = err.response.data;
+        msg = d.error || d.message || msg;
+      }
+      console.error('Error:', msg);
+      process.exit(1);
+    }
+  });
+
+export { searchCommand };

package/src/index.js

@@ -0,0 +1,35 @@
+#!/usr/bin/env node
+
+import { Command } from 'commander';
+import { initCommand } from './commands/init.js';
+import { loginCommand } from './commands/login.js';
+import { logoutCommand } from './commands/logout.js';
+import { configCommand } from './commands/config.js';
+import { getCommand } from './commands/get.js';
+import { pushCommand } from './commands/push.js';
+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 { helpCommand } from './commands/help.js';
+
+const program = new Command();
+
+program
+  .name('skm')
+  .description('CLI tool for managing BotSkill - a platform for AI agent skills')
+  .version('1.0.0');
+
+program.addCommand(initCommand);
+program.addCommand(loginCommand);
+program.addCommand(logoutCommand);
+program.addCommand(configCommand);
+program.addCommand(getCommand);
+program.addCommand(pushCommand);
+program.addCommand(publishCommand);
+program.addCommand(listCommand);
+program.addCommand(searchCommand);
+program.addCommand(infoCommand);
+program.addCommand(helpCommand);
+
+program.parse();

package/src/lib/auth.js

@@ -0,0 +1,95 @@
+import path from 'path';
+import os from 'os';
+import Configstore from 'configstore';
+import axios from 'axios';
+import { getDefaultApiUrl } from './constants.js';
+
+const CONFIG_PATH = path.join(os.homedir(), '.skm', 'config.json');
+const defaultUrl = getDefaultApiUrl();
+
+const config = new Configstore('botskill-cli', { apiUrl: defaultUrl }, {
+  configPath: CONFIG_PATH,
+});
+
+export const getConfigPath = () => config.path;
+
+/** 优先级: 环境变量 BOTSKILL_API_URL > 配置文件 > 构建时默认值 */
+export const getApiUrl = () =>
+  process.env.BOTSKILL_API_URL || config.get('apiUrl') || getDefaultApiUrl();
+
+export const setApiUrl = (url) => config.set('apiUrl', url);
+
+export const getToken = () => config.get('token');
+
+export const getRefreshToken = () => config.get('refreshToken');
+
+export const getUser = () => config.get('user');
+
+export const setAuth = (data) => {
+  if (data.token || data.accessToken) {
+    config.set('token', data.token || data.accessToken);
+  }
+  if (data.refreshToken) {
+    config.set('refreshToken', data.refreshToken);
+  }
+  if (data.user) {
+    config.set('user', data.user);
+  }
+};
+
+export const clearAuth = () => {
+  config.delete('token');
+  config.delete('refreshToken');
+  config.delete('user');
+};
+
+export const isLoggedIn = () => !!config.get('token');
+
+export const createApiClient = () => {
+  const baseURL = getApiUrl();
+  const client = axios.create({
+    baseURL,
+    timeout: 15000,
+    headers: { 'Content-Type': 'application/json' },
+  });
+
+  client.interceptors.request.use((cfg) => {
+    const token = getToken();
+    if (token) {
+      cfg.headers.Authorization = `Bearer ${token}`;
+    }
+    return cfg;
+  });
+
+  client.interceptors.response.use(
+    (res) => res,
+    async (err) => {
+      if (err.response?.status !== 401) return Promise.reject(err);
+      const req = err.config;
+      if (req._retry) return Promise.reject(err);
+      if (req.url?.includes('/auth/login') || req.url?.includes('/auth/refresh')) {
+        return Promise.reject(err);
+      }
+
+      const refreshToken = getRefreshToken();
+      if (!refreshToken) return Promise.reject(err);
+
+      try {
+        const res = await axios.post(`${baseURL}/auth/refresh`, { refreshToken });
+        const data = res.data?.data || res.data;
+        const newToken = data.accessToken || data.token;
+        const newRefresh = data.refreshToken;
+        if (newToken) {
+          config.set('token', newToken);
+          if (newRefresh) config.set('refreshToken', newRefresh);
+          req._retry = true;
+          req.headers.Authorization = `Bearer ${newToken}`;
+          return client(req);
+        }
+      } catch (_) {}
+      return Promise.reject(err);
+    }
+  );
+
+  return client;
+};

package/src/lib/constants.js

@@ -0,0 +1,10 @@
+/**
+ * 默认 API 地址，可通过 build 时环境变量 BOTSKILL_API_URL 注入
+ * 发布生产: BOTSKILL_API_URL=https://api.botskill.ai npm run build
+ * 开发/本地: 保持 __DEFAULT_API_URL__ 时使用 localhost
+ */
+export const DEFAULT_API_URL = "https://botskill.ai";
+export const FALLBACK_API_URL = 'http://localhost:3001/api';
+
+export const getDefaultApiUrl = () =>
+  DEFAULT_API_URL === '__DEFAULT_API_URL__' ? FALLBACK_API_URL : DEFAULT_API_URL;

package/src/lib/uploadSkill.js

@@ -0,0 +1,91 @@
+import path from 'path';
+import fs from 'fs-extra';
+import { createApiClient, getToken } from './auth.js';
+
+const validCategories = ['ai', 'data', 'web', 'devops', 'security', 'tools'];
+
+/**
+ * Find uploadable file in cwd
+ * Priority: SKILL.md, skill.zip, skill.tar.gz, dist.zip
+ */
+export async function findUploadFile(cwd = process.cwd()) {
+  const candidates = [
+    path.join(cwd, 'SKILL.md'),
+    path.join(cwd, 'skill.zip'),
+    path.join(cwd, 'skill.tar.gz'),
+    path.join(cwd, 'dist.zip'),
+  ];
+  for (const p of candidates) {
+    if (await fs.pathExists(p)) {
+      const stat = await fs.stat(p);
+      if (stat.isFile()) return p;
+    }
+  }
+  return null;
+}
+
+/**
+ * Upload skill file (SKILL.md, .zip, .tar.gz) to BotSkill
+ * @param {string} filePath - Path to file
+ */
+export async function uploadSkillFile(filePath) {
+  const token = getToken();
+  if (!token) {
+    throw new Error('NOT_LOGGED_IN');
+  }
+
+  if (!await fs.pathExists(filePath)) {
+    throw new Error('FILE_NOT_FOUND');
+  }
+
+  const FormData = (await import('form-data')).default;
+  const form = new FormData();
+  form.append('file', await fs.createReadStream(filePath), {
+    filename: path.basename(filePath),
+  });
+
+  const api = createApiClient();
+  const res = await api.post('/skills/upload', form, {
+    headers: form.getHeaders(),
+    maxBodyLength: Infinity,
+    maxContentLength: Infinity,
+  });
+  return res.data?.skill || res.data;
+}
+
+/**
+ * Legacy: upload via JSON (for backward compatibility, may be deprecated)
+ */
+export async function uploadSkill(options = {}) {
+  const token = getToken();
+  if (!token) throw new Error('NOT_LOGGED_IN');
+
+  let config = {};
+  const configPath = path.join(process.cwd(), 'skill.config.json');
+  if (await fs.pathExists(configPath)) {
+    config = await fs.readJson(configPath);
+  }
+
+  const skillData = {
+    name: options.name || config.name,
+    description: options.description || config.description,
+    version: options.version || config.version || '1.0.0',
+    category: options.category || config.category || 'tools',
+    tags: config.tags || [],
+    license: config.license || 'MIT',
+    repositoryUrl: config.repositoryUrl || undefined,
+    documentationUrl: config.documentationUrl || undefined,
+    demoUrl: config.demoUrl || undefined,
+  };
+
+  if (!skillData.name || !skillData.description) throw new Error('MISSING_FIELDS');
+  if (!validCategories.includes(skillData.category)) {
+    throw new Error(`Invalid category. Must be one of: ${validCategories.join(', ')}`);
+  }
+
+  const api = createApiClient();
+  const res = await api.post('/skills', skillData);
+  return res.data?.skill || res.data;
+}
+
+export { validCategories };