myskillshub 1.0.5 → 1.0.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "myskillshub",
-  "version": "1.0.5",
+  "version": "1.0.7",
   "description": "CLI tool for SkillHub skill management",
   "main": "src/index.js",
   "bin": {

package/src/commands/publish.js

@@ -1,8 +1,10 @@
 const { Command } = require('commander');
 const chalk = require('chalk');
 const fs = require('fs');
+const os = require('os');
 const path = require('path');
 const axios = require('axios');
+const readline = require('readline');
 const oraModule = require('ora');
 const ora = oraModule.default || oraModule;
 const archiver = require('archiver');
@@ -10,6 +12,7 @@ const FormData = require('form-data');
 const { createWriteStream } = require('fs');
 
 const program = new Command();
+const DEFAULT_CATEGORY_SLUG = 'dev-tools';
 
 program
   .name('publish')
@@ -17,6 +20,10 @@ program
   .argument('[directory]', 'Directory containing skill to publish (default: current directory)')
   .option('--verbose', 'Verbose output')
   .option('-a, --api-url <url>', 'SkillHub API URL', 'http://localhost:3000')
+  .option('--username <username>', 'Login username (or use SKILLSHUB_USERNAME)')
+  .option('--password <password>', 'Login password (or use SKILLSHUB_PASSWORD)')
+  .option('--category-id <id>', 'Category ID for publish')
+  .option('--category-slug <slug>', 'Category slug for publish (auto resolve to ID)')
   .action(async (directory, options) => {
     const targetDirectory = directory || '.';
     const spinner = ora('Starting publish process...').start();
@@ -40,23 +47,34 @@ program
 
       // Parse skill.md content (basic parsing)
       const skillData = parseSkillMd(skillMdContent);
+      const frontmatter = parseFrontmatter(skillMdContent);
+      skillData.description = normalizeDescription(frontmatter.description || skillData.description, skillData.name);
+      skillData.tags = normalizeTags(frontmatter.tags || []);
       spinner.succeed(chalk.green(`Found skill: ${skillData.name}`));
 
+      spinner.start('Resolving category...');
+      const categoryId = await resolveCategoryId(options.apiUrl, options, frontmatter);
+      spinner.succeed(chalk.green(`Resolved category_id: ${categoryId}`));
+
+      spinner.start('Authenticating...');
+      const auth = await getAuthCookie(options.apiUrl, options, spinner);
+      spinner.succeed(chalk.green(auth.fromCache ? 'Authenticated with cached session' : 'Login succeeded'));
+
       // Create ZIP package
-      spinner.text = 'Creating ZIP package...';
+      spinner.start('Creating ZIP package...');
       const zipPath = await createZipPackage(targetDirectory);
       spinner.succeed(chalk.green(`ZIP package created: ${zipPath}`));
 
       // Upload to SkillHub API
-      spinner.text = 'Uploading to SkillHub API...';
-      const result = await uploadSkill(zipPath, skillData, options.apiUrl);
+      spinner.start('Uploading to SkillHub API...');
+      const result = await uploadSkill(zipPath, skillData, categoryId, options.apiUrl, auth.cookie);
 
       spinner.succeed(chalk.green('Skill published successfully!'));
       console.log(chalk.cyan(`Skill slug: ${result.slug}`));
       console.log(chalk.cyan(`Skill URL: ${options.apiUrl}/skills/${result.slug}`));
 
     } catch (error) {
-      spinner.fail(chalk.red(`Publish failed: ${error.message}`));
+      spinner.fail(chalk.red(`Publish failed: ${formatErrorMessage(error)}`));
       if (options.verbose) {
         console.error(error);
       }
@@ -75,6 +93,68 @@ function resolveSkillFilePath(directory) {
   return null;
 }
 
+function parseFrontmatter(content) {
+  const text = String(content || '');
+  if (!text.startsWith('---')) {
+    return {};
+  }
+
+  const end = text.indexOf('---', 3);
+  if (end < 0) {
+    return {};
+  }
+
+  const block = text.slice(3, end).trim();
+  const lines = block.split('\n');
+  const result = {};
+  let currentArrayKey = null;
+
+  for (const rawLine of lines) {
+    const line = rawLine.trim();
+    if (!line || line.startsWith('#')) {
+      continue;
+    }
+
+    if (line.startsWith('- ')) {
+      if (currentArrayKey) {
+        if (!Array.isArray(result[currentArrayKey])) {
+          result[currentArrayKey] = [];
+        }
+        result[currentArrayKey].push(stripQuotes(line.slice(2).trim()));
+      }
+      continue;
+    }
+
+    currentArrayKey = null;
+    const idx = line.indexOf(':');
+    if (idx < 0) {
+      continue;
+    }
+
+    const key = line.slice(0, idx).trim();
+    const value = line.slice(idx + 1).trim();
+    if (!value) {
+      currentArrayKey = key;
+      result[key] = [];
+      continue;
+    }
+
+    if (value.startsWith('[') && value.endsWith(']')) {
+      const arr = value.slice(1, -1).trim();
+      result[key] = arr ? arr.split(',').map((item) => stripQuotes(item.trim())) : [];
+      continue;
+    }
+
+    result[key] = stripQuotes(value);
+  }
+
+  return result;
+}
+
+function stripQuotes(value) {
+  return String(value || '').replace(/^['"]|['"]$/g, '');
+}
+
 function parseSkillMd(content) {
   const lines = content.split('\n');
   const skillData = {
@@ -83,7 +163,8 @@ function parseSkillMd(content) {
     version: '1.0.0',
     author: '',
     keywords: [],
-    installCommand: ''
+    installCommand: '',
+    tags: []
   };
 
   let inDescription = false;
@@ -116,6 +197,249 @@ function parseSkillMd(content) {
   return skillData;
 }
 
+function normalizeDescription(description, skillName) {
+  const text = String(description || '').trim();
+  if (text.length >= 10 && text.length <= 500) {
+    return text;
+  }
+
+  const fallback = `Skill "${skillName || 'unknown'}" published via myskillshub CLI.`;
+  return fallback.slice(0, 500);
+}
+
+function normalizeTags(tags) {
+  if (!Array.isArray(tags)) {
+    return [];
+  }
+  return tags.map((item) => String(item || '').trim()).filter(Boolean).slice(0, 10);
+}
+
+async function resolveCategoryId(apiUrl, options, frontmatter) {
+  if (options.categoryId) {
+    const id = parseInt(options.categoryId, 10);
+    if (!Number.isInteger(id) || id <= 0) {
+      throw new Error(`Invalid --category-id: ${options.categoryId}`);
+    }
+    return id;
+  }
+
+  if (frontmatter.category_id) {
+    const id = parseInt(frontmatter.category_id, 10);
+    if (Number.isInteger(id) && id > 0) {
+      return id;
+    }
+  }
+
+  const slugCandidate = options.categorySlug
+    || frontmatter.category_slug
+    || frontmatter.category
+    || DEFAULT_CATEGORY_SLUG;
+
+  try {
+    const response = await axios.get(`${apiUrl}/api/categories/${encodeURIComponent(String(slugCandidate).trim())}`);
+    const category = response.data?.data?.category;
+    if (!response.data?.success || !category?.id) {
+      throw new Error(`Failed to resolve category slug: ${slugCandidate}`);
+    }
+
+    return category.id;
+  } catch (error) {
+    if (error.response?.status === 404 && slugCandidate === DEFAULT_CATEGORY_SLUG) {
+      throw new Error(`Default category "${DEFAULT_CATEGORY_SLUG}" not found. Use --category-id or --category-slug.`);
+    }
+    throw new Error(`Failed to resolve category slug: ${slugCandidate}. ${formatErrorMessage(error)}`);
+  }
+}
+
+async function getAuthCookie(apiUrl, options, spinner) {
+  const normalizedApiUrl = normalizeApiUrl(apiUrl);
+  const resolvedUsername = options.username || process.env.SKILLSHUB_USERNAME || '';
+  const resolvedPassword = options.password || process.env.SKILLSHUB_PASSWORD || '';
+  const hasCompleteExplicitCredentials = Boolean(resolvedUsername && resolvedPassword);
+
+  if (!hasCompleteExplicitCredentials) {
+    const cachedCookie = getCachedCookie(normalizedApiUrl);
+    if (cachedCookie) {
+      const isValid = await isSessionValid(normalizedApiUrl, cachedCookie);
+      if (isValid) {
+        return { cookie: cachedCookie, fromCache: true };
+      }
+      removeCachedCookie(normalizedApiUrl);
+    }
+  }
+
+  const credentials = await resolveCredentials(options, spinner);
+  const cookie = await loginAndGetCookie(normalizedApiUrl, credentials.username, credentials.password);
+  saveCachedCookie(normalizedApiUrl, cookie);
+  return { cookie, fromCache: false };
+}
+
+function normalizeApiUrl(apiUrl) {
+  return String(apiUrl || '').trim().replace(/\/+$/, '');
+}
+
+function getSessionStorePath() {
+  return path.join(os.homedir(), '.myskillshub', 'session.json');
+}
+
+function readSessionStore() {
+  const sessionStorePath = getSessionStorePath();
+  if (!fs.existsSync(sessionStorePath)) {
+    return { sessions: {} };
+  }
+
+  try {
+    const raw = fs.readFileSync(sessionStorePath, 'utf8');
+    const parsed = JSON.parse(raw);
+    if (parsed && typeof parsed === 'object' && parsed.sessions && typeof parsed.sessions === 'object') {
+      return parsed;
+    }
+    return { sessions: {} };
+  } catch (error) {
+    return { sessions: {} };
+  }
+}
+
+function writeSessionStore(data) {
+  const sessionStorePath = getSessionStorePath();
+  const sessionStoreDir = path.dirname(sessionStorePath);
+  fs.mkdirSync(sessionStoreDir, { recursive: true, mode: 0o700 });
+  fs.writeFileSync(sessionStorePath, `${JSON.stringify(data, null, 2)}\n`, { mode: 0o600 });
+}
+
+function getCachedCookie(apiUrl) {
+  const store = readSessionStore();
+  return store.sessions?.[apiUrl]?.cookie || null;
+}
+
+function saveCachedCookie(apiUrl, cookie) {
+  const store = readSessionStore();
+  store.sessions = store.sessions || {};
+  store.sessions[apiUrl] = {
+    cookie,
+    updatedAt: new Date().toISOString()
+  };
+  writeSessionStore(store);
+}
+
+function removeCachedCookie(apiUrl) {
+  const store = readSessionStore();
+  if (store.sessions && store.sessions[apiUrl]) {
+    delete store.sessions[apiUrl];
+    writeSessionStore(store);
+  }
+}
+
+async function isSessionValid(apiUrl, cookie) {
+  try {
+    const response = await axios.get(`${apiUrl}/api/auth/me`, {
+      headers: {
+        Cookie: cookie
+      },
+      validateStatus: () => true
+    });
+
+    return response.status === 200 && Boolean(response.data?.success);
+  } catch (error) {
+    return false;
+  }
+}
+
+async function resolveCredentials(options, spinner) {
+  let username = options.username || process.env.SKILLSHUB_USERNAME || '';
+  let password = options.password || process.env.SKILLSHUB_PASSWORD || '';
+  const needsPrompt = !username || !password;
+
+  if (needsPrompt && !process.stdin.isTTY) {
+    throw new Error('Missing credentials in non-interactive mode. Use --username/--password or SKILLSHUB_USERNAME/SKILLSHUB_PASSWORD.');
+  }
+
+  if (!username) {
+    if (spinner && spinner.isSpinning) {
+      spinner.stop();
+    }
+    username = await promptInput('SkillHub username: ');
+    if (spinner && !spinner.isSpinning) {
+      spinner.start('Logging in...');
+    }
+  }
+
+  if (!password) {
+    if (spinner && spinner.isSpinning) {
+      spinner.stop();
+    }
+    password = await promptPassword('SkillHub password: ');
+    if (spinner && !spinner.isSpinning) {
+      spinner.start('Logging in...');
+    }
+  }
+
+  if (!username || !password) {
+    throw new Error('Publish requires username and password.');
+  }
+
+  return { username, password };
+}
+
+function promptInput(question) {
+  return new Promise((resolve) => {
+    const rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout,
+      terminal: true
+    });
+
+    rl.question(question, (answer) => {
+      rl.close();
+      resolve(String(answer || '').trim());
+    });
+  });
+}
+
+function promptPassword(question) {
+  return new Promise((resolve) => {
+    const rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout,
+      terminal: true
+    });
+
+    rl.stdoutMuted = true;
+    const originalWriteToOutput = rl._writeToOutput;
+    rl._writeToOutput = function writeToOutput(stringToWrite) {
+      if (rl.stdoutMuted) {
+        if (stringToWrite === '\n' || stringToWrite === '\r\n') {
+          rl.output.write(stringToWrite);
+          return;
+        }
+        rl.output.write('*');
+        return;
+      }
+      originalWriteToOutput.call(rl, stringToWrite);
+    };
+
+    rl.question(question, (password) => {
+      rl.history = [];
+      rl.close();
+      resolve(String(password || '').trim());
+    });
+  });
+}
+
+async function loginAndGetCookie(apiUrl, username, password) {
+  const response = await axios.post(`${apiUrl}/api/auth/login`, {
+    username,
+    password
+  });
+
+  const setCookie = response.headers['set-cookie'];
+  if (!Array.isArray(setCookie) || setCookie.length === 0) {
+    throw new Error('Login succeeded but no session cookie returned');
+  }
+
+  return setCookie.map((cookie) => cookie.split(';')[0]).join('; ');
+}
+
 function createZipPackage(directory) {
   return new Promise((resolve, reject) => {
     const baseName = path.basename(path.resolve(directory));
@@ -153,26 +477,52 @@ function createZipPackage(directory) {
   });
 }
 
-async function uploadSkill(zipPath, skillData, apiUrl) {
+async function uploadSkill(zipPath, skillData, categoryId, apiUrl, authCookie) {
   const formData = new FormData();
   formData.append('file', fs.createReadStream(zipPath));
-  formData.append('name', skillData.name);
+  formData.append('title', skillData.name);
   formData.append('description', skillData.description);
-  formData.append('version', skillData.version);
-  formData.append('author', skillData.author);
-  formData.append('keywords', JSON.stringify(skillData.keywords));
-  formData.append('installCommand', skillData.installCommand);
+  formData.append('category_id', String(categoryId));
+  formData.append('tags', JSON.stringify(skillData.tags || []));
+
+  try {
+    const response = await axios.post(`${apiUrl}/api/skills/publish`, formData, {
+      headers: {
+        ...formData.getHeaders(),
+        Cookie: authCookie
+      }
+    });
 
-  const response = await axios.post(`${apiUrl}/api/skills/publish`, formData, {
-    headers: {
-      ...formData.getHeaders()
+    return response.data?.data || response.data;
+  } finally {
+    if (fs.existsSync(zipPath)) {
+      fs.unlinkSync(zipPath);
     }
-  });
+  }
+}
 
-  // Clean up ZIP file after successful upload
-  fs.unlinkSync(zipPath);
+function formatErrorMessage(error) {
+  if (!error) {
+    return 'Unknown error';
+  }
+
+  const status = error.response?.status;
+  const apiError = error.response?.data?.error;
+  const directMessage = error.response?.data?.message;
+
+  if (apiError?.message) {
+    return status ? `HTTP ${status}: ${apiError.message}` : apiError.message;
+  }
+
+  if (directMessage) {
+    return status ? `HTTP ${status}: ${directMessage}` : directMessage;
+  }
+
+  if (status) {
+    return `HTTP ${status}: ${error.message}`;
+  }
 
-  return response.data;
+  return error.message || 'Unknown error';
 }
 
 module.exports = program;