@cocreate/cli 1.54.1 → 1.56.0

package/src/execute.js

@@ -8,73 +8,116 @@ const { getConfig } = require("./getConfig");
 const { color } = require("./fonts");
 
 module.exports = async function execute(command, config) {
-	let failed = [];
-	let [filename, ...args] = command.replaceAll("'", '"').trim().split(" ");
+    let failed = [];
+    let [filename, ...args] = command.replaceAll("'", '"').trim().split(" ");
 
-	let type;
+    let type;
 
-	if (filename.endsWith(".js")) {
-		type = filename.slice(0, -3);
-	} else {
-		type = filename;
-		filename += ".js";
-	}
+    if (filename.endsWith(".js")) {
+        type = filename.slice(0, -3);
+    } else {
+        type = filename;
+        filename += ".js";
+    }
 
-	let predefined = path.resolve(__dirname, "commands", filename);
-	let isPredefined = fs.existsSync(predefined);
-	let repositories = [];
+    let predefined = path.resolve(__dirname, "commands", filename);
+    let isPredefined = fs.existsSync(predefined);
+    let repositories = [];
 
-	for (let repo of config.repositories || []) {
-		try {
-			if (
-				repo.exclude &&
-				(repo.exclude.includes(type) || repo.exclude.includes(filename))
-			) {
-				continue;
-			}
+    // --- CONSOLIDATE REPOSITORIES ---
+    // Merge both modules and projects from the new configuration structure
+    let targetRepos = [];
+    
+    if (config.modules) {
+        Object.entries(config.modules).forEach(([name, repo]) => {
+            // Ensure it's a valid object and has a path
+            if (typeof repo === 'object' && repo !== null && repo.path) {
+                targetRepos.push({ name, ...repo });
+            }
+        });
+    }
+    
+    if (config.projects) {
+        Object.entries(config.projects).forEach(([name, repo]) => {
+            if (typeof repo === 'object' && repo !== null && repo.path) {
+                targetRepos.push({ name, ...repo });
+            }
+        });
+    }
 
-			const packageJsonPath = path.resolve(repo.path, "package.json");
-			const packageObj = require(packageJsonPath);
-			repo.entry = packageObj.main;
+    // Backward compatibility for transitioning configs
+    if (config.repositories && Array.isArray(config.repositories)) {
+        targetRepos = targetRepos.concat(config.repositories);
+    }
 
-			if (isPredefined) {
-				repositories.push(repo);
-				continue;
-			}
+    for (let repo of targetRepos) {
+        try {
+            if (
+                repo.exclude &&
+                (repo.exclude.includes(type) || repo.exclude.includes(filename))
+            ) {
+                continue;
+            }
 
-			console.log(color.green + `${repo.name}: ` + color.reset, command);
-			let exitCode;
-			if (config.hideMessage) {
-				const { error } = await exec(command, {
-					cwd: repo.absolutePath
-				});
+            const packageJsonPath = path.resolve(repo.path, "package.json");
+            
+            // Try to load package.json if it exists
+            if (fs.existsSync(packageJsonPath)) {
+                try {
+                    const packageObj = require(packageJsonPath);
+                    repo.entry = packageObj.main;
+                } catch (err) {
+                    // Log error but continue
+                    console.error("error reading packageObj:", err.message);
+                }
+            }
 
-				if (error) exitCode = 1;
-			} else {
-				exitCode = await spawn(type, args, {
-					cwd: repo.absolutePath,
-					shell: true,
-					stdio: "inherit"
-				});
-			}
+            if (isPredefined) {
+                repositories.push(repo);
+                continue;
+            }
 
-			if (exitCode !== 0) {
-				repo.error = "command failed: " + command;
-				failed.push(repo);
-			}
-		} catch (err) {
-			console.error(
-				color.red +
-					`an error occured executing command in ${repo.name} repository` +
-					color.reset,
-				err.message
-			);
-		}
-	}
+            // For non-predefined commands, skip if package.json doesn't exist
+            if (!fs.existsSync(packageJsonPath)) {
+                continue;
+            }
 
-	if (isPredefined) {
-		failed = await require(predefined)(repositories, args);
-	}
+            console.log(color.green + `${repo.name || repo.path}: ` + color.reset, command);
+            let exitCode = 0;
+            if (config.hideMessage) {
+                try {
+                    await exec(command, {
+                        cwd: repo.absolutePath || path.resolve(repo.path)
+                    });
+                } catch (error) {
+                    exitCode = 1;
+                }
+            } else {
+                // Use spawn with shell to stream output in real-time
+                exitCode = await spawn(type, args, {
+                    cwd: repo.absolutePath || path.resolve(repo.path),
+                    shell: true,
+                    stdio: "inherit"
+                });
+            }
 
-	return failed;
-};
+            if (exitCode !== 0) {
+                repo.error = "command failed: " + command;
+                failed.push(repo);
+            }
+        } catch (err) {
+            console.error(
+                color.red +
+                    `an error occured executing command in ${repo.name || repo.path} repository` +
+                    color.reset,
+                err.message
+            );
+        }
+    }
+
+    if (isPredefined) {
+        failed = await require(predefined)(repositories, args);
+    }
+
+    return failed;
+};

package/src/getConfig.js

@@ -1,32 +1,92 @@
 const fs = require("fs");
 const path = require("path");
+const { pathToFileURL } = require("url");
 
+/**
+ * Dynamically loads and returns the configuration file.
+ * Handles:
+ * - CommonJS (module.exports = { ... })
+ * - ESM Default Export (export default { ... })
+ * - ESM Named Export Object (export const config = { ... })
+ * - ESM Individual Named Exports (export const repositories = [...])
+ * 
+ * @param {string} directory - The starting directory to search from.
+ * @param {string} filename - The target filename to append to the config filepath.
+ * @returns {Promise<Object|null>} The parsed config object, or null if not found.
+ */
 async function getConfig(directory, filename = "") {
-	let configPath = findClosestConfig(directory, "CoCreate.config.js");
-	if (configPath) {
-		let config = require(configPath);
-		config.configPath = configPath;
-		config.filePath = path.resolve(directory, filename);
-		return config;
-	} else {
-		console.log("No CoCreate.config file found in parent directories.");
-	}
+    let configPath = findClosestConfig(directory, "CoCreate.config.js");
+    if (configPath) {
+        try {
+            // Convert path to file:// URL to make dynamic imports bulletproof across OS environments (especially Windows)
+            const configUrl = pathToFileURL(configPath).href;
+            
+            // Dynamically import the module
+            const modulePayload = await import(configUrl);
+            
+            let rawConfig;
+            
+            if (modulePayload.default !== undefined) {
+                // 1. Handles 'export default { ... }' or 'module.exports = { ... }'
+                rawConfig = modulePayload.default;
+            } else if (modulePayload.config !== undefined && typeof modulePayload.config === 'object') {
+                // 2. Handles 'export const config = { ... }' or 'exports.config = { ... }'
+                rawConfig = modulePayload.config;
+            } else {
+                // 3. Handles individual exports like 'export const repositories = [...]'
+                rawConfig = modulePayload;
+            }
+            
+            // Dynamic imports return read-only namespace objects;
+            // shallow cloning allows us to safely append configPath and filePath.
+            let config = {};
+            if (rawConfig && typeof rawConfig === 'object') {
+                config = { ...rawConfig };
+            } else {
+                config = rawConfig;
+            }
+
+            config.configPath = configPath;
+            config.filePath = path.resolve(directory, filename);
+            return config;
+        } catch (error) {
+            console.error(`Error loading configuration at ${configPath}:`, error);
+            throw error;
+        }
+    } else {
+        console.log("No CoCreate.config file found in parent directories.");
+        return null;
+    }
 }
 
+/**
+ * Climbs up the directory tree to find the closest target configuration file.
+ * Safely handles file system root termination to avoid infinite loops.
+ * 
+ * @param {string} directory - Starting directory path.
+ * @param {string} filename - Target file to locate.
+ * @returns {string|null} Resolved absolute path to the file, or null if not found.
+ */
 function findClosestConfig(directory, filename) {
-	let currentDir = directory;
+    let currentDir = path.resolve(directory);
 
-	while (currentDir !== "/" && currentDir !== ".") {
-		let configFile = path.join(currentDir, filename);
+    while (true) {
+        let configFile = path.join(currentDir, filename);
 
-		if (fs.existsSync(configFile)) {
-			return configFile;
-		}
+        if (fs.existsSync(configFile)) {
+            return configFile;
+        }
 
-		currentDir = path.dirname(currentDir);
-	}
+        let parentDir = path.dirname(currentDir);
+        
+        // Safety Break: Stop climbing if we've reached the system root (e.g. '/' on Linux/Mac, 'C:\' on Windows)
+        if (parentDir === currentDir) {
+            break;
+        }
+        currentDir = parentDir;
+    }
 
-	return null;
+    return null;
 }
 
-module.exports = { getConfig, findClosestConfig };
+module.exports = { getConfig, findClosestConfig };

package/src/getOS.js

@@ -0,0 +1,22 @@
+const os = require("os");
+
+/**
+ * Detects the active operating system and provides helpful boolean flags
+ * and platform metadata.
+ * 
+ * @returns {{ platform: string, isWindows: boolean, isMac: boolean, isLinux: boolean, type: string, release: string }}
+ */
+function getOS() {
+    const platform = process.platform;
+
+    return {
+        platform,
+        isWindows: platform === "win32",
+        isMac: platform === "darwin",
+        isLinux: platform === "linux",
+        type: os.type(),     // 'Windows_NT', 'Darwin', 'Linux'
+        release: os.release() // OS release version string
+    };
+}
+
+module.exports = getOS;

package/src/getPackageManager.js

@@ -0,0 +1,46 @@
+const fs = require("fs");
+const path = require("path");
+
+/**
+ * Detects the active package manager based strictly on workspace lockfiles,
+ * distinguishing between Yarn Classic and Yarn Berry by analyzing yarn.lock directly.
+ * 
+ * @returns {"bun"|"pnpm"|"yarn-berry"|"yarn-classic"|"npm"}
+ */
+function getPackageManager() {
+    const cwd = process.cwd();
+
+    // Bun lockfile checks
+    if (fs.existsSync(path.join(cwd, "bun.lockb")) || fs.existsSync(path.join(cwd, "bun.lock"))) {
+        return "bun";
+    }
+    
+    // pnpm lockfile check
+    if (fs.existsSync(path.join(cwd, "pnpm-lock.yaml"))) {
+        return "pnpm";
+    }
+
+    // Yarn lockfile check
+    const yarnLockPath = path.join(cwd, "yarn.lock");
+    if (fs.existsSync(yarnLockPath)) {
+        try {
+            const content = fs.readFileSync(yarnLockPath, "utf8");
+            // Yarn Berry lockfiles contain a "__metadata:" block at the top
+            if (content.includes("__metadata:")) {
+                return "yarn-berry";
+            }
+        } catch (e) {
+            // Safe fallback to classic if the file cannot be read
+        }
+        return "yarn-classic";
+    }
+
+    // npm lockfile check
+    if (fs.existsSync(path.join(cwd, "package-lock.json"))) {
+        return "npm";
+    }
+
+    return "npm"; // Default fallback
+}
+
+module.exports = getPackageManager;

package/src/postinstall.js

@@ -0,0 +1,129 @@
+#!/usr/bin/env node
+
+const fs = require("fs");
+const path = require("path");
+const readline = require("readline");
+const util = require("node:util");
+const exec = util.promisify(require("node:child_process").exec);
+
+const getPackageManager = require("../getPackageManager");
+const getOS = require("../getOS");
+
+/**
+ * Prompts user for yes/no input
+ */
+function promptUser(question) {
+    return new Promise((resolve) => {
+        const rl = readline.createInterface({
+            input: process.stdin,
+            output: process.stdout
+        });
+
+        rl.question(question, (answer) => {
+            rl.close();
+            resolve(answer.toLowerCase() === "yes" || answer.toLowerCase() === "y");
+        });
+    });
+}
+
+/**
+ * Attempts to link the CLI globally
+ */
+async function linkGlobally() {
+    try {
+        // Resolve target OS properties and correct package manager binary name
+        const { isWindows, platform } = getOS();
+        const activePackageManager = getPackageManager();
+
+        // Standardize binary lookup name (fallback yarn-berry / yarn-classic to yarn executable)
+        const packageManager = (activePackageManager === "yarn-classic" || activePackageManager === "yarn-berry")
+            ? "yarn"
+            : activePackageManager;
+
+        const linkCommand = `${packageManager} link`;
+        const cliPath = path.resolve(__dirname, "..");
+
+        // First, ask user if they want to install globally
+        const wantGlobal = await promptUser(
+            `[CoCreate CLI] Would you like to install @cocreate/cli globally? (yes/no): `
+        );
+
+        if (!wantGlobal) {
+            console.log(
+                `[CoCreate CLI] Skipped global installation. You can install later by running: ${linkCommand}`
+            );
+            return;
+        }
+
+        console.log(`[CoCreate CLI] Attempting global link using ${packageManager}...`);
+
+        try {
+            await exec(linkCommand, {
+                cwd: cliPath
+            });
+            console.log(`[CoCreate CLI] Successfully linked globally via ${packageManager}`);
+        } catch (error) {
+            // Check if it's a permission error
+            if (error.message && error.message.includes("EACCES")) {
+                const useSudo = platform === "linux" || platform === "darwin";
+
+                if (useSudo) {
+                    // On Linux/macOS, offer to try with sudo
+                    const answer = await promptUser(
+                        `[CoCreate CLI] Permission denied. Try with sudo? (yes/no): `
+                    );
+
+                    if (answer) {
+                        try {
+                            const sudoCommand = `sudo ${linkCommand}`;
+                            console.log(
+                                `[CoCreate CLI] Attempting with sudo...`
+                            );
+                            await exec(sudoCommand, {
+                                cwd: cliPath,
+                                stdio: "inherit"
+                            });
+                            console.log(
+                                `[CoCreate CLI] Successfully linked globally with sudo`
+                            );
+                        } catch (sudoError) {
+                            console.warn(
+                                `[CoCreate CLI] Failed with sudo. Run this manually:`
+                            );
+                            console.warn(`  sudo ${linkCommand}`);
+                        }
+                    } else {
+                        console.warn(
+                            `[CoCreate CLI] Skipped. To link globally later, run:`
+                        );
+                        console.warn(`  ${linkCommand}`);
+                    }
+                } else if (isWindows) {
+                    // Windows
+                    console.warn(
+                        `[CoCreate CLI] Permission denied. Please run Command Prompt as Administrator and retry npm install`
+                    );
+                } else {
+                    // Other platforms
+                    console.warn(
+                        `[CoCreate CLI] Permission denied. You may need elevated privileges to link globally.`
+                    );
+                    console.warn(`  Run: ${linkCommand}`);
+                }
+            } else {
+                // Other errors
+                console.warn(
+                    `[CoCreate CLI] Failed to auto-link globally. Run this manually:`
+                );
+                console.warn(`  ${linkCommand}`);
+            }
+        }
+    } catch (error) {
+        console.warn("[CoCreate CLI] Postinstall linking encountered an issue.");
+    }
+}
+
+// Run the linking process
+linkGlobally().catch(() => {
+    // Silently fail - don't break npm install
+});

package/src/commands/fs/gitignore.js

@@ -1,32 +0,0 @@
-let glob = require("glob");
-let fs = require("fs");
-const path = require("path");
-
-function globUpdater(er, files) {
-  if (er) console.log(files, "glob resolving issue");
-  else files.forEach((filename) => update(filename));
-}
-
-function update(Path) {
-  let fileContent = `# ignore
-node_modules
-dist
-.npmrc
-
-`;
-  if (fs.existsSync(Path)) fs.unlinkSync(Path);
-  fs.writeFileSync(Path, fileContent);
-}
-
-// glob("../CoCreate-modules/CoCreate-action/.gitignore", globUpdater)
-// glob("./.gitignore", globUpdater)
-// glob("../CoCreate-adminUI/.gitignore", globUpdater)
-glob("../CoCreate-modules/*/.gitignore", globUpdater);
-glob("../CoCreate-apps/*/.gitignore", globUpdater);
-glob("../CoCreate-plugins/*/.gitignore", globUpdater);
-// glob("../CoCreate-website/.gitignore", globUpdater)
-// glob("../CoCreate-website-template/.gitignore", globUpdater)
-glob("../CoCreateCSS/.gitignore", globUpdater);
-// glob("../CoCreateJS/.gitignore", globUpdater)
-
-console.log("finished");