gingee-cli 1.0.0

package/commands/packageApp.js

@@ -0,0 +1,66 @@
+const apiClient = require('./apiClient');
+const fs = require('fs-extra');
+const path = require('path');
+
+async function packageApp(options) {
+    const { default: chalk } = await import('chalk');
+    const { default: ora } = await import('ora');
+    const { serverUrl, appName, dest: destFolder } = options;
+    const spinner = ora(`Requesting package for '${appName}' from server...`).start();
+
+    try {
+        // This returns a readable stream of the file being downloaded.
+        const response = await apiClient.packageApp(serverUrl, appName);
+        const fileStream = response.data;
+
+        let fileName = `${appName}.gin`;
+        const contentDisposition = response.headers['content-disposition'];
+        if (contentDisposition) {
+            const fileNameMatch = contentDisposition.match(/filename="(.+)"/);
+            if (fileNameMatch && fileNameMatch.length > 1) {
+                fileName = fileNameMatch[1];
+                spinner.info(`Server suggested filename: ${fileName}`);
+            }
+        }
+        
+        let destPathRoot = process.cwd(); // Default to the current working directory
+        if (destFolder) {
+            try {
+                const userDest = path.resolve(destFolder);
+                // fs-extra's ensureDirSync is like `mkdir -p`, safe to run even if it exists.
+                fs.ensureDirSync(userDest); 
+                destPathRoot = userDest;
+            } catch (err) {
+                spinner.warn(chalk.yellow(`Could not create or access destination folder '${destFolder}'. Falling back to the current directory.`));
+            }
+        }
+        const finalDestPath = path.join(destPathRoot, fileName);
+        const writer = fs.createWriteStream(finalDestPath);
+        
+        spinner.text = `Downloading package to ${fileName}...`;
+
+        // Pipe the download stream to the file writer stream.
+        fileStream.pipe(writer);
+        
+        await new Promise((resolve, reject) => {
+            writer.on('finish', resolve);
+            writer.on('error', reject);
+        });
+        
+        spinner.succeed(chalk.bgGreen(`✅ Success!`), chalk.blueBright(`Application '${appName}' packaged to:`));
+        console.log(chalk.cyan(`   ${finalDestPath}`));
+
+    } catch (err) {
+        spinner.fail(chalk.bgRed('Packaging failed.'));
+        if (err.errors) { //for AggregateError
+            const messages = err.errors.map(e => e.message).join('\n');
+            console.error(chalk.bgRed(`Error: `), chalk.blueBright(`${messages}`));
+        } else {
+            const message = _getHttpClientErrorMessage(err);
+            console.error(chalk.bgRed(`Error: `), chalk.blueBright(`${message}`));
+        }
+        process.exit(1);
+    }
+}
+
+module.exports = { packageApp };

package/commands/resetGlade.js

@@ -0,0 +1,95 @@
+const fs = require('fs-extra');
+const path = require('path');
+const argon2 = require('argon2');
+const { getProjectRoot, getWebRoot } = require('./utils');
+const { _unzipBuffer } = require('./installerUtils');
+
+async function resetGlade() {
+    const { default: chalk } = await import('chalk');
+    const { default: inquirer } = await import('inquirer');
+    const { default: ora } = await import('ora');
+    const spinner = ora();
+
+    try {
+        console.log(chalk.blueBright('⚠️  Glade Admin Panel Install/Reset Utility  ⚠️'));
+
+        const projectRoot = getProjectRoot();
+        const webRoot = getWebRoot(projectRoot);
+        const gladeAppPath = path.join(webRoot, 'glade');
+
+        // --- THIS IS THE NEW, MORE ROBUST LOGIC ---
+        if (fs.existsSync(gladeAppPath)) {
+            // If the folder exists, we are in "reset" mode. We need confirmation.
+            const { confirmation } = await inquirer.prompt([
+                {
+                    type: 'input',
+                    name: 'confirmation',
+                    message: `This will ${chalk.bgRed('PERMANENTLY DELETE')} the existing 'glade' application and reinstall it.\n  To confirm, please type the name of the app ('glade'):`,
+                }
+            ]);
+
+            if (confirmation !== 'glade') {
+                console.log(chalk.yellow('Reset cancelled. No changes were made.'));
+                return;
+            }
+
+            // Deletion
+            spinner.start('Deleting current `glade` installation...');
+            fs.removeSync(gladeAppPath);
+            spinner.succeed('Current `glade` installation deleted.');
+        }
+        // --- END OF NEW LOGIC ---
+        // If the folder didn't exist, we just proceed directly to installation.
+
+        // --- Re-installation ---
+        spinner.start('Installing a clean version of `glade`...');
+        const gladeGinPath = require.resolve('gingee/templates/glade.gin');
+        const gladePackageBuffer = fs.readFileSync(gladeGinPath);
+        await _unzipBuffer(gladePackageBuffer, gladeAppPath);
+        spinner.succeed('Clean `glade` version installed.');
+
+        // --- Re-configuration (Wizard runs in both cases) ---
+        console.log(chalk.blueBright('\nPlease set the administrator credentials.'));
+        const newCreds = await inquirer.prompt([
+            { type: 'input', name: 'adminUser', message: 'Enter a username for the Glade admin panel:', default: 'admin' },
+            { type: 'password', name: 'adminPass', message: 'Enter a password for the Glade admin:', mask: '*' },
+        ]);
+
+        if (!newCreds.adminPass) {
+            throw new Error("Admin password cannot be empty.");
+        }
+
+        spinner.start('Configuring admin credentials...');
+        const passwordHash = await argon2.hash(newCreds.adminPass);
+        const gladeAppConfigPath = path.join(gladeAppPath, 'box', 'app.json');
+        const gladeAppConfig = fs.readJsonSync(gladeAppConfigPath);
+        gladeAppConfig.env.ADMIN_USERNAME = newCreds.adminUser;
+        gladeAppConfig.env.ADMIN_PASSWORD_HASH = passwordHash;
+        fs.writeJsonSync(gladeAppConfigPath, gladeAppConfig, { spaces: 2 });
+        spinner.succeed('Admin credentials configured securely.');
+
+        spinner.start('Granting default permissions to Glade...');
+        const permissionsFilePath = path.join(projectRoot, 'settings', 'permissions.json');
+        const permissionsConfig = {
+            "glade": {
+                "granted": ["platform", "fs"]
+            }
+        };
+        fs.writeJsonSync(permissionsFilePath, permissionsConfig, { spaces: 2 });
+        spinner.succeed('Default permissions for Glade configured.');
+
+        console.log(chalk.bgGreen(`\n✅ Success!`), chalk.blueBright(`The 'glade' admin panel is ready.`));
+
+    } catch (err) {
+        spinner.fail(chalk.bgRed('Operation failed.'));
+        if (err.errors) { //for AggregateError
+            const messages = err.errors.map(e => e.message).join('\n');
+            console.error(chalk.bgRed(`Error: `), chalk.blueBright(`${messages}`));
+        } else {
+            console.error(chalk.bgRed(`\nError: `), chalk.blueBright(`${err.message}`));
+        }
+        process.exit(1);
+    }
+}
+
+module.exports = { resetGlade };

package/commands/resetPwd.js

@@ -0,0 +1,80 @@
+const fs = require('fs-extra');
+const path = require('path');
+const argon2 = require('argon2');
+const { getProjectRoot, getWebRoot } = require('./utils');
+
+async function resetPwd() {
+    const { default: chalk } = await import('chalk');
+    const { default: inquirer } = await import('inquirer');
+
+    try {
+        console.log(chalk.blueBright('Glade Admin Password Reset Utility'));
+
+        const projectRoot = getProjectRoot();
+        const webRoot = getWebRoot(projectRoot);
+        const gladeAppPath = path.join(webRoot, 'glade');
+        const gladeAppConfigPath = path.join(gladeAppPath, 'box', 'app.json');
+
+        // Verify that the glade app and its config exist
+        if (!fs.existsSync(gladeAppConfigPath)) {
+            throw new Error("Could not find the `glade` application's app.json file. Is glade installed?");
+        }
+
+        // --- Run the interactive wizard ---
+        const answers = await inquirer.prompt([
+            {
+                type: 'password',
+                name: 'newPassword',
+                message: 'Enter the new password for the Glade admin:',
+                mask: '*',
+                validate: input => {
+                    if (!input || input.length < 8) {
+                        return 'Password must be at least 8 characters long.';
+                    }
+                    return true;
+                }
+            },
+            {
+                type: 'password',
+                name: 'confirmPassword',
+                message: 'Confirm the new password:',
+                mask: '*',
+            }
+        ]);
+
+        if (answers.newPassword !== answers.confirmPassword) {
+            throw new Error("Passwords do not match. Please try again.");
+        }
+
+        console.log(chalk.blueBright('Hashing new password...'));
+        
+        // --- Hash the password ---
+        const passwordHash = await argon2.hash(answers.newPassword);
+        
+        // --- Safely update app.json ---
+        const appConfig = fs.readJsonSync(gladeAppConfigPath);
+        
+        // Ensure the env object exists
+        if (!appConfig.env) {
+            appConfig.env = {};
+        }
+        
+        appConfig.env.ADMIN_PASSWORD_HASH = passwordHash;
+        
+        fs.writeJsonSync(gladeAppConfigPath, appConfig, { spaces: 2 });
+
+        console.log(chalk.bgGreen(`\n✅ Success!`), chalk.blueBright(`The Glade admin password has been reset.`));
+        console.log(chalk.blueBright(`   You can now log in with your new password.`));
+
+    } catch (err) {
+        if (err.errors) { //for AggregateError
+            const messages = err.errors.map(e => e.message).join('\n');
+            console.error(chalk.bgRed(`Error: `), chalk.blueBright(`${messages}`));
+        } else {
+            console.error(chalk.bgRed(`\nError: `), chalk.blueBright(`${err.message}`));
+        }
+        process.exit(1);
+    }
+}
+
+module.exports = { resetPwd };

package/commands/rollbackApp.js

@@ -0,0 +1,63 @@
+const apiClient = require('./apiClient');
+const { _getHttpClientErrorMessage, _getRollbackPermissions, _readAppPreset, _validateAppPreset } = require('./installerUtils'); // Use the new, specific utility
+
+async function rollbackApp(options) {
+    const { default: chalk } = await import('chalk');
+    const { default: ora } = await import('ora');
+    const { default: inquirer } = await import('inquirer');
+    const { serverUrl, appName, file: presetFilePath } = options;
+    let finalPermissions;
+    const spinner = ora();
+
+    try {
+        if (presetFilePath) {
+            // --- NON-INTERACTIVE MODE ---
+            console.log(chalk.blueBright(`Running in non-interactive mode using preset file: ${presetFilePath}`));
+            const preset = _readAppPreset(presetFilePath);
+            _validateAppPreset(preset, 'rollback');
+            finalPermissions = preset.rollback.consent.grantPermissions;
+            console.log(chalk.blueBright(`Permissions to be granted upon rollback: [${finalPermissions.join(', ')}]`));
+        } else {
+            spinner.start(`Analyzing latest backup for '${appName}'...`);
+            const analysis = await apiClient.analyzeBackup(serverUrl, appName);
+            if (analysis.status !== 'success') throw new Error(analysis.error || 'Failed to analyze backup.');
+
+            const currentPermsResponse = await apiClient.getAppPermissions(serverUrl, appName);
+            if (currentPermsResponse.status !== 'success') throw new Error(currentPermsResponse.error || 'Failed to get current permissions.');
+            spinner.succeed('Backup analysis complete.');
+
+            console.log(chalk.blueBright(`\nThis will roll back '${appName}' to version ${analysis.version}.`));
+
+            const { proceed } = await inquirer.prompt([{
+                type: 'confirm',
+                name: 'proceed',
+                message: 'Are you sure you want to proceed with the rollback?',
+                default: false
+            }]);
+            if (!proceed) throw new Error('Rollback cancelled by user.');
+            finalPermissions = await _getRollbackPermissions(analysis.permissions, currentPermsResponse.grantedPermissions);
+        }
+
+        spinner.start(`Executing rollback for '${appName}'...`);
+        const result = await apiClient.rollbackApp(serverUrl, appName, finalPermissions);
+
+        if (result.status !== 'success') {
+            throw new Error(result.message || 'Server responded with an unknown error.');
+        }
+
+        spinner.succeed(chalk.bgGreen(`✅ Success!`), chalk.blueBright(`App '${appName}' has been rolled back.`));
+
+    } catch (err) {
+        spinner.fail(chalk.blueBright('Rollback failed.'));
+        if (err.errors) { //for AggregateError
+            const messages = err.errors.map(e => e.message).join('\n');
+            console.error(chalk.bgRed(`Error: `), chalk.blueBright(`${messages}`));
+        } else {
+            const message = _getHttpClientErrorMessage(err);
+            console.error(chalk.bgRed(`Error: `), chalk.blueBright(message));
+        }
+        process.exit(1);
+    }
+}
+
+module.exports = { rollbackApp };

package/commands/service.js

@@ -0,0 +1,123 @@
+const os = require('os');
+const path = require('path');
+
+// Dynamically and safely require the correct service library based on the OS.
+let Service;
+const platform = os.platform();
+let platformName = '';
+
+try {
+    if (platform === 'win32') {
+        Service = require('node-windows').Service;
+        platformName = 'Windows';
+    } else if (platform === 'linux') {
+        Service = require('node-linux').Service;
+        platformName = 'Linux (systemd)';
+    } else if (platform === 'darwin') {
+        Service = require('node-mac').Service;
+        platformName = 'macOS (launchd)';
+    }
+} catch (e) {
+    // This will catch the error if the optional dependency was not installed.
+    Service = null;
+}
+
+
+/**
+ * Creates a configured Service instance.
+ * @returns {Service|null}
+ */
+function getService() {
+    if (!Service) {
+        return null;
+    }
+    const { getProjectRoot } = require('./utils');
+    const projectRoot = getProjectRoot();
+    const scriptPath = path.join(projectRoot, 'start.js');
+
+    return new Service({
+        name: 'Gingee Server',
+        description: `Gingee server instance running at ${projectRoot}`,
+        script: scriptPath
+    });
+}
+
+async function install() {
+    const { default: chalk } = await import('chalk');
+    const svc = getService();
+
+    if (!svc) {
+        console.error(chalk.bgRed('Error:'), chalk.blueBright('Service installation is not supported on this operating system.'));
+        console.log(chalk.yellow('For other systems, we recommend using a process manager like PM2.'));
+        return;
+    }
+
+    svc.on('install', () => {
+        console.log(chalk.bgGreen('✅ Success!'), chalk.blueBright(`Service installed for ${platformName}.`));
+        console.log('Starting the service...');
+        svc.start();
+        console.log(chalk.blueBright('Service started. Your Gingee server is now running in the background.'));
+    });
+
+    svc.on('alreadyinstalled', () => {
+        console.log(chalk.yellow('This service is already installed.'));
+    });
+
+    svc.on('invalidinstallation', () => {
+        console.error(chalk.bgRed('Error: Invalid service installation. Do you have the necessary permissions?'));
+        console.log(chalk.yellow('On Linux/macOS, you may need to run this command with `sudo`.'));
+        console.log(chalk.yellow('On Windows, you may need to run from an Administrator terminal.'));
+    });
+
+    console.log(chalk.blue(`Attempting to install the Gingee service for ${platformName}...`));
+    svc.install();
+}
+
+// --- We can now implement the other service commands ---
+
+async function uninstall() {
+    const { default: chalk } = await import('chalk');
+    const svc = getService();
+    if (!svc) {
+        console.error(chalk.bgRed('Error:'), chalk.blueBright('Service installation is not supported on this operating system.'));
+        console.log(chalk.yellow('For other systems, we recommend using a process manager like PM2.'));
+        return;
+    }
+
+    svc.on('uninstall', () => {
+        console.log(chalk.bgGreen('✅ Success!'), chalk.blueBright('Service uninstalled.'));
+    });
+    
+    console.log(chalk.blue('Attempting to uninstall the service...'));
+    svc.uninstall();
+}
+
+async function start() {
+    const { default: chalk } = await import('chalk');
+    const svc = getService();
+    if (!svc) {
+        console.error(chalk.bgRed('Error:'), chalk.blueBright('Service installation is not supported on this operating system.'));
+        console.log(chalk.yellow('For other systems, we recommend using a process manager like PM2.'));
+        return;
+    }
+
+    svc.on('start', () => console.log(chalk.bgGreen('Service started.')));
+    console.log(chalk.blue('Attempting to start the service...'));
+    svc.start();
+}
+
+async function stop() {
+    const { default: chalk } = await import('chalk');
+    const svc = getService();
+    if (!svc) { 
+        console.error(chalk.bgRed('Error:'), chalk.blueBright('Service installation is not supported on this operating system.'));
+        console.log(chalk.yellow('For other systems, we recommend using a process manager like PM2.'));
+        return;
+    }
+    
+    svc.on('stop', () => console.log(chalk.yellow('Service stopped.')));
+    console.log(chalk.blue('Attempting to stop the service...'));
+    svc.stop();
+}
+
+module.exports = { install, uninstall, start, stop };

package/commands/upgradeApp.js

@@ -0,0 +1,80 @@
+const fs = require('fs-extra');
+const path = require('path');
+const os = require('os');
+const { _getHttpClientErrorMessage, _unzipBuffer, _repackApp, _getUpgradePermissions, _getDbRequirements, _readAppPreset, _validateAppPreset, _substituteEnvVars } = require('./installerUtils');
+const apiClient = require('./apiClient');
+
+async function upgradeApp(options) {
+    const { default: chalk } = await import('chalk');
+    const { default: ora } = await import('ora');
+    const tempDir = path.join(os.tmpdir(), `gingee-upgrade-${Date.now()}`);
+
+    const { serverUrl, appName, ginPath: ginFilePath, file: presetFilePath } = options;
+    let finalPermissions, finalDbConfig;
+    const spinner = ora();
+
+    try {
+
+        if (!fs.existsSync(ginFilePath)) {
+            throw new Error(`Package file not found at: ${ginFilePath}`);
+        }
+
+        spinner.start(`Reading new package ${path.basename(ginFilePath)}...`);
+        const packageBuffer = fs.readFileSync(ginFilePath);
+        await fs.ensureDir(tempDir);
+        const unpackedPath = path.join(tempDir, 'unpacked');
+        await _unzipBuffer(packageBuffer, unpackedPath);
+        spinner.succeed('New package unpacked.');
+
+        if (presetFilePath) {
+            // --- NON-INTERACTIVE MODE ---
+            console.log(chalk.blueBright(`Running in non-interactive mode using preset file: ${presetFilePath}`));
+            const preset = _readAppPreset(presetFilePath);
+            _validateAppPreset(preset, 'upgrade');
+            finalPermissions = preset.upgrade.consent.grantPermissions;
+            finalDbConfig = _substituteEnvVars(preset.upgrade.config.db);
+        } else {
+            spinner.start(`Fetching current permissions for '${appName}'...`);
+            const currentPermsResponse = await apiClient.getAppPermissions(serverUrl, appName);
+            if (currentPermsResponse.status !== 'success') {
+                throw new Error(currentPermsResponse.error || 'Could not fetch current permissions.');
+            }
+            spinner.succeed('Current permissions fetched.');
+
+            finalPermissions = await _getUpgradePermissions(unpackedPath, currentPermsResponse.grantedPermissions);
+
+            finalDbConfig = await _getDbRequirements(unpackedPath);
+        }
+
+        spinner.start('Applying configuration and repacking...');
+        const appJsonPath = path.join(unpackedPath, 'box', 'app.json');
+        const appJson = await fs.readJson(appJsonPath);
+        if (finalDbConfig.length > 0) appJson.db = finalDbConfig;
+        await fs.writeJson(appJsonPath, appJson, { spaces: 2 });
+
+        const finalPackageBuffer = await _repackApp(unpackedPath);
+        spinner.succeed('Configuration applied and package repacked.');
+
+        spinner.start(`Upgrading '${appName}' on ${serverUrl}...`);
+        const result = await apiClient.upgradeApp(serverUrl, appName, `${appName}.gin`, finalPackageBuffer, finalPermissions);
+
+        if (result.status !== 'success') {
+            throw new Error(result.message || 'Server responded with an unknown error.');
+        }
+
+        spinner.succeed(chalk.bgGreen(`✅ Success!`), chalk.blueBright(result.message || `App '${appName}' upgraded.`));
+
+    } catch (err) {
+        spinner.fail(chalk.bgRed('Upgrade failed.'));
+        if (err.errors) { //for AggregateError
+            const messages = err.errors.map(e => e.message).join('\n');
+            console.error(chalk.bgRed(`Error: `), chalk.blueBright(`${messages}`));
+        } else {
+            const message = _getHttpClientErrorMessage(err);
+            console.error(chalk.bgRed(`Error: `), chalk.blueBright(`${message}`));
+        }
+        process.exit(1);
+    }
+}
+
+module.exports = { upgradeApp };

package/commands/upgradeStoreApp.js

@@ -0,0 +1,97 @@
+const axios = require('axios');
+const fs = require('fs-extra');
+const path = require('path');
+const os = require('os');
+const { 
+    _unzipBuffer, 
+    _repackApp, 
+    _getUpgradePermissions, 
+    _getDbRequirements, 
+    _resolveStoreUrl,
+    _resolveDownloadUrl
+} = require('./installerUtils');
+const apiClient = require('./apiClient');
+
+async function upgradeStoreApp(appName, options) {
+    const { default: chalk } = await import('chalk');
+    const { default: ora } = await import('ora');
+    const spinner = ora();
+    const tempDir = path.join(os.tmpdir(), `gingee-upgrade-store-${Date.now()}`);
+
+    const { gStoreUrl, serverUrl } = options;
+
+    try {
+        // 1. Resolve URL and fetch the store manifest
+        const resolvedStoreUrl = _resolveStoreUrl(gStoreUrl);
+        spinner.start(`Fetching manifest from ${resolvedStoreUrl}...`);
+        
+        const manifestResponse = await axios.get(resolvedStoreUrl);
+        const appConfig = manifestResponse.data.apps.find(a => a.name === appName);
+        if (!appConfig) {
+            throw new Error(`App '${appName}' not found in the store manifest.`);
+        }
+        spinner.succeed('Found app in store manifest.');
+
+        // 2. Resolve the download URL and download the new package
+        const downloadUrl = _resolveDownloadUrl(resolvedStoreUrl, appConfig.download_url);
+        spinner.start(`Downloading new package from ${downloadUrl}...`);
+        const downloadResponse = await axios.get(downloadUrl, { responseType: 'arraybuffer' });
+        const packageBuffer = downloadResponse.data;
+        spinner.succeed('New package downloaded.');
+
+        // 3. Unpack the new package to a temporary directory
+        await fs.ensureDir(tempDir);
+        const unpackedPath = path.join(tempDir, 'unpacked');
+        await _unzipBuffer(packageBuffer, unpackedPath);
+
+        // 4. Fetch the currently granted permissions for the installed app
+        spinner.start(`Fetching current permissions for '${appName}'...`);
+        const currentPermsResponse = await apiClient.getAppPermissions(serverUrl, appName);
+        if (currentPermsResponse.status !== 'success') {
+            throw new Error(currentPermsResponse.error || 'Could not fetch current permissions.');
+        }
+        spinner.succeed('Current permissions fetched.');
+
+        // 5. Run the interactive permission comparison and consent prompt
+        const grantedPermissions = await _getUpgradePermissions(unpackedPath, currentPermsResponse.grantedPermissions);
+        
+        // 6. Run the interactive database configuration prompt
+        const dbConfigUpdates = await _getDbRequirements(unpackedPath);
+
+        // 7. Repackage the app with the new configuration
+        spinner.start('Applying configuration and repacking...');
+        const appJsonPath = path.join(unpackedPath, 'box', 'app.json');
+        const appJson = await fs.readJson(appJsonPath);
+        if (dbConfigUpdates.length > 0) {
+            appJson.db = dbConfigUpdates;
+        }
+        await fs.writeJson(appJsonPath, appJson, { spaces: 2 });
+        
+        const finalPackageBuffer = await _repackApp(unpackedPath);
+        spinner.succeed('Configuration applied and package repacked.');
+
+        // 8. Execute the upgrade via the API client
+        spinner.start(`Upgrading '${appName}' on ${serverUrl}...`);
+        const result = await apiClient.upgradeApp(serverUrl, appName, `${appName}.gin`, finalPackageBuffer, grantedPermissions);
+
+        if (result.status !== 'success') {
+            throw new Error(result.message || 'Server responded with an unknown error.');
+        }
+        spinner.succeed(chalk.bgGreen(`✅ Success! App '${appName}' upgraded on ${serverUrl}.`));
+
+    } catch (err) {
+        spinner.fail(chalk.bgRed('Upgrade failed.'));
+        if (err.errors) { //for AggregateError
+            const messages = err.errors.map(e => e.message).join('\n');
+            console.error(chalk.bgRed(`Error: `), chalk.blueBright(`${messages}`));
+        } else {
+            console.error(chalk.bgRed(`Error: `), chalk.blueBright(`${err.message}`));
+        }
+        process.exit(1);
+    } finally {
+        // 9. Cleanup
+        await fs.remove(tempDir);
+    }
+}
+
+module.exports = { upgradeStoreApp };

package/commands/utils.js

@@ -0,0 +1,35 @@
+const fs = require('fs-extra');
+const path = require('path');
+const chalk = require('chalk');
+const { error } = require('console');
+
+function getProjectRoot() {
+    const projectRoot = process.cwd();
+    if (!fs.existsSync(path.join(projectRoot, 'gingee.json'))) {
+        throw new Error('This command must be run from the root of a Gingee project.');
+    }
+    return projectRoot;
+}
+
+/**
+ * Reads the gingee.json file and resolves the correct, absolute web_root path.
+ * Correctly handles both relative and absolute paths from the config.
+ * @param {string} projectRoot - The absolute path to the project root.
+ * @returns {string} The absolute path to the web root directory.
+ */
+function getWebRoot(projectRoot) {
+    const configPath = path.join(projectRoot, 'gingee.json');
+    const config = fs.readJsonSync(configPath);
+    const configWebPath = config.web_root || './web';
+
+    // --- THIS IS THE EXPLICIT AND CORRECT LOGIC ---
+    if (path.isAbsolute(configWebPath)) {
+        // If the path is already absolute, use it directly.
+        return configWebPath;
+    } else {
+        // If it's relative, resolve it from the project's root.
+        return path.resolve(projectRoot, configWebPath);
+    }
+}
+
+module.exports = { getProjectRoot, getWebRoot };