claude-all-config 3.7.7 → 3.8.1

package/VERSION

@@ -1 +1 @@
-3.7.7
+3.8.1

package/codex

@@ -0,0 +1,49 @@
+#!/usr/bin/env bash
+#
+# codex — ClaudeAll shim that:
+#   1. Sources ~/.codex/.env (and ~/.claude/.env as fallback) so MCP servers
+#      see CONTEXT7_API_KEY / EXA_API_KEY / Z_AI_API_KEY / TELEGRAM_* / etc.
+#   2. Forwards all args to the REAL codex binary further down PATH.
+#
+# Bypass this shim entirely:
+#   command -v codex -a       # see all codex binaries
+#   /usr/local/bin/codex ...  # call the real one directly
+
+set -u
+
+# ─── Source env files (most-specific first) ───────────────────────────────
+load_env() {
+    local f="$1"
+    if [ -f "$f" ]; then
+        set -a
+        # shellcheck disable=SC1090
+        . "$f" 2>/dev/null || true
+        set +a
+    fi
+}
+load_env "$HOME/.claude/.env"
+load_env "$HOME/.codex/.env"
+
+# ─── Find the REAL codex binary (skip ourselves) ──────────────────────────
+SELF="$(readlink -f "$0" 2>/dev/null || realpath "$0" 2>/dev/null || echo "$0")"
+
+REAL_CODEX=""
+IFS=':' read -ra DIRS <<< "$PATH"
+for dir in "${DIRS[@]}"; do
+    candidate="$dir/codex"
+    [ -x "$candidate" ] || continue
+    candidate_real="$(readlink -f "$candidate" 2>/dev/null || realpath "$candidate" 2>/dev/null || echo "$candidate")"
+    if [ "$candidate_real" = "$SELF" ]; then
+        continue
+    fi
+    REAL_CODEX="$candidate"
+    break
+done
+
+if [ -z "$REAL_CODEX" ]; then
+    echo "❌ ClaudeAll codex shim: real codex binary not found in PATH." >&2
+    echo "   Install: npm install -g @openai/codex" >&2
+    exit 127
+fi
+
+exec "$REAL_CODEX" "$@"

package/codex-all

@@ -0,0 +1,42 @@
+#!/usr/bin/env bash
+#
+# codex-all — Codex CLI launcher with ClaudeAll superpowers loaded.
+#
+# What it does:
+#   1. Source ~/.codex/.env (and ~/.claude/.env as fallback) so MCP servers
+#      see CONTEXT7_API_KEY / EXA_API_KEY / Z_AI_API_KEY / TELEGRAM_* / etc.
+#   2. Forward all args to the codex binary further down PATH.
+#
+# Usage:
+#   codex-all                      # interactive session
+#   codex-all "your prompt"        # one-shot
+#   codex-all exec ...             # subcommands
+#
+# Override:
+#   CODEX_BIN=/path/to/codex codex-all
+
+set -u
+
+# ─── Source env files (most-specific first) ───────────────────────────────
+load_env() {
+    local f="$1"
+    if [ -f "$f" ]; then
+        set -a
+        # shellcheck disable=SC1090
+        . "$f" 2>/dev/null || true
+        set +a
+    fi
+}
+load_env "$HOME/.claude/.env"
+load_env "$HOME/.codex/.env"
+
+# ─── Locate codex binary ──────────────────────────────────────────────────
+CODEX_CMD="${CODEX_BIN:-codex}"
+if ! command -v "$CODEX_CMD" &>/dev/null; then
+    echo "❌ codex CLI not found in PATH." >&2
+    echo "   Install: npm install -g @openai/codex" >&2
+    echo "   Or set CODEX_BIN=/path/to/codex" >&2
+    exit 127
+fi
+
+exec "$CODEX_CMD" "$@"

package/kiro-all

@@ -0,0 +1,38 @@
+#!/usr/bin/env bash
+#
+# kiro-all — Kiro CLI launcher with ClaudeAll secrets loaded.
+#
+# Sources ~/.kiro/.env (and ~/.claude/.env as fallback), then forwards to the
+# real kiro-cli (or `kiro` if your install uses that name).
+
+set -u
+
+load_env() {
+    local f="$1"
+    if [ -f "$f" ]; then
+        set -a
+        # shellcheck disable=SC1090
+        . "$f" 2>/dev/null || true
+        set +a
+    fi
+}
+load_env "$HOME/.claude/.env"
+load_env "$HOME/.kiro/.env"
+
+# Locate kiro binary (prefer kiro-cli; fall back to kiro)
+KIRO_CMD=""
+for cand in "${KIRO_BIN:-}" kiro-cli kiro; do
+    [ -z "$cand" ] && continue
+    if command -v "$cand" &>/dev/null; then
+        KIRO_CMD="$cand"
+        break
+    fi
+done
+
+if [ -z "$KIRO_CMD" ]; then
+    echo "❌ kiro-cli not found in PATH." >&2
+    echo "   See https://kiro.dev for install instructions." >&2
+    exit 127
+fi
+
+exec "$KIRO_CMD" "$@"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-all-config",
-  "version": "3.7.7",
+  "version": "3.8.1",
   "description": "🦾 MONSTER ENGINEER v2 - Ultimate AI CLI with 63 Skills, 12 Superpowers, 14 Agents. Multi-Agent Orchestration, Cost-Aware, Security Scorecard, Parallel-First.",
   "main": "index.js",
   "bin": {
@@ -8,7 +8,9 @@
     "claude-all-skills": "./bin/skills-cli.js",
     "claude-all-update": "./update.sh",
     "claude-all-mcp": "./bin/mcp-install.js",
-    "gemini-all": "./gemini-all"
+    "gemini-all": "./gemini-all",
+    "codex-all": "./codex-all",
+    "kiro-all": "./kiro-all"
   },
   "scripts": {
     "postinstall": "node postinstall.js || bash install.sh",
@@ -89,6 +91,9 @@
     "claude-all",
     "gemini-all",
     "gemini",
+    "codex-all",
+    "codex",
+    "kiro-all",
     "install.sh",
     "install-termux.sh",
     "install-universal.sh",

package/postinstall.js

@@ -147,12 +147,16 @@ function mergeEnvFile(srcPath, destPath) {
 
 const hasClaude = commandExists('claude');
 const hasGemini = commandExists('gemini');
+const hasCodex  = commandExists('codex');
+const hasKiro   = commandExists('kiro') || commandExists('kiro-cli');
 
 console.log('🤖 ClaudeAll - Installing configurations...\n');
 
 if (hasClaude) console.log('✅ Claude CLI detected');
 if (hasGemini) console.log('✅ Gemini CLI detected');
-if (!hasClaude && !hasGemini) {
+if (hasCodex)  console.log('✅ Codex CLI detected');
+if (hasKiro)   console.log('✅ Kiro CLI detected');
+if (!hasClaude && !hasGemini && !hasCodex && !hasKiro) {
   console.log('⚠️  No CLI detected, installing configs anyway...');
 }
 console.log('');
@@ -428,6 +432,200 @@ function installGemini() {
   console.log(`   ⚙️  settings.json (MONSTER ENGINEER + auto-approve)`);
 }
 
+// Install to Codex (~/.codex/) — Codex CLI from OpenAI uses TOML config and
+// AGENTS.md for global instructions (analogous to CLAUDE.md / GEMINI.md).
+function installCodex() {
+  const CODEX_DIR = path.join(HOME, '.codex');
+  console.log('📦 Installing to Codex (~/.codex/)...');
+
+  // Create directories — Codex looks for skills directly under ~/.codex/skills/
+  const dirs = ['agents', 'skills', 'commands', 'hooks', 'lib'];
+  dirs.forEach(dir => {
+    const targetDir = path.join(CODEX_DIR, dir);
+    try {
+      if (!fs.existsSync(targetDir)) fs.mkdirSync(targetDir, { recursive: true });
+    } catch {}
+  });
+
+  // Copy content (resilient to root-owned existing files)
+  const agentCount = copyDir(path.join(PKG_DIR, 'agents'), path.join(CODEX_DIR, 'agents'));
+  console.log(`   🤖 ${agentCount} agents`);
+
+  const skillCount = copyDir(path.join(PKG_DIR, 'skills'), path.join(CODEX_DIR, 'skills'));
+  console.log(`   ⚡ ${skillCount} skill files`);
+
+  const cmdCount = copyDir(path.join(PKG_DIR, 'commands'), path.join(CODEX_DIR, 'commands'));
+  console.log(`   📝 ${cmdCount} commands`);
+
+  const hookCount = copyDir(path.join(PKG_DIR, 'hooks'), path.join(CODEX_DIR, 'hooks'));
+  console.log(`   🔗 ${hookCount} hooks`);
+
+  if (fs.existsSync(path.join(PKG_DIR, 'lib'))) {
+    copyDir(path.join(PKG_DIR, 'lib'), path.join(CODEX_DIR, 'lib'));
+    console.log(`   📚 lib`);
+  }
+
+  // AGENTS.md — Codex's equivalent of CLAUDE.md, generated from CLAUDE.md
+  // (single source of truth) with surface substitutions.
+  const claudeMdInPkg = path.join(PKG_DIR, 'CLAUDE.md');
+  const agentsMdDest = path.join(CODEX_DIR, 'AGENTS.md');
+  if (fs.existsSync(claudeMdInPkg)) {
+    try {
+      let content = fs.readFileSync(claudeMdInPkg, 'utf8');
+      content = content
+        .replace(/# ClaudeAll Global Instructions/, '# Codex Agent Instructions (ClaudeAll Global Instructions)')
+        .replace(/Claude Code enhanced with ClaudeAll superpowers\./, 'OpenAI Codex CLI enhanced with ClaudeAll superpowers.\n\n**Bypass mode**: configure approval policy in ~/.codex/config.toml (default: never).')
+        .replace(/~\/\.claude\//g, '~/.codex/')
+        .replace(/CLAUDE\.md/g, 'AGENTS.md');
+      fs.writeFileSync(agentsMdDest, content);
+      console.log(`   📄 AGENTS.md (synced from CLAUDE.md, ${content.split('\n').length} lines)`);
+    } catch (e) {
+      console.log(`   ⚠️  AGENTS.md write skipped (${e.code || 'error'})`);
+    }
+  }
+
+  // config.toml — translate mcp.json into Codex's TOML schema for MCP servers.
+  const mcpSrc = path.join(PKG_DIR, 'mcp.json');
+  const codexConfigDest = path.join(CODEX_DIR, 'config.toml');
+  if (fs.existsSync(mcpSrc)) {
+    try {
+      const mcpRaw = fs.readFileSync(mcpSrc, 'utf8').replace(/\$\{HOME\}/g, HOME);
+      const mcp = JSON.parse(mcpRaw);
+      let toml = '# ClaudeAll-managed Codex config (auto-generated from mcp.json)\n';
+      toml += '# Edit ~/.codex/.env for secrets. Re-run `npm install -g claude-all-config@latest`\n';
+      toml += '# to regenerate this file from the latest mcp.json.\n\n';
+
+      // Sandbox-friendly defaults so codex on a fresh proot/container works
+      toml += '# Default approval — match ClaudeAll style: autonomous unless overridden.\n';
+      toml += 'approval_policy = "never"\n\n';
+
+      for (const [name, cfg] of Object.entries(mcp.mcpServers || {})) {
+        const safeName = name.includes('-') ? `"${name}"` : name;
+        toml += `[mcp_servers.${safeName}]\n`;
+        if (cfg.type === 'http' || cfg.url) {
+          toml += `url = ${JSON.stringify(cfg.url)}\n`;
+          if (cfg.headers && cfg.headers.Authorization) {
+            // Pull env var name out of "Bearer ${VAR_NAME}"
+            const m = cfg.headers.Authorization.match(/\$\{([A-Z_][A-Z0-9_]*)\}/);
+            if (m) toml += `bearer_token_env_var = "${m[1]}"\n`;
+          }
+        } else if (cfg.command) {
+          toml += `command = ${JSON.stringify(cfg.command)}\n`;
+          if (Array.isArray(cfg.args)) {
+            toml += `args = ${JSON.stringify(cfg.args)}\n`;
+          }
+          if (cfg.env && Object.keys(cfg.env).length > 0) {
+            toml += `\n[mcp_servers.${safeName}.env]\n`;
+            for (const [k, v] of Object.entries(cfg.env)) {
+              toml += `${k} = ${JSON.stringify(v)}\n`;
+            }
+          }
+        }
+        toml += '\n';
+      }
+
+      // Preserve any existing user customization above ours? For now we
+      // overwrite — the user's secrets are in .env, not in this file.
+      fs.writeFileSync(codexConfigDest, toml);
+      const serverCount = Object.keys(mcp.mcpServers || {}).length;
+      console.log(`   ⚙️  config.toml (${serverCount} MCP servers, approval_policy=never)`);
+    } catch (e) {
+      console.log(`   ⚠️  config.toml write skipped (${e.code || e.message || 'error'})`);
+    }
+  }
+
+  // .env merge — same template as Claude/Gemini
+  const envSrc = path.join(PKG_DIR, '.env.example');
+  const envDest = path.join(CODEX_DIR, '.env');
+  if (fs.existsSync(envSrc)) {
+    try {
+      const r = mergeEnvFile(envSrc, envDest);
+      try { fs.chmodSync(envDest, 0o600); } catch {}
+      console.log(`   🔐 .env ${r.action} (${r.filled} filled, ${r.preserved} preserved)`);
+    } catch (e) {
+      console.log(`   ⚠️  .env merge skipped (${e.code || 'error'})`);
+    }
+  }
+}
+
+// Install to Kiro (~/.kiro/) — Kiro CLI uses skills in SKILL.md format
+// (compatible with Claude), AGENTS.md for global instructions, and stores MCP
+// config under ~/.kiro/settings/mcp.json. Agents in Kiro use a JSON schema
+// that's auto-generated by Kiro itself, so we don't ship those.
+function installKiro() {
+  const KIRO_DIR = path.join(HOME, '.kiro');
+  console.log('📦 Installing to Kiro (~/.kiro/)...');
+
+  const dirs = ['skills', 'commands', 'hooks', 'lib', 'settings', 'prompts'];
+  dirs.forEach(dir => {
+    const targetDir = path.join(KIRO_DIR, dir);
+    try {
+      if (!fs.existsSync(targetDir)) fs.mkdirSync(targetDir, { recursive: true });
+    } catch {}
+  });
+
+  // Skills are SKILL.md format — fully compatible with Kiro
+  const skillCount = copyDir(path.join(PKG_DIR, 'skills'), path.join(KIRO_DIR, 'skills'));
+  console.log(`   ⚡ ${skillCount} skill files`);
+
+  // Commands & hooks (in case Kiro adopts them)
+  const cmdCount = copyDir(path.join(PKG_DIR, 'commands'), path.join(KIRO_DIR, 'commands'));
+  console.log(`   📝 ${cmdCount} commands`);
+
+  const hookCount = copyDir(path.join(PKG_DIR, 'hooks'), path.join(KIRO_DIR, 'hooks'));
+  console.log(`   🔗 ${hookCount} hooks`);
+
+  if (fs.existsSync(path.join(PKG_DIR, 'lib'))) {
+    copyDir(path.join(PKG_DIR, 'lib'), path.join(KIRO_DIR, 'lib'));
+    console.log(`   📚 lib`);
+  }
+
+  // AGENTS.md — synced from CLAUDE.md (single source of truth)
+  const claudeMdInPkg = path.join(PKG_DIR, 'CLAUDE.md');
+  const agentsMdDest = path.join(KIRO_DIR, 'AGENTS.md');
+  if (fs.existsSync(claudeMdInPkg)) {
+    try {
+      let content = fs.readFileSync(claudeMdInPkg, 'utf8');
+      content = content
+        .replace(/# ClaudeAll Global Instructions/, '# Kiro Agent Instructions (ClaudeAll Global Instructions)')
+        .replace(/Claude Code enhanced with ClaudeAll superpowers\./, 'Kiro CLI enhanced with ClaudeAll superpowers.\n\nKiro uses its own JSON-format agents under ~/.kiro/agents/ (auto-managed). The skills, hooks, and MCP servers below are shared with Claude/Gemini/Codex.')
+        .replace(/~\/\.claude\//g, '~/.kiro/')
+        .replace(/CLAUDE\.md/g, 'AGENTS.md');
+      fs.writeFileSync(agentsMdDest, content);
+      console.log(`   📄 AGENTS.md (synced from CLAUDE.md, ${content.split('\n').length} lines)`);
+    } catch (e) {
+      console.log(`   ⚠️  AGENTS.md write skipped (${e.code || 'error'})`);
+    }
+  }
+
+  // MCP config under ~/.kiro/settings/mcp.json with ${HOME} expanded
+  const mcpSrc = path.join(PKG_DIR, 'mcp.json');
+  const mcpDest = path.join(KIRO_DIR, 'settings', 'mcp.json');
+  if (fs.existsSync(mcpSrc)) {
+    try {
+      let mcpContent = fs.readFileSync(mcpSrc, 'utf8').replace(/\$\{HOME\}/g, HOME);
+      fs.writeFileSync(mcpDest, mcpContent);
+      try { fs.chmodSync(mcpDest, 0o600); } catch {}
+      console.log(`   🔧 MCP config (11 servers, settings/mcp.json)`);
+    } catch (e) {
+      console.log(`   ⚠️  MCP config skipped (${e.code || 'error'})`);
+    }
+  }
+
+  // .env merge
+  const envSrc = path.join(PKG_DIR, '.env.example');
+  const envDest = path.join(KIRO_DIR, '.env');
+  if (fs.existsSync(envSrc)) {
+    try {
+      const r = mergeEnvFile(envSrc, envDest);
+      try { fs.chmodSync(envDest, 0o600); } catch {}
+      console.log(`   🔐 .env ${r.action} (${r.filled} filled, ${r.preserved} preserved)`);
+    } catch (e) {
+      console.log(`   ⚠️  .env merge skipped (${e.code || 'error'})`);
+    }
+  }
+}
+
 // Install uvx for MiniMax MCP support
 function installUvx() {
   const hasUvx = commandExists('uvx');
@@ -476,6 +674,10 @@ function setupLocalBinSymlinks() {
     // 'gemini' shim shadows the real `gemini` binary so plain `gemini` runs
     // in YOLO mode by default with .env loaded. Opt out with --no-yolo.
     'gemini':             path.join(PKG_DIR, 'gemini'),
+    'codex-all':          path.join(PKG_DIR, 'codex-all'),
+    // 'codex' shim shadows the real `codex` so plain `codex` auto-loads .env.
+    'codex':              path.join(PKG_DIR, 'codex'),
+    'kiro-all':           path.join(PKG_DIR, 'kiro-all'),
   };
 
   let created = 0;
@@ -543,6 +745,16 @@ if (hasGemini) {
   installGemini();
 }
 
+if (hasCodex) {
+  console.log('');
+  installCodex();
+}
+
+if (hasKiro) {
+  console.log('');
+  installKiro();
+}
+
 setupLocalBinSymlinks();
 
 // If we ran under sudo, hand ownership back to the original user so that a
@@ -551,6 +763,8 @@ if (SUDO_USER) {
   console.log(`\n🔒 Restoring ownership to ${SUDO_USER}...`);
   fixOwnership(path.join(HOME, '.claude'));
   fixOwnership(path.join(HOME, '.gemini'));
+  fixOwnership(path.join(HOME, '.codex'));
+  fixOwnership(path.join(HOME, '.kiro'));
   fixOwnership(path.join(HOME, '.mcp.json'));
   fixOwnership(path.join(HOME, '.local'));
   console.log('   ✅ Ownership fixed.');