gingee-cli 1.0.0

package/commands/init.js

@@ -0,0 +1,133 @@
+const fs = require('fs-extra');
+const path = require('path');
+const { execSync } = require('child_process');
+const argon2 = require('argon2');
+const { _unzipBuffer } = require('./installerUtils');
+
+
+async function init(projectName) {
+  const { default: ora } = await import('ora');
+  const { default: chalk } = await import('chalk');
+  const { default: inquirer } = await import('inquirer');
+
+  const spinner = ora();
+  try {
+    console.log(chalk.blueBright('🚀 Welcome to Gingee! Let\'s create your new project.'));
+    const projectPath = path.resolve(process.cwd(), projectName);
+
+    let currentPath = process.cwd();
+    while (currentPath !== path.parse(currentPath).root) {
+      if (fs.existsSync(path.join(currentPath, 'gingee.json'))) {
+        throw new Error(`Command cannot be run inside an existing Gingee project.\nDetected project root at: ${currentPath}`);
+      }
+      currentPath = path.dirname(currentPath);
+    }
+
+    if (fs.existsSync(projectPath)) {
+      throw new Error(`Directory '${projectName}' already exists. Please choose another name.`);
+    }
+
+    const answers = 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: '*', 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: '*'
+      },
+      { type: 'confirm', name: 'installDeps', message: 'Install npm dependencies automatically?', default: true },
+    ]);
+
+    if (answers.adminPass !== answers.confirmPassword) {
+      throw new Error("Passwords do not match. Please try again.");
+    }
+
+    if (!answers.adminPass) {
+      throw new Error("Admin password cannot be empty.");
+    }
+
+    spinner.start('Scaffolding project files...');
+    fs.mkdirSync(projectPath);
+    const templatePath = path.join(__dirname, '..', 'templates', 'project');
+    fs.copySync(templatePath, projectPath);
+
+    const pkgJsonPath = path.join(projectPath, 'package.json');
+    const pkgJson = fs.readJsonSync(pkgJsonPath);
+    pkgJson.name = projectName.toLowerCase().replace(/\s+/g, '-');
+    fs.writeJsonSync(pkgJsonPath, pkgJson, { spaces: 2 });
+    fs.mkdirSync(path.join(projectPath, 'settings', 'ssl'), { recursive: true });
+    fs.mkdirSync(path.join(projectPath, 'backups'), { recursive: true });
+    fs.mkdirSync(path.join(projectPath, 'logs'), { recursive: true });
+    fs.mkdirSync(path.join(projectPath, 'temp'), { recursive: true });
+
+    spinner.succeed('Project files scaffolded.');
+    spinner.start('Installing `glade` admin panel...');
+
+    // Find the glade.gin file using require.resolve, which is robust.
+    // It looks for the 'gingee' package in the CLI's own node_modules.
+    const gladeGinPath = require.resolve('gingee/templates/glade.gin');
+    const gladePackageBuffer = fs.readFileSync(gladeGinPath);
+    const gladeDestPath = path.join(projectPath, 'web', 'glade');
+
+    await _unzipBuffer(gladePackageBuffer, gladeDestPath);
+    spinner.succeed('`glade` admin panel installed.');
+    spinner.start('Configuring admin credentials...');
+
+    // Use the CLI's own argon2 dependency to hash the password.
+    const passwordHash = await argon2.hash(answers.adminPass);
+    const gladeAppConfigPath = path.join(gladeDestPath, 'box', 'app.json');
+    const gladeAppConfig = fs.readJsonSync(gladeAppConfigPath);
+    gladeAppConfig.env.ADMIN_USERNAME = answers.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(projectPath, 'settings', 'permissions.json');
+    const permissionsConfig = {
+      "glade": {
+        "granted": ["platform", "fs"]
+      }
+    };
+    fs.writeJsonSync(permissionsFilePath, permissionsConfig, { spaces: 2 });
+    spinner.succeed('Default permissions for Glade configured.');
+
+    if (answers.installDeps) {
+      spinner.start('Installing dependencies with npm (this may take a moment)...');
+      // Run `npm install` in the new project's directory
+      execSync('npm install', { cwd: projectPath, stdio: 'ignore' });
+      spinner.succeed('Dependencies installed.');
+    }
+
+    console.log(chalk.bgGreen(`\n✅ Success!`), chalk.blueBright(`Your Gingee project "${projectName}" is ready.`));
+    console.log(`\nTo get started, run the following commands:\n`);
+    console.log(chalk.blueBright(`  cd ${projectName}`));
+    //console.log(chalk.blueBright(`  git init && git add . && git commit -m "Initial commit"`));
+    console.log(chalk.blueBright(`  npm run start`));
+
+    console.log(`\n\nFor production, you have two options:`);
+    console.log(chalk.cyan(`  1. Native Service: sudo gingee-cli service install`));
+    console.log(chalk.cyan(`  2. PM2:           pm2 start`));
+    console.log(`     (Customize your PM2 deployment in ecosystem.config.js)`);
+
+  } catch (err) {
+    spinner.fail(chalk.bgRed('ERROR!: '));
+    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);
+  }
+}
+
+module.exports = { init };

package/commands/installApp.js

@@ -0,0 +1,85 @@
+const fs = require('fs-extra');
+const path = require('path');
+const { 
+    _unzipBuffer, 
+    _repackApp, 
+    _getPermissions, 
+    _getDbRequirements, 
+    _getHttpClientErrorMessage,
+    _readAppPreset,
+    _validateAppPreset,
+    _substituteEnvVars
+} = require('./installerUtils');
+const apiClient = require('./apiClient');
+
+async function installApp(options) {
+    const { default: chalk } = await import('chalk');
+    const { default: ora } = await import('ora');
+    const spinner = ora('Preparing to install application...').start();
+    const tempDir = path.join(require('os').tmpdir(), `gingee-install-local-${Date.now()}`);
+
+    try {
+        const { serverUrl = 'http://localhost:7070', appName, ginPath: ginFilePath, file: presetFilePath } = options;
+        let finalPermissions, finalDbConfig;
+
+        if (!fs.existsSync(ginFilePath)) {
+            throw new Error(`Package file not found at: ${ginFilePath}`);
+        }
+
+        spinner.start(`Reading package ${path.basename(ginFilePath)}...`);
+        const packageBuffer = fs.readFileSync(ginFilePath);
+
+        // Unpack and get user consent/config
+        await fs.ensureDir(tempDir);
+        const unpackedPath = path.join(tempDir, 'unpacked');
+        await _unzipBuffer(packageBuffer, unpackedPath);
+        spinner.succeed('Package read.');
+
+        if(presetFilePath) {
+            console.log(chalk.blueBright(`Running in non-interactive mode using preset file: ${presetFilePath}`));
+            const preset = _readAppPreset(presetFilePath);
+            _validateAppPreset(preset, 'install'); // Assumes 'install' key exists in preset
+            finalPermissions = preset.install.consent.grantPermissions;
+            finalDbConfig = _substituteEnvVars(preset.install.config.db);
+        }else{
+            finalPermissions = await _getPermissions(unpackedPath);
+            finalDbConfig = await _getDbRequirements(unpackedPath);
+        }
+
+        // Modify and Repack
+        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.');
+
+        // Infer appName from the filename without the .gin extension
+        spinner.text = `Installing app '${appName}' to server ${serverUrl}...`;
+
+        const result = await apiClient.installApp(serverUrl, appName, path.basename(ginFilePath), finalPackageBuffer, finalPermissions);
+        if (result.status !== 'success') {
+            throw new Error(result.message || 'Server responded with an unknown error.');
+        }
+
+        const successMsg = chalk.bgGreen('✅ Success!') + chalk.blueBright(` App '${appName}' installed.`);
+        spinner.succeed(successMsg);
+
+    } catch (err) {
+        spinner.fail(chalk.bgRed('Installation 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 = { installApp };

package/commands/installStoreApp.js

@@ -0,0 +1,87 @@
+const axios = require('axios');
+const fs = require('fs-extra');
+const path = require('path');
+const os = require('os');
+const { 
+    _unzipBuffer, 
+    _repackApp, 
+    _getPermissions, 
+    _getDbRequirements, 
+    _resolveStoreUrl,
+    _resolveDownloadUrl,
+    _getHttpClientErrorMessage
+} = require('./installerUtils');
+const apiClient = require('./apiClient');
+
+async function installStoreApp(appName, options) {
+    const { default: chalk } = await import('chalk');
+    const { default: ora } = await import('ora');
+    const spinner = ora();
+    const tempDir = path.join(os.tmpdir(), `gingee-install-${Date.now()}`);
+
+    const { gStoreUrl, serverUrl } = options;
+
+    try {
+        // Step 1: Resolve the manifest URL using the new utility
+        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.');
+        
+        // Step 2: Resolve the download URL using the new utility
+        const downloadUrl = _resolveDownloadUrl(resolvedStoreUrl, appConfig.download_url);
+        
+        spinner.start(`Downloading package from ${downloadUrl}...`);
+        const downloadResponse = await axios.get(downloadUrl, { responseType: 'arraybuffer' });
+        const packageBuffer = downloadResponse.data;
+        spinner.succeed('Package downloaded.');
+
+        // Steps 3, 4, and 5 (Unpack, get user consent, repack, and install) are now identical
+        // to the logic we've already defined, as they operate on the buffer.
+        await fs.ensureDir(tempDir);
+        const unpackedPath = path.join(tempDir, 'unpacked');
+        await _unzipBuffer(packageBuffer, unpackedPath);
+
+        const grantedPermissions = await _getPermissions(unpackedPath);
+        const dbConfigUpdates = await _getDbRequirements(unpackedPath);
+        
+        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.');
+
+        spinner.start(`Installing '${appName}' on ${serverUrl}...`);
+        const result = await apiClient.installApp(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!`));
+        console.log(chalk.blueBright(` App '${appName}' installed on ${serverUrl}.`));
+
+    } catch (err) {
+        spinner.fail(chalk.bgRed('Installation 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);
+    } finally {
+        await fs.remove(tempDir);
+    }
+}
+
+module.exports = { installStoreApp };