claude-code-pack 1.0.0

package/src/install.mjs

@@ -0,0 +1,391 @@
+import { execSync } from 'node:child_process';
+import { existsSync, mkdirSync, readFileSync, writeFileSync, cpSync } from 'node:fs';
+import { join, dirname, resolve } from 'node:path';
+import { homedir } from 'node:os';
+import { fileURLToPath } from 'node:url';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const PACK_ROOT = resolve(__dirname, '..');
+
+const CLAUDE_DIR = join(homedir(), '.claude');
+const PLUGINS_DIR = join(CLAUDE_DIR, 'plugins');
+const MARKETPLACES_DIR = join(PLUGINS_DIR, 'marketplaces');
+const CACHE_DIR = join(PLUGINS_DIR, 'cache');
+const SKILLS_DIR = join(CLAUDE_DIR, 'skills');
+const SETTINGS_PATH = join(CLAUDE_DIR, 'settings.json');
+const KNOWN_MARKETPLACES_PATH = join(PLUGINS_DIR, 'known_marketplaces.json');
+const INSTALLED_PLUGINS_PATH = join(PLUGINS_DIR, 'installed_plugins.json');
+
+function log(icon, msg) {
+  console.log(`  ${icon} ${msg}`);
+}
+
+function ensureDir(dir) {
+  if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+}
+
+function readJSON(path, fallback = {}) {
+  try {
+    return JSON.parse(readFileSync(path, 'utf8'));
+  } catch {
+    return fallback;
+  }
+}
+
+function writeJSON(path, data) {
+  ensureDir(dirname(path));
+  writeFileSync(path, JSON.stringify(data, null, 2) + '\n');
+}
+
+function loadConfig() {
+  const configPath = join(PACK_ROOT, 'claude-pack.config.json');
+  return JSON.parse(readFileSync(configPath, 'utf8'));
+}
+
+function gitClone(repo, dest) {
+  if (existsSync(dest)) {
+    // Pull latest
+    try {
+      execSync(`git -C "${dest}" pull --ff-only`, { stdio: 'pipe' });
+      return 'updated';
+    } catch {
+      // If pull fails, remove and re-clone
+      execSync(`rm -rf "${dest}"`);
+    }
+  }
+  execSync(`git clone --depth 1 "https://github.com/${repo}.git" "${dest}"`, {
+    stdio: 'pipe',
+  });
+  return 'cloned';
+}
+
+function getPluginVersion(marketplaceDir, pluginName) {
+  // Try to read version from plugin's package.json or manifest
+  const candidates = [
+    join(marketplaceDir, 'plugin', 'package.json'),
+    join(marketplaceDir, 'package.json'),
+  ];
+  for (const p of candidates) {
+    try {
+      const pkg = JSON.parse(readFileSync(p, 'utf8'));
+      if (pkg.version) return pkg.version;
+    } catch { /* continue */ }
+  }
+  return '0.0.0';
+}
+
+function getGitCommitSha(dir) {
+  try {
+    return execSync(`git -C "${dir}" rev-parse HEAD`, { encoding: 'utf8' }).trim();
+  } catch {
+    return '';
+  }
+}
+
+function findPluginInstallPath(marketplaceDir, pluginName) {
+  // Look for a plugin/ subdirectory or the root
+  const pluginSubdir = join(marketplaceDir, 'plugin');
+  if (existsSync(pluginSubdir)) return pluginSubdir;
+  return marketplaceDir;
+}
+
+// ─── Plugin Installation ───────────────────────────────────────────────
+
+function installPlugins(config, flags) {
+  console.log('\n📦 Plugins');
+
+  // 1. Install official marketplace first (needed for external plugins)
+  const officialDir = join(MARKETPLACES_DIR, 'claude-plugins-official');
+  if (!existsSync(officialDir)) {
+    if (flags.dryRun) {
+      log('○', 'Would clone official marketplace: anthropics/claude-plugins-official');
+    } else {
+      log('↓', 'Cloning official marketplace...');
+      gitClone('anthropics/claude-plugins-official', officialDir);
+      log('✓', 'Official marketplace installed');
+    }
+  } else {
+    if (flags.dryRun) {
+      log('●', 'Official marketplace: already installed');
+    } else {
+      log('↻', 'Updating official marketplace...');
+      gitClone('anthropics/claude-plugins-official', officialDir);
+    }
+  }
+
+  // 2. Install third-party marketplaces
+  const knownMarketplaces = readJSON(KNOWN_MARKETPLACES_PATH);
+
+  for (const mp of config.marketplaces || []) {
+    const dest = join(MARKETPLACES_DIR, mp.name);
+    if (flags.dryRun) {
+      const exists = existsSync(dest);
+      log(exists ? '●' : '○', `Marketplace "${mp.name}": ${exists ? 'already installed' : `would clone ${mp.repo}`}`);
+    } else {
+      log('↓', `Installing marketplace "${mp.name}" from ${mp.repo}...`);
+      const result = gitClone(mp.repo, dest);
+      log('✓', `Marketplace "${mp.name}" ${result}`);
+    }
+
+    // Register in known_marketplaces.json
+    if (!flags.dryRun) {
+      knownMarketplaces[mp.name] = {
+        source: { source: 'github', repo: mp.repo },
+        installLocation: dest,
+        lastUpdated: new Date().toISOString(),
+      };
+    }
+  }
+
+  if (!flags.dryRun) {
+    // Also register official marketplace
+    knownMarketplaces['claude-plugins-official'] = {
+      source: { source: 'github', repo: 'anthropics/claude-plugins-official' },
+      installLocation: officialDir,
+      lastUpdated: new Date().toISOString(),
+    };
+    writeJSON(KNOWN_MARKETPLACES_PATH, knownMarketplaces);
+  }
+
+  // 3. Install and enable individual plugins
+  const installedPlugins = readJSON(INSTALLED_PLUGINS_PATH, { version: 2, plugins: {} });
+  if (!installedPlugins.version) installedPlugins.version = 2;
+  if (!installedPlugins.plugins) installedPlugins.plugins = {};
+
+  const settings = readJSON(SETTINGS_PATH);
+  if (!settings.enabledPlugins) settings.enabledPlugins = {};
+  if (!settings.extraKnownMarketplaces) settings.extraKnownMarketplaces = {};
+
+  for (const plugin of config.plugins || []) {
+    const pluginId = `${plugin.name}@${plugin.marketplace}`;
+    const marketplaceDir = join(MARKETPLACES_DIR, plugin.marketplace);
+    const alreadyInstalled = installedPlugins.plugins[pluginId];
+
+    if (alreadyInstalled && !flags.force) {
+      if (flags.dryRun) {
+        log('●', `Plugin "${pluginId}": already installed`);
+      } else {
+        log('●', `Plugin "${pluginId}": already installed (use --force to reinstall)`);
+      }
+    } else {
+      if (flags.dryRun) {
+        log('○', `Would install plugin "${pluginId}" from ${plugin.repo}`);
+      } else {
+        const version = getPluginVersion(marketplaceDir, plugin.name);
+        const sha = getGitCommitSha(marketplaceDir);
+        const pluginSrc = findPluginInstallPath(marketplaceDir, plugin.name);
+
+        // Cache the plugin
+        const cacheDir = join(CACHE_DIR, plugin.marketplace, plugin.name, version);
+        ensureDir(dirname(cacheDir));
+        if (existsSync(cacheDir) && flags.force) {
+          execSync(`rm -rf "${cacheDir}"`);
+        }
+        if (!existsSync(cacheDir)) {
+          cpSync(pluginSrc, cacheDir, { recursive: true });
+        }
+
+        installedPlugins.plugins[pluginId] = [
+          {
+            scope: 'user',
+            installPath: cacheDir,
+            version,
+            installedAt: new Date().toISOString(),
+            lastUpdated: new Date().toISOString(),
+            gitCommitSha: sha,
+          },
+        ];
+
+        log('✓', `Plugin "${pluginId}" installed (v${version})`);
+      }
+    }
+
+    // Enable plugin in settings
+    if (!flags.dryRun) {
+      if (plugin.enabled !== false) {
+        settings.enabledPlugins[pluginId] = true;
+      }
+      // Add marketplace to extraKnownMarketplaces in settings
+      const mp = (config.marketplaces || []).find((m) => m.name === plugin.marketplace);
+      if (mp) {
+        settings.extraKnownMarketplaces[mp.name] = {
+          source: { source: 'github', repo: mp.repo },
+        };
+      }
+    }
+  }
+
+  // Also register non-plugin marketplaces in settings
+  for (const mp of config.marketplaces || []) {
+    if (!flags.dryRun) {
+      settings.extraKnownMarketplaces[mp.name] = {
+        source: { source: 'github', repo: mp.repo },
+      };
+    }
+  }
+
+  if (!flags.dryRun) {
+    writeJSON(INSTALLED_PLUGINS_PATH, installedPlugins);
+    writeJSON(SETTINGS_PATH, settings);
+  }
+}
+
+// ─── Skill Installation ────────────────────────────────────────────────
+
+function installSkills(config, flags) {
+  console.log('\n🛠  Skills');
+
+  for (const skill of config.skills || []) {
+    const dest = join(SKILLS_DIR, skill.name);
+    const exists = existsSync(dest);
+
+    if (skill.source === 'bundled') {
+      // Copy from package's bundled skills/
+      const src = join(PACK_ROOT, 'skills', skill.name);
+      if (!existsSync(src)) {
+        log('✗', `Skill "${skill.name}": bundled source not found at ${src}`);
+        continue;
+      }
+
+      if (exists && !flags.force) {
+        if (flags.dryRun) {
+          log('●', `Skill "${skill.name}": already installed`);
+        } else {
+          log('●', `Skill "${skill.name}": already installed (use --force to overwrite)`);
+        }
+      } else {
+        if (flags.dryRun) {
+          log('○', `Would install bundled skill "${skill.name}"`);
+        } else {
+          ensureDir(SKILLS_DIR);
+          cpSync(src, dest, { recursive: true });
+          log('✓', `Skill "${skill.name}" installed (bundled)`);
+        }
+      }
+    } else if (skill.source === 'github' && skill.repo) {
+      // Clone from GitHub
+      if (exists && !flags.force) {
+        if (flags.dryRun) {
+          log('●', `Skill "${skill.name}": already installed`);
+        } else {
+          log('↻', `Updating skill "${skill.name}" from ${skill.repo}...`);
+          gitClone(skill.repo, dest);
+        }
+      } else {
+        if (flags.dryRun) {
+          log('○', `Would clone skill "${skill.name}" from ${skill.repo}`);
+        } else {
+          log('↓', `Cloning skill "${skill.name}" from ${skill.repo}...`);
+          const result = gitClone(skill.repo, dest);
+          log('✓', `Skill "${skill.name}" ${result}`);
+        }
+      }
+    } else {
+      log('✗', `Skill "${skill.name}": unknown source type "${skill.source}"`);
+    }
+  }
+}
+
+// ─── Settings Merge ────────────────────────────────────────────────────
+
+function installSettings(config, flags) {
+  console.log('\n⚙  Settings');
+
+  const settings = readJSON(SETTINGS_PATH);
+
+  // Merge model preference
+  if (config.settings?.model) {
+    if (flags.dryRun) {
+      log('○', `Would set model to "${config.settings.model}"`);
+    } else {
+      settings.model = config.settings.model;
+      log('✓', `Model set to "${config.settings.model}"`);
+    }
+  }
+
+  // Merge statusline
+  if (config.settings?.statusLine) {
+    if (flags.dryRun) {
+      log('○', 'Would configure statusline');
+    } else {
+      // Copy statusline script
+      if (config.assets?.statusline) {
+        const src = join(PACK_ROOT, config.assets.statusline);
+        const dest = join(CLAUDE_DIR, 'statusline-command.sh');
+        if (existsSync(src)) {
+          const content = readFileSync(src, 'utf8');
+          writeFileSync(dest, content, { mode: 0o755 });
+          log('✓', 'Statusline script installed');
+        }
+      }
+      // Resolve $HOME in the command
+      const cmd = config.settings.statusLine.command.replace('$HOME', homedir());
+      settings.statusLine = {
+        ...config.settings.statusLine,
+        command: cmd,
+      };
+      log('✓', 'Statusline configured');
+    }
+  }
+
+  // Merge MCP servers
+  if (config.mcpServers && Object.keys(config.mcpServers).length > 0) {
+    if (!settings.mcpServers) settings.mcpServers = {};
+    for (const [name, serverConfig] of Object.entries(config.mcpServers)) {
+      if (flags.dryRun) {
+        log('○', `Would configure MCP server "${name}"`);
+      } else {
+        settings.mcpServers[name] = serverConfig;
+        log('✓', `MCP server "${name}" configured`);
+      }
+    }
+  } else {
+    log('●', 'No MCP servers to configure (they come from plugins)');
+  }
+
+  if (!flags.dryRun) {
+    writeJSON(SETTINGS_PATH, settings);
+  }
+}
+
+// ─── Main Install ──────────────────────────────────────────────────────
+
+export async function install(flags = {}) {
+  const config = loadConfig();
+
+  console.log('╔══════════════════════════════════════════╗');
+  console.log('║         claude-pack installer            ║');
+  console.log('╚══════════════════════════════════════════╝');
+
+  if (flags.dryRun) {
+    console.log('\n  (dry run — no changes will be made)\n');
+  }
+
+  // Ensure base directories exist
+  if (!flags.dryRun) {
+    ensureDir(CLAUDE_DIR);
+    ensureDir(PLUGINS_DIR);
+    ensureDir(MARKETPLACES_DIR);
+    ensureDir(SKILLS_DIR);
+  }
+
+  // Check git is available
+  try {
+    execSync('git --version', { stdio: 'pipe' });
+  } catch {
+    console.error('\n  ✗ git is required but not found. Please install git first.');
+    process.exit(1);
+  }
+
+  if (!flags.skipPlugins) installPlugins(config, flags);
+  if (!flags.skipSkills) installSkills(config, flags);
+  if (!flags.skipSettings) installSettings(config, flags);
+
+  console.log('\n────────────────────────────────────────────');
+  if (flags.dryRun) {
+    console.log('  Dry run complete. Run without --dry-run to apply.');
+  } else {
+    console.log('  ✓ All done! Restart Claude Code to pick up changes.');
+  }
+  console.log('');
+}