claude-code-pack 1.0.1 → 1.2.1

package/README.md

@@ -88,9 +88,21 @@ Everything is fetched fresh from GitHub, so you always get the latest version.
 
 | Setting | Value |
 |---------|-------|
-| **Model** | `opus` |
+| **Model (Claude Code)** | `opus` |
+| **Model (Codex)** | `gpt-5.4` (reasoning effort: `xhigh`) |
 | **Statusline** | Custom bash script with context window, 5h/7d rate limit bars, and color-coded usage indicators |
 
+### Codex Integration
+
+The installer also generates a `~/.codex/config.toml` that **reuses the same MCP servers and skills** as Claude Code — no duplicate configuration needed.
+
+| What | How it works |
+|------|-------------|
+| **MCP servers** | Generated into `config.toml` from the same `mcpServers` in `claude-pack.config.json` |
+| **Skills** | Installed to both `~/.claude/skills/` (Claude Code) and `~/.codex/skills/` (Codex) from the same bundled source |
+
+This means when you add a new MCP server or skill to the pack, both Claude Code and Codex pick it up.
+
 ## Commands
 
 ```bash
@@ -103,6 +115,7 @@ claude-pack install --force         # Overwrite existing installations
 claude-pack install --skip-plugins  # Skip plugin installation
 claude-pack install --skip-skills   # Skip skill installation
 claude-pack install --skip-settings # Skip settings merge
+claude-pack install --skip-codex    # Skip Codex config generation
 claude-pack install --dry-run       # Preview without changes
 ```
 

package/bin/claude-pack.mjs

@@ -11,6 +11,7 @@ const flags = {
   skipPlugins: args.includes('--skip-plugins'),
   skipSkills: args.includes('--skip-skills'),
   skipSettings: args.includes('--skip-settings'),
+  skipCodex: args.includes('--skip-codex'),
 };
 
 switch (command) {
@@ -44,5 +45,6 @@ Flags:
   --skip-plugins    Skip plugin installation
   --skip-skills     Skip skill installation
   --skip-settings   Skip settings merge
+  --skip-codex      Skip Codex config generation
 `);
 }

package/claude-pack.config.json

@@ -76,6 +76,33 @@
       "args": [
         "mcp-server-time"
       ]
+    },
+    "playwright": {
+      "command": "npx",
+      "args": ["-y", "@playwright/mcp@latest"]
+    },
+    "aws_knowledge_mcp": {
+      "type": "http",
+      "url": "https://knowledge-mcp.global.api.aws"
+    },
+    "awslabs_core_mcp_server": {
+      "command": "uvx",
+      "args": ["awslabs.core-mcp-server@latest"],
+      "env": { "FASTMCP_LOG_LEVEL": "ERROR" }
+    },
+    "awslabs_aws_api_mcp_server": {
+      "command": "uvx",
+      "args": ["awslabs.aws-api-mcp-server@latest"],
+      "env": { "AWS_REGION": "us-east-1" }
+    },
+    "awslabs_aws_documentation_mcp_server": {
+      "command": "uvx",
+      "args": ["awslabs.aws-documentation-mcp-server@latest"],
+      "env": { "FASTMCP_LOG_LEVEL": "ERROR", "AWS_DOCUMENTATION_PARTITION": "aws" }
+    },
+    "exa": {
+      "command": "npx",
+      "args": ["-y", "exa-mcp-server"]
     }
   },
   "settings": {
@@ -87,5 +114,11 @@
   },
   "assets": {
     "statusline": "assets/statusline-command.sh"
+  },
+  "codex": {
+    "enabled": true,
+    "model": "gpt-5.4",
+    "model_reasoning_effort": "xhigh",
+    "configPath": "$HOME/.codex/config.toml"
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-code-pack",
-  "version": "1.0.1",
+  "version": "1.2.1",
   "description": "Portable Claude Code setup — installs plugins, skills, MCP servers, and statusline on any machine",
   "type": "module",
   "bin": {

package/src/install.mjs

@@ -13,6 +13,8 @@ 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 CODEX_DIR = join(homedir(), '.codex');
+const CODEX_SKILLS_DIR = join(CODEX_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');
@@ -264,56 +266,55 @@ function installPlugins(config, flags) {
 
 // ─── 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;
-      }
+function installSkillTo(skill, targetDir, label, flags) {
+  const dest = join(targetDir, skill.name);
+  const exists = existsSync(dest);
 
-      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);
-        }
+  if (skill.source === 'bundled') {
+    const src = join(PACK_ROOT, 'skills', skill.name);
+    if (!existsSync(src)) {
+      log('✗', `${label} "${skill.name}": bundled source not found`);
+      return;
+    }
+    if (exists && !flags.force) {
+      log('●', `${label} "${skill.name}": already installed`);
+    } else if (flags.dryRun) {
+      log('○', `Would install bundled skill "${skill.name}" to ${label}`);
+    } else {
+      ensureDir(targetDir);
+      cpSync(src, dest, { recursive: true });
+      log('✓', `${label} "${skill.name}" installed`);
+    }
+  } else if (skill.source === 'github' && skill.repo) {
+    if (exists && !flags.force) {
+      if (flags.dryRun) {
+        log('●', `${label} "${skill.name}": already installed`);
       } 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}`);
-        }
+        log('↻', `Updating ${label} "${skill.name}" from ${skill.repo}...`);
+        gitClone(skill.repo, dest);
       }
+    } else if (flags.dryRun) {
+      log('○', `Would clone skill "${skill.name}" to ${label}`);
     } else {
-      log('✗', `Skill "${skill.name}": unknown source type "${skill.source}"`);
+      log('↓', `Cloning ${label} "${skill.name}" from ${skill.repo}...`);
+      const result = gitClone(skill.repo, dest);
+      log('✓', `${label} "${skill.name}" ${result}`);
+    }
+  } else {
+    log('✗', `${label} "${skill.name}": unknown source "${skill.source}"`);
+  }
+}
+
+function installSkills(config, flags) {
+  console.log('\n🛠  Skills (Claude Code → ~/.claude/skills/)');
+  for (const skill of config.skills || []) {
+    installSkillTo(skill, SKILLS_DIR, 'Claude', flags);
+  }
+
+  if (!flags.skipCodex && config.codex?.enabled) {
+    console.log('\n🛠  Skills (Codex → ~/.codex/skills/)');
+    for (const skill of config.skills || []) {
+      installSkillTo(skill, CODEX_SKILLS_DIR, 'Codex', flags);
     }
   }
 }
@@ -361,6 +362,7 @@ async function installSettings(config, flags) {
   }
 
   // Merge MCP servers
+  let resolvedFsPath = null;
   if (config.mcpServers && Object.keys(config.mcpServers).length > 0) {
     console.log('\n🔌 MCP Servers');
     if (!settings.mcpServers) settings.mcpServers = {};
@@ -377,6 +379,7 @@ async function installSettings(config, flags) {
         const answer = await prompt(`  Use "${home}" as filesystem root? [Y/n/custom path] `);
 
         if (answer === '' || answer.toLowerCase() === 'y' || answer.toLowerCase() === 'yes') {
+          resolvedFsPath = home;
           const resolved = JSON.parse(JSON.stringify(serverConfig));
           resolved.args = resolved.args.map((a) => a === '$HOME' ? home : a);
           settings.mcpServers[name] = resolved;
@@ -392,6 +395,7 @@ async function installSettings(config, flags) {
         } else {
           // User provided a custom path
           const customPath = answer.replace(/^~/, home);
+          resolvedFsPath = customPath;
           const resolved = JSON.parse(JSON.stringify(serverConfig));
           resolved.args = resolved.args.map((a) => a === '$HOME' ? customPath : a);
           settings.mcpServers[name] = resolved;
@@ -413,6 +417,110 @@ async function installSettings(config, flags) {
   if (!flags.dryRun) {
     writeJSON(SETTINGS_PATH, settings);
   }
+
+  return resolvedFsPath;
+}
+
+// ─── Codex Config Generation ───────────────────────────────────────────
+
+function tomlValue(val) {
+  if (typeof val === 'string') return `"${val}"`;
+  if (typeof val === 'boolean') return val ? 'true' : 'false';
+  if (typeof val === 'number') return String(val);
+  if (Array.isArray(val)) {
+    const items = val.map(tomlValue);
+    // Use multiline for long arrays
+    if (items.join(', ').length > 60) {
+      return '[\n  ' + items.join(',\n  ') + '\n]';
+    }
+    return '[' + items.join(', ') + ']';
+  }
+  return `"${val}"`;
+}
+
+function generateCodexToml(config, resolvedFsPath) {
+  const codex = config.codex;
+  const home = homedir();
+  const lines = [];
+
+  lines.push(`model = "${codex.model}"`);
+  if (codex.model_reasoning_effort) {
+    lines.push(`model_reasoning_effort = "${codex.model_reasoning_effort}"`);
+  }
+  lines.push('');
+
+  // Generate MCP server sections from the shared config
+  for (const [name, serverConfig] of Object.entries(config.mcpServers || {})) {
+    lines.push(`[mcp_servers.${name}]`);
+    lines.push('enabled = true');
+
+    if (serverConfig.type === 'http' || serverConfig.url) {
+      lines.push(`url = "${serverConfig.url}"`);
+    } else if (serverConfig.command) {
+      let command = serverConfig.command;
+      const args = serverConfig.args || [];
+
+      // For npx commands, resolve to full node/npx path for Codex compatibility
+      let resolvedArgs = args.map((a) => {
+        if (a === '$HOME') return resolvedFsPath || home;
+        return a;
+      });
+
+      lines.push(`command = "${command}"`);
+      if (resolvedArgs.length > 0) {
+        lines.push(`args = ${tomlValue(resolvedArgs)}`);
+      }
+    }
+
+    // Environment variables
+    if (serverConfig.env && Object.keys(serverConfig.env).length > 0) {
+      lines.push('');
+      lines.push(`[mcp_servers.${name}.env]`);
+      for (const [k, v] of Object.entries(serverConfig.env)) {
+        lines.push(`${k} = "${v}"`);
+      }
+    }
+
+    lines.push('');
+  }
+
+  return lines.join('\n');
+}
+
+async function installCodex(config, flags, resolvedFsPath) {
+  if (!config.codex?.enabled) return;
+
+  console.log('\n🤖 Codex');
+
+  const home = homedir();
+  const configPath = (config.codex.configPath || '$HOME/.codex/config.toml').replace(/\$HOME/g, home);
+  const configDir = dirname(configPath);
+
+  if (flags.dryRun) {
+    log('○', `Would generate Codex config at ${configPath}`);
+    log('○', `Model: ${config.codex.model}`);
+    const mcpCount = Object.keys(config.mcpServers || {}).length;
+    log('○', `MCP servers: ${mcpCount} (same as Claude Code)`);
+    return;
+  }
+
+  const toml = generateCodexToml(config, resolvedFsPath);
+  ensureDir(configDir);
+
+  const exists = existsSync(configPath);
+  if (exists && !flags.force) {
+    const answer = await prompt(`  Codex config exists at ${configPath}. Overwrite? [y/N] `);
+    if (answer.toLowerCase() !== 'y' && answer.toLowerCase() !== 'yes') {
+      log('⊘', 'Codex config skipped (use --force to overwrite)');
+      return;
+    }
+  }
+
+  writeFileSync(configPath, toml);
+  log('✓', `Codex config written to ${configPath}`);
+  log('✓', `Model: ${config.codex.model}`);
+  log('✓', `Skills: ~/.codex/skills/ (installed separately)`);
+  log('✓', `MCP servers: ${Object.keys(config.mcpServers || {}).length} configured`);
 }
 
 // ─── Main Install ──────────────────────────────────────────────────────
@@ -446,13 +554,19 @@ export async function install(flags = {}) {
 
   if (!flags.skipPlugins) installPlugins(config, flags);
   if (!flags.skipSkills) installSkills(config, flags);
-  if (!flags.skipSettings) await installSettings(config, flags);
+  let resolvedFsPath = null;
+  if (!flags.skipSettings) {
+    resolvedFsPath = await installSettings(config, flags);
+  }
+  if (!flags.skipCodex) {
+    await installCodex(config, flags, resolvedFsPath);
+  }
 
   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('  ✓ All done! Restart Claude Code / Codex to pick up changes.');
   }
   console.log('');
 }