@cocreate/cli 1.54.2 → 1.56.0

package/src/commands/link.js

@@ -1,82 +1,217 @@
 const spawn = require("../spawn");
 const path = require("path");
 const fs = require("fs");
-const { color } = require("../fonts");
+const getPackageManager = require("../getPackageManager");
+const getOS = require("../getOS");
 
+const { isWindows } = getOS();
+
+/**
+ * Resolves the configured target node_modules directory path.
+ * Targeted check: parses RC files only associated with the active package manager.
+ * 
+ * @param {string} packageManager - The active package manager name (npm, pnpm, yarn-classic, yarn-berry, bun).
+ * @returns {string} Fully resolved path to the node_modules folder.
+ */
+function getTargetNodeModulesPath(packageManager) {
+    const cwd = process.cwd();
+
+    // Check .npmrc config if utilizing npm or pnpm
+    if (packageManager === "npm" || packageManager === "pnpm") {
+        const npmrcPath = path.join(cwd, ".npmrc");
+        if (fs.existsSync(npmrcPath)) {
+            try {
+                const content = fs.readFileSync(npmrcPath, "utf-8");
+                const match = content.match(/^\s*modules-dir\s*=\s*["']?([^"'\r\n#;]+)["']?/m);
+                if (match && match[1]) {
+                    return path.resolve(cwd, match[1].trim());
+                }
+            } catch (e) {
+                // Gracefully ignore reading errors
+            }
+        }
+    }
+
+    // Check .yarnrc config if utilizing Yarn (Classic or Berry configured for custom folders)
+    if (packageManager === "yarn-classic" || packageManager === "yarn-berry") {
+        const yarnrcPath = path.join(cwd, ".yarnrc");
+        if (fs.existsSync(yarnrcPath)) {
+            try {
+                const content = fs.readFileSync(yarnrcPath, "utf-8");
+                const match = content.match(/^\s*--(?:install\.)?modules-folder\s+["']?([^"'\r\n#]+)["']?/m);
+                if (match && match[1]) {
+                    return path.resolve(cwd, match[1].trim());
+                }
+            } catch (e) {
+                // Gracefully ignore reading errors
+            }
+        }
+    }
+
+    // Fallback to default
+    return path.resolve(cwd, "node_modules");
+}
+
+/**
+ * CLI-compatible link command that establishes local connections using 
+ * direct symlinking (fast mode) or the host system's package manager.
+ * 
+ * @param {Array<Object>} repos - Array of repository configurations.
+ * @param {Array<string>} args - Process arguments passed to the CLI command.
+ * @returns {Promise<Array<Object>>} List of packages that encountered real errors.
+ */
 module.exports = async (repos, args) => {
-	const failed = [],
-		isLinked = {};
-
-	try {
-		for (let repo of repos) {
-			if (!repo) continue;
-			if (repo.exclude && repo.exclude.includes("link")) continue;
-
-			if (process.cwd() === repo.absolutePath) continue;
-
-			if (repo.packageManager === "npm") {
-				let dir = path.resolve(process.cwd(), "node_modules");
-				let dest = path.resolve(
-					path.resolve(repo.absolutePath),
-					"node_modules"
-				);
-				if (dir && dest) {
-					if (fs.existsSync(dest))
-						await fs.promises.rm(dest, {
-							recursive: true,
-							force: true
-						});
-
-					await fs.promises.symlink(dir, dest, "dir");
-					console.log(repo.packageManager, "link", repo.packageName);
-				}
-			} else {
-				let exitCode = await spawn(repo.packageManager, ["link"], {
-					cwd: repo.absolutePath,
-					shell: true,
-					stdio: "inherit"
-				});
-
-				if (exitCode !== 0) {
-					failed.push({
-						name: repo.name,
-						error: `${repo.packageManager} link failed`
-					});
-					console.error(
-						color.red +
-							`${repo.name}: ${repo.packageManager} link failed` +
-							color.reset
-					);
-				} else {
-					console.log(repo.packageManager, "link", repo.packageName);
-
-					let exitCode = await spawn(
-						repo.packageManager,
-						["link", repo.packageName],
-						{
-							cwd: process.cwd(),
-							shell: true,
-							stdio: "inherit"
-						}
-					);
-					if (exitCode !== 0) {
-						failed.push({
-							name: repo.name,
-							error: `${repo.packageManager} link ${repo.packageName} failed`
-						});
-						console.error(
-							color.red +
-								`${repo.name}: ${repo.packageManager} link ${repo.packageName} failed` +
-								color.reset
-						);
-					}
-				}
-			}
-		}
-	} catch (err) {
-		failed.push({ name: "GENERAL", error: err.message });
-		console.error(color.red + `${err}` + color.reset);
-	}
-
-	return failed;
-};
+    const failed = [];
+    const packageManager = getPackageManager();
+    const cwd = process.cwd();
+    
+    // Convert generic internal yarn manager labels to the standard system execution binary name
+    const binName = (packageManager === "yarn-classic" || packageManager === "yarn-berry") 
+        ? "yarn" 
+        : packageManager;
+    
+    const useSymlink = args && args.includes("--symlink");
+    let targetNodeModules = null;
+
+    // --- PLUG'N'PLAY DETECTION & SHORT-CIRCUIT ---
+    const isPnp = packageManager === "yarn-berry" && (
+        fs.existsSync(path.join(cwd, ".pnp.cjs")) || 
+        fs.existsSync(path.join(cwd, ".pnp.js"))
+    );
+
+    if (isPnp) {
+        console.log(`Active Package Manager: ${packageManager.toUpperCase()} (Plug'n'Play Active)`);
+        console.log("No linking required (automatic mapping handled natively by the package manager).");
+        return failed;
+    }
+
+    console.log(`Active Package Manager: ${packageManager.toUpperCase()}`);
+
+    if (useSymlink) {
+        targetNodeModules = getTargetNodeModulesPath(packageManager);
+        const relativeTargetDir = path.relative(cwd, targetNodeModules) || "node_modules";
+        
+        console.log(`[Symlink Mode] Target: ${relativeTargetDir}\n`);
+
+        if (!fs.existsSync(targetNodeModules)) {
+            await fs.promises.mkdir(targetNodeModules, { recursive: true });
+        }
+    } else {
+        console.log(""); 
+    }
+
+    for (let repo of repos) {
+        if (!repo) continue;
+        if (repo.exclude && repo.exclude.includes("link")) continue;
+
+        const rawPath = repo.path || repo.absolutePath || repo.directory;
+        if (!rawPath) continue;
+
+        // Resolve local path values relative to the active command execution folder
+        repo.absolutePath = repo.absolutePath || path.resolve(cwd, rawPath);
+        repo.directory = repo.directory || path.dirname(repo.absolutePath);
+        repo.name = repo.name || path.basename(repo.absolutePath);
+
+        // Do not process current execution folder inside linking commands
+        if (cwd === repo.absolutePath) continue;
+
+        const relativeRepoPath = path.relative(cwd, repo.absolutePath);
+
+        // Verify package directory exists on local disk
+        if (!fs.existsSync(repo.absolutePath)) {
+            console.log(`Skipped (not found): ${relativeRepoPath}`);
+            continue;
+        }
+
+        // Dynamically resolve package name from local package.json if it is missing
+        if (!repo.packageName) {
+            const packageJsonPath = path.join(repo.absolutePath, "package.json");
+            if (fs.existsSync(packageJsonPath)) {
+                try {
+                    const packageObj = JSON.parse(fs.readFileSync(packageJsonPath, "utf8"));
+                    repo.packageName = packageObj.name;
+                } catch (e) {
+                    // Ignore reading errors
+                }
+            }
+            repo.packageName = repo.packageName || repo.name;
+        }
+
+        try {
+            if (useSymlink) {
+                const linkDestination = path.join(targetNodeModules, repo.packageName);
+                const sourcePath = path.resolve(repo.absolutePath);
+
+                await fs.promises.mkdir(path.dirname(linkDestination), { recursive: true });
+                try {
+                    const stat = await fs.promises.lstat(linkDestination);
+                    if (stat.isSymbolicLink() || stat.isFile()) {
+                        await fs.promises.unlink(linkDestination);
+                    } else {
+                        await fs.promises.rm(linkDestination, { recursive: true, force: true });
+                    }
+                } catch (e) {}
+
+                const type = isWindows ? "junction" : "dir";
+                await fs.promises.symlink(sourcePath, linkDestination, type);
+
+                console.log(`Successfully symlinked: ${relativeRepoPath} -> node_modules/${repo.packageName}`);
+            } else {
+                
+                // --- 1-STEP DIRECT PATH LINKING (pnpm & Yarn Berry) ---
+                if (packageManager === "pnpm" || packageManager === "yarn-berry") {
+                    console.log(`Linking: ${repo.packageName}...`);
+
+                    let linkCode = await spawn(binName, ["link", repo.absolutePath], {
+                        cwd: cwd,
+                        shell: true,
+                        stdio: "inherit"
+                    });
+
+                    if (linkCode !== 0) {
+                        throw new Error(`Execution failed`);
+                    }
+                    
+                } else {
+                    // --- 2-STEP GLOBAL REGISTRY LINKING (npm, Yarn Classic, Bun) ---
+                    console.log(`Registering: ${repo.packageName}...`);
+                    
+                    let regCode = await spawn(binName, ["link"], {
+                        cwd: repo.absolutePath,
+                        shell: true,
+                        stdio: "inherit"
+                    });
+
+                    if (regCode !== 0) {
+                        throw new Error(`Global registration failed`);
+                    }
+
+                    console.log(`Linking: ${repo.packageName}...`);
+
+                    let linkCode = await spawn(binName, ["link", repo.packageName], {
+                        cwd: cwd,
+                        shell: true,
+                        stdio: "inherit"
+                    });
+
+                    if (linkCode !== 0) {
+                        throw new Error(`Host linkage failed`);
+                    }
+                }
+                
+                console.log(`Successfully linked: ${repo.packageName}`);
+                console.log(""); 
+            }
+
+        } catch (err) {
+            // Log failure message and append package metadata for downstream retrying steps
+            failed.push({
+                name: repo.name || repo.packageName,
+                error: err.message
+            });
+            console.error(`Failed to link: ${repo.name || repo.packageName} (${err.message})`);
+        }
+    }
+
+    return failed;
+};

package/src/commands/{symlink.js → other/symlink.js}

@@ -1,6 +1,6 @@
 const fs = require("fs");
 const path = require("path");
-const spawn = require("../spawn");
+const spawn = require("../../spawn");
 
 const cwdPath = path.resolve(process.cwd());
 let cwdNodeModulesPath = path.resolve(cwdPath, "node_modules");

package/src/commands/upload.js

@@ -1,95 +1,129 @@
-const file = require("@cocreate/file");
+let fileModule = require("@cocreate/file");
+// Safely resolve default export if it's wrapped as an ESM module
+const file = fileModule && fileModule.default ? fileModule.default : fileModule;
+
 const path = require("path");
 const fs = require("fs");
 const { getConfig } = require("../getConfig");
 const translate = require("./other/translate");
 
 module.exports = async function upload(directory, args) {
-	if (args && !Array.isArray(args)) args = [args];
-
-	let isWatch = false;
-	let translateFn = null;
-
-	if (args && (args.includes("-t") || args.includes("--translate"))) {
-		translateFn = translate;
-		args = args.filter((arg) => arg !== "-t" && arg !== "--translate");
-	}
-
-	if (directory && typeof directory === "string") {
-		if (["-w", "--watch"].includes(directory)) {
-			isWatch = true;
-		}
-	}
-
-	directory = process.cwd();
-
-	if (
-		isWatch ||
-		(args && (args.includes("-w") || args.includes("--watch")))
-	) {
-		for (let i = 0; i < args.length; i++) {
-			if (args[i].startsWith("-")) continue;
-			else if (path.isAbsolute(args[i])) directory = args[i];
-			else directory = path.resolve(directory, args[i]);
-		}
-
-		console.log("Watching: ", directory);
-		fs.watch(
-			directory,
-			{ recursive: true },
-			async (eventType, filename) => {
-				if (!filename.includes("CoCreate.config.js")) {
-					const config = await getConfig(directory, filename);
-					if (config.configPath) {
-						await file(config, config.configPath, config.filePath, {
-							translate: translateFn
-						});
-					} else {
-						console.log(
-							"Failed to read or parse CoCreate.config.js."
-						);
-					}
-				}
-			}
-		);
-	} else {
-		if (!args || !args.length) {
-			const CoCreateConfig = await getConfig(directory);
-			if (CoCreateConfig.configPath) {
-				await file(
-					CoCreateConfig,
-					CoCreateConfig.configPath,
-					CoCreateConfig.filePath,
-					{ translate: translateFn }
-				);
-			} else {
-				console.log("Failed to read or parse CoCreate.config.js.");
-			}
-		} else {
-			for (let arg of args) {
-				arg = path.resolve(directory, arg);
-				let CoCreateConfig;
-
-				try {
-					CoCreateConfig = JSON.parse(arg);
-				} catch (error) {}
-
-				if (!CoCreateConfig) {
-					CoCreateConfig = await getConfig(arg);
-					if (CoCreateConfig.configPath) {
-						await file(
-							CoCreateConfig,
-							CoCreateConfig.configPath,
-							CoCreateConfig.filePath,
-							{ translate: translateFn }
-						);
-					} else {
-						console.log(
-							"Failed to read or parse CoCreate.config.js."
-						);
-					}
-				}
-			}
-		}
-	}
-};
+    if (args && !Array.isArray(args)) args = [args];
+
+    let isWatch = false;
+    let translateFn = null;
+
+    if (args && (args.includes("-t") || args.includes("--translate"))) {
+        translateFn = translate;
+        args = args.filter((arg) => arg !== "-t" && arg !== "--translate");
+    }
+
+    if (directory && typeof directory === "string") {
+        if (["-w", "--watch"].includes(directory)) {
+            isWatch = true;
+        }
+    }
+
+    directory = process.cwd();
+
+    if (
+        isWatch ||
+        (args && (args.includes("-w") || args.includes("--watch")))
+    ) {
+        for (let i = 0; i < args.length; i++) {
+            if (args[i].startsWith("-")) continue;
+            else if (path.isAbsolute(args[i])) directory = args[i];
+            else directory = path.resolve(directory, args[i]);
+        }
+
+        console.log("Watching: ", directory);
+        
+        // Initialize Map to store timers for debouncing rapid duplicate events
+        const debounceTimers = new Map();
+
+        fs.watch(
+            directory,
+            { recursive: true },
+            (eventType, filename) => {
+                // Guard against null filenames and ignore config changes
+                if (!filename || filename.includes("CoCreate.config.js")) return;
+
+                // Clear any existing timer for this file
+                if (debounceTimers.has(filename)) {
+                    clearTimeout(debounceTimers.get(filename));
+                }
+
+                // Set a new timer to debounce the event
+                const timer = setTimeout(async () => {
+                    // Remove the timer from the map once it executes
+                    debounceTimers.delete(filename);
+
+                    // 1. Only check file existence if the OS flagged a 'rename'
+                    // This handles creates, moves, and deletions properly.
+                    if (eventType === 'rename') {
+                        const fullPath = path.resolve(directory, filename);
+                        if (!fs.existsSync(fullPath)) {
+                            // console.log(`File deleted, renamed or relocated: ${filename}`);
+                            // TODO: Add file deletion/removal logic here in the future.
+                            return;
+                        }
+                    }
+
+                    // 2. Process the valid, updated file
+                    const config = await getConfig(directory, filename);
+                    if (config.configPath) {
+                        await file(config, config.configPath, config.filePath, {
+                            translate: translateFn
+                        });
+                    } else {
+                        console.log(
+                            "Failed to read or parse CoCreate.config.js."
+                        );
+                    }
+                }, 100); // 100ms debounce window
+
+                // Store the timer
+                debounceTimers.set(filename, timer);
+            }
+        );
+    } else {
+        if (!args || !args.length) {
+            const CoCreateConfig = await getConfig(directory);
+            if (CoCreateConfig.configPath) {
+                await file(
+                    CoCreateConfig,
+                    CoCreateConfig.configPath,
+                    CoCreateConfig.filePath,
+                    { translate: translateFn }
+                );
+            } else {
+                console.log("Failed to read or parse CoCreate.config.js.");
+            }
+        } else {
+            for (let arg of args) {
+                arg = path.resolve(directory, arg);
+                let CoCreateConfig;
+
+                try {
+                    CoCreateConfig = JSON.parse(arg);
+                } catch (error) {}
+
+                if (!CoCreateConfig) {
+                    CoCreateConfig = await getConfig(arg);
+                    if (CoCreateConfig.configPath) {
+                        await file(
+                            CoCreateConfig,
+                            CoCreateConfig.configPath,
+                            CoCreateConfig.filePath,
+                            { translate: translateFn }
+                        );
+                    } else {
+                        console.log(
+                            "Failed to read or parse CoCreate.config.js."
+                        );
+                    }
+                }
+            }
+        }
+    }
+};

package/src/config.template.js

@@ -0,0 +1,106 @@
+module.exports = {
+	// Organization and API credentials
+	organization_id: "YOUR_ORGANIZATION_ID",
+	key: "YOUR_API_KEY",
+
+	// WebSocket host configuration for different branches
+	// Update the domain name to your server domain
+	host: {
+		$branch: {
+			master: "wss://YOUR_DOMAIN.com",
+			dev: "wss://dev.YOUR_DOMAIN.com",
+			test: "wss://test.YOUR_DOMAIN.com"
+		}
+	},
+
+	// Directories to upload to the server
+	// Each directory entry specifies files to upload and how to store them
+	directories: [
+		{
+			// Path to the directory containing files to upload
+			entry: "./dist",
+			
+			// File patterns to exclude from upload
+			exclude: [".txt"],
+			
+			// Array name for storing files on server
+			array: "files",
+			
+			// Object structure for each file
+			// {{name}}, {{source}}, {{directory}}, etc. are template variables replaced automatically
+			object: {
+				name: "{{name}}",
+				src: "{{source}}",
+				host: ["*"],
+				directory: "{{directory}}",
+				path: "{{path}}",
+				pathname: "{{pathname}}",
+				"content-type": "{{content-type}}",
+				public: "true"
+			}
+		}
+	],
+
+	// Sources allows you to inject file contents into objects on the server
+	// Example: map file contents to specific keys
+	// Useful for embedding demo files, templates, etc.
+	sources: [
+		// {
+		// 	array: "demos",
+		// 	object: {
+		// 		_id: "unique_id",
+		// 		"demo-name": "{{./path/to/demo/file.html}}"
+		// 	}
+		// }
+	],
+
+	// Modules configuration for lazy loading and bundling
+	// Define which modules are lazy loaded vs always included
+	// Leave empty if modules are loaded from individual package.json files
+	modules: {
+		// outputPath: "./CoCreate.modules.js",
+		// "module-name": {
+		// 	import: "@cocreate/module-name",
+		// 	selector: "[attribute-selector]"
+		// }
+	},
+
+	// Plugin whitelist - add any plugins you use in your application
+	// Just whitelisting them here enables dynamic plugin loading from HTML
+	plugins: {
+		// Common plugins - add more as needed
+		Toastify: {
+			js: [{ src: "https://cdn.jsdelivr.net/npm/toastify-js", crossOrigin: "anonymous" }],
+			css: ["https://cdn.jsdelivr.net/npm/toastify-js/src/toastify.min.css"]
+		},
+		// Add other plugins here following the same structure
+		// Each plugin can have 'js' and 'css' arrays with CDN links
+	},
+
+	// Repositories for polyrepo management
+	// Each entry is a local repository that coc commands can operate on
+	// When you run "coc <command>", it executes that command on all listed repositories
+	// Example: "coc git status" runs "git status" on each repo (except those where "git" is excluded)
+	repositories: [
+		{
+			// Relative path to the repository
+			path: "./CoCreateJS",
+			
+			// Git repository URL
+			repo: "github.com/CoCreate-app/CoCreateJS.git",
+			
+			// Optional: exclude command types from running on this repository
+			// These are COMMAND TYPES to exclude, not file patterns
+			// Examples: "git", "npm", "link", "install", "clone"
+			// Use "git" to prevent git commands from running on this repo
+			// Use "link" to prevent npm link from running during "coc install"
+			exclude: ["git"]
+		}
+		// Add more repositories as needed for polyrepo management
+		// {
+		// 	path: "./CoCreate-modules/CoCreate-cli",
+		// 	repo: "github.com/CoCreate-app/CoCreate-cli.git",
+		// 	exclude: ["link"] // Don't link this package during "coc install"
+		// }
+	]
+};