cli-profile-manager 0.0.1

package/src/utils/config.js

@@ -0,0 +1,102 @@
+import { homedir } from 'os';
+import { join } from 'path';
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs';
+
+const HOME = homedir();
+
+/**
+ * Find Claude directory - checks project root first (codespaces), then home
+ */
+function findClaudeDir() {
+  const candidates = [
+    join(process.cwd(), '.claude'),  // Project root (codespaces, dev environments)
+    join(HOME, '.claude'),           // Home directory (standard local install)
+  ];
+
+  for (const dir of candidates) {
+    if (existsSync(dir)) {
+      return dir;
+    }
+  }
+
+  // Default to home directory if not found
+  return join(HOME, '.claude');
+}
+
+// Default paths
+const DEFAULTS = {
+  claudeDir: findClaudeDir(),
+  profilesDir: join(HOME, '.claude-profiles'),
+  cacheDir: join(HOME, '.claude-profiles', '.cache'),
+  configFile: join(HOME, '.claude-profiles', 'config.json'),
+  marketplaceRepo: 'brrichards/cli-profile-manager'
+};
+
+/**
+ * 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,421 @@
+import { existsSync, mkdirSync, readdirSync, statSync, readFileSync, writeFileSync, cpSync, rmSync } from 'fs';
+import { join, dirname, sep } from 'path';
+import { getConfig, DEFAULTS } from './config.js';
+
+// Files/patterns to exclude by default (secrets, caches, infra)
+const DEFAULT_EXCLUDES = [
+  '.credentials',
+  '.auth',
+  '*.key',
+  '*.pem',
+  '*.secret',
+  'oauth_token*',
+  '.cache',
+  'node_modules',
+  '.git',
+  // Claude Code plugin infrastructure -- present in every install,
+  // not user-authored content. Excluded from snapshots and preserved
+  // during profile installs (cleanProfileContent).
+  'plugins/cache',
+  'plugins/install-counts-cache',
+  'plugins/installed_plugins',
+  'plugins/known_marketplaces',
+  'plugins/marketplaces'
+];
+
+// Plugin subdirectories that are Claude Code infrastructure.
+// These must be preserved when cleaning profile content.
+const PLUGIN_INFRA_DIRS = [
+  'cache',
+  'install-counts-cache',
+  'installed_plugins',
+  'known_marketplaces',
+  'marketplaces'
+];
+
+// Files that are safe to include (functional customizations only)
+const SAFE_INCLUDES = [
+  'CLAUDE.md',
+  'commands',
+  'commands/**',
+  'skills',
+  'skills/**',
+  'hooks',
+  'hooks/**',
+  'plugins',
+  'plugins/**',
+  'mcp.json',
+  'mcp_servers',
+  'mcp_servers/**',
+  'agents',
+  'agents/**'
+];
+
+/**
+ * Create a snapshot of the .claude folder by copying files directly
+ */
+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 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: []
+  };
+
+  // Get list of files to include
+  const files = getFilesToArchive(claudeDir, options.includeSecrets);
+  metadata.files = files;
+
+  // Copy each file into the profile directory
+  for (const file of files) {
+    const srcPath = join(claudeDir, file);
+    const destPath = join(profileDir, file);
+
+    // Ensure parent directory exists
+    mkdirSync(dirname(destPath), { recursive: true });
+
+    const content = readFileSync(srcPath);
+    writeFileSync(destPath, content);
+  }
+
+  // Derive structured contents from file list
+  metadata.contents = deriveContentsWithMcp(metadata.files, claudeDir);
+
+  // Save metadata
+  writeFileSync(metadataPath, JSON.stringify(metadata, null, 2));
+
+  return { profileDir, metadata };
+}
+
+/**
+ * Derive a structured contents summary from a list of file paths.
+ * Returns an object with category keys mapping to arrays of item names.
+ */
+export function deriveContents(files) {
+  const contents = {};
+
+  for (const file of files) {
+    const normalized = file.split(sep).join('/');
+
+    if (normalized === 'CLAUDE.md') {
+      if (!contents.instructions) contents.instructions = [];
+      contents.instructions.push('CLAUDE.md');
+      continue;
+    }
+
+    if (normalized === 'mcp.json') {
+      if (!contents.mcp) contents.mcp = [];
+      contents.mcp.push('mcp.json');
+      continue;
+    }
+
+    const parts = normalized.split('/');
+    if (parts.length >= 2) {
+      const category = parts[0];
+      const itemName = parts[1].replace(/\.[^.]+$/, ''); // strip extension
+      if (!contents[category]) contents[category] = [];
+      if (!contents[category].includes(itemName)) {
+        contents[category].push(itemName);
+      }
+    }
+  }
+
+  return contents;
+}
+
+/**
+ * Derive contents and try to enrich MCP server names from the actual mcp.json file
+ */
+function deriveContentsWithMcp(files, claudeDir) {
+  const contents = deriveContents(files);
+
+  if (contents.mcp && claudeDir) {
+    try {
+      const mcpPath = join(claudeDir, 'mcp.json');
+      if (existsSync(mcpPath)) {
+        const mcpData = JSON.parse(readFileSync(mcpPath, 'utf-8'));
+        const serverNames = Object.keys(mcpData.mcpServers || mcpData);
+        if (serverNames.length > 0) {
+          contents.mcp = serverNames;
+        }
+      }
+    } catch {
+      // Keep the fallback
+    }
+  }
+
+  return contents;
+}
+
+/**
+ * Get list of files to archive (using allowlist approach)
+ */
+export 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;
+
+      if (!isAllowed(entry, relPath)) {
+        continue;
+      }
+
+      if (shouldExclude(entry, relPath, excludes)) {
+        continue;
+      }
+
+      const stat = statSync(fullPath);
+
+      if (stat.isDirectory()) {
+        walk(fullPath, relPath);
+      } else {
+        // Always use forward slashes for portable metadata
+        files.push(relPath.split(sep).join('/'));
+      }
+    }
+  }
+
+  walk(dir);
+  return files;
+}
+
+/**
+ * Check if a file/folder is in the allowlist
+ */
+function isAllowed(name, path) {
+  const normalizedPath = path.split(sep).join('/');
+
+  for (const pattern of SAFE_INCLUDES) {
+    if (pattern.endsWith('/**')) {
+      const dirName = pattern.slice(0, -3);
+      if (normalizedPath.startsWith(dirName + '/') || normalizedPath === dirName) {
+        return true;
+      }
+    } else if (name === pattern || normalizedPath === pattern) {
+      return true;
+    }
+  }
+  return false;
+}
+
+/**
+ * Check if a file/folder should be excluded
+ */
+function shouldExclude(name, path, excludes) {
+  const normalizedPath = path.split(sep).join('/');
+  for (const pattern of excludes) {
+    if (pattern.startsWith('*.')) {
+      const ext = pattern.slice(1);
+      if (name.endsWith(ext)) return true;
+    } else if (name === pattern || normalizedPath === pattern) {
+      return true;
+    } else if (pattern.endsWith('*') && name.startsWith(pattern.slice(0, -1))) {
+      return true;
+    }
+  }
+  return false;
+}
+
+/**
+ * Extract a profile to the .claude folder by copying files directly.
+ * Uses a merge strategy to work even when Claude Code is running.
+ */
+export async function extractSnapshot(profileName, options = {}) {
+  const config = await getConfig();
+  const profileDir = join(config.profilesDir, profileName);
+  const claudeDir = config.claudeDir;
+
+  if (!existsSync(profileDir) || !existsSync(join(profileDir, 'profile.json'))) {
+    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 });
+  }
+
+  // Check if we need force flag
+  if (existsSync(claudeDir) && !options.force) {
+    throw new Error('Claude directory exists. Use --force to overwrite or --backup to save current config.');
+  }
+
+  // Ensure .claude directory exists
+  mkdirSync(claudeDir, { recursive: true });
+
+  // Clean out old profile content before installing new files
+  cleanProfileContent(claudeDir);
+
+  // Copy profile files (excluding profile.json) into .claude
+  copyProfileFiles(profileDir, claudeDir);
+
+  return { claudeDir };
+}
+
+/**
+ * Remove existing profile content from a .claude directory.
+ * Only removes items in the SAFE_INCLUDES allowlist (commands/, hooks/, etc.)
+ * so non-profile files (settings, credentials) are preserved.
+ */
+export function cleanProfileContent(claudeDir) {
+  // Directories to wipe entirely
+  const contentDirs = ['commands', 'skills', 'hooks', 'mcp_servers', 'agents'];
+  for (const dir of contentDirs) {
+    const dirPath = join(claudeDir, dir);
+    if (existsSync(dirPath)) {
+      rmSync(dirPath, { recursive: true, force: true });
+    }
+  }
+
+  // Plugins: only remove user-authored content, preserve Claude Code infra
+  const pluginsDir = join(claudeDir, 'plugins');
+  if (existsSync(pluginsDir)) {
+    for (const entry of readdirSync(pluginsDir)) {
+      if (!PLUGIN_INFRA_DIRS.includes(entry)) {
+        rmSync(join(pluginsDir, entry), { recursive: true, force: true });
+      }
+    }
+  }
+
+  // Individual files to remove
+  const contentFiles = ['CLAUDE.md', 'mcp.json'];
+  for (const file of contentFiles) {
+    const filePath = join(claudeDir, file);
+    if (existsSync(filePath)) {
+      rmSync(filePath, { force: true });
+    }
+  }
+}
+
+/**
+ * Copy profile content files (not profile.json) from source to destination.
+ */
+function copyProfileFiles(srcDir, destDir) {
+  const entries = readdirSync(srcDir, { withFileTypes: true });
+
+  for (const entry of entries) {
+    // Skip profile.json -- it's metadata, not a profile file
+    if (entry.name === 'profile.json') continue;
+
+    const srcPath = join(srcDir, entry.name);
+    const destPath = join(destDir, entry.name);
+
+    if (entry.isDirectory()) {
+      mkdirSync(destPath, { recursive: true });
+      copyDirMerge(srcPath, destPath);
+    } else {
+      try {
+        const content = readFileSync(srcPath);
+        writeFileSync(destPath, content);
+      } catch (err) {
+        if (err.code === 'EBUSY') {
+          throw new Error(`Cannot write to ${entry.name} - file is locked. Please close Claude Code and try again.`);
+        }
+        throw err;
+      }
+    }
+  }
+}
+
+/**
+ * Recursively copy/merge directory contents, overwriting files.
+ * This works even when the target directory has open file handles.
+ */
+export function copyDirMerge(src, dest) {
+  const entries = readdirSync(src, { withFileTypes: true });
+
+  for (const entry of entries) {
+    const srcPath = join(src, entry.name);
+    const destPath = join(dest, entry.name);
+
+    if (entry.isDirectory()) {
+      mkdirSync(destPath, { recursive: true });
+      copyDirMerge(srcPath, destPath);
+    } else {
+      try {
+        const content = readFileSync(srcPath);
+        writeFileSync(destPath, content);
+      } catch (err) {
+        if (err.code === 'EBUSY') {
+          throw new Error(`Cannot write to ${entry.name} - file is locked. Please close Claude Code and try again.`);
+        }
+        throw err;
+      }
+    }
+  }
+}
+
+/**
+ * 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'));
+    });
+}

package/test/cli.test.js

@@ -0,0 +1,22 @@
+import { describe, it } from 'node:test';
+import assert from 'node:assert';
+import { execSync } from 'child_process';
+import { join } from 'path';
+
+const CLI = join(import.meta.dirname, '..', 'src', 'cli.js');
+
+describe('CLI smoke test', () => {
+  it('--help exits 0 and shows expected commands', () => {
+    const output = execSync(`node ${CLI} --help`, { encoding: 'utf-8' });
+    assert.ok(output.includes('save'), 'should list save command');
+    assert.ok(output.includes('load'), 'should list load command');
+    assert.ok(output.includes('install'), 'should list install command');
+    assert.ok(output.includes('publish'), 'should list publish command');
+    assert.ok(output.includes('list'), 'should list list command');
+  });
+
+  it('--version outputs a version string', () => {
+    const output = execSync(`node ${CLI} --version`, { encoding: 'utf-8' });
+    assert.match(output.trim(), /^\d+\.\d+\.\d+$/);
+  });
+});

package/test/config.test.js

@@ -0,0 +1,15 @@
+import { describe, it } from 'node:test';
+import assert from 'node:assert';
+
+describe('config defaults', () => {
+  it('marketplaceRepo defaults to brrichards/cli-profile-manager', async () => {
+    const { DEFAULTS } = await import('../src/utils/config.js');
+    assert.strictEqual(DEFAULTS.marketplaceRepo, 'brrichards/cli-profile-manager');
+  });
+
+  it('getConfig returns the new marketplace repo', async () => {
+    const { getConfig } = await import('../src/utils/config.js');
+    const config = await getConfig();
+    assert.strictEqual(config.marketplaceRepo, 'brrichards/cli-profile-manager');
+  });
+});

package/test/references.test.js

@@ -0,0 +1,39 @@
+import { describe, it } from 'node:test';
+import assert from 'node:assert';
+import { readFileSync, readdirSync, statSync } from 'fs';
+import { join } from 'path';
+
+const ROOT = join(import.meta.dirname, '..');
+const OLD_REPO = 'brennanr9/claude-profile-manager';
+
+function collectFiles(dir, extensions) {
+  const results = [];
+  for (const entry of readdirSync(dir, { withFileTypes: true })) {
+    const full = join(dir, entry.name);
+    if (entry.name === 'node_modules' || entry.name === '.git') continue;
+    if (entry.isDirectory()) {
+      results.push(...collectFiles(full, extensions));
+    } else if (extensions.some(ext => entry.name.endsWith(ext))) {
+      results.push(full);
+    }
+  }
+  return results;
+}
+
+describe('repo reference cleanup', () => {
+  const extensions = ['.js', '.mjs', '.json', '.md', '.yml'];
+  const files = collectFiles(ROOT, extensions);
+
+  it('no source files reference the old repo', () => {
+    const violations = [];
+    for (const file of files) {
+      // Skip test files themselves and package-lock
+      if (file.includes('/test/') || file.includes('package-lock')) continue;
+      const content = readFileSync(file, 'utf-8');
+      if (content.includes(OLD_REPO)) {
+        violations.push(file.replace(ROOT + '/', ''));
+      }
+    }
+    assert.deepStrictEqual(violations, [], `Files still referencing ${OLD_REPO}: ${violations.join(', ')}`);
+  });
+});

package/test/snapshot.test.js

@@ -0,0 +1,61 @@
+import { describe, it } from 'node:test';
+import assert from 'node:assert';
+
+describe('deriveContents', () => {
+  it('categorizes files into correct content buckets', async () => {
+    const { deriveContents } = await import('../src/utils/snapshot.js');
+
+    const files = [
+      'CLAUDE.md',
+      'commands/review.md',
+      'commands/test-gen.md',
+      'hooks/pre-commit.md',
+      'mcp.json',
+      'skills/debugging/SKILL.md'
+    ];
+
+    const contents = deriveContents(files);
+
+    assert.deepStrictEqual(contents.instructions, ['CLAUDE.md']);
+    assert.deepStrictEqual(contents.commands, ['review', 'test-gen']);
+    assert.deepStrictEqual(contents.hooks, ['pre-commit']);
+    assert.deepStrictEqual(contents.mcp, ['mcp.json']);
+    assert.deepStrictEqual(contents.skills, ['debugging']);
+  });
+
+  it('returns empty object for empty file list', async () => {
+    const { deriveContents } = await import('../src/utils/snapshot.js');
+    const contents = deriveContents([]);
+    assert.deepStrictEqual(contents, {});
+  });
+});
+
+describe('getFilesToArchive', () => {
+  it('only includes files matching the allowlist', async () => {
+    const { getFilesToArchive } = await import('../src/utils/snapshot.js');
+    const { mkdirSync, writeFileSync, rmSync } = await import('fs');
+    const { join } = await import('path');
+    const { tmpdir } = await import('os');
+
+    // Create a temp .claude-like directory
+    const testDir = join(tmpdir(), `cpm-test-${Date.now()}`);
+    mkdirSync(join(testDir, 'commands'), { recursive: true });
+    mkdirSync(join(testDir, 'secrets'), { recursive: true });
+    writeFileSync(join(testDir, 'CLAUDE.md'), 'instructions');
+    writeFileSync(join(testDir, 'commands', 'foo.md'), 'command');
+    writeFileSync(join(testDir, 'secrets', 'key.pem'), 'secret');
+    writeFileSync(join(testDir, '.credentials'), 'creds');
+    writeFileSync(join(testDir, 'random.txt'), 'not allowed');
+
+    try {
+      const files = getFilesToArchive(testDir);
+      assert.ok(files.includes('CLAUDE.md'), 'should include CLAUDE.md');
+      assert.ok(files.includes('commands/foo.md'), 'should include commands/foo.md');
+      assert.ok(!files.includes('secrets/key.pem'), 'should not include secrets/');
+      assert.ok(!files.includes('.credentials'), 'should not include .credentials');
+      assert.ok(!files.includes('random.txt'), 'should not include random.txt');
+    } finally {
+      rmSync(testDir, { recursive: true, force: true });
+    }
+  });
+});