fix: improve npx sandbox detection (#62)

* feat: Implement npx sandbox detection and enhance file download logic

- Added `detect-npx.mjs` to identify if the CLI is running in an npx sandbox.
- Updated `download-files.mjs` to utilize the new detection logic for improved path resolution.
- Introduced `find-package-root.mjs` to locate the package root based on `package.json` and `.cursor` directory.
- Adjusted `package-lock.json` to reflect changes in file paths and permissions.

* feat: Enhance interactive mode and default output path

- Introduced `findPackageRoot` to dynamically locate the package root for rules.
- Updated `scanAvailableRules` to use the resolved source rules path.
- Set a default output directory to the user's Downloads folder for improved usability.

* refactor: Update interactive menu and rule scanning logic

- Replaced `fs/promises` with synchronous `fs` methods for improved performance in the interactive menu.
- Enhanced `scanAvailableRules` to accept a base path parameter, allowing for more flexible rule path resolution.
- Updated console output methods from `console.log` to `console.info` for better clarity in the interactive menu.
- Added debug logging in `validateDirname` to assist with path validation troubleshooting.

Author: usrrname

cli/commands.mjs

@@ -1,14 +1,17 @@
 'use strict'
 import * as fs from 'node:fs/promises';
+import { homedir } from 'node:os';
 import { dirname, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { downloadFiles, downloadSelectedFiles } from './utils/download-files.mjs';
+import { findPackageRoot } from './utils/find-package-root.mjs';
 import { interactiveCategorySelection, prepareMenu, scanAvailableRules, selectRules } from './utils/interactive-menu.mjs';
 import { validateDirname } from './utils/validate-dirname.mjs';
 
 export const __dirname = dirname(fileURLToPath(import.meta.url));
 export const packageJsonPath = resolve(__dirname, '..', 'package.json');
 export const packageJson = JSON.parse(await fs.readFile(packageJsonPath, 'utf-8'));
+const defaultOutput = resolve(homedir(), 'Downloads', '.cursor');
 
 /** @returns {void} */
 export const help = () => {
@@ -44,7 +47,9 @@ export const version = () => console.log(`${packageJson?.name} v${packageJson?.v
 */
 export const interactiveMode = async (values) => {
     console.log('🎯 Starting interactive mode...');
-    const rules = await scanAvailableRules();
+    const packageRoot = findPackageRoot(__dirname, '@usrrname/cursorrules');
+    const sourceRulesBasePath = resolve(packageRoot, '.cursor', 'rules');
+    const rules = await scanAvailableRules(sourceRulesBasePath);
     // Prepare persistent selection state for each category
     const categories = Object.keys(rules).filter(cat => rules[cat].length > 0);
 
@@ -63,7 +68,7 @@ export const interactiveMode = async (values) => {
             const allSelectedRules = Object.values(persistentSelections)
                 .flat()
                 .filter(rule => rule.selected);
-            const outputDir = values?.output?.toString() ?? `${process.cwd()}/.cursor/`;
+            const outputDir = values?.output?.toString() ?? defaultOutput;
             if (allSelectedRules.length > 0)
                 return await downloadSelectedFiles(outputDir, allSelectedRules);
             else

cli/index.mjs

@@ -0,0 +1,56 @@
+import { dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
+export function detectNpxSandbox() {
+    // Check environment variables
+    const npmPrefix = process.env.npm_config_prefix || '';
+    const npmCache = process.env.npm_config_cache || '';
+    const tempDir = process.env.TMPDIR || process.env.TEMP || process.env.TMP || '';
+
+    // Analyze current file path
+    const currentPath = __dirname;
+
+    //Check for npx-specific patterns in the path
+    const npxPatterns = [
+        '_npx',
+        'npm-cache',
+        '_cacache',
+        /npm-\d+-[a-f0-9]+/,  // npm-<pid>-<random>
+        /tmp.*npm/,           // temp directories with npm
+    ];
+
+    // Check if we're in node_modules of a temp-like directory
+    const isInNodeModules = currentPath.includes('node_modules');
+    const pathSegments = currentPath.split(/[/\\]/);
+
+    // Look for npx indicators
+    const hasNpxIndicators = npxPatterns.some(pattern => {
+        if (typeof pattern === 'string') {
+            return currentPath.includes(pattern) || npmPrefix.includes(pattern) || npmCache.includes(pattern);
+        } else {
+            return pattern.test(currentPath) || pattern.test(npmPrefix) || pattern.test(npmCache);
+        }
+    });
+
+    // Check for temporary directory characteristics
+    const isTempLike = pathSegments.some(segment =>
+        /^(tmp|temp|cache)$/i.test(segment) ||
+        /^[a-f0-9]{8,}$/.test(segment) ||  // long hex strings
+        /^\d+$/.test(segment)              // numeric directories
+    );
+
+    return {
+        isNpxSandbox: hasNpxIndicators || (isInNodeModules && isTempLike),
+        currentPath,
+        npmPrefix,
+        npmCache,
+        indicators: {
+            hasNpxIndicators,
+            isInNodeModules,
+            isTempLike,
+            pathSegments
+        }
+    };
+}

cli/utils/detect-npx.mjs

@@ -1,28 +1,29 @@
 import { copyFile, cp, mkdir } from 'node:fs/promises';
-import { dirname, join, sep as pathSep, resolve } from 'node:path';
+import { dirname, join, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { help } from '../commands.mjs';
+import { detectNpxSandbox } from './detect-npx.mjs';
 import { findFolderUp } from './find-folder-up.mjs';
+import { findPackageRoot } from './find-package-root.mjs';
 import { validateDirname } from './validate-dirname.mjs';
 
-export const __dirname = dirname(fileURLToPath(import.meta.url));
+const detection = detectNpxSandbox();
+console.log('🔍 NPX Detection Results:', detection);
 
-// Detect if we're running inside an npx sandbox. npm sets npm_config_prefix to that temp dir.
-const npmPrefix = process.env.npm_config_prefix?.toString() || '';
-const isNpxSandbox = npmPrefix.includes(`${pathSep}_npx${pathSep}`);
+const __dirname = dirname(fileURLToPath(import.meta.url));
+console.log('🔍 __dirname:', __dirname);
 /** @type {string} */
 let sourceRulesBasePath;
 
-console.log('DEBUG: npmPrefix:', npmPrefix);
-console.log('DEBUG: pathSep:', pathSep);
-console.log('DEBUG: isNpxSandbox check string:', `${pathSep}_npx${pathSep}`);
-console.log('DEBUG: isNpxSandbox:', isNpxSandbox);
-
-if (isNpxSandbox) {
-    // inside npx → rules live alongside package contents
-    sourceRulesBasePath = resolve(npmPrefix, 'rules');
+if (detection.isNpxSandbox) {
+    const packageRoot = findPackageRoot(__dirname, '@usrrname/cursorrules');
+    console.log('DEBUG: packageRoot (npx branch):', packageRoot);
+    sourceRulesBasePath = resolve(packageRoot, '.cursor', 'rules');
+    console.log('DEBUG: sourceRulesBasePath:', sourceRulesBasePath);
 }
 
+
+// only for local development and testing
 if (process.env.CI || ['development', 'test'].includes(process.env.NODE_ENV ?? '')) {
     // running inside repo / globally installed copy → locate nearest .cursor
     const found = await findFolderUp('.cursor', process.cwd())

cli/utils/download-files.mjs

@@ -0,0 +1,39 @@
+import { readFileSync, statSync } from "node:fs";
+import { dirname, resolve } from "node:path";
+/**
+ * @param {string} startPath
+ * @param {string} packageName
+ * @returns {string}
+ */
+export function findPackageRoot(startPath, packageName) {
+    let currentPath = startPath;
+
+    while (currentPath !== dirname(currentPath)) {
+        // Look for package.json or your package-specific markers
+        try {
+            const packageJsonPath = resolve(currentPath, 'package.json');
+            const packageJson = JSON.parse(readFileSync(packageJsonPath, 'utf8'));
+
+            // Verify package
+            if (packageJson.name === packageName) {
+                return currentPath;
+            }
+        } catch (e) {
+            // Continue searching up
+        }
+
+        // Also check for .cursor directory as a marker
+        try {
+            const cursorPath = resolve(currentPath, '.cursor');
+            if (statSync(cursorPath).isDirectory()) {
+                return currentPath;
+            }
+        } catch (e) {
+            // Continue searching up
+        }
+
+        currentPath = dirname(currentPath);
+    }
+
+    throw new Error('Package root not found');
+}

cli/utils/find-package-root.mjs

@@ -1,7 +1,5 @@
-import * as fs from 'node:fs/promises';
-import * as path from 'node:path';
-import * as url from 'node:url';
-import { findFolderUp } from './find-folder-up.mjs';
+import { readdirSync } from 'node:fs';
+import { join, resolve } from 'node:path';
 /**
  * Finds all rules in category and prepares them for display in menu
  * @param {Record<string, Array<{name: string, path: string, fullPath: string}>>} rules
@@ -36,18 +34,18 @@ export const prepareMenu = (rules) => {
 export const createMenu = ({ title, items, currentIndex, footerLines = [] }) => {
     process.stdout.write('\x1B[2J\x1B[0f');
     if (title) {
-        console.log(title);
-        console.log('='.repeat(title.length) + '\n');
+        console.info(title);
+        console.info('='.repeat(title.length) + '\n');
     }
     items.forEach((item, idx) => {
         const isCurrent = idx === currentIndex;
         const indicator = isCurrent ? '▶ ' : '  ';
         const highlight = isCurrent ? '\x1B[7m' : '';
         const reset = '\x1B[0m';
-        console.log(`${highlight}${indicator}${item}${reset}`);
+        console.info(`${highlight}${indicator}${item}${reset}`);
     });
     if (footerLines.length) {
-        footerLines.forEach(line => console.log(line));
+        footerLines.forEach(line => console.info(line));
     }
 }
 
@@ -229,32 +227,30 @@ export const selectRules = async (rulesInCategory) => {
 
 /**
  * Scan available rules from standards and test directories
+ * @param {string} rulesBasePath
  * @returns {Promise<Record<string, Array<{name: string, path: string, fullPath: string}>>>} Object with categorized rules
  */
-export const scanAvailableRules = async () => {
-    // whereever this function is called, it should find the rules path relative to the current file
-    const cursorFolder = await findFolderUp('.cursor', process.cwd());
-    const rulesPath = url.fileURLToPath(url.resolve(import.meta.url, `${cursorFolder}/rules`));
+export const scanAvailableRules = async (rulesBasePath) => {
 
     const categories = ['standards', 'test', 'utils'];
     /** @type {Record<string, Array<{name: string, path: string, fullPath: string}>>} */
     let rules = {}
 
     for (const category of categories) {
-        const categoryPath = path.join(rulesPath, category);
+        const categoryPath = resolve(rulesBasePath, category);
         try {
-            const files = await fs.readdir(categoryPath, { withFileTypes: true });
+            const files = await readdirSync(categoryPath, { withFileTypes: true });
             rules[category] = files
                 .filter(file => file.isFile() && file.name.endsWith('.mdc'))
                 .map(file => ({
                     name: file.name.replace('.mdc', ''),
-                    path: path.join(category, file.name),
-                    fullPath: path.join(categoryPath, file.name)
+                    path: join(category, file.name),
+                    fullPath: resolve(categoryPath, file.name)
                 }));
         } catch (err) {
             rules[category] = [];
         }
     }
 
     return rules;
-};
+};

cli/utils/interactive-menu.mjs

@@ -43,6 +43,8 @@ const hasInvalidSegmentChars = (segment) => {
  * @returns {Promise<string>} - the validated and resolved absolute path
  */
 export const validateDirname = async (rawPath, projectRoot = process.cwd()) => {
+    console.log('DEBUG: validateDirname rawPath:', rawPath);
+    console.log('DEBUG: validateDirname projectRoot:', projectRoot);
     const attemptedPath = rawPath;
 
     // Remove = prefix if it exists