claude-profile-manager 1.0.0

package/src/commands/publish.js

@@ -0,0 +1,184 @@
+import chalk from 'chalk';
+import ora from 'ora';
+import inquirer from 'inquirer';
+import { existsSync, readFileSync, mkdirSync, cpSync, writeFileSync } from 'fs';
+import { join } from 'path';
+import { execSync } from 'child_process';
+import { getConfig, updateConfig, getProfilePath } from '../utils/config.js';
+import { readProfileMetadata } from '../utils/snapshot.js';
+
+/**
+ * Publish a local profile to the marketplace
+ */
+export async function publishProfile(name, options) {
+  const profilePath = getProfilePath(name);
+  
+  if (!existsSync(profilePath)) {
+    console.log(chalk.red(`✗ Profile not found: ${name}`));
+    console.log(chalk.dim('  List local profiles with: cpm local'));
+    process.exit(1);
+  }
+  
+  const metadata = readProfileMetadata(name);
+  
+  if (!metadata) {
+    console.log(chalk.red('✗ Invalid profile: missing metadata'));
+    process.exit(1);
+  }
+  
+  console.log('');
+  console.log(chalk.bold('Publish Profile to Marketplace'));
+  console.log(chalk.dim('─'.repeat(50)));
+  console.log('');
+  
+  // Get GitHub username
+  let gitUsername;
+  try {
+    gitUsername = execSync('git config user.name', { encoding: 'utf-8' }).trim();
+  } catch {
+    gitUsername = '';
+  }
+  
+  // Gather publication info
+  const answers = await inquirer.prompt([
+    {
+      type: 'input',
+      name: 'author',
+      message: 'Your GitHub username:',
+      default: gitUsername,
+      validate: (input) => {
+        if (!input || !/^[a-z0-9-]+$/i.test(input)) {
+          return 'Please enter a valid GitHub username';
+        }
+        return true;
+      }
+    },
+    {
+      type: 'input',
+      name: 'description',
+      message: 'Profile description:',
+      default: metadata.description || '',
+      validate: (input) => input.length >= 10 || 'Description must be at least 10 characters'
+    },
+    {
+      type: 'input',
+      name: 'tags',
+      message: 'Tags (comma-separated):',
+      default: metadata.tags?.join(', ') || '',
+      filter: (input) => input.split(',').map(t => t.trim().toLowerCase()).filter(Boolean)
+    },
+    {
+      type: 'confirm',
+      name: 'confirm',
+      message: 'Ready to publish?',
+      default: true
+    }
+  ]);
+  
+  if (!answers.confirm) {
+    console.log(chalk.yellow('Aborted.'));
+    process.exit(0);
+  }
+  
+  const config = await getConfig();
+  
+  console.log('');
+  console.log(chalk.bold('📦 Publishing Profile'));
+  console.log('');
+  console.log(chalk.dim('To publish your profile, you need to:'));
+  console.log('');
+  console.log(chalk.cyan('1.') + ' Fork the marketplace repository:');
+  console.log(chalk.dim(`   https://github.com/${config.marketplaceRepo}`));
+  console.log('');
+  console.log(chalk.cyan('2.') + ' Clone your fork locally:');
+  console.log(chalk.dim(`   git clone https://github.com/${answers.author}/claude-profile-marketplace`));
+  console.log('');
+  console.log(chalk.cyan('3.') + ' Copy your profile to the profiles directory:');
+  
+  const targetDir = `profiles/${answers.author}/${name}`;
+  console.log(chalk.dim(`   mkdir -p ${targetDir}`));
+  console.log(chalk.dim(`   cp -r ~/.claude-profiles/${name}/* ${targetDir}/`));
+  console.log('');
+  console.log(chalk.cyan('4.') + ' Update the profile metadata:');
+  console.log(chalk.dim(`   Edit ${targetDir}/profile.json`));
+  console.log('');
+  console.log(chalk.cyan('5.') + ' Commit and push:');
+  console.log(chalk.dim(`   git add .`));
+  console.log(chalk.dim(`   git commit -m "Add profile: ${answers.author}/${name}"`));
+  console.log(chalk.dim(`   git push origin main`));
+  console.log('');
+  console.log(chalk.cyan('6.') + ' Open a Pull Request on GitHub');
+  console.log('');
+  
+  // Offer to prepare the files
+  const { prepare } = await inquirer.prompt([{
+    type: 'confirm',
+    name: 'prepare',
+    message: 'Would you like me to prepare the files for you?',
+    default: true
+  }]);
+  
+  if (prepare) {
+    const exportDir = join(process.cwd(), 'publish-ready', answers.author, name);
+    mkdirSync(exportDir, { recursive: true });
+    
+    // Copy profile files
+    cpSync(profilePath, exportDir, { recursive: true });
+    
+    // Update metadata with author info
+    const updatedMetadata = {
+      ...metadata,
+      author: answers.author,
+      description: answers.description,
+      tags: answers.tags,
+      publishedAt: new Date().toISOString()
+    };
+    
+    writeFileSync(
+      join(exportDir, 'profile.json'),
+      JSON.stringify(updatedMetadata, null, 2)
+    );
+    
+    console.log('');
+    console.log(chalk.green('✓ Files prepared at:'));
+    console.log(chalk.cyan(`  ${exportDir}`));
+    console.log('');
+    console.log(chalk.dim('Copy these files to your fork of the marketplace repository.'));
+  }
+  
+  console.log('');
+}
+
+/**
+ * Set a custom marketplace repository
+ */
+export async function setRepository(repository) {
+  // Validate format
+  if (!/^[a-z0-9-]+\/[a-z0-9-]+$/i.test(repository)) {
+    console.log(chalk.red('✗ Invalid repository format. Use: owner/repo'));
+    process.exit(1);
+  }
+  
+  const spinner = ora('Validating repository...').start();
+  
+  try {
+    // Try to fetch the index to validate
+    const response = await fetch(
+      `https://raw.githubusercontent.com/${repository}/main/index.json`
+    );
+    
+    if (!response.ok && response.status !== 404) {
+      throw new Error(`Repository not accessible: ${response.status}`);
+    }
+    
+    await updateConfig({ marketplaceRepo: repository });
+    
+    spinner.succeed(chalk.green(`Repository set to: ${chalk.bold(repository)}`));
+    console.log('');
+    console.log(chalk.dim('Browse profiles with: ') + chalk.cyan('cpm list'));
+    
+  } catch (error) {
+    spinner.fail(chalk.red(`Failed to set repository: ${error.message}`));
+    process.exit(1);
+  }
+}

package/src/utils/config.js

@@ -0,0 +1,83 @@
+import { homedir } from 'os';
+import { join } from 'path';
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs';
+
+const HOME = homedir();
+
+// Default paths
+const DEFAULTS = {
+  claudeDir: join(HOME, '.claude'),
+  profilesDir: join(HOME, '.claude-profiles'),
+  cacheDir: join(HOME, '.claude-profiles', '.cache'),
+  configFile: join(HOME, '.claude-profiles', 'config.json'),
+  marketplaceRepo: 'YOUR_USERNAME/claude-profile-marketplace'
+};
+
+/**
+ * Ensure required directories exist
+ */
+export function ensureDirs() {
+  const dirs = [DEFAULTS.profilesDir, DEFAULTS.cacheDir];
+  for (const dir of dirs) {
+    if (!existsSync(dir)) {
+      mkdirSync(dir, { recursive: true });
+    }
+  }
+}
+
+/**
+ * Get current configuration
+ */
+export async function getConfig() {
+  ensureDirs();
+  
+  let userConfig = {};
+  
+  if (existsSync(DEFAULTS.configFile)) {
+    try {
+      userConfig = JSON.parse(readFileSync(DEFAULTS.configFile, 'utf-8'));
+    } catch (e) {
+      // Ignore invalid config
+    }
+  }
+  
+  return {
+    ...DEFAULTS,
+    ...userConfig
+  };
+}
+
+/**
+ * Update configuration
+ */
+export async function updateConfig(updates) {
+  ensureDirs();
+  
+  const current = await getConfig();
+  const newConfig = { ...current, ...updates };
+  
+  // Only save user-configurable options
+  const toSave = {
+    marketplaceRepo: newConfig.marketplaceRepo
+  };
+  
+  writeFileSync(DEFAULTS.configFile, JSON.stringify(toSave, null, 2));
+  
+  return newConfig;
+}
+
+/**
+ * Get the path for a local profile
+ */
+export function getProfilePath(name) {
+  return join(DEFAULTS.profilesDir, name);
+}
+
+/**
+ * Check if Claude directory exists
+ */
+export function claudeDirExists() {
+  return existsSync(DEFAULTS.claudeDir);
+}
+
+export { DEFAULTS };

package/src/utils/snapshot.js

@@ -0,0 +1,280 @@
+import { createWriteStream, createReadStream, existsSync, mkdirSync, readdirSync, statSync, rmSync, cpSync, readFileSync, writeFileSync } from 'fs';
+import { join, basename, relative } from 'path';
+import archiver from 'archiver';
+import extractZip from 'extract-zip';
+import { getConfig, DEFAULTS } from './config.js';
+
+// Files/patterns to exclude by default (secrets, caches, etc.)
+const DEFAULT_EXCLUDES = [
+  '.credentials',
+  '.auth',
+  '*.key',
+  '*.pem',
+  '*.secret',
+  'oauth_token*',
+  '.cache',
+  'node_modules',
+  '.git'
+];
+
+// Files that are safe to include
+const SAFE_INCLUDES = [
+  'settings.json',
+  'settings.local.json', 
+  'CLAUDE.md',
+  'commands',
+  'commands/**',
+  'projects',
+  'projects/**',
+  'templates',
+  'templates/**',
+  'hooks',
+  'hooks/**',
+  'mcp.json',
+  'mcp_servers',
+  'mcp_servers/**'
+];
+
+/**
+ * Create a snapshot of the .claude folder
+ */
+export async function createSnapshot(profileName, options = {}) {
+  const config = await getConfig();
+  const claudeDir = config.claudeDir;
+  const profileDir = join(config.profilesDir, profileName);
+  
+  if (!existsSync(claudeDir)) {
+    throw new Error(`Claude directory not found: ${claudeDir}`);
+  }
+  
+  // Create profile directory
+  if (existsSync(profileDir)) {
+    throw new Error(`Profile "${profileName}" already exists. Use a different name or delete the existing one.`);
+  }
+  
+  mkdirSync(profileDir, { recursive: true });
+  
+  const zipPath = join(profileDir, 'snapshot.zip');
+  const metadataPath = join(profileDir, 'profile.json');
+  
+  // Create metadata
+  const metadata = {
+    name: profileName,
+    version: '1.0.0',
+    description: options.description || '',
+    tags: options.tags ? options.tags.split(',').map(t => t.trim()) : [],
+    createdAt: new Date().toISOString(),
+    claudeVersion: await getClaudeVersion(),
+    platform: process.platform,
+    includesSecrets: options.includeSecrets || false,
+    files: []
+  };
+  
+  // Create zip archive
+  const output = createWriteStream(zipPath);
+  const archive = archiver('zip', { zlib: { level: 9 } });
+  
+  return new Promise((resolve, reject) => {
+    output.on('close', async () => {
+      // Save metadata
+      writeFileSync(metadataPath, JSON.stringify(metadata, null, 2));
+      resolve({ profileDir, metadata });
+    });
+    
+    archive.on('error', reject);
+    archive.on('entry', (entry) => {
+      metadata.files.push(entry.name);
+    });
+    
+    archive.pipe(output);
+    
+    // Add files from .claude directory
+    const files = getFilesToArchive(claudeDir, options.includeSecrets);
+    
+    for (const file of files) {
+      const fullPath = join(claudeDir, file);
+      const stat = statSync(fullPath);
+      
+      if (stat.isDirectory()) {
+        archive.directory(fullPath, file);
+      } else {
+        archive.file(fullPath, { name: file });
+      }
+    }
+    
+    archive.finalize();
+  });
+}
+
+/**
+ * Get list of files to archive (respecting excludes)
+ */
+function getFilesToArchive(dir, includeSecrets = false) {
+  const files = [];
+  const excludes = includeSecrets ? [] : DEFAULT_EXCLUDES;
+  
+  function walk(currentDir, relativePath = '') {
+    const entries = readdirSync(currentDir);
+    
+    for (const entry of entries) {
+      const fullPath = join(currentDir, entry);
+      const relPath = relativePath ? join(relativePath, entry) : entry;
+      
+      // Check exclusions
+      if (shouldExclude(entry, relPath, excludes)) {
+        continue;
+      }
+      
+      const stat = statSync(fullPath);
+      
+      if (stat.isDirectory()) {
+        walk(fullPath, relPath);
+      } else {
+        files.push(relPath);
+      }
+    }
+  }
+  
+  walk(dir);
+  return files;
+}
+
+/**
+ * Check if a file/folder should be excluded
+ */
+function shouldExclude(name, path, excludes) {
+  for (const pattern of excludes) {
+    if (pattern.startsWith('*.')) {
+      // Extension pattern
+      const ext = pattern.slice(1);
+      if (name.endsWith(ext)) return true;
+    } else if (name === pattern || path === pattern) {
+      return true;
+    } else if (pattern.endsWith('*') && name.startsWith(pattern.slice(0, -1))) {
+      return true;
+    }
+  }
+  return false;
+}
+
+/**
+ * Extract a snapshot to the .claude folder
+ */
+export async function extractSnapshot(profileName, options = {}) {
+  const config = await getConfig();
+  const profileDir = join(config.profilesDir, profileName);
+  const zipPath = join(profileDir, 'snapshot.zip');
+  const claudeDir = config.claudeDir;
+  
+  if (!existsSync(zipPath)) {
+    throw new Error(`Profile "${profileName}" not found or corrupted`);
+  }
+  
+  // Backup existing .claude if requested
+  if (options.backup && existsSync(claudeDir)) {
+    const backupName = `.claude-backup-${Date.now()}`;
+    const backupPath = join(DEFAULTS.profilesDir, backupName);
+    cpSync(claudeDir, backupPath, { recursive: true });
+  }
+  
+  // Clear existing .claude directory (if force or confirmed)
+  if (existsSync(claudeDir)) {
+    if (!options.force) {
+      throw new Error('Claude directory exists. Use --force to overwrite or --backup to save current config.');
+    }
+    rmSync(claudeDir, { recursive: true, force: true });
+  }
+  
+  // Create fresh .claude directory
+  mkdirSync(claudeDir, { recursive: true });
+  
+  // Extract snapshot
+  await extractZip(zipPath, { dir: claudeDir });
+  
+  return { claudeDir };
+}
+
+/**
+ * Extract a downloaded snapshot (from marketplace)
+ */
+export async function extractDownloadedSnapshot(zipBuffer, options = {}) {
+  const config = await getConfig();
+  const claudeDir = config.claudeDir;
+  const tempZip = join(config.cacheDir, `temp-${Date.now()}.zip`);
+  
+  // Write buffer to temp file
+  writeFileSync(tempZip, zipBuffer);
+  
+  try {
+    // Backup existing .claude if requested
+    if (options.backup && existsSync(claudeDir)) {
+      const backupName = `.claude-backup-${Date.now()}`;
+      const backupPath = join(DEFAULTS.profilesDir, backupName);
+      cpSync(claudeDir, backupPath, { recursive: true });
+    }
+    
+    // Clear existing .claude directory
+    if (existsSync(claudeDir)) {
+      if (!options.force) {
+        throw new Error('Claude directory exists. Use --force to overwrite or --backup to save current config.');
+      }
+      rmSync(claudeDir, { recursive: true, force: true });
+    }
+    
+    mkdirSync(claudeDir, { recursive: true });
+    await extractZip(tempZip, { dir: claudeDir });
+    
+    return { claudeDir };
+  } finally {
+    // Clean up temp file
+    if (existsSync(tempZip)) {
+      rmSync(tempZip);
+    }
+  }
+}
+
+/**
+ * Get Claude CLI version if installed
+ */
+async function getClaudeVersion() {
+  try {
+    const { execSync } = await import('child_process');
+    const version = execSync('claude --version', { encoding: 'utf-8' }).trim();
+    return version;
+  } catch {
+    return 'unknown';
+  }
+}
+
+/**
+ * Read profile metadata
+ */
+export function readProfileMetadata(profileName) {
+  const config = DEFAULTS;
+  const metadataPath = join(config.profilesDir, profileName, 'profile.json');
+  
+  if (!existsSync(metadataPath)) {
+    return null;
+  }
+  
+  return JSON.parse(readFileSync(metadataPath, 'utf-8'));
+}
+
+/**
+ * List all local profiles
+ */
+export function listLocalProfileNames() {
+  const profilesDir = DEFAULTS.profilesDir;
+  
+  if (!existsSync(profilesDir)) {
+    return [];
+  }
+  
+  return readdirSync(profilesDir)
+    .filter(name => {
+      if (name.startsWith('.')) return false;
+      const profilePath = join(profilesDir, name);
+      const stat = statSync(profilePath);
+      return stat.isDirectory() && existsSync(join(profilePath, 'profile.json'));
+    });
+}