@miphamai/cli 0.69.0 → 0.71.0

package/src/skills/marketplace.ts

@@ -0,0 +1,233 @@
+/**
+ * Marketplace sources — discover and install skills from any public GitHub
+ * repository that follows the standard `SKILL.md` (frontmatter name/description)
+ * convention. This lifts skill installation out of the hard-coded community
+ * registry so users can add any public repo as a source.
+ */
+import { parse as parseYaml } from 'yaml'
+import { homedir } from 'node:os'
+import { join } from 'node:path'
+import { spawn } from 'node:child_process'
+import { URL } from 'node:url'
+
+export const MARKETPLACES_PATH = join(homedir(), '.mipham', 'marketplaces.json')
+
+export interface SkillFrontmatter {
+  name: string
+  description: string
+}
+
+/**
+ * Parse a `SKILL.md` document's frontmatter for `name`/`description`. Returns
+ * null when there is no frontmatter, the YAML is invalid, or `name` is missing.
+ */
+export function parseSkillFrontmatter(content: string): SkillFrontmatter | null {
+  const src = content.replace(/^/, '')
+  const match = src.match(/^---\n([\s\S]*?)\n---/)
+  if (!match) return null
+  let data: Record<string, unknown>
+  try {
+    data = parseYaml(match[1] || '') as Record<string, unknown>
+  } catch {
+    return null
+  }
+  const name = typeof data.name === 'string' ? data.name.trim() : ''
+  if (!name) return null
+  const description = typeof data.description === 'string' ? data.description : ''
+  return { name, description }
+}
+
+export interface MarketplaceSource {
+  owner: string
+  repo: string
+}
+
+export const DEFAULT_MARKETPLACES: MarketplaceSource[] = [
+  { owner: 'anthropics', repo: 'claude-plugins-community' },
+  { owner: 'anthropics', repo: 'skills' },
+]
+
+/** owner/repo must be plain GitHub names (letters, digits, dot, dash, underscore). */
+export function isValidMarketplaceRef(owner: string, repo: string): boolean {
+  const valid = (s: string) => /^[a-zA-Z0-9._-]+$/.test(s) && s.length > 0
+  return valid(owner) && valid(repo)
+}
+
+/**
+ * Read the marketplace sources from disk. A missing or corrupt file falls back
+ * to the default Anthropic sources.
+ */
+export function readMarketplaces(readFile: (path: string) => string | null): MarketplaceSource[] {
+  const raw = readFile(MARKETPLACES_PATH)
+  if (raw === null) return [...DEFAULT_MARKETPLACES]
+  try {
+    const parsed = JSON.parse(raw)
+    if (!Array.isArray(parsed)) return [...DEFAULT_MARKETPLACES]
+    return parsed.filter(
+      (s): s is MarketplaceSource =>
+        !!s && typeof s === 'object' && typeof s.owner === 'string' && typeof s.repo === 'string',
+    )
+  } catch {
+    return [...DEFAULT_MARKETPLACES]
+  }
+}
+
+export function addMarketplace(
+  current: MarketplaceSource[],
+  owner: string,
+  repo: string,
+): { sources: MarketplaceSource[]; added: boolean } {
+  if (current.some((s) => s.owner === owner && s.repo === repo)) {
+    return { sources: current, added: false }
+  }
+  return { sources: [...current, { owner, repo }], added: true }
+}
+
+export function removeMarketplace(
+  current: MarketplaceSource[],
+  owner: string,
+  repo: string,
+): { sources: MarketplaceSource[]; removed: boolean } {
+  const sources = current.filter((s) => !(s.owner === owner && s.repo === repo))
+  return { sources, removed: sources.length !== current.length }
+}
+
+export interface DiscoveredSkill {
+  name: string
+  description: string
+  path: string
+}
+
+/** Minimal fetch shape (ok/json/text) so discovery is testable without real network. */
+export interface FetchLike {
+  (url: string): Promise<{ ok: boolean; json: () => Promise<unknown>; text: () => Promise<string> }>
+}
+
+/**
+ * List every `SKILL.md` blob path in a repository via the GitHub trees API.
+ * Returns [] on any failure (network, rate-limit, non-2xx).
+ */
+export async function listSkillPaths(
+  source: MarketplaceSource,
+  fetchFn: FetchLike,
+): Promise<string[]> {
+  const url = `https://api.github.com/repos/${source.owner}/${source.repo}/git/trees/HEAD?recursive=1`
+  try {
+    const res = await fetchFn(url)
+    if (!res.ok) return []
+    const data = (await res.json()) as { tree?: Array<{ path?: string; type?: string }> }
+    return (data.tree ?? [])
+      .filter((e) => e.type === 'blob' && e.path?.endsWith('SKILL.md'))
+      .map((e) => e.path!)
+  } catch {
+    return []
+  }
+}
+
+/**
+ * Discover every skill in a repository: list `SKILL.md` paths, fetch each from
+ * raw.githubusercontent.com, and parse its frontmatter for name/description.
+ */
+export async function discoverSkills(
+  source: MarketplaceSource,
+  fetchFn: FetchLike,
+  download: (url: string) => Promise<string>,
+): Promise<DiscoveredSkill[]> {
+  const paths = await listSkillPaths(source, fetchFn)
+  const skills = await Promise.all(
+    paths.map(async (path) => {
+      const rawUrl = `https://raw.githubusercontent.com/${source.owner}/${source.repo}/HEAD/${path}`
+      try {
+        const fm = parseSkillFrontmatter(await download(rawUrl))
+        return fm ? { name: fm.name, description: fm.description, path } : null
+      } catch {
+        return null
+      }
+    }),
+  )
+  return skills.filter((s): s is DiscoveredSkill => s !== null)
+}
+
+export interface FoundSkill {
+  name: string
+  description: string
+  source: MarketplaceSource
+  path: string
+  rawUrl: string
+}
+
+/**
+ * Search every marketplace source for a skill by name (first match wins, in
+ * source order). Returns null when no source exposes it.
+ */
+export async function findSkillInMarketplaces(
+  skillName: string,
+  sources: MarketplaceSource[],
+  fetchFn: FetchLike,
+  download: (url: string) => Promise<string>,
+): Promise<FoundSkill | null> {
+  for (const source of sources) {
+    const skills = await discoverSkills(source, fetchFn, download)
+    const found = skills.find((s) => s.name === skillName)
+    if (found) {
+      return {
+        name: found.name,
+        description: found.description,
+        source,
+        path: found.path,
+        rawUrl: `https://raw.githubusercontent.com/${source.owner}/${source.repo}/HEAD/${found.path}`,
+      }
+    }
+  }
+  return null
+}
+
+/** Allowed domains for remote skill installation. */
+const ALLOWED_DOMAINS = [
+  'raw.githubusercontent.com',
+  'github.com',
+  'gist.githubusercontent.com',
+  'gitlab.com',
+]
+
+/**
+ * Download a file over HTTPS via `curl` (spawn, no shell injection), restricted
+ * to known-safe domains. Async so multiple downloads can run in parallel.
+ */
+export async function downloadFile(rawUrl: string): Promise<string> {
+  let parsed: URL
+  try {
+    parsed = new URL(rawUrl)
+  } catch {
+    throw new Error(`Invalid URL: ${rawUrl}`)
+  }
+  if (parsed.protocol !== 'https:') {
+    throw new Error(`Only HTTPS URLs are allowed (got: ${parsed.protocol})`)
+  }
+  if (!ALLOWED_DOMAINS.some((d) => parsed.hostname === d || parsed.hostname.endsWith('.' + d))) {
+    throw new Error(
+      `Domain not allowed: ${parsed.hostname}. Allowed: ${ALLOWED_DOMAINS.join(', ')}`,
+    )
+  }
+
+  return new Promise<string>((resolve, reject) => {
+    const proc = spawn('curl', ['-fsSL', rawUrl], { stdio: ['pipe', 'pipe', 'pipe'] })
+    let stdout = ''
+    let stderr = ''
+    const timer = setTimeout(() => {
+      proc.kill()
+      reject(new Error(`Download timed out: ${rawUrl}`))
+    }, 15_000)
+    proc.stdout.on('data', (c) => (stdout += c))
+    proc.stderr.on('data', (c) => (stderr += c))
+    proc.on('error', (err) => {
+      clearTimeout(timer)
+      reject(new Error(`Failed to download: ${err.message}`))
+    })
+    proc.on('close', (code) => {
+      clearTimeout(timer)
+      if (code === 0) resolve(stdout)
+      else reject(new Error(`Download failed with status ${code}: ${stderr}`))
+    })
+  })
+}

package/src/skills/registry.ts

@@ -5,13 +5,19 @@
  * from remote sources (GitHub repos, direct URLs).
  */
 
-import { existsSync, mkdirSync, writeFileSync, readdirSync, unlinkSync } from 'node:fs'
+import {
+  existsSync,
+  mkdirSync,
+  writeFileSync,
+  readdirSync,
+  unlinkSync,
+  readFileSync,
+} from 'node:fs'
 import { join } from 'node:path'
 import { homedir } from 'node:os'
-import { spawnSync } from 'node:child_process'
-import { URL } from 'node:url'
 import type { MiphamConfig } from '../shared/types.js'
 import communitySkills from './community-registry.json'
+import { readMarketplaces, findSkillInMarketplaces, downloadFile } from './marketplace'
 
 const SKILLS_DIR = join(homedir(), '.mipham', 'skills')
 
@@ -117,17 +123,13 @@ function isMarketplaceAllowed(url: string, config?: MiphamConfig['marketplace'])
  * Clones the repo to a temp directory, copies the skill file(s),
  * and cleans up.
  */
-export function installSkill(
+export async function installSkill(
   skillName: string,
   marketplaceConfig?: MiphamConfig['marketplace'],
-): InstallResult {
+): Promise<InstallResult> {
   const entry = COMMUNITY_SKILLS.find((s) => s.name === skillName)
   if (!entry) {
-    return {
-      success: false,
-      name: skillName,
-      message: `Skill "${skillName}" not found in the registry. Use /browse-skills to see available skills.`,
-    }
+    return installFromMarketplace(skillName, marketplaceConfig)
   }
 
   // Check marketplace restrictions
@@ -165,7 +167,7 @@ export function installSkill(
   try {
     // Download the skill file from GitHub raw content
     const rawUrl = githubRawUrl(entry.url, entry.file || `${skillName}.SKILL.md`)
-    const content = downloadFile(rawUrl)
+    const content = await downloadFile(rawUrl)
 
     // Validate it's a proper skill file (has frontmatter)
     if (!content.includes('---')) {
@@ -193,13 +195,74 @@ export function installSkill(
   }
 }
 
+/**
+ * Install a skill by discovering it across the user's marketplace sources.
+ * Called when the name is not in the built-in community registry.
+ */
+async function installFromMarketplace(
+  skillName: string,
+  marketplaceConfig?: MiphamConfig['marketplace'],
+): Promise<InstallResult> {
+  const sources = readMarketplaces((p) => (existsSync(p) ? readFileSync(p, 'utf-8') : null))
+  const found = await findSkillInMarketplaces(skillName, sources, globalThis.fetch, downloadFile)
+
+  if (!found) {
+    return {
+      success: false,
+      name: skillName,
+      message: `Skill "${skillName}" not found in the registry or any marketplace. Use /browse-skills or /browse-marketplace.`,
+    }
+  }
+  if (!isMarketplaceAllowed(found.rawUrl, marketplaceConfig)) {
+    return {
+      success: false,
+      name: skillName,
+      message: `Skill "${skillName}" is from a blocked or unapproved marketplace: ${found.rawUrl}`,
+    }
+  }
+
+  const destPath = join(SKILLS_DIR, `${found.name}.SKILL.md`)
+  if (existsSync(destPath)) {
+    return {
+      success: false,
+      name: found.name,
+      message: `Skill "${found.name}" is already installed. Remove it first to reinstall.`,
+    }
+  }
+
+  mkdirSync(SKILLS_DIR, { recursive: true })
+  try {
+    const content = await downloadFile(found.rawUrl)
+    if (!content.includes('---')) {
+      return {
+        success: false,
+        name: found.name,
+        message: `Downloaded file does not appear to be a valid skill (missing frontmatter).`,
+      }
+    }
+    writeFileSync(destPath, content, 'utf-8')
+    return {
+      success: true,
+      name: found.name,
+      message: `Skill "${found.name}" installed from ${found.source.owner}/${found.source.repo} to ${destPath}\nRun /reload-skills to activate it.`,
+    }
+  } catch (err: unknown) {
+    const msg = err instanceof Error ? err.message : String(err)
+    return {
+      success: false,
+      name: found.name,
+      message: `Failed to install "${found.name}": ${msg}`,
+    }
+  }
+}
+
 /**
  * Install a skill from a direct URL (GitHub raw, gist, or any HTTP URL).
  */
-export function installSkillFromUrl(
+export async function installSkillFromUrl(
   url: string,
   marketplaceConfig?: MiphamConfig['marketplace'],
-): InstallResult {
+): Promise<InstallResult> {
   // Check marketplace restrictions
   if (!isMarketplaceAllowed(url, marketplaceConfig)) {
     return {
@@ -222,7 +285,7 @@ export function installSkillFromUrl(
   mkdirSync(destDir, { recursive: true })
 
   try {
-    const content = downloadFile(url)
+    const content = await downloadFile(url)
 
     if (!content.includes('---')) {
       return {
@@ -288,52 +351,3 @@ function githubRawUrl(repoUrl: string, file: string): string {
   const base = repoUrl.replace('https://github.com/', 'https://raw.githubusercontent.com/')
   return `${base}/main/${file}`
 }
-
-/** Allowed domains for remote skill installation */
-const ALLOWED_DOMAINS = [
-  'raw.githubusercontent.com',
-  'github.com',
-  'gist.githubusercontent.com',
-  'gitlab.com',
-]
-
-/**
- * Download a file from a URL using curl with spawn (no shell injection).
- * Only allows HTTPS URLs from known safe domains.
- */
-function downloadFile(rawUrl: string): string {
-  let parsed: URL
-  try {
-    parsed = new URL(rawUrl)
-  } catch {
-    throw new Error(`Invalid URL: ${rawUrl}`)
-  }
-
-  // Protocol must be HTTPS
-  if (parsed.protocol !== 'https:') {
-    throw new Error(`Only HTTPS URLs are allowed (got: ${parsed.protocol})`)
-  }
-
-  // Domain must be in allowlist
-  if (!ALLOWED_DOMAINS.some((d) => parsed.hostname === d || parsed.hostname.endsWith('.' + d))) {
-    throw new Error(
-      `Domain not allowed: ${parsed.hostname}. Allowed: ${ALLOWED_DOMAINS.join(', ')}`,
-    )
-  }
-
-  // Use spawnSync with args array — no shell, no injection
-  const result = spawnSync('curl', ['-fsSL', rawUrl], {
-    encoding: 'utf-8',
-    timeout: 15_000,
-    stdio: ['pipe', 'pipe', 'pipe'],
-  })
-
-  if (result.error) {
-    throw new Error(`Failed to download: ${result.error.message}`)
-  }
-  if (result.status !== 0) {
-    throw new Error(`Download failed with status ${result.status}`)
-  }
-
-  return result.stdout
-}

package/src/tools/exec/bash.ts

@@ -130,7 +130,10 @@ export function isBlocked(command: string): string | null {
 
   // Detect dangerous git operations invoked via Bash — anywhere in the command,
   // so `echo ok && git push --force` is still caught (not just `^git`).
-  if (/(?:^|[\s;&|])(?:sudo\s+)?(?:git|gh)\s+/.test(normalized)) {
+  // `gh` is deliberately NOT scanned: DANGEROUS_GIT_PATTERNS are all git
+  // subcommands (push/reset/clean/…), and scanning `gh` only produced false
+  // positives (e.g. `gh issue create --body "...git config user.name..."`).
+  if (/(?:^|[\s;&|])(?:sudo\s+)?git\s+/.test(normalized)) {
     for (const { pattern, description } of DANGEROUS_GIT_PATTERNS) {
       if (pattern.test(normalized)) {
         return `Dangerous git command blocked: "${description}". Run manually if intended.`