@girardmedia/bootspring 1.2.0 → 2.0.3

package/cli/skill.js

@@ -5,8 +5,12 @@
 
 const utils = require('../core/utils');
 const entitlements = require('../core/entitlements');
+const tierEnforcement = require('../core/tier-enforcement');
 const telemetry = require('../core/telemetry');
-const skills = require('../skills');
+const api = require('../core/api-client');
+const auth = require('../core/auth');
+
+// Note: skills module removed - all content fetched from API (thin client)
 
 function trackTelemetry(event, payload) {
   try {
@@ -16,234 +20,302 @@ function trackTelemetry(event, payload) {
   }
 }
 
-function printBuiltInSkills() {
-  const categories = skills.getCategories();
-  for (const category of categories) {
-    const patterns = skills.getPatternsByCategory(category);
-    if (patterns.length === 0) continue;
-
-    console.log(`${utils.COLORS.bold}${category}${utils.COLORS.reset}`);
-    for (const pattern of patterns) {
-      const id = `${category}/${pattern}`;
-      const metadata = skills.getSkillMetadata(id);
-      const description = metadata?.description ? ` - ${metadata.description}` : '';
-      console.log(`  ${utils.COLORS.cyan}${id}${utils.COLORS.reset}${description}`);
+// Use centralized tier badge formatting
+const { formatTierBadge } = tierEnforcement;
+
+/**
+ * Fetch skills list from API (thin client)
+ */
+async function fetchSkillsList(options = {}) {
+  if (!auth.isAuthenticated()) {
+    return { error: 'auth_required' };
+  }
+
+  try {
+    const response = await api.listSkills(options);
+    return response;
+  } catch (error) {
+    if (error.status === 401) {
+      return { error: 'auth_required' };
     }
-    console.log('');
+    return { error: 'network_error', message: error.message };
   }
 }
 
-function printExternalSkills(options = {}) {
-  const {
-    limit = 20,
-    accessOptions = {}
-  } = options;
+/**
+ * Fetch skill content from API (thin client)
+ */
+async function fetchSkillContent(skillId) {
+  if (!auth.isAuthenticated()) {
+    return { error: 'auth_required' };
+  }
 
-  if (!skills.hasExternalSkillLibrary()) {
-    console.log(`${utils.COLORS.dim}No external skills catalog found${utils.COLORS.reset}\n`);
-    return;
+  try {
+    const response = await api.getSkillContent(skillId);
+    return response;
+  } catch (error) {
+    if (error.status === 403) {
+      return { error: 'upgrade_required', requiredTier: 'pro' };
+    }
+    if (error.status === 401) {
+      return { error: 'auth_required' };
+    }
+    if (error.status === 404) {
+      return { error: 'not_found' };
+    }
+    return { error: 'network_error', message: error.message };
   }
+}
+
+/**
+ * List skills from API (thin client)
+ */
+async function listSkills(options = {}) {
+  const { tierFilter, category } = options;
 
-  const externalIds = skills.listExternalSkills();
-  const { allowed: accessibleIds, denied } = entitlements.filterAccessibleSkills(externalIds, accessOptions);
-  const shown = accessibleIds.slice(0, limit);
+  // Check authentication
+  if (!auth.isAuthenticated()) {
+    console.log(`
+${utils.COLORS.cyan}${utils.COLORS.bold}⚡ Bootspring Skills${utils.COLORS.reset}
+${utils.COLORS.red}Authentication required${utils.COLORS.reset}
 
-  if (shown.length === 0) {
-    console.log(`${utils.COLORS.bold}external${utils.COLORS.reset}`);
-    console.log(`  ${utils.COLORS.dim}No external skills available for current entitlement${utils.COLORS.reset}\n`);
-    if (denied.length > 0) {
-      utils.print.dim(denied[0].reason);
-    }
+${utils.COLORS.dim}Skills are served from the API. Please log in:${utils.COLORS.reset}
+  ${utils.COLORS.cyan}bootspring auth login${utils.COLORS.reset}
+`);
     return;
   }
 
-  console.log(`${utils.COLORS.bold}external${utils.COLORS.reset}`);
-  for (const id of shown) {
-    const metadata = skills.getSkillMetadata(id);
-    const description = metadata?.description ? ` - ${metadata.description}` : '';
-    console.log(`  ${utils.COLORS.yellow}${id}${utils.COLORS.reset}${description}`);
-  }
+  const tierLabel = tierFilter ? ` (${tierFilter} tier)` : '';
+  console.log(`
+${utils.COLORS.cyan}${utils.COLORS.bold}⚡ Bootspring Skills${utils.COLORS.reset}${tierLabel}
+${utils.COLORS.dim}Code patterns served from API${utils.COLORS.reset}
+`);
+
+  const spinner = utils.createSpinner('Loading skills...');
+  spinner.start();
+
+  const result = await fetchSkillsList({ category });
 
-  if (accessibleIds.length > shown.length) {
-    const remaining = accessibleIds.length - shown.length;
-    console.log(`\n${utils.COLORS.dim}${remaining} more external skills hidden.${utils.COLORS.reset}`);
-    console.log(`${utils.COLORS.dim}Use --limit <n> or search with --external.${utils.COLORS.reset}`);
+  if (result.error === 'auth_required') {
+    spinner.fail('Authentication required');
+    console.log(`${utils.COLORS.dim}Run: bootspring auth login${utils.COLORS.reset}`);
+    return;
   }
-  if (denied.length > 0) {
-    console.log(`\n${utils.COLORS.dim}${denied.length} external skills locked by entitlement policy${utils.COLORS.reset}`);
+
+  if (result.error === 'network_error') {
+    spinner.fail('Failed to load skills');
+    console.log(`${utils.COLORS.dim}Check your internet connection.${utils.COLORS.reset}`);
+    return;
   }
-  console.log('');
-}
 
-function listSkills(options = {}) {
-  const {
-    includeExternal = false,
-    externalOnly = false,
-    limit = 20,
-    accessOptions = {}
-  } = options;
+  spinner.succeed(`Loaded ${result.skills?.length || 0} skills`);
 
-  console.log(`
-${utils.COLORS.cyan}${utils.COLORS.bold}⚡ Bootspring Skills${utils.COLORS.reset}
-${utils.COLORS.dim}Built-in patterns + optional external skill catalog${utils.COLORS.reset}
-`);
+  // Group skills by category
+  const categories = {};
+  for (const skill of result.skills || []) {
+    // Apply tier filter if specified
+    if (tierFilter && skill.tier !== tierFilter) continue;
 
-  if (!externalOnly) {
-    printBuiltInSkills();
+    if (!categories[skill.category]) {
+      categories[skill.category] = [];
+    }
+    categories[skill.category].push(skill);
   }
 
-  if (includeExternal || externalOnly) {
-    printExternalSkills({ limit, accessOptions });
+  // Display by category
+  for (const [cat, catSkills] of Object.entries(categories).sort()) {
+    console.log(`\n${utils.COLORS.bold}${cat}${utils.COLORS.reset}`);
+    for (const skill of catSkills) {
+      const tierBadge = formatTierBadge(skill.tier);
+      const lockIcon = skill.accessible ? '' : ` ${utils.COLORS.red}🔒${utils.COLORS.reset}`;
+      const description = skill.description ? ` - ${skill.description}` : '';
+      console.log(`  ${utils.COLORS.cyan}${skill.id}${utils.COLORS.reset} ${tierBadge}${lockIcon}${description}`);
+    }
   }
 
-  const builtInCount = skills.listSkills().length;
-  const externalCount = skills.hasExternalSkillLibrary() ? skills.listExternalSkills().length : 0;
-  console.log(`${utils.COLORS.dim}${builtInCount} built-in skills available${utils.COLORS.reset}`);
-  if (skills.hasExternalSkillLibrary()) {
-    console.log(`${utils.COLORS.dim}${externalCount} external skills indexed${utils.COLORS.reset}`);
-  }
+  const accessibleCount = (result.skills || []).filter(s => s.accessible).length;
+  const lockedCount = (result.skills || []).length - accessibleCount;
+
+  console.log(`\n${utils.COLORS.dim}${accessibleCount} skills available, ${lockedCount} locked${utils.COLORS.reset}`);
+  console.log(`${utils.COLORS.dim}Your tier: ${result.userTier || 'free'}${utils.COLORS.reset}`);
   console.log(`${utils.COLORS.dim}Use "bootspring skill show <id>" to view a skill${utils.COLORS.reset}`);
 }
 
-function showSkill(skillId, options = {}) {
-  // Require MCP for viewing skill content
-  if (!utils.requireMCP('Skill content viewing')) {
+/**
+ * Show skill content from API (thin client)
+ */
+async function showSkill(skillId, _options = {}) {
+  // Check authentication first
+  if (!auth.isAuthenticated()) {
+    console.log(`
+${utils.COLORS.cyan}${utils.COLORS.bold}⚡ Skill: ${skillId}${utils.COLORS.reset}
+${utils.COLORS.red}Authentication required${utils.COLORS.reset}
+
+${utils.COLORS.dim}Skill content is served from the API. Please log in:${utils.COLORS.reset}
+  ${utils.COLORS.cyan}bootspring auth login${utils.COLORS.reset}
+`);
     return;
   }
 
-  const {
-    includeExternal = false,
-    summary = false,
-    sections,
-    maxChars,
-    accessOptions = {}
-  } = options;
+  const isMCP = utils.isMCPContext();
+
+  const spinner = utils.createSpinner('Loading skill...');
+  spinner.start();
 
-  const metadata = skills.getSkillMetadata(skillId);
-  const resolvedSkillId = metadata?.id || skillId;
-  const access = entitlements.checkSkillAccess(resolvedSkillId, accessOptions);
+  const result = await fetchSkillContent(skillId);
 
-  if (!access.allowed) {
+  if (result.error === 'auth_required') {
+    spinner.fail('Authentication required');
+    console.log(`${utils.COLORS.dim}Run: bootspring auth login${utils.COLORS.reset}`);
+    return;
+  }
+
+  if (result.error === 'upgrade_required') {
+    spinner.fail('Upgrade required');
     trackTelemetry('premium_prompted', {
-      capability: 'external_skill',
-      skillId: resolvedSkillId,
-      mode: access.context?.mode,
-      tier: access.context?.tier,
-      reason: access.code
+      capability: 'premium_pattern',
+      skillId,
+      reason: 'upgrade_required'
     });
-    utils.print.error(access.reason);
+    console.log(tierEnforcement.getUpgradePrompt(`skill: ${skillId}`, result.requiredTier || 'pro'));
     return;
   }
 
-  const rawContent = skills.loadSkill(skillId, { includeExternal });
-
-  if (!rawContent) {
-    utils.print.error(`Skill not found: ${skillId}`);
+  if (result.error === 'not_found') {
+    spinner.fail('Skill not found');
     utils.print.dim('Try: bootspring skill list');
-    utils.print.dim('Or: bootspring skill search <query> --external');
     return;
   }
 
-  const content = skills.formatSkillContent(rawContent, {
-    summary,
-    sections,
-    maxChars
+  if (result.error === 'network_error') {
+    spinner.fail('Failed to load skill');
+    console.log(`${utils.COLORS.dim}Check your internet connection.${utils.COLORS.reset}`);
+    return;
+  }
+
+  spinner.succeed('Skill loaded');
+
+  const tierBadge = formatTierBadge(result.tier || 'free');
+
+  console.log(`
+${utils.COLORS.cyan}${utils.COLORS.bold}${result.name || skillId}${utils.COLORS.reset} ${tierBadge}
+${utils.COLORS.dim}ID: ${result.id || skillId} | Tier: ${result.tier || 'free'}${utils.COLORS.reset}
+`);
+
+  // Track successful access
+  trackTelemetry('skill_accessed', {
+    skillId: result.id || skillId,
+    tier: result.tier
   });
 
-  const headerName = metadata?.name || skillId;
-  const source = metadata?.source || 'built-in';
-  if (String(source).startsWith('external')) {
-    trackTelemetry('premium_unlocked', {
-      capability: 'external_skill',
-      skillId: metadata?.id || skillId,
-      mode: access.context?.mode,
-      tier: access.context?.tier,
-      reason: access.code
-    });
+  // In MCP mode, output full content
+  if (isMCP) {
+    console.log(result.content);
+    return;
+  }
+
+  // CLI mode - show content with truncation notice
+  const contentLines = result.content.split('\n');
+  const previewLines = contentLines.slice(0, 40);
+  const hasMore = contentLines.length > 40;
+
+  console.log(previewLines.join('\n'));
+
+  if (hasMore) {
+    console.log(`\n${utils.COLORS.dim}... (${contentLines.length - 40} more lines)${utils.COLORS.reset}`);
   }
 
   console.log(`
-${utils.COLORS.cyan}${utils.COLORS.bold}${headerName}${utils.COLORS.reset}
-${utils.COLORS.dim}ID: ${metadata?.id || skillId} | Source: ${source}${utils.COLORS.reset}
-`);
+${utils.COLORS.bold}Usage:${utils.COLORS.reset}
+  Copy the pattern above and adapt it to your project.
 
-  console.log(content);
+${utils.COLORS.yellow}${utils.COLORS.bold}Full Content in MCP Mode${utils.COLORS.reset}
+${utils.COLORS.dim}With MCP integration, skills are available directly in your AI assistant.${utils.COLORS.reset}
+  ${utils.COLORS.cyan}bootspring mcp start${utils.COLORS.reset}
+`);
 }
 
-function searchSkills(query, options = {}) {
-  const {
-    includeExternal = false,
-    externalOnly = false,
-    limit = 20,
-    accessOptions = {}
-  } = options;
-
-  let results = skills.searchSkills(query, {
-    includeExternal: includeExternal || externalOnly,
-    limit
-  });
+/**
+ * Search skills via API (thin client)
+ */
+async function searchSkills(query, options = {}) {
+  const { tierFilter } = options;
+
+  // Check authentication
+  if (!auth.isAuthenticated()) {
+    console.log(`
+${utils.COLORS.cyan}${utils.COLORS.bold}Search: "${query}"${utils.COLORS.reset}
+${utils.COLORS.red}Authentication required${utils.COLORS.reset}
+
+${utils.COLORS.dim}Skills are served from the API. Please log in:${utils.COLORS.reset}
+  ${utils.COLORS.cyan}bootspring auth login${utils.COLORS.reset}
+`);
+    return;
+  }
+
+  const spinner = utils.createSpinner('Searching...');
+  spinner.start();
+
+  const result = await fetchSkillsList({ search: query });
+
+  if (result.error) {
+    spinner.fail('Search failed');
+    console.log(`${utils.COLORS.dim}${result.message || 'Check your internet connection.'}${utils.COLORS.reset}`);
+    return;
+  }
+
+  spinner.succeed('Search complete');
+
+  let skills = result.skills || [];
 
-  if (externalOnly) {
-    results = results.filter(id => id.startsWith('external/'));
+  // Apply tier filter if specified
+  if (tierFilter) {
+    skills = skills.filter(s => s.tier === tierFilter);
   }
-  const filtered = entitlements.filterAccessibleSkills(results, accessOptions);
-  results = filtered.allowed;
 
+  const tierLabel = tierFilter ? ` (${tierFilter} tier)` : '';
   console.log(`
-${utils.COLORS.cyan}${utils.COLORS.bold}Search Results${utils.COLORS.reset}
+${utils.COLORS.cyan}${utils.COLORS.bold}Search Results${utils.COLORS.reset}${tierLabel}
 ${utils.COLORS.dim}Query: "${query}"${utils.COLORS.reset}
 `);
 
-  if (results.length === 0) {
+  if (skills.length === 0) {
     utils.print.warning('No matching skills found');
     utils.print.dim('Try: bootspring skill list');
     return;
   }
 
-  for (const id of results) {
-    const metadata = skills.getSkillMetadata(id);
-    const source = String(metadata?.source || '').startsWith('external') ? 'external' : 'built-in';
-    const description = metadata?.description ? ` - ${metadata.description}` : '';
-    const color = source === 'external' ? utils.COLORS.yellow : utils.COLORS.cyan;
-    console.log(`  ${color}${id}${utils.COLORS.reset} ${utils.COLORS.dim}[${source}]${utils.COLORS.reset}${description}`);
+  for (const skill of skills) {
+    const tierBadge = formatTierBadge(skill.tier);
+    const lockIcon = skill.accessible ? '' : ` ${utils.COLORS.red}🔒${utils.COLORS.reset}`;
+    const description = skill.description ? ` - ${skill.description}` : '';
+    console.log(`  ${utils.COLORS.cyan}${skill.id}${utils.COLORS.reset} ${tierBadge}${lockIcon}${description}`);
   }
 
-  console.log(`\n${utils.COLORS.dim}${results.length} match(es)${utils.COLORS.reset}`);
-  if (filtered.denied.length > 0) {
-    console.log(`${utils.COLORS.dim}${filtered.denied.length} result(s) hidden by entitlement policy${utils.COLORS.reset}`);
+  const accessibleCount = skills.filter(s => s.accessible).length;
+  const lockedCount = skills.length - accessibleCount;
+
+  console.log(`\n${utils.COLORS.dim}${skills.length} match(es)${utils.COLORS.reset}`);
+  if (lockedCount > 0) {
+    console.log(`${utils.COLORS.dim}${lockedCount} result(s) require upgrade${utils.COLORS.reset}`);
+    console.log(`${utils.COLORS.dim}Run: bootspring billing upgrade${utils.COLORS.reset}`);
   }
 }
 
-async function syncCatalog(options = {}) {
-  const {
-    manifestUrl,
-    contentBaseUrl,
-    token,
-    timeoutMs,
-    cacheDir,
-    manifestPublicKey,
-    requireManifestSignature
-  } = options;
-
-  const spinner = utils.createSpinner('Syncing external skill catalog').start();
-  try {
-    const result = await skills.syncExternalCatalog({
-      manifestUrl,
-      contentBaseUrl,
-      token,
-      timeoutMs,
-      cacheDir,
-      manifestPublicKey,
-      requireManifestSignature
-    });
-    spinner.succeed(`Synced ${result.fetched} external skills`);
-    if (result.skipped.length > 0) {
-      utils.print.warning(`Skipped ${result.skipped.length} skill(s): ${result.skipped.join(', ')}`);
-    }
-    utils.print.dim(`Cache: ${result.manifestPath}`);
-  } catch (error) {
-    spinner.fail(`Sync failed: ${error.message}`);
-  }
+/**
+ * Sync is no longer needed - thin client fetches from API
+ * @deprecated
+ */
+async function syncCatalog() {
+  console.log(`
+${utils.COLORS.cyan}${utils.COLORS.bold}Sync Not Required${utils.COLORS.reset}
+
+${utils.COLORS.dim}Skills are now served directly from the API.${utils.COLORS.reset}
+${utils.COLORS.dim}No local sync needed - content is always up to date.${utils.COLORS.reset}
+
+${utils.COLORS.bold}To view available skills:${utils.COLORS.reset}
+  ${utils.COLORS.cyan}bootspring skill list${utils.COLORS.reset}
+`);
 }
 
 function showHelp() {
@@ -257,36 +329,42 @@ ${utils.COLORS.cyan}Commands:${utils.COLORS.reset}
   ${utils.COLORS.cyan}list${utils.COLORS.reset}                      List built-in skills
   ${utils.COLORS.cyan}show${utils.COLORS.reset} <id>                 Show skill content
   ${utils.COLORS.cyan}search${utils.COLORS.reset} <query>            Search skills
-  ${utils.COLORS.cyan}sync${utils.COLORS.reset}                      Sync external catalog from remote manifest
 
 ${utils.COLORS.cyan}Options:${utils.COLORS.reset}
-  ${utils.COLORS.cyan}--external${utils.COLORS.reset}                Include external skills catalog
-  ${utils.COLORS.cyan}--external-only${utils.COLORS.reset}           External skills only
-  ${utils.COLORS.cyan}--limit <n>${utils.COLORS.reset}               Limit results (default: 20)
-  ${utils.COLORS.cyan}--summary${utils.COLORS.reset}                 Show concise summary for skill show
-  ${utils.COLORS.cyan}--sections a,b${utils.COLORS.reset}            Show matching sections for skill show
-  ${utils.COLORS.cyan}--max-chars <n>${utils.COLORS.reset}           Cap output size for skill show
-  ${utils.COLORS.cyan}--access-mode <mode>${utils.COLORS.reset}      Access mode: local (default) or server
-  ${utils.COLORS.cyan}--entitled <bool>${utils.COLORS.reset}         Entitlement override for external skills
-  ${utils.COLORS.cyan}--tier <tier>${utils.COLORS.reset}             Tier override: free, pro, team, enterprise
-  ${utils.COLORS.cyan}--manifest-url <url>${utils.COLORS.reset}      Remote manifest URL for skill sync
-  ${utils.COLORS.cyan}--content-base-url <url>${utils.COLORS.reset}  Base URL for SKILL.md files when missing contentUrl
-  ${utils.COLORS.cyan}--token <value>${utils.COLORS.reset}           Bearer token for remote catalog APIs
-  ${utils.COLORS.cyan}--cache-dir <path>${utils.COLORS.reset}        Override local skill cache directory
-  ${utils.COLORS.cyan}--manifest-public-key <pem>${utils.COLORS.reset} Public key for manifest signature verification
-  ${utils.COLORS.cyan}--require-signature <bool>${utils.COLORS.reset} Require remote manifest signature validation
+  ${utils.COLORS.cyan}--tier-filter <tier>${utils.COLORS.reset}      Filter by tier: free or pro
+  ${utils.COLORS.cyan}--category <cat>${utils.COLORS.reset}          Filter by category
+
+${utils.COLORS.cyan}Tier Information:${utils.COLORS.reset}
+  Skills are labeled with their tier: ${utils.COLORS.green}[FREE]${utils.COLORS.reset} or ${utils.COLORS.yellow}[PRO]${utils.COLORS.reset}
+  - FREE tier patterns are available to all authenticated users
+  - PRO tier patterns require a Pro subscription
+
+${utils.COLORS.cyan}Authentication:${utils.COLORS.reset}
+  All skill commands require authentication.
+  Run: ${utils.COLORS.cyan}bootspring auth login${utils.COLORS.reset}
 
 ${utils.COLORS.cyan}Examples:${utils.COLORS.reset}
   bootspring skill list
-  bootspring skill list --external
+  bootspring skill list --tier-filter=free
   bootspring skill search auth
-  bootspring skill search vercel --external
   bootspring skill show auth/clerk
-  bootspring skill show external/vercel-automation
-  bootspring skill sync --manifest-url https://api.bootspring.com/skills/manifest.json
+  bootspring skill show api/route-handler
 `);
 }
 
+/**
+ * Normalize tier filter value
+ */
+function normalizeTierFilter(value) {
+  if (!value) return undefined;
+  const normalized = String(value).trim().toLowerCase();
+  if (normalized === 'free' || normalized === 'pro' || normalized === 'premium') {
+    // Treat 'premium' as 'pro' for filtering purposes
+    return normalized === 'premium' ? 'pro' : normalized;
+  }
+  return undefined;
+}
+
 /**
  * Run skill command
  */
@@ -300,6 +378,10 @@ async function run(args) {
   const parsedLimit = parsedArgs.limit ? Number(parsedArgs.limit) : 20;
   const limit = Number.isFinite(parsedLimit) && parsedLimit > 0 ? parsedLimit : 20;
   const maxChars = parsedArgs['max-chars'] ? Number(parsedArgs['max-chars']) : undefined;
+
+  // Parse tier filter (for list/search filtering) separately from access tier
+  const tierFilter = normalizeTierFilter(parsedArgs['tier-filter'] || parsedArgs['filter-tier']);
+
   const accessOptions = {
     mode: parsedArgs['access-mode'],
     entitled: parsedArgs.entitled,
@@ -308,7 +390,7 @@ async function run(args) {
 
   switch (subcommand) {
     case 'list':
-      listSkills({ includeExternal, externalOnly, limit, accessOptions });
+      await listSkills({ tierFilter, category: parsedArgs.category });
       break;
 
     case 'show':
@@ -317,13 +399,7 @@ async function run(args) {
         utils.print.dim('Usage: bootspring skill show <id>');
         return;
       }
-      showSkill(subargs[0], {
-        includeExternal: true,
-        summary: Boolean(parsedArgs.summary),
-        sections: parsedArgs.sections,
-        maxChars,
-        accessOptions
-      });
+      await showSkill(subargs[0], {});
       break;
 
     case 'search':
@@ -332,19 +408,11 @@ async function run(args) {
         utils.print.dim('Usage: bootspring skill search <query>');
         return;
       }
-      searchSkills(subargs.join(' '), { includeExternal, externalOnly, limit, accessOptions });
+      await searchSkills(subargs.join(' '), { tierFilter });
       break;
 
     case 'sync':
-      await syncCatalog({
-        manifestUrl: parsedArgs['manifest-url'],
-        contentBaseUrl: parsedArgs['content-base-url'],
-        token: parsedArgs.token,
-        timeoutMs: parsedArgs.timeout,
-        cacheDir: parsedArgs['cache-dir'],
-        manifestPublicKey: parsedArgs['manifest-public-key'],
-        requireManifestSignature: parsedArgs['require-signature']
-      });
+      await syncCatalog();
       break;
 
     case 'help':
@@ -355,13 +423,7 @@ async function run(args) {
 
     default:
       // Shortcut: `bootspring skill auth/clerk`
-      showSkill(subcommand, {
-        includeExternal: true,
-        summary: Boolean(parsedArgs.summary),
-        sections: parsedArgs.sections,
-        maxChars,
-        accessOptions
-      });
+      await showSkill(subcommand, {});
   }
 }