claude-all-config 3.5.8 → 3.5.10

package/VERSION

@@ -1 +1 @@
-3.5.8
+3.5.10

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-all-config",
-  "version": "3.5.8",
+  "version": "3.5.10",
   "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": {

package/postinstall.js

@@ -8,15 +8,65 @@ const fs = require('fs');
 const path = require('path');
 const { execSync } = require('child_process');
 
-const HOME = process.env.HOME || process.env.USERPROFILE;
+// --- Sudo-aware HOME detection ----------------------------------------------
+// When the package is installed via `sudo npm install -g`, npm runs the
+// postinstall as root, so process.env.HOME is /root and configs would land in
+// the wrong place. We honor SUDO_USER to write into the invoking user's HOME
+// and chown the result back to them so a follow-up non-sudo install does not
+// trip over EACCES on root-owned files.
+const SUDO_USER = process.env.SUDO_USER && process.env.SUDO_USER !== 'root'
+  ? process.env.SUDO_USER : null;
+const SUDO_UID = process.env.SUDO_UID ? Number(process.env.SUDO_UID) : null;
+const SUDO_GID = process.env.SUDO_GID ? Number(process.env.SUDO_GID) : null;
+
+function resolveHome() {
+  if (SUDO_USER) {
+    // Look up the real home from /etc/passwd
+    try {
+      const passwd = fs.readFileSync('/etc/passwd', 'utf8');
+      const line = passwd.split('\n').find(l => l.startsWith(SUDO_USER + ':'));
+      if (line) {
+        const parts = line.split(':');
+        if (parts[5] && fs.existsSync(parts[5])) return parts[5];
+      }
+    } catch {}
+    // Fallback to /home/$SUDO_USER
+    const fallback = `/home/${SUDO_USER}`;
+    if (fs.existsSync(fallback)) return fallback;
+  }
+  return process.env.HOME || process.env.USERPROFILE;
+}
+
+const HOME = resolveHome();
 const PKG_DIR = __dirname;
 
-// Detect installed CLIs
+if (SUDO_USER) {
+  console.log(`ℹ️  Running under sudo — installing for user '${SUDO_USER}' (HOME=${HOME})\n`);
+}
+
+// Recursively chown a path back to the invoking user when running under sudo.
+function fixOwnership(target) {
+  if (SUDO_UID === null || SUDO_GID === null) return;
+  try { fs.lchownSync(target, SUDO_UID, SUDO_GID); } catch {}
+  let stat;
+  try { stat = fs.lstatSync(target); } catch { return; }
+  if (stat.isSymbolicLink() || !stat.isDirectory()) return;
+  let entries;
+  try { entries = fs.readdirSync(target); } catch { return; }
+  for (const entry of entries) fixOwnership(path.join(target, entry));
+}
+
+// Detect installed CLIs — also check the resolved user's ~/.local/bin so that
+// a sudo invocation still finds claude installed via the native installer.
 function commandExists(cmd) {
   try {
     execSync(`which ${cmd}`, { stdio: 'ignore' });
     return true;
   } catch {
+    if (HOME) {
+      const userBin = path.join(HOME, '.local', 'bin', cmd);
+      if (fs.existsSync(userBin)) return true;
+    }
     return false;
   }
 }
@@ -33,32 +83,54 @@ if (!hasClaude && !hasGemini) {
 }
 console.log('');
 
-// Copy function
+// Copy function — resilient: skip files that can't be copied (e.g., EACCES from
+// previous sudo install) instead of crashing the whole postinstall.
 function copyDir(src, dest) {
   if (!fs.existsSync(src)) return 0;
 
-  if (!fs.existsSync(dest)) {
-    fs.mkdirSync(dest, { recursive: true });
+  try {
+    if (!fs.existsSync(dest)) {
+      fs.mkdirSync(dest, { recursive: true });
+    }
+  } catch (e) {
+    return 0;
   }
 
-  const files = fs.readdirSync(src);
+  let files;
+  try { files = fs.readdirSync(src); } catch { return 0; }
   let count = 0;
+  let skipped = 0;
 
   files.forEach(file => {
     const srcPath = path.join(src, file);
     const destPath = path.join(dest, file);
 
-    if (fs.statSync(srcPath).isDirectory()) {
-      if (!fs.existsSync(destPath)) {
-        fs.mkdirSync(destPath, { recursive: true });
-      }
+    let stat;
+    try { stat = fs.statSync(srcPath); } catch { return; }
+
+    if (stat.isDirectory()) {
+      try {
+        if (!fs.existsSync(destPath)) {
+          fs.mkdirSync(destPath, { recursive: true });
+        }
+      } catch { skipped++; return; }
       count += copyDir(srcPath, destPath);
     } else {
-      fs.copyFileSync(srcPath, destPath);
-      count++;
+      try {
+        fs.copyFileSync(srcPath, destPath);
+        count++;
+      } catch (e) {
+        // EACCES from a prior root-owned copy, EBUSY, etc — skip and continue
+        skipped++;
+      }
     }
   });
 
+  if (skipped > 0) {
+    // Surface a hint without aborting; user can sudo chown -R if they really want everything fresh
+    process.env._CA_COPY_SKIPS = String(Number(process.env._CA_COPY_SKIPS || 0) + skipped);
+  }
+
   return count;
 }
 
@@ -103,9 +175,13 @@ function installClaude() {
   const mcpSrc = path.join(PKG_DIR, 'mcp.json');
   const mcpDest = path.join(HOME, '.mcp.json');
   if (fs.existsSync(mcpSrc)) {
-    fs.copyFileSync(mcpSrc, mcpDest);
-    fs.chmodSync(mcpDest, 0o600);
-    console.log(`   🔧 MCP config (7 servers)`);
+    try {
+      fs.copyFileSync(mcpSrc, mcpDest);
+      try { fs.chmodSync(mcpDest, 0o600); } catch {}
+      console.log(`   🔧 MCP config (7 servers)`);
+    } catch (e) {
+      console.log(`   ⚠️  MCP config skipped (${e.code || 'error'}): ${mcpDest}`);
+    }
   }
 
   // Settings - create both settings.json AND settings.local.json
@@ -122,20 +198,31 @@ function installClaude() {
 
   // Write settings.json (main config - Claude reads this)
   const settingsJsonPath = path.join(CLAUDE_DIR, 'settings.json');
-  fs.writeFileSync(settingsJsonPath, JSON.stringify(settings, null, 2));
+  try {
+    fs.writeFileSync(settingsJsonPath, JSON.stringify(settings, null, 2));
+  } catch (e) {
+    console.log(`   ⚠️  settings.json skipped (${e.code || 'error'}) — try: sudo chown -R $USER ~/.claude`);
+  }
 
   // Write settings.local.json (backup/local overrides)
   const settingsLocalPath = path.join(CLAUDE_DIR, 'settings.local.json');
-  fs.writeFileSync(settingsLocalPath, JSON.stringify(settings, null, 2));
-
-  console.log(`   ⚙️  settings.json + settings.local.json (@proactive-mode enabled)`);
+  try {
+    fs.writeFileSync(settingsLocalPath, JSON.stringify(settings, null, 2));
+    console.log(`   ⚙️  settings.json + settings.local.json (@proactive-mode enabled)`);
+  } catch (e) {
+    console.log(`   ⚠️  settings.local.json skipped (${e.code || 'error'})`);
+  }
 
   // Copy CLAUDE.md (global instructions)
   const claudeMdSrc = path.join(PKG_DIR, 'CLAUDE.md');
   const claudeMdDest = path.join(CLAUDE_DIR, 'CLAUDE.md');
   if (fs.existsSync(claudeMdSrc)) {
-    fs.copyFileSync(claudeMdSrc, claudeMdDest);
-    console.log(`   📋 CLAUDE.md (global instructions)`);
+    try {
+      fs.copyFileSync(claudeMdSrc, claudeMdDest);
+      console.log(`   📋 CLAUDE.md (global instructions)`);
+    } catch (e) {
+      console.log(`   ⚠️  CLAUDE.md skipped (${e.code || 'error'})`);
+    }
   }
 }
 
@@ -340,6 +427,25 @@ if (hasGemini) {
 
 setupLocalBinSymlinks();
 
+// If we ran under sudo, hand ownership back to the original user so that a
+// follow-up non-sudo `npm install -g claude-all-config` does not hit EACCES.
+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, '.mcp.json'));
+  fixOwnership(path.join(HOME, '.local'));
+  console.log('   ✅ Ownership fixed.');
+}
+
+const skips = Number(process.env._CA_COPY_SKIPS || 0);
+if (skips > 0) {
+  console.log('');
+  console.log(`⚠️  ${skips} files were skipped (likely owned by root from a prior sudo install).`);
+  console.log('   To force-refresh everything, run:');
+  console.log('     sudo chown -R $USER ~/.claude ~/.gemini 2>/dev/null && npm install -g claude-all-config');
+}
+
 console.log('\n✅ Installation complete!\n');
 
 if (hasClaude) {