@bobschlowinskii/clicraft 0.4.0

package/commands/install.js

@@ -0,0 +1,130 @@
+import chalk from 'chalk';
+import fs from 'fs';
+import path from 'path';
+import { downloadFile, loadConfig, saveConfig, getInstancePath, requireConfig } from '../helpers/utils.js';
+import { getProject, getProjectVersions } from '../helpers/modrinth.js';
+
+export async function installMod(modSlug, options) {
+    const instancePath = getInstancePath(options);
+    
+    const config = requireConfig(instancePath);
+    if (!config) return;
+
+    console.log(chalk.cyan(`\n📦 Installing "${modSlug}" to ${config.name}...\n`));
+
+    try {
+        // Get project info
+        const project = await getProject(modSlug);
+        if (!project) {
+            console.log(chalk.red(`Error: Mod "${modSlug}" not found on Modrinth.`));
+            console.log(chalk.gray('Use "clicraft search <query>" to find available mods.'));
+            return;
+        }
+
+        if (project.project_type !== 'mod') {
+            console.log(chalk.red(`Error: "${modSlug}" is a ${project.project_type}, not a mod.`));
+            return;
+        }
+
+        console.log(chalk.gray(`Found: ${project.title}`));
+        console.log(chalk.gray(`Looking for ${config.modLoader} version for Minecraft ${config.minecraftVersion}...`));
+
+        // Get compatible versions
+        const versions = await getProjectVersions(modSlug, config.minecraftVersion, config.modLoader);
+        
+        if (versions.length === 0) {
+            console.log(chalk.red(`\nNo compatible version found for ${config.modLoader} on Minecraft ${config.minecraftVersion}`));
+            
+            // Show available versions
+            const allVersions = await getProjectVersions(modSlug);
+            if (allVersions.length > 0) {
+                const loaders = [...new Set(allVersions.flatMap(v => v.loaders))];
+                const gameVersions = [...new Set(allVersions.flatMap(v => v.game_versions))].slice(0, 10);
+                console.log(chalk.gray(`\nAvailable loaders: ${loaders.join(', ')}`));
+                console.log(chalk.gray(`Recent game versions: ${gameVersions.join(', ')}`));
+            }
+            return;
+        }
+
+        // Use the latest compatible version
+        const version = versions[0];
+        const file = version.files.find(f => f.primary) || version.files[0];
+
+        if (!file) {
+            console.log(chalk.red('Error: No downloadable file found for this version.'));
+            return;
+        }
+
+        // Check if already installed
+        const existingMod = config.mods.find(m => m.projectId === project.id);
+        if (existingMod && !options.force) {
+            console.log(chalk.yellow(`\n⚠️  ${project.title} is already installed (version ${existingMod.versionNumber})`));
+            console.log(chalk.gray('Use --force to reinstall or update.'));
+            return;
+        }
+
+        // Create mods folder if needed
+        const modsPath = path.join(instancePath, 'mods');
+        if (!fs.existsSync(modsPath)) {
+            fs.mkdirSync(modsPath, { recursive: true });
+        }
+
+        // Remove old version if updating
+        if (existingMod) {
+            const oldFilePath = path.join(modsPath, existingMod.fileName);
+            if (fs.existsSync(oldFilePath)) {
+                fs.unlinkSync(oldFilePath);
+                console.log(chalk.gray(`Removed old version: ${existingMod.fileName}`));
+            }
+            config.mods = config.mods.filter(m => m.projectId !== project.id);
+        }
+
+        // Download the mod
+        const destPath = path.join(modsPath, file.filename);
+        console.log(chalk.gray(`Downloading ${file.filename}...`));
+        await downloadFile(file.url, destPath, null, false);
+
+        // Update config
+        config.mods.push({
+            projectId: project.id,
+            slug: project.slug,
+            name: project.title,
+            versionId: version.id,
+            versionNumber: version.version_number,
+            fileName: file.filename,
+            installedAt: new Date().toISOString()
+        });
+
+        saveConfig(instancePath, config);
+
+        console.log(chalk.green(`\n✅ Successfully installed ${project.title} v${version.version_number}`));
+        console.log(chalk.gray(`   File: mods/${file.filename}`));
+
+        // Show dependencies if any
+        if (version.dependencies?.length > 0) {
+            const requiredDeps = version.dependencies.filter(d => d.dependency_type === 'required');
+            if (requiredDeps.length > 0) {
+                console.log(chalk.yellow(`\n⚠️  This mod has ${requiredDeps.length} required dependencies:`));
+                for (const dep of requiredDeps) {
+                    if (dep.project_id) {
+                        const depProject = await getProject(dep.project_id);
+                        if (depProject) {
+                            const isInstalled = config.mods.some(m => m.projectId === dep.project_id);
+                            const status = isInstalled ? chalk.green('✓') : chalk.red('✗');
+                            console.log(chalk.gray(`   ${status} ${depProject.title} (${depProject.slug})`));
+                        }
+                    }
+                }
+                console.log(chalk.gray('\nInstall dependencies with: clicraft install <slug>'));
+            }
+        }
+
+    } catch (error) {
+        console.error(chalk.red('Error installing mod:'), error.message);
+        if (options.verbose) {
+            console.error(error);
+        }
+    }
+}
+
+export default { installMod };

package/commands/launch.js

@@ -0,0 +1,296 @@
+import chalk from 'chalk';
+import fs from 'fs';
+import path from 'path';
+import { spawn } from 'child_process';
+import { refreshAuth } from './auth.js';
+import { captureGameSettings } from '../commands/config.js';
+import { loadSettings, writeGameSettings } from '../helpers/config.js';
+import { 
+    loadConfig, 
+    getInstancePath, 
+    requireConfig, 
+    mavenToPath 
+} from '../helpers/utils.js';
+
+// Find Java executable
+function findJava() {
+    const javaHome = process.env.JAVA_HOME;
+    if (javaHome) {
+        const javaBin = path.join(javaHome, 'bin', process.platform === 'win32' ? 'java.exe' : 'java');
+        if (fs.existsSync(javaBin)) {
+            return javaBin;
+        }
+    }
+    return 'java';
+}
+
+// Get classpath separator
+function getClasspathSeparator() {
+    return process.platform === 'win32' ? ';' : ':';
+}
+
+// Build classpath from libraries
+function buildClasspath(instancePath, versionData) {
+    const sep = getClasspathSeparator();
+    const librariesPath = path.join(instancePath, 'libraries');
+    const classpath = [];
+
+    for (const lib of versionData.libraries || []) {
+        // Check OS rules
+        if (lib.rules) {
+            let dominated = false;
+            for (const rule of lib.rules) {
+                if (rule.os?.name) {
+                    const osName = process.platform === 'darwin' ? 'osx' : 
+                                   process.platform === 'win32' ? 'windows' : 'linux';
+                    if (rule.action === 'allow' && rule.os.name === osName) {
+                        dominated = true;
+                        break;
+                    }
+                } else if (rule.action === 'allow') {
+                    dominated = true;
+                    break;
+                }
+            }
+            if (!dominated) continue;
+        }
+
+        let libPath = null;
+        
+        if (lib.downloads?.artifact) {
+            libPath = path.join(librariesPath, lib.downloads.artifact.path);
+        } else if (lib.name) {
+            const relativePath = mavenToPath(lib.name);
+            if (relativePath) {
+                libPath = path.join(librariesPath, relativePath);
+            }
+        }
+        
+        if (libPath && fs.existsSync(libPath)) {
+            classpath.push(libPath);
+        }
+    }
+
+    return classpath.join(sep);
+}
+
+// Replace argument variables
+function replaceArgVariables(arg, variables) {
+    let result = arg;
+    for (const [key, value] of Object.entries(variables)) {
+        result = result.replace(new RegExp(`\\$\\{${key}\\}`, 'g'), value);
+    }
+    return result;
+}
+
+// Parse arguments from version JSON
+function parseArguments(args, variables) {
+    const result = [];
+    
+    for (const arg of args) {
+        if (typeof arg === 'string') {
+            result.push(replaceArgVariables(arg, variables));
+        } else if (typeof arg === 'object') {
+            let allowed = arg.rules?.some(rule => {
+                if (rule.os?.name) {
+                    const osName = process.platform === 'darwin' ? 'osx' : 
+                                   process.platform === 'win32' ? 'windows' : 'linux';
+                    return rule.action === 'allow' && rule.os.name === osName;
+                }
+                if (rule.features) return false;
+                return rule.action === 'allow';
+            }) ?? true;
+            
+            if (allowed && arg.value) {
+                const values = Array.isArray(arg.value) ? arg.value : [arg.value];
+                for (const v of values) {
+                    result.push(replaceArgVariables(v, variables));
+                }
+            }
+        }
+    }
+    
+    return result;
+}
+
+export async function launchInstance(options) {
+    const settings = loadSettings();
+    const instancePath = getInstancePath(options);
+    
+    // Apply saved game settings if enabled
+    if (settings.autoLoadConfigOnLaunch) {
+        const config = loadConfig(instancePath);
+        if (config?.gameSettings) {
+            writeGameSettings(instancePath, config.gameSettings);
+            if (options.verbose) {
+                console.log(chalk.gray('Applied saved game settings to options.txt'));
+            }
+        }
+    }
+
+    const config = requireConfig(instancePath);
+    if (!config) return;
+
+    if (config.type === 'server') {
+        console.log(chalk.red('Error: This is a server instance. Use ./start.sh to start the server.'));
+        return;
+    }
+
+    console.log(chalk.cyan(`\n🎮 Launching ${config.name}...\n`));
+
+    try {
+        // Get authentication
+        let auth = null;
+        if (!options.offline) {
+            auth = await refreshAuth();
+            if (!auth) {
+                console.log(chalk.yellow('Not logged in. Use "clicraft login" to authenticate.'));
+                console.log(chalk.gray('Or use --offline to play offline (if available).'));
+                return;
+            }
+            console.log(chalk.gray(`Logged in as: ${auth.username}`));
+        } else {
+            console.log(chalk.yellow('Launching in offline mode...'));
+            auth = {
+                uuid: '00000000000000000000000000000000',
+                username: 'Player',
+                accessToken: 'offline'
+            };
+        }
+
+        // Find version JSON
+        const versionId = config.versionId;
+        let versionData;
+
+        const fabricVersionPath = path.join(instancePath, 'versions', versionId, `${versionId}.json`);
+        const vanillaVersionPath = path.join(instancePath, 'versions', config.minecraftVersion, `${config.minecraftVersion}.json`);
+
+        if (fs.existsSync(fabricVersionPath)) {
+            versionData = JSON.parse(fs.readFileSync(fabricVersionPath, 'utf-8'));
+            
+            if (versionData.inheritsFrom && fs.existsSync(vanillaVersionPath)) {
+                const parentData = JSON.parse(fs.readFileSync(vanillaVersionPath, 'utf-8'));
+                versionData.libraries = [...(versionData.libraries || []), ...(parentData.libraries || [])];
+                versionData.assetIndex = versionData.assetIndex || parentData.assetIndex;
+                versionData.assets = versionData.assets || parentData.assets;
+                if (parentData.arguments) {
+                    versionData.arguments = versionData.arguments || {};
+                    versionData.arguments.jvm = [...(parentData.arguments?.jvm || []), ...(versionData.arguments?.jvm || [])];
+                    versionData.arguments.game = [...(versionData.arguments?.game || []), ...(parentData.arguments?.game || [])];
+                }
+            }
+        } else if (fs.existsSync(vanillaVersionPath)) {
+            versionData = JSON.parse(fs.readFileSync(vanillaVersionPath, 'utf-8'));
+        } else {
+            console.log(chalk.red('Error: Version data not found.'));
+            console.log(chalk.gray(`Expected: ${fabricVersionPath}`));
+            return;
+        }
+
+        // Find client JAR
+        const clientJarPath = path.join(instancePath, 'versions', config.minecraftVersion, `${config.minecraftVersion}.jar`);
+        if (!fs.existsSync(clientJarPath)) {
+            console.log(chalk.red('Error: Minecraft client JAR not found.'));
+            return;
+        }
+
+        // Build classpath
+        const sep = getClasspathSeparator();
+        const classpath = buildClasspath(instancePath, versionData) + sep + clientJarPath;
+
+        // Set up natives directory
+        const nativesPath = path.join(instancePath, 'natives');
+        fs.mkdirSync(nativesPath, { recursive: true });
+
+        const variables = {
+            'auth_player_name': auth.username,
+            'auth_uuid': auth.uuid,
+            'auth_access_token': auth.accessToken,
+            'auth_xuid': '',
+            'user_type': 'msa',
+            'version_name': versionId,
+            'version_type': 'release',
+            'game_directory': instancePath,
+            'assets_root': path.join(instancePath, 'assets'),
+            'assets_index_name': versionData.assets || versionData.assetIndex?.id || config.minecraftVersion,
+            'natives_directory': nativesPath,
+            'launcher_name': 'clicraft',
+            'launcher_version': '0.1.0',
+            'classpath': classpath,
+            'clientid': '',
+            'user_properties': '{}',
+            'resolution_width': '854',
+            'resolution_height': '480'
+        };
+
+        // Build JVM arguments
+        const jvmArgs = [
+            `-Djava.library.path=${nativesPath}`,
+            '-Xmx2G',
+            '-Xms512M',
+            '-XX:+UnlockExperimentalVMOptions',
+            '-XX:+UseG1GC',
+            '-XX:G1NewSizePercent=20',
+            '-XX:G1ReservePercent=20',
+            '-XX:MaxGCPauseMillis=50',
+            '-XX:G1HeapRegionSize=32M',
+            '-cp', classpath
+        ];
+
+        const mainClass = versionData.mainClass;
+
+        // Build game arguments
+        let gameArgs = [];
+        if (versionData.arguments?.game) {
+            gameArgs = parseArguments(versionData.arguments.game, variables);
+        } else if (versionData.minecraftArguments) {
+            gameArgs = versionData.minecraftArguments.split(' ').map(arg => replaceArgVariables(arg, variables));
+        }
+
+        const java = findJava();
+        const fullArgs = [...jvmArgs, mainClass, ...gameArgs];
+
+        console.log(chalk.gray(`Java: ${java}`));
+        console.log(chalk.gray(`Main class: ${mainClass}`));
+        console.log(chalk.gray(`Game directory: ${instancePath}`));
+        console.log();
+
+        if (options.verbose) {
+            console.log(chalk.gray('Full command:'));
+            console.log(chalk.gray(`${java} ${fullArgs.join(' ')}`));
+            console.log();
+        }
+
+        console.log(chalk.green('🚀 Starting Minecraft...\n'));
+
+        const minecraft = spawn(java, fullArgs, {
+            cwd: instancePath,
+            stdio: 'inherit',
+            detached: false
+        });
+
+        minecraft.on('error', (err) => {
+            console.error(chalk.red('Failed to start Minecraft:'), err.message);
+        });
+
+        minecraft.on('close', (code) => {
+            if (settings.autoSaveToConfig) {
+                captureGameSettings({ instance: instancePath, verbose: options.verbose }, settings.autoSaveToConfig);
+            }
+
+            if (code === 0) {
+                console.log(chalk.green('\nMinecraft closed normally.'));
+            } else {
+                console.log(chalk.yellow(`\nMinecraft exited with code ${code}`));
+            }
+        });
+
+    } catch (error) {
+        console.error(chalk.red('Error launching Minecraft:'), error.message);
+        if (options.verbose) {
+            console.error(error);
+        }
+    }
+}
+
+export default { launchInstance };

package/commands/search.js

@@ -0,0 +1,50 @@
+import chalk from 'chalk';
+import { searchMods as searchModrinth } from '../helpers/modrinth.js';
+import { formatDownloads } from '../helpers/utils.js';
+
+export async function searchMods(query, options) {
+    if (!query) {
+        console.log(chalk.red('Error: Please provide a search query'));
+        console.log(chalk.gray('Usage: clicraft search <query> [options]'));
+        return;
+    }
+
+    console.log(chalk.cyan(`\n🔍 Searching for "${query}" on Modrinth...\n`));
+
+    try {
+        const results = await searchModrinth(query, {
+            limit: options.limit || 10,
+            version: options.version,
+            loader: options.loader
+        });
+
+        if (results.hits.length === 0) {
+            console.log(chalk.yellow('No mods found matching your search.'));
+            return;
+        }
+
+        console.log(chalk.gray(`Found ${results.total_hits} results (showing ${results.hits.length}):\n`));
+
+        results.hits.forEach((mod, index) => {
+            const downloads = formatDownloads(mod.downloads);
+            const loaders = mod.categories?.filter(c => 
+                ['fabric', 'forge', 'quilt', 'neoforge'].includes(c)
+            ).join(', ') || 'Unknown';
+            
+            console.log(chalk.bold.white(`${index + 1}. ${mod.title}`));
+            console.log(chalk.gray(`   Slug: ${chalk.cyan(mod.slug)}`));
+            console.log(chalk.gray(`   ${mod.description}`));
+            console.log(chalk.gray(`   📥 ${chalk.green(downloads)} downloads  |  🔧 ${chalk.yellow(loaders)}`));
+            console.log(chalk.gray(`   🔗 https://modrinth.com/mod/${mod.slug}`));
+            console.log();
+        });
+
+    } catch (error) {
+        console.error(chalk.red('Error searching Modrinth:'), error.message);
+        if (options.verbose) {
+            console.error(error);
+        }
+    }
+}
+
+export default { searchMods };

package/commands/uninstall.js

@@ -0,0 +1,94 @@
+import chalk from 'chalk';
+import fs from 'fs';
+import path from 'path';
+import inquirer from 'inquirer';
+import { loadConfig, saveConfig, getInstancePath, requireConfig } from '../helpers/utils.js';
+import { findMod } from '../helpers/modrinth.js';
+
+export async function uninstallMod(modSlug, options) {
+    const instancePath = getInstancePath(options);
+    
+    const config = requireConfig(instancePath);
+    if (!config) return;
+
+    // If no mod specified, show interactive selection
+    if (!modSlug) {
+        if (!config.mods || config.mods.length === 0) {
+            console.log(chalk.yellow('\nNo mods installed in this instance.'));
+            return;
+        }
+
+        const { selectedMods } = await inquirer.prompt([{
+            type: 'checkbox',
+            name: 'selectedMods',
+            message: 'Select mods to uninstall:',
+            choices: config.mods.map(m => ({
+                name: `${m.name} (${m.versionNumber})`,
+                value: m.slug
+            }))
+        }]);
+
+        if (selectedMods.length === 0) {
+            console.log(chalk.yellow('\nNo mods selected.'));
+            return;
+        }
+
+        for (const slug of selectedMods) {
+            await uninstallSingleMod(instancePath, config, slug, options);
+        }
+        return;
+    }
+
+    await uninstallSingleMod(instancePath, config, modSlug, options);
+}
+
+async function uninstallSingleMod(instancePath, config, modSlug, options) {
+    const mod = findMod(config.mods, modSlug);
+    
+    if (!mod) {
+        console.log(chalk.red(`Error: Mod "${modSlug}" is not installed.`));
+        console.log(chalk.gray('Use "clicraft info --mods" to see installed mods.'));
+        return;
+    }
+
+    console.log(chalk.cyan(`\n🗑️  Uninstalling "${mod.name}"...\n`));
+
+    if (!options.force) {
+        const { confirm } = await inquirer.prompt([{
+            type: 'confirm',
+            name: 'confirm',
+            message: `Are you sure you want to uninstall ${mod.name}?`,
+            default: false
+        }]);
+
+        if (!confirm) {
+            console.log(chalk.yellow('Uninstall cancelled.'));
+            return;
+        }
+    }
+
+    try {
+        const modsPath = path.join(instancePath, 'mods');
+        const modFilePath = path.join(modsPath, mod.fileName);
+        
+        if (fs.existsSync(modFilePath)) {
+            fs.unlinkSync(modFilePath);
+            console.log(chalk.gray(`Deleted: mods/${mod.fileName}`));
+        } else {
+            console.log(chalk.yellow(`Warning: Mod file not found: mods/${mod.fileName}`));
+        }
+
+        config.mods = config.mods.filter(m => m.projectId !== mod.projectId);
+        saveConfig(instancePath, config);
+
+        console.log(chalk.green(`\n✅ Successfully uninstalled ${mod.name}`));
+
+    } catch (error) {
+        console.error(chalk.red('Error uninstalling mod:'), error.message);
+        if (options.verbose) {
+            console.error(error);
+        }
+    }
+}
+
+export default { uninstallMod };