@botskill/cli 1.0.4 → 1.0.6

package/package.json

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

package/src/commands/get.js

@@ -25,7 +25,8 @@ getCommand
   .option('-o, --output <dir>', 'Output directory (default: current directory)')
   .option('--dry-run', 'Show what would be downloaded without actually downloading')
   .option('--api-url <url>', 'API base URL (overrides config for this command)')
-  .action(async (specifier, options) => {
+  .action(async (specifier, options, command) => {
+    const apiUrl = command.optsWithGlobals().apiUrl;
     const { name, version } = parseSpecifier(specifier);
     const outputDir = path.resolve(options.output || process.cwd());
 
@@ -42,7 +43,7 @@ getCommand
     }
 
     try {
-      const api = createApiClient(options.apiUrl);
+      const api = createApiClient(apiUrl);
 
       const fullSpec = version ? `${name}@${version}` : name;
       console.log(`Downloading skill: ${fullSpec}`);

package/src/commands/info.js

@@ -17,7 +17,7 @@ infoCommand
   .description('Show skill details from BotSkill')
   .argument('<specifier>', 'Skill name or name@version')
   .option('--api-url <url>', 'API base URL (overrides config for this command)')
-  .action(async (specifier, options = {}) => {
+  .action(async (specifier, options, command) => {
     const { name, version } = parseSpecifier(specifier);
 
     if (!name) {
@@ -25,8 +25,9 @@ infoCommand
       process.exit(1);
     }
 
+    const apiUrl = command.optsWithGlobals().apiUrl;
     try {
-      const api = createApiClient(options.apiUrl);
+      const api = createApiClient(apiUrl);
       const fullSpec = version ? `${name}@${version}` : name;
 
       const resolveRes = await api.get(`/skills/by-name/${encodeURIComponent(fullSpec)}`);

package/src/commands/init.js

@@ -3,22 +3,25 @@ import path from 'path';
 import fs from 'fs-extra';
 import inquirer from 'inquirer';
 
+function toSkillName(raw) {
+  const s = String(raw || 'my-skill').trim();
+  return s.toLowerCase()
+    .replace(/\s+/g, '-')
+    .replace(/[^a-z0-9-]/g, '')
+    .replace(/-+/g, '-')
+    .replace(/^-|-$/g, '') || 'my-skill';
+}
+
 const initCommand = new Command('init');
 initCommand
   .description('Initialize a new skill project')
+  .argument('[path]', 'Target directory: "." or path for current/specified dir; omit to create skill-named directory')
   .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) => {
+  .action(async (pathArg, 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 = {};
 
@@ -68,6 +71,25 @@ initCommand
       ]);
     }
 
+    const skillName = toSkillName(answers.name);
+    let targetDir;
+
+    if (pathArg && pathArg !== '.') {
+      targetDir = path.resolve(cwd, pathArg);
+      await fs.ensureDir(targetDir);
+    } else if (pathArg === '.') {
+      targetDir = cwd;
+    } else {
+      targetDir = path.join(cwd, skillName);
+      await fs.ensureDir(targetDir);
+    }
+
+    const configPath = path.join(targetDir, 'skill.config.json');
+    if (await fs.pathExists(configPath)) {
+      console.error(`skill.config.json already exists in ${targetDir}`);
+      process.exit(1);
+    }
+
     const config = {
       name: answers.name,
       description: answers.description,
@@ -82,12 +104,6 @@ initCommand
 
     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}
@@ -115,10 +131,13 @@ Add your usage documentation here. The Markdown body contains skill instructions
 \`\`\`
 `;
 
-    const skillMdPath = path.join(cwd, 'SKILL.md');
+    const skillMdPath = path.join(targetDir, 'SKILL.md');
     await fs.writeFile(skillMdPath, skillMd, 'utf-8');
 
     console.log('Created skill.config.json and SKILL.md');
+    if (targetDir !== cwd) {
+      console.log(`Location: ${targetDir}`);
+    }
     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');

package/src/commands/list.js

@@ -8,7 +8,9 @@ function formatSkillDisplay(skill) {
   const downloads = skill.downloads ?? 0;
   const category = skill.category || '—';
   const status = skill.status || '—';
-  return { name, version, downloads, category, status };
+  const desc = (skill.description || '').trim();
+  const description = desc.length > 80 ? desc.slice(0, 77) + '...' : desc || '—';
+  return { name, version, downloads, category, status, description };
 }
 
 const listCommand = new Command('list');
@@ -21,8 +23,9 @@ listCommand
   .option('-l, --limit <number>', 'Maximum number of results (default: 20)', '20')
   .option('-p, --page <number>', 'Page number for pagination (default: 1)', '1')
   .option('--api-url <url>', 'API base URL (overrides config for this command)')
-  .action(async (options) => {
-    const api = createApiClient(options.apiUrl);
+  .action(async (options, command) => {
+    const apiUrl = command.optsWithGlobals().apiUrl;
+    const api = createApiClient(apiUrl);
     const limit = parseInt(options.limit, 10) || 20;
     const page = parseInt(options.page, 10) || 1;
 
@@ -59,9 +62,10 @@ listCommand
       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 { name, version, downloads, category, status, description } = formatSkillDisplay(skill);
         const statusStr = options.mine ? ` | ${status}` : '';
         console.log(`  ${name}`);
+        console.log(`    ${description}`);
         console.log(`    Version: ${version} | Downloads: ${downloads} | Category: ${category}${statusStr}`);
       });
       if (pagination.totalPages > 1) {

package/src/commands/login.js

@@ -12,8 +12,8 @@ loginCommand
   .option('-p, --password <password>', 'Password')
   .option('-t, --token <token>', 'Use access token directly (from web)')
   .option('--api-url <url>', 'API base URL (overrides config for this command)')
-  .action(async (options) => {
-    const apiUrl = normalizeApiUrl(options.apiUrl || getApiUrl());
+  .action(async (options, command) => {
+    const apiUrl = normalizeApiUrl(command.optsWithGlobals().apiUrl || getApiUrl());
 
     if (options.token) {
       setAuth({ token: options.token });

package/src/commands/logout.js

@@ -6,8 +6,8 @@ const logoutCommand = new Command('logout');
 logoutCommand
   .description('Logout from BotSkill')
   .option('--api-url <url>', 'API base URL (overrides config for this command)')
-  .action(async (options) => {
-    const apiUrl = normalizeApiUrl(options.apiUrl || getApiUrl());
+  .action(async (options, command) => {
+    const apiUrl = normalizeApiUrl(command.optsWithGlobals().apiUrl || getApiUrl());
     const refreshToken = getRefreshToken();
     if (refreshToken) {
       try {

package/src/commands/pack.js

@@ -0,0 +1,53 @@
+import { Command } from 'commander';
+import path from 'path';
+import fs from 'fs-extra';
+import { packDirectory } from '../lib/packSkill.js';
+import { printSimpleError } from '../lib/formatError.js';
+
+const packCommand = new Command('pack');
+packCommand
+  .description('Pack current or specified directory into upload format (skill.zip)')
+  .argument('[path]', 'Directory to pack (default: current directory)')
+  .option('-o, --output <file>', 'Output file path (default: skill.zip in source directory)')
+  .option('--dry-run', 'Validate only, do not create zip')
+  .action(async (pathArg, options) => {
+    const cwd = process.cwd();
+    const dirPath = pathArg ? path.resolve(cwd, pathArg) : cwd;
+
+    if (!(await fs.pathExists(dirPath))) {
+      printSimpleError('Directory not found', dirPath);
+    }
+
+    const stat = await fs.stat(dirPath);
+    if (!stat.isDirectory()) {
+      printSimpleError('Not a directory', dirPath);
+    }
+
+    const skillMdPath = path.join(dirPath, 'SKILL.md');
+    if (!(await fs.pathExists(skillMdPath))) {
+      printSimpleError('SKILL.md not found', 'Create SKILL.md in the directory first');
+    }
+
+    if (options.dryRun) {
+      console.log('[DRY RUN] Would pack:', dirPath);
+      console.log('[DRY RUN] Output:', options.output || path.join(dirPath, 'skill.zip'));
+      return;
+    }
+
+    try {
+      const outputPath = await packDirectory(dirPath, { output: options.output });
+      console.log('Packed successfully!');
+      console.log(`Output: ${outputPath}`);
+      console.log('\nUse "skm push" or "skm push -f <path>" to upload.');
+    } catch (err) {
+      if (err.message === 'NO_SKILL_MD') {
+        printSimpleError('SKILL.md not found', 'Create SKILL.md in the directory first');
+      } else if (err.message === 'FILE_NOT_FOUND') {
+        printSimpleError('Directory not found', dirPath);
+      } else {
+        printSimpleError(err.message || 'Pack failed');
+      }
+    }
+  });
+
+export { packCommand };

package/src/commands/publish.js

@@ -4,14 +4,17 @@ import fs from 'fs-extra';
 import { getToken } from '../lib/auth.js';
 import { printApiError, printSimpleError } from '../lib/formatError.js';
 import { uploadSkillFile, findUploadFile } from '../lib/uploadSkill.js';
+import { packDirectory } from '../lib/packSkill.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('--config-dir <path>', 'Directory containing skill.config.json (default: same as file)')
   .option('--dry-run', 'Validate without uploading')
   .option('--api-url <url>', 'API base URL (overrides config for this command)')
-  .action(async (options) => {
+  .action(async (options, command) => {
+    const apiUrl = command.optsWithGlobals().apiUrl;
     if (!getToken()) {
       console.error('Not logged in. Run: skm login');
       process.exit(1);
@@ -31,14 +34,37 @@ publishCommand
       }
     }
 
-    if (options.dryRun) {
+    const configDir = options.configDir ? path.resolve(options.configDir) : path.dirname(path.resolve(filePath));
+    let tempPackPath = null;
+    let uploadPath = filePath;
+
+    const isSkillMd = filePath.toLowerCase().endsWith('.md') || path.basename(filePath) === 'SKILL.md';
+    if (isSkillMd) {
+      const dirPath = path.dirname(path.resolve(filePath));
+      if (options.dryRun) {
+        console.log('[DRY RUN] Would pack directory to temp (skill-{version}.zip) and upload');
+        console.log('[DRY RUN] Source:', path.resolve(filePath));
+        return;
+      }
+      try {
+        tempPackPath = await packDirectory(dirPath, { useTempDir: true });
+        uploadPath = tempPackPath;
+      } catch (err) {
+        if (err.message === 'NO_SKILL_MD') {
+          printSimpleError('SKILL.md not found', 'Create SKILL.md in the directory first');
+        } else {
+          printSimpleError(err.message || 'Pack failed');
+        }
+        process.exit(1);
+      }
+    } else if (options.dryRun) {
       console.log('[DRY RUN] Would publish:', path.resolve(filePath));
       return;
     }
 
-    console.log(`Publishing skill from ${path.basename(filePath)}...`);
+    console.log(`Publishing skill from ${path.basename(uploadPath)}...`);
     try {
-      const skill = await uploadSkillFile(filePath, { apiUrl: options.apiUrl });
+      const skill = await uploadSkillFile(uploadPath, { apiUrl, configDir });
       console.log('Skill published successfully!');
       console.log(`Name: ${skill?.name}`);
       console.log(`Version: ${skill?.version || (skill?.versions?.[0]?.version)}`);
@@ -47,13 +73,19 @@ publishCommand
       if (err.message === 'NOT_LOGGED_IN') {
         printSimpleError('Not logged in', 'Run "skm login" first');
       } else if (err.message === 'FILE_NOT_FOUND') {
-        printSimpleError('File not found', 'Check the path with --file <path>');
+        printSimpleError('File not found', uploadPath);
       } else {
         const msg = err.response?.data?.error || err.response?.data?.details?.[0];
         if (msg) err._overrideMsg = msg;
         if (err.response?.status === 401) err._overrideMsg = 'Token expired or invalid. Run "skm login" first.';
         printApiError(err, { prefix: 'Publish failed' });
       }
+    } finally {
+      if (tempPackPath) {
+        try {
+          await fs.remove(path.dirname(tempPackPath));
+        } catch (_) {}
+      }
     }
   });
 

package/src/commands/push.js

@@ -3,15 +3,18 @@ import path from 'path';
 import fs from 'fs-extra';
 import { getToken } from '../lib/auth.js';
 import { printApiError, printSimpleError } from '../lib/formatError.js';
-import { uploadSkillFile, findUploadFile, validCategories } from '../lib/uploadSkill.js';
+import { uploadSkillFile, findUploadFile } from '../lib/uploadSkill.js';
+import { packDirectory } from '../lib/packSkill.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('--config-dir <path>', 'Directory containing skill.config.json (default: same as file)')
   .option('--dry-run', 'Validate without uploading')
   .option('--api-url <url>', 'API base URL')
-  .action(async (options) => {
+  .action(async (options, command) => {
+    const apiUrl = command.optsWithGlobals().apiUrl;
     if (!getToken()) {
       console.error('Not logged in. Run: skm login');
       process.exit(1);
@@ -31,14 +34,38 @@ pushCommand
       }
     }
 
-    if (options.dryRun) {
+    const configDir = options.configDir ? path.resolve(options.configDir) : path.dirname(path.resolve(filePath));
+    let tempPackPath = null;
+    let uploadPath = filePath;
+
+    // 当源是 SKILL.md 时，打包到临时目录并加上版本号
+    const isSkillMd = filePath.toLowerCase().endsWith('.md') || path.basename(filePath) === 'SKILL.md';
+    if (isSkillMd) {
+      const dirPath = path.dirname(path.resolve(filePath));
+      if (options.dryRun) {
+        console.log('[DRY RUN] Would pack directory to temp (skill-{version}.zip) and upload');
+        console.log('[DRY RUN] Source:', path.resolve(filePath));
+        return;
+      }
+      try {
+        tempPackPath = await packDirectory(dirPath, { useTempDir: true });
+        uploadPath = tempPackPath;
+      } catch (err) {
+        if (err.message === 'NO_SKILL_MD') {
+          printSimpleError('SKILL.md not found', 'Create SKILL.md in the directory first');
+        } else {
+          printSimpleError(err.message || 'Pack failed');
+        }
+        process.exit(1);
+      }
+    } else if (options.dryRun) {
       console.log('[DRY RUN] Would upload:', path.resolve(filePath));
       return;
     }
 
-    console.log(`Pushing skill from ${path.basename(filePath)}...`);
+    console.log(`Pushing skill from ${path.basename(uploadPath)}...`);
     try {
-      const skill = await uploadSkillFile(filePath, { apiUrl: options.apiUrl });
+      const skill = await uploadSkillFile(uploadPath, { apiUrl, configDir });
       console.log('Skill uploaded successfully!');
       console.log(`Name: ${skill?.name}`);
       console.log(`Version: ${skill?.version || (skill?.versions?.[0]?.version)}`);
@@ -47,13 +74,19 @@ pushCommand
       if (err.message === 'NOT_LOGGED_IN') {
         printSimpleError('Not logged in', 'Run "skm login" first');
       } else if (err.message === 'FILE_NOT_FOUND') {
-        printSimpleError('File not found', 'Check the path with --file <path>');
+        printSimpleError('File not found', uploadPath);
       } else {
         const msg = err.response?.data?.error || err.response?.data?.details?.[0];
         if (msg) err._overrideMsg = msg;
         if (err.response?.status === 401) err._overrideMsg = 'Token expired or invalid. Run "skm login" first.';
         printApiError(err, { prefix: 'Push failed' });
       }
+    } finally {
+      if (tempPackPath) {
+        try {
+          await fs.remove(path.dirname(tempPackPath));
+        } catch (_) {}
+      }
     }
   });
 

package/src/commands/search.js

@@ -9,7 +9,9 @@ function formatSkillDisplay(skill) {
   const version = skill.version || (skill.versions?.[0]?.version) || '—';
   const downloads = skill.downloads ?? 0;
   const category = skill.category || '—';
-  return { displayName, version, downloads, category };
+  const desc = (skill.description || '').trim();
+  const description = desc.length > 80 ? desc.slice(0, 77) + '...' : desc || '—';
+  return { displayName, version, downloads, category, description };
 }
 
 const searchCommand = new Command('search');
@@ -20,8 +22,9 @@ searchCommand
   .option('-l, --limit <number>', 'Maximum number of results (default: 20)', '20')
   .option('-p, --page <number>', 'Page number for pagination (default: 1)', '1')
   .option('--api-url <url>', 'API base URL (overrides config for this command)')
-  .action(async (query, options) => {
-    const api = createApiClient(options.apiUrl);
+  .action(async (query, options, command) => {
+    const apiUrl = command.optsWithGlobals().apiUrl;
+    const api = createApiClient(apiUrl);
     const limit = parseInt(options.limit, 10) || 20;
     const page = parseInt(options.page, 10) || 1;
 
@@ -41,8 +44,9 @@ searchCommand
       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);
+        const { displayName, version, downloads, category, description } = formatSkillDisplay(skill);
         console.log(`  ${displayName}`);
+        console.log(`    ${description}`);
         console.log(`    Version: ${version} | Downloads: ${downloads} | Category: ${category}`);
       });
       if (pagination.totalPages > 1) {

package/src/index.js

@@ -9,6 +9,7 @@ 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 { packCommand } from './commands/pack.js';
 import { pushCommand } from './commands/push.js';
 import { publishCommand } from './commands/publish.js';
 import { listCommand } from './commands/list.js';
@@ -28,13 +29,15 @@ const program = new Command();
 program
   .name('skm')
   .description('CLI tool for managing BotSkill - a platform for AI agent skills')
-  .version(version);
+  .version(version)
+  .option('--api-url <url>', 'API base URL (overrides config for this command)');
 
 program.addCommand(initCommand);
 program.addCommand(loginCommand);
 program.addCommand(logoutCommand);
 program.addCommand(configCommand);
 program.addCommand(getCommand);
+program.addCommand(packCommand);
 program.addCommand(pushCommand);
 program.addCommand(publishCommand);
 program.addCommand(listCommand);

package/src/lib/packSkill.js

@@ -0,0 +1,95 @@
+import path from 'path';
+import os from 'os';
+import fs from 'fs-extra';
+import AdmZip from 'adm-zip';
+
+const DEFAULT_EXCLUDE = [
+  'node_modules',
+  '.git',
+  '.DS_Store',
+  'skill.zip',
+  'skill.tar.gz',
+  'dist.zip',
+];
+
+/**
+ * Create filter that excludes common unwanted paths
+ */
+function createExcludeFilter(exclude = DEFAULT_EXCLUDE) {
+  const patterns = exclude.map((p) => p.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'));
+  const re = new RegExp(`(^|/)(${patterns.join('|')})(/|$)`, 'i');
+  return (zipPath) => !re.test(zipPath.replace(/\\/g, '/'));
+}
+
+/**
+ * Get name and version from skill.config.json in directory
+ */
+async function getConfigFromDir(dirPath) {
+  const configPath = path.join(dirPath, 'skill.config.json');
+  const defaultValue = { name: 'skill', version: '1.0.0' };
+  if (!(await fs.pathExists(configPath))) return defaultValue;
+  try {
+    const config = await fs.readJson(configPath);
+    return {
+      name: config.name || 'skill',
+      version: config.version || '1.0.0',
+    };
+  } catch {
+    return defaultValue;
+  }
+}
+
+function toSafeId(str) {
+  return String(str || 'skill')
+    .toLowerCase()
+    .replace(/[^a-z0-9.-]/g, '-')
+    .replace(/-+/g, '-')
+    .replace(/^-|-$/g, '') || 'skill';
+}
+
+/**
+ * Pack a directory into skill.zip format for upload
+ * @param {string} dirPath - Directory to pack (must contain SKILL.md)
+ * @param {Object} [opts]
+ * @param {string} [opts.output] - Output file path (default: skill.zip in dirPath)
+ * @param {string} [opts.version] - Version for filename when using tempDir
+ * @param {boolean} [opts.useTempDir] - If true, output to temp dir with skill-{version}.zip
+ * @param {string[]} [opts.exclude] - Additional paths to exclude
+ * @returns {Promise<string>} Path to created zip file
+ */
+export async function packDirectory(dirPath, opts = {}) {
+  const resolved = path.resolve(dirPath);
+  if (!(await fs.pathExists(resolved))) {
+    throw new Error('FILE_NOT_FOUND');
+  }
+  const stat = await fs.stat(resolved);
+  if (!stat.isDirectory()) {
+    throw new Error('NOT_DIRECTORY');
+  }
+
+  const skillMdPath = path.join(resolved, 'SKILL.md');
+  if (!(await fs.pathExists(skillMdPath))) {
+    throw new Error('NO_SKILL_MD');
+  }
+
+  let outputPath;
+  if (opts.output) {
+    outputPath = path.resolve(opts.output);
+  } else if (opts.useTempDir) {
+    const { name, version } = await getConfigFromDir(resolved);
+    const safeName = toSafeId(opts.name ?? name);
+    const safeVersion = String(opts.version ?? version).replace(/[^a-zA-Z0-9.-]/g, '-');
+    const tmpDir = path.join(os.tmpdir(), `skm-pack-${Date.now()}-${Math.random().toString(36).slice(2)}`);
+    await fs.ensureDir(tmpDir);
+    outputPath = path.join(tmpDir, `${safeName}-${safeVersion}.zip`);
+  } else {
+    outputPath = path.join(resolved, 'skill.zip');
+  }
+  const excludeFilter = createExcludeFilter(opts.exclude);
+
+  const zip = new AdmZip();
+  zip.addLocalFolder(resolved, '', (p) => excludeFilter(p.replace(/\\/g, '/')));
+  zip.writeZip(outputPath);
+
+  return outputPath;
+}

package/src/lib/uploadSkill.js

@@ -24,11 +24,50 @@ export async function findUploadFile(cwd = process.cwd()) {
   return null;
 }
 
+/**
+ * Load skill.config.json from directory (same dir as file or parent)
+ */
+export async function loadSkillConfig(filePath) {
+  const dir = path.dirname(path.resolve(filePath));
+  const configPath = path.join(dir, 'skill.config.json');
+  if (!(await fs.pathExists(configPath))) return null;
+  try {
+    return await fs.readJson(configPath);
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Append skill.config.json fields to FormData (version, category, license, tags, urls)
+ */
+function appendConfigToForm(form, config) {
+  if (!config) return;
+  const fields = [
+    'version',
+    'category',
+    'license',
+    'repositoryUrl',
+    'documentationUrl',
+    'demoUrl',
+  ];
+  for (const key of fields) {
+    const val = config[key];
+    if (val !== undefined && val !== null && val !== '') {
+      form.append(key, Array.isArray(val) ? JSON.stringify(val) : String(val));
+    }
+  }
+  if (Array.isArray(config.tags) && config.tags.length > 0) {
+    form.append('tags', JSON.stringify(config.tags));
+  }
+}
+
 /**
  * Upload skill file (SKILL.md, .zip, .tar.gz) to BotSkill
  * @param {string} filePath - Path to file
  * @param {Object} [opts] - 可选
  * @param {string} [opts.apiUrl] - 覆盖 API 地址（来自 --api-url）
+ * @param {string} [opts.configDir] - 指定读取 skill.config.json 的目录（默认与文件同目录）
  */
 export async function uploadSkillFile(filePath, opts = {}) {
   const token = getToken();
@@ -46,6 +85,15 @@ export async function uploadSkillFile(filePath, opts = {}) {
     filename: path.basename(filePath),
   });
 
+  const configDir = opts.configDir ?? path.dirname(path.resolve(filePath));
+  const configPath = path.join(configDir, 'skill.config.json');
+  if (await fs.pathExists(configPath)) {
+    try {
+      const config = await fs.readJson(configPath);
+      appendConfigToForm(form, config);
+    } catch (_) {}
+  }
+
   const api = createApiClient(opts.apiUrl);
   const res = await api.post('/skills/upload', form, {
     headers: form.getHeaders(),