skillscokac 1.1.0 → 1.4.0

package/README.md

@@ -31,8 +31,9 @@ The CLI will:
 | `-i, --install-skill <skillName>` | Install a single skill |
 | `-c, --install-collection <collectionId>` | Install all skills from a collection |
 | `-d, --download <skillName> [path]` | Download a skill to a directory (defaults to current directory) |
-| `-u, --upload <skillDir>` | Upload a skill to skills.cokac.com (requires `--apikey`) |
-| `--apikey <key>` | API key for uploading skills |
+| `-u, --upload <skillDir>` | Upload a new skill to skills.cokac.com (requires `--apikey`) |
+| `-m, --uploadmodify <skillDir>` | Upload or update a skill (creates if new, updates if exists, requires `--apikey`) |
+| `--apikey <key>` | API key for uploading/updating skills |
 | `-l, --list-installed-skills` | List all installed skills |
 | `-r, --remove-skill <skillName>` | Remove an installed skill (with confirmation) |
 | `-f, --remove-skill-force <skillName>` | Remove a skill without confirmation |
@@ -69,6 +70,15 @@ npx skillscokac --upload ./my-skill --apikey ck_live_xxxxx
 
 This will upload your skill to the marketplace. Requires an API key from skills.cokac.com.
 
+**Upload or update a skill:**
+```bash
+npx skillscokac --uploadmodify ./my-skill --apikey ck_live_xxxxx
+# or use short option
+npx skillscokac -m ./my-skill --apikey ck_live_xxxxx
+```
+
+This will create a new skill if it doesn't exist, or update it if it already exists. Perfect for maintaining and iterating on your skills.
+
 **List installed skills:**
 ```bash
 npx skillscokac -l
@@ -137,7 +147,11 @@ This will:
 You can upload your own skills to skills.cokac.com using the upload command:
 
 ```bash
+# Upload a new skill (fails if skill name already exists)
 npx skillscokac --upload <skillDir> --apikey <your-api-key>
+
+# Upload or update a skill (creates new or updates existing)
+npx skillscokac --uploadmodify <skillDir> --apikey <your-api-key>
 ```
 
 ### Requirements
@@ -165,8 +179,9 @@ The CLI will:
 3. Upload all additional files in the directory (excluding hidden files and common ignore patterns)
 4. Return the skill URL
 
-### Example
+### Examples
 
+**Upload a new skill:**
 ```bash
 # Upload a skill from current directory
 npx skillscokac --upload . --apikey ck_live_xxxxx
@@ -175,6 +190,36 @@ npx skillscokac --upload . --apikey ck_live_xxxxx
 npx skillscokac --upload ./skills/my-awesome-skill --apikey ck_live_xxxxx
 ```
 
+**Upload or update a skill:**
+```bash
+# Create new skill or update if it exists
+npx skillscokac --uploadmodify ./my-skill --apikey ck_live_xxxxx
+
+# Short option
+npx skillscokac -m ./my-skill --apikey ck_live_xxxxx
+```
+
+### Difference between --upload and --uploadmodify
+
+| Feature | `--upload` | `--uploadmodify` |
+|---------|------------|------------------|
+| **Behavior** | Creates a new skill only | Creates new OR updates existing skill |
+| **If skill exists** | ❌ Fails with error (409 Conflict) | ✅ Updates the existing skill |
+| **If skill doesn't exist** | ✅ Creates new skill | ✅ Creates new skill |
+| **Use case** | First-time upload | Maintaining and iterating on skills |
+| **Update process** | N/A | Replaces all files atomically |
+
+**When to use `--upload`:**
+- First time publishing a skill
+- When you want to ensure you're creating a brand new skill
+- When duplicate skill names should be prevented
+
+**When to use `--uploadmodify`:**
+- Updating an existing skill with improvements
+- Continuous development workflow
+- When you want "create or update" behavior
+- Maintaining published skills over time
+
 ### What Gets Uploaded
 
 - **SKILL.md**: Main skill file (required, used as primary content)
@@ -274,20 +319,6 @@ When you install a skill, the CLI downloads and extracts:
 - **Node.js**: 14.0.0 or higher
 - **Claude Code**: Installed and configured
 
-## API Endpoints
-
-This CLI communicates with the following endpoints:
-
-| Endpoint | Method | Purpose |
-|----------|--------|---------|
-| `/api/marketplace` | GET | Fetch marketplace data to find skills |
-| `/api/posts/{postId}/export-skill-zip` | GET | Download skill ZIP package |
-| `/api/collections/{collectionId}` | GET | Fetch collection metadata and skills |
-| `/api/posts` | POST | Create a new skill (requires API key) |
-| `/api/posts/{postId}/files` | POST | Upload additional files to a skill (requires API key) |
-
-**Base URL**: `https://skills.cokac.com`
-
 ## Development
 
 ### Local Testing

package/bin/skillscokac.js

@@ -18,6 +18,45 @@ const VERSION = packageJson.version
 
 const API_BASE_URL = 'https://skills.cokac.com'
 
+// Configuration constants
+const MAX_ZIP_SIZE = 50 * 1024 * 1024 // 50MB
+const MAX_FILE_SIZE = 5 * 1024 * 1024 // 5MB
+const AXIOS_TIMEOUT = 30000 // 30 seconds
+
+/**
+ * Validate skill name for security
+ */
+function validateSkillName(skillName) {
+  if (!skillName || typeof skillName !== 'string') {
+    throw new Error('Invalid skill name')
+  }
+
+  const trimmed = skillName.trim()
+
+  if (trimmed.length === 0) {
+    throw new Error('Skill name cannot be empty')
+  }
+
+  if (trimmed.includes('/') || trimmed.includes('\\')) {
+    throw new Error('Skill name cannot contain path separators')
+  }
+
+  if (trimmed.includes('..')) {
+    throw new Error('Skill name cannot contain ".."')
+  }
+
+  if (trimmed.startsWith('.')) {
+    throw new Error('Skill name cannot start with a dot')
+  }
+
+  // Check for other potentially dangerous characters
+  if (/[<>:"|?*\x00-\x1f]/.test(trimmed)) {
+    throw new Error('Skill name contains invalid characters')
+  }
+
+  return trimmed
+}
+
 /**
  * Parse frontmatter from markdown content
  */
@@ -79,12 +118,16 @@ async function fetchSkill(skillName, options = {}) {
   const spinner = silent ? null : ora(`Searching for skill: ${skillName}`).start()
 
   try {
+    // Validate skill name
+    skillName = validateSkillName(skillName)
+
     // Step 1: Get marketplace data to find postId
     if (spinner) spinner.text = 'Fetching marketplace data...'
     const marketplaceResponse = await axios.get(`${API_BASE_URL}/api/marketplace`, {
       headers: {
         'User-Agent': `skillscokac-cli/${VERSION}`
-      }
+      },
+      timeout: AXIOS_TIMEOUT
     })
 
     const marketplace = marketplaceResponse.data
@@ -125,15 +168,34 @@ async function fetchSkill(skillName, options = {}) {
         responseType: 'arraybuffer',
         headers: {
           'User-Agent': `skillscokac-cli/${VERSION}`
-        }
+        },
+        timeout: AXIOS_TIMEOUT,
+        maxContentLength: MAX_ZIP_SIZE
       }
     )
 
+    // Check ZIP file size
+    const zipSize = zipResponse.data.byteLength
+    if (zipSize > MAX_ZIP_SIZE) {
+      throw new Error(`Skill package too large (${Math.round(zipSize / 1024 / 1024)}MB). Maximum: ${Math.round(MAX_ZIP_SIZE / 1024 / 1024)}MB`)
+    }
+
     // Step 3: Extract ZIP
     if (spinner) spinner.text = 'Extracting files...'
     const zip = new AdmZip(Buffer.from(zipResponse.data))
     const zipEntries = zip.getEntries()
 
+    // Check total uncompressed size
+    let totalSize = 0
+    for (const entry of zipEntries) {
+      if (!entry.isDirectory) {
+        totalSize += entry.header.size
+        if (totalSize > MAX_ZIP_SIZE * 2) {
+          throw new Error('Skill package contains too much data (possible zip bomb)')
+        }
+      }
+    }
+
     // Find SKILL.md
     const skillMdEntry = zipEntries.find(entry =>
       entry.entryName.endsWith('SKILL.md') && !entry.isDirectory
@@ -309,6 +371,14 @@ async function installSkill(skill, installType, options = {}) {
  * Install skill command handler
  */
 async function installSkillCommand(skillName) {
+  // Validate skill name (fetchSkill also validates, but do it early)
+  try {
+    skillName = validateSkillName(skillName)
+  } catch (error) {
+    console.log(chalk.red(`✗ ${error.message}`))
+    process.exit(1)
+  }
+
   // Fetch skill
   const skill = await fetchSkill(skillName)
 
@@ -333,7 +403,8 @@ async function installCollectionCommand(collectionId) {
     const response = await axios.get(`${API_BASE_URL}/api/collections/${collectionId}`, {
       headers: {
         'User-Agent': `skillscokac-cli/${VERSION}`
-      }
+      },
+      timeout: AXIOS_TIMEOUT
     })
 
     const collection = response.data
@@ -468,6 +539,14 @@ function getSkillsFromDirectory(skillsDir) {
  * Remove skill command handler
  */
 async function removeSkillCommand(skillName, force = false) {
+  // Validate skill name
+  try {
+    skillName = validateSkillName(skillName)
+  } catch (error) {
+    console.log(chalk.red(`✗ ${error.message}`))
+    process.exit(1)
+  }
+
   // Check if skill exists in personal and/or project directories
   const personalSkillDir = path.join(os.homedir(), '.claude', 'skills', skillName)
   const projectSkillDir = path.join(process.cwd(), '.claude', 'skills', skillName)
@@ -679,6 +758,14 @@ async function removeAllSkillsCommand(force = false) {
  * Download skill command handler
  */
 async function downloadSkillCommand(skillName, downloadPath) {
+  // Validate skill name (fetchSkill also validates, but do it early)
+  try {
+    skillName = validateSkillName(skillName)
+  } catch (error) {
+    console.log(chalk.red(`✗ ${error.message}`))
+    process.exit(1)
+  }
+
   // Use current directory if no path specified
   if (!downloadPath) {
     downloadPath = process.cwd()
@@ -847,7 +934,7 @@ async function listInstalledSkillsCommand() {
 /**
  * Create skill on SkillsCokac API
  */
-async function createSkill(skillData, apiKey) {
+async function createSkill(skillData, apiKey, silent = false) {
   const payload = {
     type: 'SKILL',
     title: skillData.name,
@@ -858,31 +945,31 @@ async function createSkill(skillData, apiKey) {
     tags: skillData.tags || ['claude-code', 'agent-skill']
   }
 
-  const spinner = ora('Creating skill on SkillsCokac...').start()
-
   try {
     const response = await axios.post(`${API_BASE_URL}/api/posts`, payload, {
       headers: {
         'Authorization': `Bearer ${apiKey}`,
         'Content-Type': 'application/json',
         'User-Agent': `skillscokac-cli/${VERSION}`
-      }
+      },
+      timeout: AXIOS_TIMEOUT
     })
 
-    spinner.succeed(chalk.green('Skill created successfully!'))
-    const skill = response.data
-    console.log(chalk.dim('  ID: ') + chalk.cyan(skill.id))
-    console.log(chalk.dim('  URL: ') + chalk.cyan(`https://skills.cokac.com/s/${skill.id}`))
-    console.log()
-
-    return skill
+    return response.data
   } catch (error) {
-    spinner.fail(chalk.red('Failed to create skill'))
-    if (error.response) {
-      console.error(chalk.red('  Status:'), error.response.status)
-      console.error(chalk.red('  Response:'), error.response.data)
-    } else {
-      console.error(chalk.red('  Error:'), error.message)
+    // Handle 409 Conflict (skill name already exists)
+    if (error.response && error.response.status === 409) {
+      if (!silent) {
+        console.log(chalk.red('✗ Skill name already exists. Please choose a different name.'))
+      }
+    } else if (!silent) {
+      console.log(chalk.red('✗ Failed to create skill'))
+      if (error.response) {
+        console.error(chalk.red('  Status:'), error.response.status)
+        console.error(chalk.red('  Response:'), error.response.data)
+      } else {
+        console.error(chalk.red('  Error:'), error.message)
+      }
     }
     throw error
   }
@@ -891,9 +978,7 @@ async function createSkill(skillData, apiKey) {
 /**
  * Upload skill files to SkillsCokac API
  */
-async function uploadSkillFiles(skillId, skillDir, apiKey) {
-  const spinner = ora('Uploading additional files...').start()
-
+async function uploadSkillFiles(skillId, skillDir, apiKey, silent = false) {
   let uploadedCount = 0
   let failedCount = 0
   const files = []
@@ -932,21 +1017,27 @@ async function uploadSkillFiles(skillId, skillDir, apiKey) {
     findFiles(skillDir, skillDir)
 
     if (files.length === 0) {
-      spinner.succeed(chalk.green('No additional files to upload'))
-      return
+      return { uploadedCount: 0, failedCount: 0 }
     }
 
-    spinner.text = `Found ${files.length} file${files.length !== 1 ? 's' : ''} to upload...`
-
     for (const file of files) {
       try {
+        // Check file size before reading
+        const stats = fs.statSync(file.fullPath)
+        if (stats.size > MAX_FILE_SIZE) {
+          if (!silent) {
+            console.warn(chalk.yellow(`⚠ Skipping large file (${Math.round(stats.size / 1024 / 1024)}MB): ${file.relativePath}`))
+          }
+          failedCount++
+          continue
+        }
+
         // Try to read as text
         let content
         try {
           content = fs.readFileSync(file.fullPath, 'utf8')
         } catch (err) {
           // Skip binary files
-          spinner.warn(chalk.yellow(`  Skipping binary file: ${file.relativePath}`))
           continue
         }
 
@@ -955,8 +1046,6 @@ async function uploadSkillFiles(skillId, skillDir, apiKey) {
           content: content
         }
 
-        spinner.text = `Uploading: ${file.relativePath}`
-
         const response = await axios.post(
           `${API_BASE_URL}/api/posts/${skillId}/files`,
           filePayload,
@@ -965,7 +1054,8 @@ async function uploadSkillFiles(skillId, skillDir, apiKey) {
               'Authorization': `Bearer ${apiKey}`,
               'Content-Type': 'application/json',
               'User-Agent': `skillscokac-cli/${VERSION}`
-            }
+            },
+            timeout: AXIOS_TIMEOUT
           }
         )
 
@@ -976,22 +1066,14 @@ async function uploadSkillFiles(skillId, skillDir, apiKey) {
         }
       } catch (error) {
         failedCount++
-        console.error(chalk.red(`\n  ✗ Failed to upload: ${file.relativePath}`))
-        if (error.response) {
-          console.error(chalk.red('    Status:'), error.response.status)
-        }
       }
     }
 
-    if (failedCount === 0) {
-      spinner.succeed(chalk.green(`Uploaded ${uploadedCount} file${uploadedCount !== 1 ? 's' : ''}`))
-    } else {
-      spinner.warn(chalk.yellow(`Uploaded ${uploadedCount}, Failed ${failedCount}`))
-    }
-    console.log()
-
+    return { uploadedCount, failedCount }
   } catch (error) {
-    spinner.fail(chalk.red('Failed to upload files'))
+    if (!silent) {
+      console.error(chalk.red('Failed to upload files'))
+    }
     throw error
   }
 }
@@ -1027,21 +1109,10 @@ async function uploadSkillCommand(skillDir, apiKey) {
     process.exit(1)
   }
 
-  console.log(boxen(
-    chalk.bold.cyan('SkillsCokac Skill Uploader'),
-    {
-      padding: { top: 0, bottom: 0, left: 1, right: 1 },
-      borderStyle: 'round',
-      borderColor: 'cyan'
-    }
-  ))
-  console.log()
-  console.log(chalk.dim('  Directory: ') + chalk.white(resolvedSkillDir))
-  console.log()
-
+  let spinner
   try {
     // Step 1: Parse SKILL.md
-    const spinner = ora('Parsing SKILL.md...').start()
+    spinner = ora('Uploading skill...').start()
     const skillMdContent = fs.readFileSync(skillMdPath, 'utf8')
     const { metadata } = parseFrontmatter(skillMdContent)
 
@@ -1063,31 +1134,255 @@ async function uploadSkillCommand(skillDir, apiKey) {
       tags: ['claude-code', 'agent-skill']
     }
 
-    spinner.succeed(chalk.green('SKILL.md parsed'))
-    console.log(chalk.dim('  Name: ') + chalk.white(skillData.name))
-    console.log(chalk.dim('  Description: ') + chalk.white(skillData.description))
-    console.log()
-
     // Step 2: Create skill
-    const skill = await createSkill(skillData, apiKey)
+    spinner.text = 'Creating skill...'
+    const skill = await createSkill(skillData, apiKey, true)
 
     // Step 3: Upload additional files
-    await uploadSkillFiles(skill.id, resolvedSkillDir, apiKey)
+    spinner.text = 'Uploading files...'
+    const { uploadedCount, failedCount } = await uploadSkillFiles(skill.id, resolvedSkillDir, apiKey, true)
 
     // Success summary
-    console.log(boxen(
-      chalk.bold.green('✓ Upload complete!\n\n') +
-      chalk.dim('Skill URL: ') + chalk.cyan(`https://skills.cokac.com/s/${skill.id}`),
-      {
-        padding: { top: 0, bottom: 0, left: 1, right: 1 },
-        borderStyle: 'round',
-        borderColor: 'green'
+    const fileInfo = uploadedCount > 0 ? ` (${uploadedCount} file${uploadedCount !== 1 ? 's' : ''})` : ''
+    spinner.succeed(chalk.green(`Uploaded: ${skillData.name}${fileInfo}`))
+    console.log(chalk.cyan(`https://skills.cokac.com/p/${skill.id}`))
+
+  } catch (error) {
+    if (spinner) spinner.stop()
+    // Handle 409 Conflict (skill name already exists)
+    if (error.response && error.response.status === 409) {
+      console.log(chalk.red('✗ Skill name already exists. Please choose a different name.'))
+    } else {
+      console.error(chalk.red('✗ Upload failed:'), error.message)
+    }
+    process.exit(1)
+  }
+}
+
+/**
+ * Find skill by name
+ */
+async function findSkillByName(skillName, apiKey) {
+  try {
+    const response = await axios.get(`${API_BASE_URL}/api/skills/${skillName}`, {
+      headers: {
+        'Authorization': `Bearer ${apiKey}`,
+        'User-Agent': `skillscokac-cli/${VERSION}`
+      },
+      timeout: AXIOS_TIMEOUT
+    })
+    return response.data
+  } catch (error) {
+    if (error.response && error.response.status === 404) {
+      return null
+    }
+    throw error
+  }
+}
+
+/**
+ * Update skill using batch API
+ */
+async function updateSkillWithBatch(postId, skillMdContent, skillDir, apiKey, silent = false) {
+  // Collect all files to upload
+  const files = []
+
+  function findFiles(dir, baseDir) {
+    const entries = fs.readdirSync(dir, { withFileTypes: true })
+
+    for (const entry of entries) {
+      const fullPath = path.join(dir, entry.name)
+
+      if (entry.isDirectory()) {
+        if (entry.name.startsWith('.') || entry.name === '__pycache__' || entry.name === 'node_modules') {
+          continue
+        }
+        findFiles(fullPath, baseDir)
+      } else if (entry.isFile()) {
+        const relativePath = path.relative(baseDir, fullPath)
+        if (relativePath === 'SKILL.md') {
+          continue
+        }
+        if (entry.name.startsWith('.')) {
+          continue
+        }
+
+        // Check file size
+        const stats = fs.statSync(fullPath)
+        if (stats.size > MAX_FILE_SIZE) {
+          if (!silent) {
+            console.warn(chalk.yellow(`⚠ Skipping large file (${Math.round(stats.size / 1024 / 1024)}MB): ${relativePath}`))
+          }
+          continue
+        }
+
+        // Try to read as text
+        let content
+        try {
+          content = fs.readFileSync(fullPath, 'utf8')
+        } catch (err) {
+          // Skip binary files
+          continue
+        }
+
+        files.push({
+          path: relativePath.replace(/\\/g, '/'),
+          content: content
+        })
       }
-    ))
+    }
+  }
+
+  findFiles(skillDir, skillDir)
+
+  // Get existing files to delete
+  const existingSkill = await axios.get(`${API_BASE_URL}/api/posts/${postId}`, {
+    headers: {
+      'Authorization': `Bearer ${apiKey}`,
+      'User-Agent': `skillscokac-cli/${VERSION}`
+    },
+    timeout: AXIOS_TIMEOUT
+  })
+
+  const existingFiles = existingSkill.data.skillFiles || []
+
+  // Prepare batch payload
+  const batchPayload = {
+    skillMd: skillMdContent,
+    files: {
+      delete: existingFiles.map(f => ({ id: f.id })),
+      create: files
+    }
+  }
+
+  // Execute batch update
+  const response = await axios.post(
+    `${API_BASE_URL}/api/posts/${postId}/files/batch`,
+    batchPayload,
+    {
+      headers: {
+        'Authorization': `Bearer ${apiKey}`,
+        'Content-Type': 'application/json',
+        'User-Agent': `skillscokac-cli/${VERSION}`
+      },
+      timeout: AXIOS_TIMEOUT
+    }
+  )
+
+  return {
+    uploadedCount: files.length,
+    deletedCount: existingFiles.length
+  }
+}
+
+/**
+ * Upload or modify skill command handler
+ */
+async function uploadModifySkillCommand(skillDir, apiKey) {
+  // Validate API key
+  if (!apiKey) {
+    console.log(chalk.red('✗ API key is required'))
+    console.log(chalk.dim('Usage: npx skillscokac --uploadmodify <skillDir> --apikey <key>'))
+    console.log()
+    process.exit(1)
+  }
+
+  // Resolve skill directory
+  const resolvedSkillDir = path.resolve(skillDir)
+  const skillMdPath = path.join(resolvedSkillDir, 'SKILL.md')
+
+  // Validate directory exists
+  if (!fs.existsSync(resolvedSkillDir)) {
+    console.log(chalk.red(`✗ Directory not found: ${resolvedSkillDir}`))
     console.log()
+    process.exit(1)
+  }
+
+  // Validate SKILL.md exists
+  if (!fs.existsSync(skillMdPath)) {
+    console.log(chalk.red(`✗ SKILL.md not found in: ${resolvedSkillDir}`))
+    console.log(chalk.dim('  The skill directory must contain a SKILL.md file'))
+    console.log()
+    process.exit(1)
+  }
+
+  let spinner
+  try {
+    // Step 1: Parse SKILL.md
+    spinner = ora('Checking skill...').start()
+    const skillMdContent = fs.readFileSync(skillMdPath, 'utf8')
+    const { metadata } = parseFrontmatter(skillMdContent)
+
+    if (!metadata.name) {
+      spinner.fail(chalk.red('SKILL.md must have a "name" in frontmatter'))
+      process.exit(1)
+    }
+
+    if (!metadata.description) {
+      spinner.fail(chalk.red('SKILL.md must have a "description" in frontmatter'))
+      process.exit(1)
+    }
+
+    const skillName = metadata.name
+
+    // Step 2: Check if skill exists
+    spinner.text = 'Checking if skill exists...'
+    const existingSkill = await findSkillByName(skillName, apiKey)
+
+    if (existingSkill) {
+      // Update existing skill
+      console.log(chalk.yellow(`Skill "${skillName}" already exists. Updating...`))
+
+      spinner.text = 'Updating skill and files...'
+      const { uploadedCount, deletedCount } = await updateSkillWithBatch(
+        existingSkill.id,
+        skillMdContent,
+        resolvedSkillDir,
+        apiKey,
+        true
+      )
+
+      spinner.succeed(chalk.green(`Updated: ${skillName} (${uploadedCount} files)`))
+      console.log(chalk.dim(`  Deleted ${deletedCount} old file${deletedCount !== 1 ? 's' : ''}, uploaded ${uploadedCount} new file${uploadedCount !== 1 ? 's' : ''}`))
+      console.log(chalk.cyan(`https://skills.cokac.com/p/${existingSkill.id}`))
+    } else {
+      // Create new skill
+      console.log(chalk.cyan(`Skill "${skillName}" does not exist. Creating new...`))
+
+      const skillData = {
+        name: metadata.name,
+        description: metadata.description,
+        content: skillMdContent,
+        visibility: 'PUBLIC',
+        tags: ['claude-code', 'agent-skill']
+      }
+
+      spinner.text = 'Creating skill...'
+      const skill = await createSkill(skillData, apiKey, true)
+
+      spinner.text = 'Uploading files...'
+      const { uploadedCount } = await uploadSkillFiles(skill.id, resolvedSkillDir, apiKey, true)
+
+      const fileInfo = uploadedCount > 0 ? ` (${uploadedCount} file${uploadedCount !== 1 ? 's' : ''})` : ''
+      spinner.succeed(chalk.green(`Created: ${skillData.name}${fileInfo}`))
+      console.log(chalk.cyan(`https://skills.cokac.com/p/${skill.id}`))
+    }
 
   } catch (error) {
-    console.error(chalk.red('\n✗ Upload failed:'), error.message)
+    if (spinner) spinner.stop()
+
+    // Handle specific errors
+    if (error.response) {
+      if (error.response.status === 403) {
+        console.log(chalk.red('✗ Forbidden: You do not have permission to modify this skill'))
+      } else if (error.response.status === 401) {
+        console.log(chalk.red('✗ Unauthorized: Invalid API key'))
+      } else {
+        console.error(chalk.red('✗ Upload/Update failed:'), error.response.data?.error || error.message)
+      }
+    } else {
+      console.error(chalk.red('✗ Upload/Update failed:'), error.message)
+    }
     process.exit(1)
   }
 }
@@ -1107,6 +1402,7 @@ program
   .option('-c, --install-collection <collectionId>', 'Install all skills from a collection')
   .option('-d, --download <args...>', 'Download a skill to a directory (usage: --download <skillName> [path], defaults to current directory)')
   .option('-u, --upload <skillDir>', 'Upload a skill from a directory (requires --apikey)')
+  .option('-m, --uploadmodify <skillDir>', 'Upload or update a skill (creates if new, updates if exists, requires --apikey)')
   .option('--apikey <key>', 'API key for uploading skills')
   .option('-r, --remove-skill <skillName>', 'Remove an installed skill')
   .option('-f, --remove-skill-force <skillName>', 'Remove skill from all locations without confirmation')
@@ -1136,6 +1432,8 @@ const options = program.opts()
       await downloadSkillCommand(skillName, downloadPath)
     } else if (options.upload) {
       await uploadSkillCommand(options.upload, options.apikey)
+    } else if (options.uploadmodify) {
+      await uploadModifySkillCommand(options.uploadmodify, options.apikey)
     } else if (options.removeAllSkillsForce) {
       await removeAllSkillsCommand(true)
     } else if (options.removeAllSkills) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "skillscokac",
-  "version": "1.1.0",
+  "version": "1.4.0",
   "description": "CLI tool to install and manage Claude Code skills from skills.cokac.com",
   "main": "bin/skillscokac.js",
   "bin": {