@guardinstall/cli 0.1.2 → 0.1.4

package/dist/index.js

@@ -39,7 +39,7 @@ const program = new commander_1.Command();
 program
     .name('guardinstall')
     .description('A kernel-level behavioral sandbox for npm/pnpm/bun install scripts')
-    .version('0.0.1');
+    .version('0.1.3');
 program
     .command('install')
     .description('Run npm install with sandbox protection')

package/dist/resolver.js

@@ -5,6 +5,8 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getInstallScripts = void 0;
 const arborist_1 = __importDefault(require("@npmcli/arborist"));
+const path_1 = __importDefault(require("path"));
+const fs_1 = __importDefault(require("fs"));
 const lockfile_1 = require("./lockfile");
 async function getInstallScripts(projectRoot) {
     const arb = new arborist_1.default({ path: projectRoot });
@@ -12,32 +14,93 @@ async function getInstallScripts(projectRoot) {
     try {
         tree = await arb.loadActual();
     }
-    catch {
-        tree = await arb.loadVirtual();
+    catch (e) {
+        console.error('Warning: Error loading package tree:', e instanceof Error ? e.message : e);
+        return getInstallScriptsFromNodeModules(projectRoot); // Fallback to manual scan
     }
     const packagesWithScripts = [];
     const lockfile = (0, lockfile_1.readLockfile)(projectRoot);
-    for (const node of tree.inventory.values()) {
-        const pkg = node.package;
-        if (!pkg)
-            continue;
-        const scripts = pkg.scripts ?? {};
-        const hasInstallScript = ['preinstall', 'install', 'postinstall']
-            .some(s => s in scripts);
-        if (hasInstallScript) {
-            const installScripts = pick(scripts, ['preinstall', 'install', 'postinstall']);
-            packagesWithScripts.push({
-                name: node.name,
-                version: node.version,
-                scripts: installScripts,
-                path: node.path,
-                isNew: !(0, lockfile_1.isInLockfile)(node.name, node.version, lockfile)
-            });
+    try {
+        for (const node of tree.inventory.values()) {
+            const pkg = node.package;
+            if (!pkg)
+                continue;
+            const scripts = pkg.scripts ?? {};
+            const hasInstallScript = ['preinstall', 'install', 'postinstall']
+                .some(s => s in scripts);
+            if (hasInstallScript) {
+                const installScripts = pick(scripts, ['preinstall', 'install', 'postinstall']);
+                packagesWithScripts.push({
+                    name: node.name,
+                    version: node.version,
+                    scripts: installScripts,
+                    path: node.path,
+                    isNew: !(0, lockfile_1.isInLockfile)(node.name, node.version, lockfile)
+                });
+            }
         }
     }
+    catch (e) {
+        console.error('Warning: Error iterating package tree:', e instanceof Error ? e.message : e);
+        return getInstallScriptsFromNodeModules(projectRoot);
+    }
     return packagesWithScripts;
 }
 exports.getInstallScripts = getInstallScripts;
+// Fallback: manually scan node_modules for package.json files
+function getInstallScriptsFromNodeModules(projectRoot) {
+    const packagesWithScripts = [];
+    const lockfile = (0, lockfile_1.readLockfile)(projectRoot);
+    try {
+        const nodeModulesPath = path_1.default.join(projectRoot, 'node_modules');
+        if (!fs_1.default.existsSync(nodeModulesPath))
+            return packagesWithScripts;
+        const scanDir = (dir, depth = 0) => {
+            if (depth > 2)
+                return; // Limit recursion depth
+            try {
+                const entries = fs_1.default.readdirSync(dir, { withFileTypes: true });
+                for (const entry of entries) {
+                    if (entry.isDirectory()) {
+                        if (entry.name.startsWith('@')) {
+                            // Scoped package directory
+                            scanDir(path_1.default.join(dir, entry.name), depth + 1);
+                        }
+                        else if (depth === 0 || depth === 1) {
+                            // Check package.json in this directory
+                            const pkgPath = path_1.default.join(dir, entry.name, 'package.json');
+                            if (fs_1.default.existsSync(pkgPath)) {
+                                try {
+                                    const pkgJson = JSON.parse(fs_1.default.readFileSync(pkgPath, 'utf-8'));
+                                    if (pkgJson.scripts && ('preinstall' in pkgJson.scripts || 'install' in pkgJson.scripts || 'postinstall' in pkgJson.scripts)) {
+                                        packagesWithScripts.push({
+                                            name: pkgJson.name || entry.name,
+                                            version: pkgJson.version || 'unknown',
+                                            scripts: pick(pkgJson.scripts, ['preinstall', 'install', 'postinstall']),
+                                            path: path_1.default.join(dir, entry.name),
+                                            isNew: !(0, lockfile_1.isInLockfile)(pkgJson.name || entry.name, pkgJson.version || 'unknown', lockfile)
+                                        });
+                                    }
+                                }
+                                catch (e) {
+                                    // Ignore parse errors
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+            catch (e) {
+                // Ignore permission errors
+            }
+        };
+        scanDir(nodeModulesPath);
+    }
+    catch (e) {
+        // Ignore errors
+    }
+    return packagesWithScripts;
+}
 function pick(obj, keys) {
     const result = {};
     for (const key of keys) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@guardinstall/cli",
-  "version": "0.1.2",
+  "version": "0.1.4",
   "description": "CLI wrapper for guardinstall - intercepts and sandboxes install scripts",
   "main": "dist/index.js",
   "bin": {
@@ -13,8 +13,8 @@
     "test": "jest"
   },
   "dependencies": {
-    "@guardinstall/policy-engine": "0.1.0",
-    "@guardinstall/sandbox": "0.1.0",
+    "@guardinstall/policy-engine": "0.1.4",
+    "@guardinstall/sandbox": "0.1.4",
     "@npmcli/arborist": "7.5.4",
     "chalk": "4.1.2",
     "commander": "12.1.0"

package/src/index.ts

@@ -13,7 +13,7 @@ const program = new Command()
 program
   .name('guardinstall')
   .description('A kernel-level behavioral sandbox for npm/pnpm/bun install scripts')
-  .version('0.0.1')
+  .version('0.1.3')
 
 program
   .command('install')

package/src/resolver.ts

@@ -17,36 +17,97 @@ export async function getInstallScripts(projectRoot: string): Promise<PackageInf
   let tree
   try {
     tree = await arb.loadActual()
-  } catch {
-    tree = await arb.loadVirtual()
+  } catch (e) {
+    console.error('Warning: Error loading package tree:', e instanceof Error ? e.message : e)
+    return getInstallScriptsFromNodeModules(projectRoot) // Fallback to manual scan
   }
 
   const packagesWithScripts: PackageInfo[] = []
   const lockfile = readLockfile(projectRoot)
 
-  for (const node of tree.inventory.values()) {
-    const pkg = node.package
-    if (!pkg) continue
-    
-    const scripts = pkg.scripts ?? {}
-    const hasInstallScript = ['preinstall', 'install', 'postinstall']
-      .some(s => s in scripts)
-
-    if (hasInstallScript) {
-      const installScripts = pick(scripts, ['preinstall', 'install', 'postinstall'])
-      packagesWithScripts.push({
-        name: node.name,
-        version: node.version,
-        scripts: installScripts as Record<string, string> | undefined,
-        path: node.path,
-        isNew: !isInLockfile(node.name, node.version, lockfile)
-      })
+  try {
+    for (const node of tree.inventory.values()) {
+      const pkg = node.package
+      if (!pkg) continue
+      
+      const scripts = pkg.scripts ?? {}
+      const hasInstallScript = ['preinstall', 'install', 'postinstall']
+        .some(s => s in scripts)
+
+      if (hasInstallScript) {
+        const installScripts = pick(scripts, ['preinstall', 'install', 'postinstall'])
+        packagesWithScripts.push({
+          name: node.name,
+          version: node.version,
+          scripts: installScripts as Record<string, string> | undefined,
+          path: node.path,
+          isNew: !isInLockfile(node.name, node.version, lockfile)
+        })
+      }
     }
+  } catch (e) {
+    console.error('Warning: Error iterating package tree:', e instanceof Error ? e.message : e)
+    return getInstallScriptsFromNodeModules(projectRoot)
   }
 
   return packagesWithScripts
 }
 
+// Fallback: manually scan node_modules for package.json files
+function getInstallScriptsFromNodeModules(projectRoot: string): PackageInfo[] {
+  const packagesWithScripts: PackageInfo[] = []
+  const lockfile = readLockfile(projectRoot)
+  
+  try {
+    const nodeModulesPath = path.join(projectRoot, 'node_modules')
+    if (!fs.existsSync(nodeModulesPath)) return packagesWithScripts
+    
+    const scanDir = (dir: string, depth: number = 0) => {
+      if (depth > 2) return // Limit recursion depth
+      
+      try {
+        const entries = fs.readdirSync(dir, { withFileTypes: true })
+        
+        for (const entry of entries) {
+          if (entry.isDirectory()) {
+            if (entry.name.startsWith('@')) {
+              // Scoped package directory
+              scanDir(path.join(dir, entry.name), depth + 1)
+            } else if (depth === 0 || depth === 1) {
+              // Check package.json in this directory
+              const pkgPath = path.join(dir, entry.name, 'package.json')
+              if (fs.existsSync(pkgPath)) {
+                try {
+                  const pkgJson = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'))
+                  if (pkgJson.scripts && ('preinstall' in pkgJson.scripts || 'install' in pkgJson.scripts || 'postinstall' in pkgJson.scripts)) {
+                    packagesWithScripts.push({
+                      name: pkgJson.name || entry.name,
+                      version: pkgJson.version || 'unknown',
+                      scripts: pick(pkgJson.scripts, ['preinstall', 'install', 'postinstall']) as Record<string, string> | undefined,
+                      path: path.join(dir, entry.name),
+                      isNew: !isInLockfile(pkgJson.name || entry.name, pkgJson.version || 'unknown', lockfile)
+                    })
+                  }
+                } catch (e) {
+                  // Ignore parse errors
+                }
+              }
+            }
+          }
+        }
+      } catch (e) {
+        // Ignore permission errors
+      }
+    }
+    
+    scanDir(nodeModulesPath)
+  } catch (e) {
+    // Ignore errors
+  }
+  
+  return packagesWithScripts
+}
+
 function pick<T extends Record<string, unknown>>(obj: T, keys: string[]): Partial<T> {
   const result: Partial<T> = {}
   for (const key of keys) {