mudhost 1.0.0

package/README.md

@@ -0,0 +1,85 @@
+## Quick Start
+
+#### Login to your Hosting instance:
+
+```bash
+npx mudhost login --api https://your-domain.com
+```
+
+Alternatively, you can provide username and password directly:
+```
+ mudhost login -u admin -p admin123 --api https://your-domain.com
+```
+
+#### Deploy your project:
+
+```bash
+npx mudhost deploy my-project ./dist
+```
+
+#### Access your preview:
+
+```text
+https://my-project-main-12345.your-domain.com
+```
+
+## Commands
+
+Login
+```bash
+npx mudhost login [options]
+```
+Deploy
+
+```bash
+npx mudhost deploy <project-id> [dist-dir] [options]
+```
+List Deployments
+```bash
+npx mudhost list [options]
+```
+
+Delete Deployment
+
+```bash
+npx mudhost delete <deployment-id>
+```
+Whoami
+
+```bash
+npx mudhost whoami
+```
+
+Logout
+```bash
+npx mudhost logout
+```
+
+
+### Examples
+
+```bash
+# Deploy with custom branch
+npx mudhost deploy my-app ./build --branch feature/new-ui
+
+# Deploy to custom API
+npx mudhost deploy my-app ./dist --api https://staging.example.com
+
+# List deployments for a project
+npx mudhost list --project my-app
+```
+
+
+## Configuration
+
+The CLI automatically saves your authentication token and API URL in ~/.mudhost/config.json.
+
+You can also create a mudhost.json file in your project:
+
+```json
+{
+"apiUrl": "https://your-domain.com",
+"defaultProject": "my-app",
+"defaultBranch": "main"
+}
+```

package/bin/hosting.js

@@ -0,0 +1,9 @@
+#!/usr/bin/env node
+
+const { CLI } = require('../src/cli');
+
+const cli = new CLI();
+cli.run().catch(error => {
+    console.error('❌ Error:', error.message);
+    process.exit(1);
+});

package/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "mudhost",
+  "version": "1.0.0",
+  "description": "CLI for Hosting - deploy preview environments with one command",
+  "main": "src/cli.js",
+  "bin": {
+    "mudhost": "./bin/hosting.js"
+  },
+  "scripts": {
+    "start": "node src/cli.js",
+    "test": "echo \"No tests yet\" && exit 0"
+  },
+  "keywords": [
+    "hosting",
+    "preview",
+    "deployment",
+    "cli",
+    "mudhost"
+  ],
+  "author": "Irustm",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/irustm/mudhost"
+  },
+  "dependencies": {
+    "axios": "^1.6.0",
+    "chalk": "^4.1.2",
+    "commander": "^11.1.0",
+    "inquirer": "^8.2.6",
+    "fs-extra": "^11.1.1",
+    "glob": "^10.3.0",
+    "mime-types": "^2.1.35",
+    "ora": "^5.4.1"
+  },
+  "engines": {
+    "node": ">=14.0.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/src/auth.js

@@ -0,0 +1,98 @@
+const axios = require('axios');
+const chalk = require('chalk');
+const inquirer = require('inquirer');
+const fs = require('fs-extra');
+const path = require('path');
+const { ConfigManager } = require('./utils');
+
+class AuthManager {
+    constructor() {
+        this.config = new ConfigManager();
+    }
+
+    async login(apiUrl, options) {
+        let { username, password } = options;
+
+        // Если credentials не предоставлены, запросим их
+        if (!username || !password) {
+            const answers = await inquirer.prompt([
+                {
+                    type: 'input',
+                    name: 'username',
+                    message: 'Username:',
+                    when: !username
+                },
+                {
+                    type: 'password',
+                    name: 'password',
+                    message: 'Password:',
+                    when: !password
+                }
+            ]);
+
+            username = username || answers.username;
+            password = password || answers.password;
+        }
+
+        if (!username || !password) {
+            throw new Error('Username and password are required');
+        }
+
+        try {
+            const response = await axios.post(`${apiUrl}/api/auth/login`, {
+                username,
+                password
+            });
+
+            const { token, user } = response.data;
+
+            // Сохраняем токен и настройки
+            await this.config.set('token', token);
+            await this.config.set('apiUrl', apiUrl);
+            await this.config.set('user', user);
+
+            console.log(chalk.green(`✅ Logged in as ${user.username} (${user.role})`));
+            return token;
+        } catch (error) {
+            if (error.response?.status === 401) {
+                throw new Error('Invalid credentials');
+            }
+            throw new Error(`Login failed: ${error.message}`);
+        }
+    }
+
+    async getAuthHeaders() {
+        const token = await this.config.get('token');
+        if (!token) {
+            throw new Error('Not authenticated. Please run "mudhost login" first.');
+        }
+
+        return {
+            'Authorization': `Bearer ${token}`,
+            'Content-Type': 'application/json'
+        };
+    }
+
+    async whoami(apiUrl) {
+        try {
+            const headers = await this.getAuthHeaders();
+            const response = await axios.get(`${apiUrl}/api/auth/me`, { headers });
+
+            const user = response.data.user;
+            const config = await this.config.getAll();
+
+            console.log(chalk.blue('👤 Current User:'));
+            console.log(`  Username: ${chalk.bold(user.username)}`);
+            console.log(`  Role: ${chalk.bold(user.role)}`);
+            console.log(`  API: ${chalk.bold(config.apiUrl)}`);
+        } catch (error) {
+            throw new Error(`Failed to get user info: ${error.message}`);
+        }
+    }
+
+    logout() {
+        this.config.clear();
+    }
+}
+
+module.exports = { AuthManager };

package/src/cli.js

@@ -0,0 +1,183 @@
+const { Command } = require('commander');
+const chalk = require('chalk');
+const { AuthManager } = require('./auth');
+const { DeployManager } = require('./deploy');
+const { ConfigManager } = require('./utils');
+
+class CLI {
+    constructor() {
+        this.program = new Command();
+        this.auth = new AuthManager();
+        this.deploy = new DeployManager();
+        this.config = new ConfigManager();
+        this.setupCommands();
+    }
+
+    setupCommands() {
+        this.program
+            .name('mudhost')
+            .description('CLI for Mud Hosting - Deploy preview environments')
+            .version('1.0.0');
+
+        // Login command
+        this.program
+            .command('login')
+            .description('Login to Mud Hosting')
+            .option('-u, --username <username>', 'Username')
+            .option('-p, --password <password>', 'Password')
+            .option('--api <url>', 'API URL', 'http://localhost:8000')
+            .action(async (options) => {
+                await this.handleLogin(options);
+            });
+
+        // Deploy command
+        this.program
+            .command('deploy')
+            .description('Deploy a project')
+            .argument('<project-id>', 'Project ID')
+            .argument('[dist-dir]', 'Distribution directory', './dist')
+            .option('-b, --branch <branch>', 'Git branch', 'main')
+            .option('-c, --commit <commit>', 'Git commit', 'latest')
+            .option('--api <url>', 'API URL')
+            .option('--config <file>', 'Config file')
+            .action(async (projectId, distDir, options) => {
+                await this.handleDeploy(projectId, distDir, options);
+            });
+
+        // List command
+        this.program
+            .command('list')
+            .description('List deployments')
+            .option('--api <url>', 'API URL')
+            .option('-p, --project <projectId>', 'Filter by project')
+            .action(async (options) => {
+                await this.handleList(options);
+            });
+
+        // Delete command
+        this.program
+            .command('delete')
+            .description('Delete a deployment')
+            .argument('<deployment-id>', 'Deployment ID')
+            .option('--api <url>', 'API URL')
+            .action(async (deploymentId, options) => {
+                await this.handleDelete(deploymentId, options);
+            });
+
+        // Whoami command
+        this.program
+            .command('whoami')
+            .description('Show current user info')
+            .option('--api <url>', 'API URL')
+            .action(async (options) => {
+                await this.handleWhoami(options);
+            });
+
+        // Logout command
+        this.program
+            .command('logout')
+            .description('Logout and clear saved token')
+            .action(() => {
+                this.handleLogout();
+            });
+
+        // Init command
+        this.program
+            .command('init')
+            .description('Create config file')
+            .action(() => {
+                this.handleInit();
+            });
+    }
+
+    async handleLogin(options) {
+        const apiUrl = options.api || await this.config.get('apiUrl') || 'http://localhost:8000';
+
+        try {
+            await this.auth.login(apiUrl, options);
+            console.log(chalk.green('✅ Login successful!'));
+        } catch (error) {
+            console.error(chalk.red('❌ Login failed:'), error.message);
+            process.exit(1);
+        }
+    }
+
+    async handleDeploy(projectId, distDir, options) {
+        const apiUrl = options.api || await this.config.get('apiUrl');
+
+        if (!apiUrl) {
+            console.error(chalk.red('❌ API URL not configured. Please login first or use --api option.'));
+            process.exit(1);
+        }
+
+        try {
+            await this.deploy.deploy(projectId, distDir, options, apiUrl);
+        } catch (error) {
+            console.error(chalk.red('❌ Deployment failed:'), error.message);
+            process.exit(1);
+        }
+    }
+
+    async handleList(options) {
+        const apiUrl = options.api || await this.config.get('apiUrl');
+
+        if (!apiUrl) {
+            console.error(chalk.red('❌ API URL not configured. Please login first or use --api option.'));
+            process.exit(1);
+        }
+
+        try {
+            await this.deploy.listDeployments(apiUrl, options.project);
+        } catch (error) {
+            console.error(chalk.red('❌ Failed to list deployments:'), error.message);
+            process.exit(1);
+        }
+    }
+
+    async handleDelete(deploymentId, options) {
+        const apiUrl = options.api || await this.config.get('apiUrl');
+
+        if (!apiUrl) {
+            console.error(chalk.red('❌ API URL not configured. Please login first or use --api option.'));
+            process.exit(1);
+        }
+
+        try {
+            await this.deploy.deleteDeployment(deploymentId, apiUrl);
+        } catch (error) {
+            console.error(chalk.red('❌ Failed to delete deployment:'), error.message);
+            process.exit(1);
+        }
+    }
+
+    async handleWhoami(options) {
+        const apiUrl = options.api || await this.config.get('apiUrl');
+
+        if (!apiUrl) {
+            console.error(chalk.red('❌ API URL not configured. Please login first or use --api option.'));
+            process.exit(1);
+        }
+
+        try {
+            await this.auth.whoami(apiUrl);
+        } catch (error) {
+            console.error(chalk.red('❌ Failed to get user info:'), error.message);
+            process.exit(1);
+        }
+    }
+
+    handleLogout() {
+        this.auth.logout();
+        console.log(chalk.green('✅ Logged out successfully!'));
+    }
+
+    handleInit() {
+        this.config.createConfig();
+    }
+
+    async run() {
+        await this.program.parseAsync(process.argv);
+    }
+}
+
+module.exports = { CLI };

package/src/deploy.js

@@ -0,0 +1,177 @@
+const axios = require('axios');
+const chalk = require('chalk');
+const fs = require('fs-extra');
+const path = require('path');
+const glob = require('glob');
+const mime = require('mime-types');
+const ora = require('ora');
+const { AuthManager } = require('./auth');
+
+class DeployManager {
+    constructor() {
+        this.auth = new AuthManager();
+    }
+
+    async collectFiles(distDir) {
+        const spinner = ora('📁 Scanning files...').start();
+
+        if (!await fs.pathExists(distDir)) {
+            spinner.fail();
+            throw new Error(`Directory not found: ${distDir}`);
+        }
+
+        try {
+            const files = {};
+            const allFiles = glob.sync('**/*', {
+                cwd: distDir,
+                nodir: true,
+                dot: true
+            });
+
+            for (const filePath of allFiles) {
+                const fullPath = path.join(distDir, filePath);
+                const content = await fs.readFile(fullPath, 'utf8');
+                files[filePath] = content;
+            }
+
+            spinner.succeed(`Found ${allFiles.length} files`);
+            return files;
+        } catch (error) {
+            spinner.fail();
+            throw new Error(`Failed to read files: ${error.message}`);
+        }
+    }
+
+    async deploy(projectId, distDir, options, apiUrl) {
+        const spinner = ora('🚀 Deploying...').start();
+
+        try {
+            // Собираем файлы
+            const files = await this.collectFiles(distDir);
+
+            if (Object.keys(files).length === 0) {
+                spinner.fail();
+                throw new Error(`No files found in ${distDir}`);
+            }
+
+            // Получаем заголовки аутентификации
+            const headers = await this.auth.getAuthHeaders();
+
+            // Отправляем деплой
+            spinner.text = '📦 Uploading deployment...';
+
+            const response = await axios.post(`${apiUrl}/api/deployments`, {
+                projectId,
+                branch: options.branch,
+                commit: options.commit,
+                files
+            }, { headers });
+
+            const deployment = response.data;
+
+            spinner.succeed('✅ Deployment successful!');
+
+            console.log(chalk.green('\n📊 Deployment Info:'));
+            console.log(`  Project: ${chalk.bold(deployment.projectId)}`);
+            console.log(`  Branch: ${chalk.bold(deployment.branch)}`);
+            console.log(`  ID: ${chalk.bold(deployment.id)}`);
+            console.log(`  Files: ${chalk.bold(deployment.files.length)}`);
+
+            console.log(chalk.blue('\n🌐 Preview URLs:'));
+            deployment.urls?.forEach(url => {
+                console.log(`  ${chalk.cyan('→')} ${chalk.underline(url)}`);
+            });
+
+            if (deployment.url) {
+                console.log(`  ${chalk.cyan('→')} ${chalk.underline(deployment.url)}`);
+            }
+
+            return deployment;
+        } catch (error) {
+            spinner.fail();
+
+            if (error.response) {
+                const status = error.response.status;
+                const message = error.response.data?.error || error.message;
+
+                switch (status) {
+                    case 401:
+                        throw new Error('Authentication failed. Please login again.');
+                    case 413:
+                        throw new Error('Deployment too large. Reduce file size.');
+                    default:
+                        throw new Error(`HTTP ${status}: ${message}`);
+                }
+            }
+
+            throw new Error(`Deployment failed: ${error.message}`);
+        }
+    }
+
+    async listDeployments(apiUrl, projectFilter) {
+        const spinner = ora('📋 Loading deployments...').start();
+
+        try {
+            const headers = await this.auth.getAuthHeaders();
+            const response = await axios.get(`${apiUrl}/api/deployments`, { headers });
+
+            let deployments = response.data;
+
+            // Фильтруем по проекту если нужно
+            if (projectFilter) {
+                deployments = deployments.filter(d => d.projectId === projectFilter);
+            }
+
+            spinner.succeed(`Found ${deployments.length} deployments`);
+
+            if (deployments.length === 0) {
+                console.log(chalk.yellow('No deployments found'));
+                return;
+            }
+
+            console.log('\n' + chalk.blue.bold('📦 Deployments:'));
+            console.log('=' .repeat(80));
+
+            deployments.forEach(deployment => {
+                const status = deployment.isExpired ? chalk.red('❌ EXPIRED') : chalk.green('✅ ACTIVE');
+                const daysLeft = deployment.isExpired ?
+                    'EXPIRED' :
+                    `${Math.ceil(deployment.expiresIn / (1000 * 60 * 60 * 24))} days`;
+
+                console.log(`🆔 ${chalk.bold(deployment.id)}`);
+                console.log(`   📁 ${chalk.gray('Project:')} ${deployment.projectId}`);
+                console.log(`   🌿 ${chalk.gray('Branch:')} ${deployment.branch}`);
+                console.log(`   🔗 ${chalk.gray('URL:')} ${chalk.cyan(deployment.url)}`);
+                console.log(`   📅 ${chalk.gray('Created:')} ${new Date(deployment.createdAt).toLocaleString()}`);
+                console.log(`   ⏰ ${chalk.gray('Status:')} ${status} (${daysLeft} left)`);
+                console.log(`   📊 ${chalk.gray('Files:')} ${deployment.files.length}`);
+                console.log('-'.repeat(80));
+            });
+
+        } catch (error) {
+            spinner.fail();
+            throw new Error(`Failed to list deployments: ${error.message}`);
+        }
+    }
+
+    async deleteDeployment(deploymentId, apiUrl) {
+        const spinner = ora('🗑️ Deleting deployment...').start();
+
+        try {
+            const headers = await this.auth.getAuthHeaders();
+            await axios.delete(`${apiUrl}/api/deployments/${deploymentId}`, { headers });
+
+            spinner.succeed(`✅ Deployment ${deploymentId} deleted successfully`);
+        } catch (error) {
+            spinner.fail();
+
+            if (error.response?.status === 404) {
+                throw new Error(`Deployment not found: ${deploymentId}`);
+            }
+
+            throw new Error(`Failed to delete deployment: ${error.message}`);
+        }
+    }
+}
+
+module.exports = { DeployManager };

package/src/utils.js

@@ -0,0 +1,70 @@
+const fs = require('fs-extra');
+const path = require('path');
+const os = require('os');
+const chalk = require('chalk');
+
+class ConfigManager {
+    constructor() {
+        this.configDir = path.join(os.homedir(), '.mudhost');
+        this.configFile = path.join(this.configDir, 'config.json');
+        this.ensureConfigDir();
+    }
+
+    ensureConfigDir() {
+        if (!fs.existsSync(this.configDir)) {
+            fs.mkdirSync(this.configDir, { recursive: true });
+        }
+    }
+
+    async get(key) {
+        try {
+            const config = await this.getAll();
+            return config[key];
+        } catch (error) {
+            return null;
+        }
+    }
+
+    async getAll() {
+        try {
+            if (await fs.pathExists(this.configFile)) {
+                return await fs.readJson(this.configFile);
+            }
+            return {};
+        } catch (error) {
+            return {};
+        }
+    }
+
+    async set(key, value) {
+        const config = await this.getAll();
+        config[key] = value;
+        await fs.writeJson(this.configFile, config, { spaces: 2 });
+    }
+
+    async clear() {
+        if (await fs.pathExists(this.configFile)) {
+            await fs.remove(this.configFile);
+        }
+    }
+
+    createConfig() {
+        const configTemplate = {
+            apiUrl: 'http://localhost:8000',
+            defaultProject: 'my-app',
+            defaultBranch: 'main'
+        };
+
+        const configPath = path.join(process.cwd(), 'mudhost.json');
+
+        if (fs.existsSync(configPath)) {
+            console.log(chalk.yellow('⚠️ Config file already exists'));
+            return;
+        }
+
+        fs.writeJsonSync(configPath, configTemplate, { spaces: 2 });
+        console.log(chalk.green('✅ Created mudhost.json config file'));
+    }
+}
+
+module.exports = { ConfigManager };