claude-code-pack 1.0.1 → 1.2.0

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's shared |
+|------|----------------|
+| **MCP servers** | Generated into `config.toml` from the same `mcpServers` in `claude-pack.config.json` |
+| **Skills** | Codex `[[skills.config]]` points to `~/.claude/skills/` (the same directory Claude Code uses) |
+
+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

@@ -87,5 +87,12 @@
   },
   "assets": {
     "statusline": "assets/statusline-command.sh"
+  },
+  "codex": {
+    "enabled": true,
+    "model": "gpt-5.4",
+    "model_reasoning_effort": "xhigh",
+    "configPath": "$HOME/.codex/config.toml",
+    "skillsPath": "$HOME/.claude/skills"
   }
 }

package/package.json

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

package/src/install.mjs

@@ -361,6 +361,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 +378,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 +394,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 +416,118 @@ 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('');
+  }
+
+  // Skills — point to the shared ~/.claude/skills directory
+  const skillsPath = (codex.skillsPath || '$HOME/.claude/skills').replace(/\$HOME/g, home);
+  lines.push('[[skills.config]]');
+  lines.push(`path = "${skillsPath}"`);
+  lines.push('enabled = true');
+  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}`);
+    log('○', `Skills path: ~/.claude/skills (shared with Claude Code)`);
+    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: ~/.claude/skills (shared with Claude Code)`);
+  log('✓', `MCP servers: ${Object.keys(config.mcpServers || {}).length} configured`);
 }
 
 // ─── Main Install ──────────────────────────────────────────────────────
@@ -446,13 +561,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('');
 }