@bobschlowinskii/clicraft 0.4.0

package/helpers/auth/storage.js

@@ -0,0 +1,260 @@
+import fs from 'fs';
+import path from 'path';
+import { getConfigDir } from '../config.js';
+
+// Auth directory for storing multiple accounts
+const CONFIG_DIR = getConfigDir();
+const AUTH_DIR = path.join(CONFIG_DIR, 'auth');
+const ACCOUNTS_FILE = path.join(AUTH_DIR, 'accounts.json');
+
+// Ensure auth directory exists
+function ensureAuthDir() {
+    if (!fs.existsSync(AUTH_DIR)) {
+        fs.mkdirSync(AUTH_DIR, { recursive: true });
+    }
+}
+
+/**
+ * Load all accounts data
+ * @returns {{ accounts: Object.<string, AccountData>, currentAccount: string|null }}
+ */
+export function loadAccounts() {
+    ensureAuthDir();
+    if (fs.existsSync(ACCOUNTS_FILE)) {
+        try {
+            const data = JSON.parse(fs.readFileSync(ACCOUNTS_FILE, 'utf-8'));
+            return {
+                accounts: data.accounts || {},
+                currentAccount: data.currentAccount || null
+            };
+        } catch {
+            return { accounts: {}, currentAccount: null };
+        }
+    }
+    return { accounts: {}, currentAccount: null };
+}
+
+/**
+ * Save accounts data
+ * @param {{ accounts: Object, currentAccount: string|null }} data
+ */
+export function saveAccounts(data) {
+    ensureAuthDir();
+    fs.writeFileSync(ACCOUNTS_FILE, JSON.stringify(data, null, 2));
+}
+
+/**
+ * Get the currently active account
+ * @returns {AccountData|null}
+ */
+export function getCurrentAccount() {
+    const data = loadAccounts();
+    if (data.currentAccount && data.accounts[data.currentAccount]) {
+        return data.accounts[data.currentAccount];
+    }
+    return null;
+}
+
+/**
+ * Get account by UUID or username
+ * @param {string} identifier - UUID or username
+ * @returns {AccountData|null}
+ */
+export function getAccount(identifier) {
+    const data = loadAccounts();
+    const lowerIdentifier = identifier.toLowerCase();
+    
+    // Try UUID first
+    if (data.accounts[identifier]) {
+        return data.accounts[identifier];
+    }
+    
+    // Try username (case-insensitive)
+    for (const [uuid, account] of Object.entries(data.accounts)) {
+        if (account.username.toLowerCase() === lowerIdentifier) {
+            return account;
+        }
+    }
+    
+    return null;
+}
+
+/**
+ * Add or update an account
+ * @param {AccountData} accountData
+ * @param {boolean} setAsCurrent - Whether to set as current account
+ */
+export function addAccount(accountData, setAsCurrent = true) {
+    const data = loadAccounts();
+    data.accounts[accountData.uuid] = accountData;
+    
+    if (setAsCurrent || !data.currentAccount) {
+        data.currentAccount = accountData.uuid;
+    }
+    
+    saveAccounts(data);
+}
+
+/**
+ * Remove an account
+ * @param {string} identifier - UUID or username
+ * @returns {boolean} - Whether the account was removed
+ */
+export function removeAccount(identifier) {
+    const data = loadAccounts();
+    const lowerIdentifier = identifier.toLowerCase();
+    
+    let uuidToRemove = null;
+    
+    // Find by UUID
+    if (data.accounts[identifier]) {
+        uuidToRemove = identifier;
+    } else {
+        // Find by username
+        for (const [uuid, account] of Object.entries(data.accounts)) {
+            if (account.username.toLowerCase() === lowerIdentifier) {
+                uuidToRemove = uuid;
+                break;
+            }
+        }
+    }
+    
+    if (!uuidToRemove) {
+        return false;
+    }
+    
+    const removedAccount = data.accounts[uuidToRemove];
+    delete data.accounts[uuidToRemove];
+    
+    // If we removed the current account, switch to another one
+    if (data.currentAccount === uuidToRemove) {
+        const remaining = Object.keys(data.accounts);
+        data.currentAccount = remaining.length > 0 ? remaining[0] : null;
+    }
+    
+    saveAccounts(data);
+    return removedAccount;
+}
+
+/**
+ * Switch to a different account
+ * @param {string} identifier - UUID or username
+ * @returns {AccountData|null} - The account switched to, or null if not found
+ */
+export function switchAccount(identifier) {
+    const data = loadAccounts();
+    const lowerIdentifier = identifier.toLowerCase();
+    
+    let targetUuid = null;
+    
+    // Find by UUID
+    if (data.accounts[identifier]) {
+        targetUuid = identifier;
+    } else {
+        // Find by username
+        for (const [uuid, account] of Object.entries(data.accounts)) {
+            if (account.username.toLowerCase() === lowerIdentifier) {
+                targetUuid = uuid;
+                break;
+            }
+        }
+    }
+    
+    if (!targetUuid) {
+        return null;
+    }
+    
+    data.currentAccount = targetUuid;
+    saveAccounts(data);
+    
+    return data.accounts[targetUuid];
+}
+
+/**
+ * Get all accounts
+ * @returns {AccountData[]}
+ */
+export function getAllAccounts() {
+    const data = loadAccounts();
+    return Object.values(data.accounts);
+}
+
+/**
+ * Get account count
+ * @returns {number}
+ */
+export function getAccountCount() {
+    const data = loadAccounts();
+    return Object.keys(data.accounts).length;
+}
+
+/**
+ * Check if an account exists
+ * @param {string} identifier - UUID or username
+ * @returns {boolean}
+ */
+export function accountExists(identifier) {
+    return getAccount(identifier) !== null;
+}
+
+/**
+ * Update account data (e.g., refresh token)
+ * @param {string} uuid
+ * @param {Partial<AccountData>} updates
+ */
+export function updateAccount(uuid, updates) {
+    const data = loadAccounts();
+    if (data.accounts[uuid]) {
+        data.accounts[uuid] = { ...data.accounts[uuid], ...updates };
+        saveAccounts(data);
+    }
+}
+
+/**
+ * Migrate from old auth.json format
+ */
+export function migrateFromLegacy() {
+    const legacyFile = path.join(CONFIG_DIR, 'auth.json');
+    
+    if (fs.existsSync(legacyFile)) {
+        try {
+            const legacyAuth = JSON.parse(fs.readFileSync(legacyFile, 'utf-8'));
+            
+            if (legacyAuth.uuid && legacyAuth.username) {
+                const data = loadAccounts();
+                
+                // Only migrate if not already present
+                if (!data.accounts[legacyAuth.uuid]) {
+                    data.accounts[legacyAuth.uuid] = legacyAuth;
+                    data.currentAccount = legacyAuth.uuid;
+                    saveAccounts(data);
+                }
+                
+                // Backup and remove legacy file
+                const backupFile = path.join(CONFIG_DIR, 'auth.json.backup');
+                fs.renameSync(legacyFile, backupFile);
+                
+                return true;
+            }
+        } catch {
+            // Ignore migration errors
+        }
+    }
+    
+    return false;
+}
+
+export default {
+    loadAccounts,
+    saveAccounts,
+    getCurrentAccount,
+    getAccount,
+    addAccount,
+    removeAccount,
+    switchAccount,
+    getAllAccounts,
+    getAccountCount,
+    accountExists,
+    updateAccount,
+    migrateFromLegacy
+};

package/helpers/config.js

@@ -0,0 +1,258 @@
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+
+// Get the .clicraft config directory path
+export function getConfigDir() {
+    const configDir = path.join(os.homedir(), '.clicraft');
+    if (!fs.existsSync(configDir)) {
+        fs.mkdirSync(configDir, { recursive: true });
+    }
+    return configDir;
+}
+
+// Default settings
+const DEFAULT_SETTINGS = {
+    // to implement in the future
+
+    // Default Java path (null = auto-detect)
+    // javaPath: null,
+    // Default memory allocation
+    // minMemory: '1G',
+    // maxMemory: '2G',
+
+    checkUpdates: true,
+    autoSaveToConfig: true,
+    autoLoadConfigOnLaunch: true,
+    settingsVersion: '0.3.0',
+};
+
+// Default game settings to apply to new instances
+// These are Minecraft options.txt settings
+const DEFAULT_GAME_SETTINGS = {
+    // Common defaults - users can customize in ~/.clicraft/default-game-settings.json
+    // renderDistance: 12,
+    // fov: 70,
+    // guiScale: 0,
+    // gamma: 0.5,
+    // maxFps: 120,
+    // lang: 'en_us'
+};
+
+// Default list of game settings to ignore when sharing configs
+// These are typically user-specific or machine-specific
+const DEFAULT_GAME_SETTINGS_IGNORE = [
+    // Window/display settings (machine-specific)
+    'fullscreen',
+    'overrideWidth',
+    'overrideHeight',
+    'fullscreenResolution',
+    // Account/identity (user-specific)
+    'lastServer',
+    'resourcePacks',
+    'incompatibleResourcePacks',
+    // Keybinds (often personal preference, can cause issues)
+    'key_*',
+    // Accessibility (personal)
+    'narrator',
+    'highContrast',
+    // Telemetry
+    'telemetryOptInExtra',
+    'onboardAccessibility'
+];
+
+
+
+// Load global settings from ~/.clicraft/settings.json
+export function loadSettings() {
+    const configDir = getConfigDir();
+    const settingsPath = path.join(configDir, 'settings.json');
+    
+    if (!fs.existsSync(settingsPath)) {
+        // Create default settings file
+        saveSettings(DEFAULT_SETTINGS);
+        return { ...DEFAULT_SETTINGS };
+    }
+    
+    try {
+        const content = fs.readFileSync(settingsPath, 'utf-8');
+        const userSettings = JSON.parse(content);
+        // Merge with defaults to ensure all keys exist
+        return { ...DEFAULT_SETTINGS, ...userSettings };
+    } catch (err) {
+        console.error('Warning: Could not parse settings.json, using defaults');
+        return { ...DEFAULT_SETTINGS };
+    }
+}
+
+// Save global settings to ~/.clicraft/settings.json
+export function saveSettings(settings) {
+    const configDir = getConfigDir();
+    const settingsPath = path.join(configDir, 'settings.json');
+    fs.writeFileSync(settingsPath, JSON.stringify(settings, null, 2));
+}
+
+// Load the game settings ignore list from ~/.clicraft/game-settings-ignore.json
+export function loadGameSettingsIgnore() {
+    const configDir = getConfigDir();
+    const ignorePath = path.join(configDir, 'game-settings-ignore.json');
+    
+    if (!fs.existsSync(ignorePath)) {
+        // Create default ignore file
+        saveGameSettingsIgnore(DEFAULT_GAME_SETTINGS_IGNORE);
+        return [...DEFAULT_GAME_SETTINGS_IGNORE];
+    }
+    
+    try {
+        const content = fs.readFileSync(ignorePath, 'utf-8');
+        return JSON.parse(content);
+    } catch (err) {
+        console.error('Warning: Could not parse game-settings-ignore.json, using defaults');
+        return [...DEFAULT_GAME_SETTINGS_IGNORE];
+    }
+}
+
+// Save the game settings ignore list
+export function saveGameSettingsIgnore(ignoreList) {
+    const configDir = getConfigDir();
+    const ignorePath = path.join(configDir, 'game-settings-ignore.json');
+    fs.writeFileSync(ignorePath, JSON.stringify(ignoreList, null, 2));
+}
+
+// Load default game settings from ~/.clicraft/default-game-settings.json
+export function loadDefaultGameSettings() {
+    const configDir = getConfigDir();
+    const defaultsPath = path.join(configDir, 'default-game-settings.json');
+    
+    if (!fs.existsSync(defaultsPath)) {
+        // Create default file with commented example
+        saveDefaultGameSettings(DEFAULT_GAME_SETTINGS);
+        return { ...DEFAULT_GAME_SETTINGS };
+    }
+    
+    try {
+        const content = fs.readFileSync(defaultsPath, 'utf-8');
+        return JSON.parse(content);
+    } catch (err) {
+        console.error('Warning: Could not parse default-game-settings.json, using defaults');
+        return { ...DEFAULT_GAME_SETTINGS };
+    }
+}
+
+// Save default game settings
+export function saveDefaultGameSettings(settings) {
+    const configDir = getConfigDir();
+    const defaultsPath = path.join(configDir, 'default-game-settings.json');
+    fs.writeFileSync(defaultsPath, JSON.stringify(settings, null, 2));
+}
+
+// Check if a setting key matches the ignore list (supports wildcards)
+export function isSettingIgnored(key, ignoreList) {
+    for (const pattern of ignoreList) {
+        if (pattern.endsWith('*')) {
+            // Wildcard match
+            const prefix = pattern.slice(0, -1);
+            if (key.startsWith(prefix)) {
+                return true;
+            }
+        } else if (key === pattern) {
+            return true;
+        }
+    }
+    return false;
+}
+
+// Parse Minecraft options.txt into an object
+export function parseOptionsTxt(content) {
+    const options = {};
+    const lines = content.split('\n');
+    
+    for (const line of lines) {
+        const trimmed = line.trim();
+        if (!trimmed || !trimmed.includes(':')) continue;
+        
+        const colonIndex = trimmed.indexOf(':');
+        const key = trimmed.substring(0, colonIndex);
+        const value = trimmed.substring(colonIndex + 1);
+        
+        // Try to parse as number or boolean
+        if (value === 'true') {
+            options[key] = true;
+        } else if (value === 'false') {
+            options[key] = false;
+        } else if (!isNaN(value) && value !== '') {
+            options[key] = parseFloat(value);
+        } else {
+            options[key] = value;
+        }
+    }
+    
+    return options;
+}
+
+// Generate options.txt content from an object
+export function generateOptionsTxt(options) {
+    const lines = [];
+    
+    for (const [key, value] of Object.entries(options)) {
+        lines.push(`${key}:${value}`);
+    }
+    
+    return lines.join('\n');
+}
+
+// Extract game settings from options.txt, filtering out ignored settings
+export function extractGameSettings(optionsTxtPath) {
+    if (!fs.existsSync(optionsTxtPath)) {
+        return null;
+    }
+    
+    const content = fs.readFileSync(optionsTxtPath, 'utf-8');
+    const allOptions = parseOptionsTxt(content);
+    const ignoreList = loadGameSettingsIgnore();
+    
+    const filteredOptions = {};
+    for (const [key, value] of Object.entries(allOptions)) {
+        if (!isSettingIgnored(key, ignoreList)) {
+            filteredOptions[key] = value;
+        }
+    }
+    
+    return filteredOptions;
+}
+
+// Write game settings to options.txt in an instance
+export function writeGameSettings(instancePath, gameSettings) {
+    if (!gameSettings || Object.keys(gameSettings).length === 0) {
+        return;
+    }
+    
+    const optionsPath = path.join(instancePath, 'options.txt');
+    
+    // If options.txt already exists, merge with existing settings
+    let existingOptions = {};
+    if (fs.existsSync(optionsPath)) {
+        const content = fs.readFileSync(optionsPath, 'utf-8');
+        existingOptions = parseOptionsTxt(content);
+    }
+    
+    // Merge: gameSettings values override existing
+    const mergedOptions = { ...existingOptions, ...gameSettings };
+    
+    fs.writeFileSync(optionsPath, generateOptionsTxt(mergedOptions));
+}
+
+export default {
+    getConfigDir,
+    loadSettings,
+    saveSettings,
+    loadGameSettingsIgnore,
+    saveGameSettingsIgnore,
+    loadDefaultGameSettings,
+    saveDefaultGameSettings,
+    isSettingIgnored,
+    parseOptionsTxt,
+    generateOptionsTxt,
+    extractGameSettings,
+    writeGameSettings
+};

package/helpers/constants.js

@@ -0,0 +1,38 @@
+import version from './getv.js';
+
+// User agent for all API requests
+export const USER_AGENT = `clicraft/${version} (https://github.com/theinfamousben/clicraft)`;
+
+// Modrinth API base URL
+export const MODRINTH_API = 'https://api.modrinth.com/v2';
+
+// Mojang/Minecraft APIs
+export const MOJANG_VERSION_MANIFEST = 'https://launchermeta.mojang.com/mc/game/version_manifest.json';
+export const MOJANG_RESOURCES = 'https://resources.download.minecraft.net';
+
+// Fabric APIs
+export const FABRIC_META = 'https://meta.fabricmc.net/v2';
+export const FABRIC_MAVEN = 'https://maven.fabricmc.net';
+
+// Forge APIs
+export const FORGE_MAVEN = 'https://maven.minecraftforge.net';
+export const FORGE_PROMOS = 'https://files.minecraftforge.net/net/minecraftforge/forge/promotions_slim.json';
+
+// Pagination constants
+export const PAGE_SIZE = 10;
+export const NEXT_PAGE = '__NEXT_PAGE__';
+export const PREV_PAGE = '__PREV_PAGE__';
+
+export default {
+    USER_AGENT,
+    MODRINTH_API,
+    MOJANG_VERSION_MANIFEST,
+    MOJANG_RESOURCES,
+    FABRIC_META,
+    FABRIC_MAVEN,
+    FORGE_MAVEN,
+    FORGE_PROMOS,
+    PAGE_SIZE,
+    NEXT_PAGE,
+    PREV_PAGE
+};

package/helpers/getv.js

@@ -0,0 +1,5 @@
+import pkg from '../package.json' with { type: "json" };
+
+const version = pkg.version ?? pkg.default.version;
+
+export default version;